talexander
/
freebsd_amp_hwpstate
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
freebsd_amp_hwpstate/sys/dev/sound/macio/i2s.c

764 lines
18 KiB
C
Raw Blame History

/*-
* Copyright 2008 by Marco Trillo. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
* AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*
* $FreeBSD$
*/
/*-
* Copyright (c) 2002, 2003 Tsubai Masanari. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. The name of the author may not be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* NetBSD: snapper.c,v 1.28 2008/05/16 03:49:54 macallan Exp
* Id: snapper.c,v 1.11 2002/10/31 17:42:13 tsubai Exp
*/
/*
* Apple I2S audio controller.
*/
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/module.h>
#include <sys/bus.h>
#include <sys/malloc.h>
#include <sys/lock.h>
#include <sys/mutex.h>
#include <machine/dbdma.h>
#include <machine/intr_machdep.h>
#include <machine/resource.h>
#include <machine/bus.h>
#include <machine/pio.h>
#include <sys/rman.h>
#include <dev/ofw/ofw_bus.h>
#ifdef HAVE_KERNEL_OPTION_HEADERS
#include "opt_snd.h"
#endif
#include <dev/sound/pcm/sound.h>
#include <dev/sound/macio/aoa.h>
#include <powerpc/powermac/macgpiovar.h>
struct i2s_softc {
struct aoa_softc aoa;
phandle_t node;
phandle_t soundnode;
struct resource *reg;
u_int output_mask;
struct mtx port_mtx;
};
static int i2s_probe(device_t);
static int i2s_attach(device_t);
static void i2s_postattach(void *);
static int i2s_setup(struct i2s_softc *, u_int, u_int, u_int);
static void i2s_mute_headphone (struct i2s_softc *, int);
static void i2s_mute_lineout (struct i2s_softc *, int);
static void i2s_mute_speaker (struct i2s_softc *, int);
static void i2s_set_outputs(void *, u_int);
static struct intr_config_hook *i2s_delayed_attach = NULL;
kobj_class_t i2s_mixer_class = NULL;
device_t i2s_mixer = NULL;
static device_method_t pcm_i2s_methods[] = {
/* Device interface. */
DEVMETHOD(device_probe, i2s_probe),
DEVMETHOD(device_attach, i2s_attach),
{ 0, 0 }
};
static driver_t pcm_i2s_driver = {
"pcm",
pcm_i2s_methods,
PCM_SOFTC_SIZE
};
DRIVER_MODULE(pcm_i2s, macio, pcm_i2s_driver, pcm_devclass, 0, 0);
MODULE_DEPEND(pcm_i2s, sound, SOUND_MINVER, SOUND_PREFVER, SOUND_MAXVER);
static int aoagpio_probe(device_t);
static int aoagpio_attach(device_t);
static device_method_t aoagpio_methods[] = {
/* Device interface. */
DEVMETHOD(device_probe, aoagpio_probe),
DEVMETHOD(device_attach, aoagpio_attach),
{ 0, 0 }
};
struct aoagpio_softc {
device_t dev;
int ctrl;
int detect_active; /* for extint-gpio */
int level; /* for extint-gpio */
struct i2s_softc *i2s; /* for extint-gpio */
};
static driver_t aoagpio_driver = {
"aoagpio",
aoagpio_methods,
sizeof(struct aoagpio_softc)
};
static devclass_t aoagpio_devclass;
DRIVER_MODULE(aoagpio, macgpio, aoagpio_driver, aoagpio_devclass, 0, 0);
/*****************************************************************************
Probe and attachment routines.
*****************************************************************************/
static int
i2s_probe(device_t self)
{
const char *name;
phandle_t subchild;
char subchildname[255];
name = ofw_bus_get_name(self);
if (!name)
return (ENXIO);
if (strcmp(name, "i2s") != 0)
return (ENXIO);
/*
* Do not attach to "lightshow" I2S devices on Xserves. This controller
* is used there to control the LEDs on the front panel, and this
* driver can't handle it.
*/
subchild = OF_child(OF_child(ofw_bus_get_node(self)));
if (subchild != 0 && OF_getprop(subchild, "name", subchildname,
sizeof(subchildname)) > 0 && strcmp(subchildname, "lightshow") == 0)
return (ENXIO);
device_set_desc(self, "Apple I2S Audio Controller");
return (0);
}
static phandle_t of_find_firstchild_byname(phandle_t, const char *);
static int
i2s_attach(device_t self)
{
struct i2s_softc *sc;
struct resource *dbdma_irq;
void *dbdma_ih;
int rid, oirq, err;
phandle_t port;
sc = malloc(sizeof(*sc), M_DEVBUF, M_WAITOK | M_ZERO);
sc->aoa.sc_dev = self;
sc->node = ofw_bus_get_node(self);
port = of_find_firstchild_byname(sc->node, "i2s-a");
if (port == -1)
return (ENXIO);
sc->soundnode = of_find_firstchild_byname(port, "sound");
if (sc->soundnode == -1)
return (ENXIO);
mtx_init(&sc->port_mtx, "port_mtx", NULL, MTX_DEF);
/* Map the controller register space. */
rid = 0;
sc->reg = bus_alloc_resource_any(self, SYS_RES_MEMORY, &rid, RF_ACTIVE);
if (sc->reg == NULL)
return ENXIO;
/* Map the DBDMA channel register space. */
rid = 1;
sc->aoa.sc_odma = bus_alloc_resource_any(self, SYS_RES_MEMORY, &rid,
RF_ACTIVE);
if (sc->aoa.sc_odma == NULL)
return ENXIO;
/* Establish the DBDMA channel edge-triggered interrupt. */
rid = 1;
dbdma_irq = bus_alloc_resource_any(self, SYS_RES_IRQ,
&rid, RF_SHAREABLE | RF_ACTIVE);
if (dbdma_irq == NULL)
return (ENXIO);
/* Now initialize the controller. */
err = i2s_setup(sc, 44100, 16, 64);
if (err != 0)
return (err);
snd_setup_intr(self, dbdma_irq, INTR_MPSAFE, aoa_interrupt,
sc, &dbdma_ih);
oirq = rman_get_start(dbdma_irq);
err = powerpc_config_intr(oirq, INTR_TRIGGER_EDGE, INTR_POLARITY_LOW);
if (err != 0)
return (err);
/*
* Register a hook for delayed attach in order to allow
* the I2C controller to attach.
*/
if ((i2s_delayed_attach = malloc(sizeof(struct intr_config_hook),
M_TEMP, M_WAITOK | M_ZERO)) == NULL)
return (ENOMEM);
i2s_delayed_attach->ich_func = i2s_postattach;
i2s_delayed_attach->ich_arg = sc;
if (config_intrhook_establish(i2s_delayed_attach) != 0)
return (ENOMEM);
return (aoa_attach(sc));
}
/*****************************************************************************
GPIO routines.
*****************************************************************************/
enum gpio_ctrl {
AMP_MUTE,
HEADPHONE_MUTE,
LINEOUT_MUTE,
AUDIO_HW_RESET,
HEADPHONE_DETECT,
LINEOUT_DETECT,
GPIO_CTRL_NUM
};
#define GPIO_CTRL_EXTINT_SET \
((1 << HEADPHONE_DETECT) | \
(1 << LINEOUT_DETECT))
static struct aoagpio_softc *gpio_ctrls[GPIO_CTRL_NUM] =
{NULL, NULL, NULL, NULL, NULL, NULL};
static struct gpio_match {
const char *name;
enum gpio_ctrl ctrl;
} gpio_controls[] = {
{"headphone-mute", HEADPHONE_MUTE},
{"lineout-mute", LINEOUT_MUTE},
{"amp-mute", AMP_MUTE},
{"headphone-detect", HEADPHONE_DETECT},
{"lineout-detect", LINEOUT_DETECT},
{"line-output-detect", LINEOUT_DETECT},
{"audio-hw-reset", AUDIO_HW_RESET},
{"hw-reset", AUDIO_HW_RESET},
{NULL, GPIO_CTRL_NUM}
};
static void i2s_cint(struct i2s_softc *);
static void
aoagpio_int(void *cookie)
{
device_t self = cookie;
struct aoagpio_softc *sc;
sc = device_get_softc(self);
if (macgpio_read(self) & GPIO_LEVEL_RO)
sc->level = sc->detect_active;
else
sc->level = !(sc->detect_active);
if (sc->i2s)
i2s_cint(sc->i2s);
}
static int
aoagpio_probe(device_t gpio)
{
phandle_t node;
char bname[32];
const char *name;
struct gpio_match *m;
struct aoagpio_softc *sc;
node = ofw_bus_get_node(gpio);
if (node == 0 || node == -1)
return (EINVAL);
bzero(bname, sizeof(bname));
if (OF_getprop(node, "audio-gpio", bname, sizeof(bname)) > 2)
name = bname;
else
name = ofw_bus_get_name(gpio);
/* Try to find a match. */
for (m = gpio_controls; m->name != NULL; m++) {
if (strcmp(name, m->name) == 0) {
sc = device_get_softc(gpio);
gpio_ctrls[m->ctrl] = sc;
sc->dev = gpio;
sc->ctrl = m->ctrl;
sc->level = 0;
sc->detect_active = 0;
sc->i2s = NULL;
OF_getprop(node, "audio-gpio-active-state",
&sc->detect_active, sizeof(sc->detect_active));
if ((1 << m->ctrl) & GPIO_CTRL_EXTINT_SET)
aoagpio_int(gpio);
device_set_desc(gpio, m->name);
device_quiet(gpio);
return (0);
}
}
return (ENXIO);
}
static int
aoagpio_attach(device_t gpio)
{
struct aoagpio_softc *sc;
struct resource *r;
void *cookie;
int irq, rid = 0;
sc = device_get_softc(gpio);
if ((1 << sc->ctrl) & GPIO_CTRL_EXTINT_SET) {
r = bus_alloc_resource_any(gpio, SYS_RES_IRQ, &rid, RF_ACTIVE);
if (r == NULL)
return (ENXIO);
irq = rman_get_start(r);
DPRINTF(("interrupting at irq %d\n", irq));
if (powerpc_config_intr(irq, INTR_TRIGGER_EDGE,
INTR_POLARITY_LOW) != 0)
return (ENXIO);
bus_setup_intr(gpio, r, INTR_TYPE_MISC | INTR_MPSAFE |
INTR_ENTROPY, NULL, aoagpio_int, gpio, &cookie);
}
return (0);
}
/*
* I2S module registers
*/
#define I2S_INT 0x00
#define I2S_FORMAT 0x10
#define I2S_FRAMECOUNT 0x40
#define I2S_FRAMEMATCH 0x50
#define I2S_WORDSIZE 0x60
/* I2S_INT register definitions */
#define I2S_INT_CLKSTOPPEND 0x01000000 /* clock-stop interrupt pending */
/* I2S_FORMAT register definitions */
#define CLKSRC_49MHz 0x80000000 /* Use 49152000Hz Osc. */
#define CLKSRC_45MHz 0x40000000 /* Use 45158400Hz Osc. */
#define CLKSRC_18MHz 0x00000000 /* Use 18432000Hz Osc. */
#define MCLK_DIV_MASK 0x1f000000 /* MCLK = SRC / DIV */
#define SCLK_DIV_MASK 0x00f00000 /* SCLK = MCLK / DIV */
#define SCLK_MASTER 0x00080000 /* Master mode */
#define SCLK_SLAVE 0x00000000 /* Slave mode */
#define SERIAL_FORMAT 0x00070000
#define SERIAL_SONY 0x00000000
#define SERIAL_64x 0x00010000
#define SERIAL_32x 0x00020000
#define SERIAL_DAV 0x00040000
#define SERIAL_SILICON 0x00050000
/* I2S_WORDSIZE register definitions */
#define INPUT_STEREO (2 << 24)
#define INPUT_MONO (1 << 24)
#define INPUT_16BIT (0 << 16)
#define INPUT_24BIT (3 << 16)
#define OUTPUT_STEREO (2 << 8)
#define OUTPUT_MONO (1 << 8)
#define OUTPUT_16BIT (0 << 0)
#define OUTPUT_24BIT (3 << 0)
/* Master clock, needed by some codecs. We hardcode this
to 256 * fs as this is valid for most codecs. */
#define MCLK_FS 256
/* Number of clock sources we can use. */
#define NCLKS 3
static const struct i2s_clksrc {
u_int cs_clock;
u_int cs_reg;
} clksrc[NCLKS] = {
{49152000, CLKSRC_49MHz},
{45158400, CLKSRC_45MHz},
{18432000, CLKSRC_18MHz}
};
/* Configure the I2S controller for the required settings.
'rate' is the frame rate.
'wordsize' is the sample size (usually 16 bits).
'sclk_fs' is the SCLK/framerate ratio, which needs to be equal
or greater to the number of bits per frame. */
static int
i2s_setup(struct i2s_softc *sc, u_int rate, u_int wordsize, u_int sclk_fs)
{
u_int mclk, mdiv, sdiv;
u_int reg = 0, x, wordformat;
u_int i;
/* Make sure the settings are consistent... */
if ((wordsize * 2) > sclk_fs)
return (EINVAL);
if (sclk_fs != 32 && sclk_fs != 64)
return (EINVAL);
/*
* Find a clock source to derive the master clock (MCLK)
* and the I2S bit block (SCLK) and set the divisors as
* appropriate.
*/
mclk = rate * MCLK_FS;
sdiv = MCLK_FS / sclk_fs;
for (i = 0; i < NCLKS; ++i) {
if ((clksrc[i].cs_clock % mclk) == 0) {
reg = clksrc[i].cs_reg;
mdiv = clksrc[i].cs_clock / mclk;
break;
}
}
if (reg == 0)
return (EINVAL);
switch (mdiv) {
/* exception cases */
case 1:
x = 14;
break;
case 3:
x = 13;
break;
case 5:
x = 12;
break;
default:
x = (mdiv / 2) - 1;
break;
}
reg |= (x << 24) & MCLK_DIV_MASK;
switch (sdiv) {
case 1:
x = 8;
break;
case 3:
x = 9;
break;
default:
x = (sdiv / 2) - 1;
break;
}
reg |= (x << 20) & SCLK_DIV_MASK;
/*
* XXX use master mode for now. This needs to be
* revisited if we want to add recording from SPDIF some day.
*/
reg |= SCLK_MASTER;
switch (sclk_fs) {
case 64:
reg |= SERIAL_64x;
break;
case 32:
reg |= SERIAL_32x;
break;
}
/* stereo input and output */
wordformat = INPUT_STEREO | OUTPUT_STEREO;
switch (wordsize) {
case 16:
wordformat |= INPUT_16BIT | OUTPUT_16BIT;
break;
case 24:
wordformat |= INPUT_24BIT | OUTPUT_24BIT;
break;
default:
return (EINVAL);
}
x = bus_read_4(sc->reg, I2S_WORDSIZE);
if (x != wordformat)
bus_write_4(sc->reg, I2S_WORDSIZE, wordformat);
x = bus_read_4(sc->reg, I2S_FORMAT);
if (x != reg) {
/*
* XXX to change the format we need to stop the clock
* via the FCR registers. For now, rely on the firmware
* to set sane defaults (44100).
*/
printf("i2s_setup: changing format not supported yet.\n");
return (ENOTSUP);
#ifdef notyet
if (obio_fcr_isset(OBIO_FCR1, I2S0CLKEN)) {
bus_space_write_4(sc->sc_tag, sc->sc_bsh, I2S_INT,
I2S_INT_CLKSTOPPEND);
obio_fcr_clear(OBIO_FCR1, I2S0CLKEN);
for (timo = 1000; timo > 0; timo--) {
if (bus_space_read_4(sc->sc_tag, sc->sc_bsh,
I2S_INT) & I2S_INT_CLKSTOPPEND)
break;
DELAY(10);
}
if (timo == 0)
printf("%s: timeout waiting for clock to stop\n",
sc->sc_dev.dv_xname);
}
bus_space_write_4(sc->sc_tag, sc->sc_bsh, I2S_FORMAT, reg);
obio_fcr_set(OBIO_FCR1, I2S0CLKEN);
#endif
}
return (0);
}
/* XXX this does not belong here. */
static phandle_t
of_find_firstchild_byname(phandle_t node, const char *req_name)
{
char name[32]; /* max name len per OF spec. */
phandle_t n;
for (n = OF_child(node); n != -1; n = OF_peer(n)) {
bzero(name, sizeof(name));
OF_getprop(n, "name", name, sizeof(name));
if (strcmp(name, req_name) == 0)
return (n);
}
return (-1);
}
static u_int
gpio_read(enum gpio_ctrl ctrl)
{
struct aoagpio_softc *sc;
if ((sc = gpio_ctrls[ctrl]) == NULL)
return (0);
return (macgpio_read(sc->dev) & GPIO_DATA);
}
static void
gpio_write(enum gpio_ctrl ctrl, u_int x)
{
struct aoagpio_softc *sc;
u_int reg;
if ((sc = gpio_ctrls[ctrl]) == NULL)
return;
reg = GPIO_DDR_OUTPUT;
if (x)
reg |= GPIO_DATA;
macgpio_write(sc->dev, reg);
}
static void
i2s_cint(struct i2s_softc *sc)
{
u_int mask = 0;
if (gpio_ctrls[HEADPHONE_DETECT] &&
gpio_ctrls[HEADPHONE_DETECT]->level)
mask |= 1 << 1;
if (gpio_ctrls[LINEOUT_DETECT] &&
gpio_ctrls[LINEOUT_DETECT]->level)
mask |= 1 << 2;
if (mask == 0)
mask = 1 << 0; /* fall back to speakers. */
i2s_set_outputs(sc, mask);
}
#define reset_active 0
/* these values are in microseconds */
#define RESET_SETUP_TIME 5000
#define RESET_HOLD_TIME 20000
#define RESET_RELEASE_TIME 10000
static void
i2s_audio_hw_reset(struct i2s_softc *sc)
{
if (gpio_ctrls[AUDIO_HW_RESET]) {
DPRINTF(("resetting codec\n"));
gpio_write(AUDIO_HW_RESET, !reset_active); /* Negate RESET */
DELAY(RESET_SETUP_TIME);
gpio_write(AUDIO_HW_RESET, reset_active); /* Assert RESET */
DELAY(RESET_HOLD_TIME);
gpio_write(AUDIO_HW_RESET, !reset_active); /* Negate RESET */
DELAY(RESET_RELEASE_TIME);
} else {
DPRINTF(("no audio_hw_reset\n"));
}
}
#define AMP_ACTIVE 0 /* XXX OF */
#define HEADPHONE_ACTIVE 0 /* XXX OF */
#define LINEOUT_ACTIVE 0 /* XXX OF */
#define MUTE_CONTROL(xxx, yyy) \
static void \
i2s_mute_##xxx(struct i2s_softc *sc, int mute) \
{ \
int x; \
\
if (gpio_ctrls[yyy##_MUTE] == NULL) \
return; \
if (mute) \
x = yyy##_ACTIVE; \
else \
x = ! yyy##_ACTIVE; \
\
if (x != gpio_read(yyy##_MUTE)) \
gpio_write(yyy##_MUTE, x); \
}
MUTE_CONTROL(speaker, AMP)
MUTE_CONTROL(headphone, HEADPHONE)
MUTE_CONTROL(lineout, LINEOUT)
static void
i2s_set_outputs(void *ptr, u_int mask)
{
struct i2s_softc *sc = ptr;
if (mask == sc->output_mask)
return;
mtx_lock(&sc->port_mtx);
i2s_mute_speaker(sc, 1);
i2s_mute_headphone(sc, 1);
i2s_mute_lineout(sc, 1);
DPRINTF(("enabled outputs: "));
if (mask & (1 << 0)) {
DPRINTF(("SPEAKER "));
i2s_mute_speaker(sc, 0);
}
if (mask & (1 << 1)) {
DPRINTF(("HEADPHONE "));
i2s_mute_headphone(sc, 0);
}
if (mask & (1 << 2)) {
DPRINTF(("LINEOUT "));
i2s_mute_lineout(sc, 0);
}
DPRINTF(("\n"));
sc->output_mask = mask;
mtx_unlock(&sc->port_mtx);
}
static void
i2s_postattach(void *xsc)
{
struct i2s_softc *sc = xsc;
device_t self;
int i;
self = sc->aoa.sc_dev;
/* Reset the codec. */
i2s_audio_hw_reset(sc);
/* If we have a codec, initialize it. */
if (i2s_mixer)
mixer_init(self, i2s_mixer_class, i2s_mixer);
/* Read initial port status. */
i2s_cint(sc);
/* Enable GPIO interrupt callback. */
for (i = 0; i < GPIO_CTRL_NUM; i++)
if (gpio_ctrls[i])
gpio_ctrls[i]->i2s = sc;
config_intrhook_disestablish(i2s_delayed_attach);
free(i2s_delayed_attach, M_TEMP);
}
Reference in New Issue View Git Blame Copy Permalink