1 /*-
2 * SPDX-License-Identifier: BSD-2-Clause AND BSD-3-Clause
3 *
4 * Copyright 2008 by Marco Trillo. All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
20 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
21 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
22 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
23 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
24 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
25 * SUCH DAMAGE.
26 */
27 /*-
28 * Copyright (c) 2002, 2003 Tsubai Masanari. All rights reserved.
29 *
30 * Redistribution and use in source and binary forms, with or without
31 * modification, are permitted provided that the following conditions
32 * are met:
33 * 1. Redistributions of source code must retain the above copyright
34 * notice, this list of conditions and the following disclaimer.
35 * 2. Redistributions in binary form must reproduce the above copyright
36 * notice, this list of conditions and the following disclaimer in the
37 * documentation and/or other materials provided with the distribution.
38 * 3. The name of the author may not be used to endorse or promote products
39 * derived from this software without specific prior written permission.
40 *
41 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
42 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
43 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
44 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
45 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
46 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
47 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
48 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
49 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
50 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
51 *
52 * NetBSD: snapper.c,v 1.28 2008/05/16 03:49:54 macallan Exp
53 * Id: snapper.c,v 1.11 2002/10/31 17:42:13 tsubai Exp
54 */
55
56 /*
57 * Apple I2S audio controller.
58 */
59
60 #include <sys/param.h>
61 #include <sys/systm.h>
62 #include <sys/kernel.h>
63 #include <sys/module.h>
64 #include <sys/bus.h>
65 #include <sys/malloc.h>
66 #include <sys/lock.h>
67 #include <sys/mutex.h>
68 #include <machine/dbdma.h>
69 #include <machine/intr_machdep.h>
70 #include <machine/resource.h>
71 #include <machine/bus.h>
72 #include <machine/pio.h>
73 #include <sys/rman.h>
74 #include <dev/ofw/ofw_bus.h>
75
76 #ifdef HAVE_KERNEL_OPTION_HEADERS
77 #include "opt_snd.h"
78 #endif
79
80 #include <dev/sound/pcm/sound.h>
81 #include <dev/sound/macio/aoa.h>
82
83 #include <powerpc/powermac/macgpiovar.h>
84
85 struct i2s_softc {
86 struct aoa_softc aoa;
87 phandle_t node;
88 phandle_t soundnode;
89 struct resource *reg;
90 u_int output_mask;
91 struct mtx port_mtx;
92 };
93
94 static int i2s_probe(device_t);
95 static int i2s_attach(device_t);
96 static void i2s_postattach(void *);
97 static int i2s_setup(struct i2s_softc *, u_int, u_int, u_int);
98 static void i2s_mute_headphone (struct i2s_softc *, int);
99 static void i2s_mute_lineout (struct i2s_softc *, int);
100 static void i2s_mute_speaker (struct i2s_softc *, int);
101 static void i2s_set_outputs(void *, u_int);
102
103 static struct intr_config_hook *i2s_delayed_attach = NULL;
104
105 kobj_class_t i2s_mixer_class = NULL;
106 device_t i2s_mixer = NULL;
107
108 static device_method_t pcm_i2s_methods[] = {
109 /* Device interface. */
110 DEVMETHOD(device_probe, i2s_probe),
111 DEVMETHOD(device_attach, i2s_attach),
112 { 0, 0 }
113 };
114
115 static driver_t pcm_i2s_driver = {
116 "pcm",
117 pcm_i2s_methods,
118 PCM_SOFTC_SIZE
119 };
120
121 DRIVER_MODULE(pcm_i2s, macio, pcm_i2s_driver, 0, 0);
122 MODULE_DEPEND(pcm_i2s, sound, SOUND_MINVER, SOUND_PREFVER, SOUND_MAXVER);
123
124 static int aoagpio_probe(device_t);
125 static int aoagpio_attach(device_t);
126
127 static device_method_t aoagpio_methods[] = {
128 /* Device interface. */
129 DEVMETHOD(device_probe, aoagpio_probe),
130 DEVMETHOD(device_attach, aoagpio_attach),
131 { 0, 0 }
132 };
133
134 struct aoagpio_softc {
135 device_t dev;
136 int ctrl;
137 int detect_active; /* for extint-gpio */
138 int level; /* for extint-gpio */
139 struct i2s_softc *i2s; /* for extint-gpio */
140 };
141
142 static driver_t aoagpio_driver = {
143 "aoagpio",
144 aoagpio_methods,
145 sizeof(struct aoagpio_softc)
146 };
147
148 DRIVER_MODULE(aoagpio, macgpio, aoagpio_driver, 0, 0);
149
150 /*****************************************************************************
151 Probe and attachment routines.
152 *****************************************************************************/
153 static int
i2s_probe(device_t self)154 i2s_probe(device_t self)
155 {
156 const char *name;
157 phandle_t subchild;
158 char subchildname[255];
159
160 name = ofw_bus_get_name(self);
161 if (!name)
162 return (ENXIO);
163
164 if (strcmp(name, "i2s") != 0)
165 return (ENXIO);
166
167 /*
168 * Do not attach to "lightshow" I2S devices on Xserves. This controller
169 * is used there to control the LEDs on the front panel, and this
170 * driver can't handle it.
171 */
172 subchild = OF_child(OF_child(ofw_bus_get_node(self)));
173 if (subchild != 0 && OF_getprop(subchild, "name", subchildname,
174 sizeof(subchildname)) > 0 && strcmp(subchildname, "lightshow") == 0)
175 return (ENXIO);
176
177 device_set_desc(self, "Apple I2S Audio Controller");
178
179 return (0);
180 }
181
182 static phandle_t of_find_firstchild_byname(phandle_t, const char *);
183
184 static int
i2s_attach(device_t self)185 i2s_attach(device_t self)
186 {
187 struct i2s_softc *sc;
188 struct resource *dbdma_irq;
189 void *dbdma_ih;
190 int rid, oirq, err;
191 phandle_t port;
192
193 sc = malloc(sizeof(*sc), M_DEVBUF, M_WAITOK | M_ZERO);
194
195 sc->aoa.sc_dev = self;
196 sc->node = ofw_bus_get_node(self);
197
198 port = of_find_firstchild_byname(sc->node, "i2s-a");
199 if (port == -1)
200 return (ENXIO);
201 sc->soundnode = of_find_firstchild_byname(port, "sound");
202 if (sc->soundnode == -1)
203 return (ENXIO);
204
205 mtx_init(&sc->port_mtx, "port_mtx", NULL, MTX_DEF);
206
207 /* Map the controller register space. */
208 rid = 0;
209 sc->reg = bus_alloc_resource_any(self, SYS_RES_MEMORY, &rid, RF_ACTIVE);
210 if (sc->reg == NULL)
211 return ENXIO;
212
213 /* Map the DBDMA channel register space. */
214 rid = 1;
215 sc->aoa.sc_odma = bus_alloc_resource_any(self, SYS_RES_MEMORY, &rid,
216 RF_ACTIVE);
217 if (sc->aoa.sc_odma == NULL)
218 return ENXIO;
219
220 /* Establish the DBDMA channel edge-triggered interrupt. */
221 rid = 1;
222 dbdma_irq = bus_alloc_resource_any(self, SYS_RES_IRQ,
223 &rid, RF_SHAREABLE | RF_ACTIVE);
224 if (dbdma_irq == NULL)
225 return (ENXIO);
226
227 /* Now initialize the controller. */
228 err = i2s_setup(sc, 44100, 16, 64);
229 if (err != 0)
230 return (err);
231
232 snd_setup_intr(self, dbdma_irq, INTR_MPSAFE, aoa_interrupt,
233 sc, &dbdma_ih);
234
235 oirq = rman_get_start(dbdma_irq);
236 err = powerpc_config_intr(oirq, INTR_TRIGGER_EDGE, INTR_POLARITY_LOW);
237 if (err != 0)
238 return (err);
239
240 /*
241 * Register a hook for delayed attach in order to allow
242 * the I2C controller to attach.
243 */
244 if ((i2s_delayed_attach = malloc(sizeof(struct intr_config_hook),
245 M_TEMP, M_WAITOK | M_ZERO)) == NULL)
246 return (ENOMEM);
247
248 i2s_delayed_attach->ich_func = i2s_postattach;
249 i2s_delayed_attach->ich_arg = sc;
250
251 if (config_intrhook_establish(i2s_delayed_attach) != 0)
252 return (ENOMEM);
253
254 return (aoa_attach(sc));
255 }
256
257 /*****************************************************************************
258 GPIO routines.
259 *****************************************************************************/
260
261 enum gpio_ctrl {
262 AMP_MUTE,
263 HEADPHONE_MUTE,
264 LINEOUT_MUTE,
265 AUDIO_HW_RESET,
266 HEADPHONE_DETECT,
267 LINEOUT_DETECT,
268 GPIO_CTRL_NUM
269 };
270
271 #define GPIO_CTRL_EXTINT_SET \
272 ((1 << HEADPHONE_DETECT) | \
273 (1 << LINEOUT_DETECT))
274
275 static struct aoagpio_softc *gpio_ctrls[GPIO_CTRL_NUM] =
276 {NULL, NULL, NULL, NULL, NULL, NULL};
277
278 static struct gpio_match {
279 const char *name;
280 enum gpio_ctrl ctrl;
281 } gpio_controls[] = {
282 {"headphone-mute", HEADPHONE_MUTE},
283 {"lineout-mute", LINEOUT_MUTE},
284 {"amp-mute", AMP_MUTE},
285 {"headphone-detect", HEADPHONE_DETECT},
286 {"lineout-detect", LINEOUT_DETECT},
287 {"line-output-detect", LINEOUT_DETECT},
288 {"audio-hw-reset", AUDIO_HW_RESET},
289 {"hw-reset", AUDIO_HW_RESET},
290 {NULL, GPIO_CTRL_NUM}
291 };
292
293 static void i2s_cint(struct i2s_softc *);
294
295 static void
aoagpio_int(void * cookie)296 aoagpio_int(void *cookie)
297 {
298 device_t self = cookie;
299 struct aoagpio_softc *sc;
300
301 sc = device_get_softc(self);
302
303 if (macgpio_read(self) & GPIO_LEVEL_RO)
304 sc->level = sc->detect_active;
305 else
306 sc->level = !(sc->detect_active);
307
308 if (sc->i2s)
309 i2s_cint(sc->i2s);
310 }
311
312 static int
aoagpio_probe(device_t gpio)313 aoagpio_probe(device_t gpio)
314 {
315 phandle_t node;
316 char bname[32];
317 const char *name;
318 struct gpio_match *m;
319 struct aoagpio_softc *sc;
320
321 node = ofw_bus_get_node(gpio);
322 if (node == 0 || node == -1)
323 return (EINVAL);
324
325 bzero(bname, sizeof(bname));
326 if (OF_getprop(node, "audio-gpio", bname, sizeof(bname)) > 2)
327 name = bname;
328 else
329 name = ofw_bus_get_name(gpio);
330
331 /* Try to find a match. */
332 for (m = gpio_controls; m->name != NULL; m++) {
333 if (strcmp(name, m->name) == 0) {
334 sc = device_get_softc(gpio);
335 gpio_ctrls[m->ctrl] = sc;
336 sc->dev = gpio;
337 sc->ctrl = m->ctrl;
338 sc->level = 0;
339 sc->detect_active = 0;
340 sc->i2s = NULL;
341
342 OF_getprop(node, "audio-gpio-active-state",
343 &sc->detect_active, sizeof(sc->detect_active));
344
345 if ((1 << m->ctrl) & GPIO_CTRL_EXTINT_SET)
346 aoagpio_int(gpio);
347
348 device_set_desc(gpio, m->name);
349 device_quiet(gpio);
350 return (0);
351 }
352 }
353
354 return (ENXIO);
355 }
356
357 static int
aoagpio_attach(device_t gpio)358 aoagpio_attach(device_t gpio)
359 {
360 struct aoagpio_softc *sc;
361 struct resource *r;
362 void *cookie;
363 int irq, rid = 0;
364
365 sc = device_get_softc(gpio);
366
367 if ((1 << sc->ctrl) & GPIO_CTRL_EXTINT_SET) {
368 r = bus_alloc_resource_any(gpio, SYS_RES_IRQ, &rid, RF_ACTIVE);
369 if (r == NULL)
370 return (ENXIO);
371
372 irq = rman_get_start(r);
373 DPRINTF(("interrupting at irq %d\n", irq));
374
375 if (powerpc_config_intr(irq, INTR_TRIGGER_EDGE,
376 INTR_POLARITY_LOW) != 0)
377 return (ENXIO);
378
379 bus_setup_intr(gpio, r, INTR_TYPE_MISC | INTR_MPSAFE |
380 INTR_ENTROPY, NULL, aoagpio_int, gpio, &cookie);
381 }
382
383 return (0);
384 }
385
386 /*
387 * I2S module registers
388 */
389 #define I2S_INT 0x00
390 #define I2S_FORMAT 0x10
391 #define I2S_FRAMECOUNT 0x40
392 #define I2S_FRAMEMATCH 0x50
393 #define I2S_WORDSIZE 0x60
394
395 /* I2S_INT register definitions */
396 #define I2S_INT_CLKSTOPPEND 0x01000000 /* clock-stop interrupt pending */
397
398 /* I2S_FORMAT register definitions */
399 #define CLKSRC_49MHz 0x80000000 /* Use 49152000Hz Osc. */
400 #define CLKSRC_45MHz 0x40000000 /* Use 45158400Hz Osc. */
401 #define CLKSRC_18MHz 0x00000000 /* Use 18432000Hz Osc. */
402 #define MCLK_DIV_MASK 0x1f000000 /* MCLK = SRC / DIV */
403 #define SCLK_DIV_MASK 0x00f00000 /* SCLK = MCLK / DIV */
404 #define SCLK_MASTER 0x00080000 /* Master mode */
405 #define SCLK_SLAVE 0x00000000 /* Slave mode */
406 #define SERIAL_FORMAT 0x00070000
407 #define SERIAL_SONY 0x00000000
408 #define SERIAL_64x 0x00010000
409 #define SERIAL_32x 0x00020000
410 #define SERIAL_DAV 0x00040000
411 #define SERIAL_SILICON 0x00050000
412
413 /* I2S_WORDSIZE register definitions */
414 #define INPUT_STEREO (2 << 24)
415 #define INPUT_MONO (1 << 24)
416 #define INPUT_16BIT (0 << 16)
417 #define INPUT_24BIT (3 << 16)
418 #define OUTPUT_STEREO (2 << 8)
419 #define OUTPUT_MONO (1 << 8)
420 #define OUTPUT_16BIT (0 << 0)
421 #define OUTPUT_24BIT (3 << 0)
422
423 /* Master clock, needed by some codecs. We hardcode this
424 to 256 * fs as this is valid for most codecs. */
425 #define MCLK_FS 256
426
427 /* Number of clock sources we can use. */
428 #define NCLKS 3
429 static const struct i2s_clksrc {
430 u_int cs_clock;
431 u_int cs_reg;
432 } clksrc[NCLKS] = {
433 {49152000, CLKSRC_49MHz},
434 {45158400, CLKSRC_45MHz},
435 {18432000, CLKSRC_18MHz}
436 };
437
438 /* Configure the I2S controller for the required settings.
439 'rate' is the frame rate.
440 'wordsize' is the sample size (usually 16 bits).
441 'sclk_fs' is the SCLK/framerate ratio, which needs to be equal
442 or greater to the number of bits per frame. */
443
444 static int
i2s_setup(struct i2s_softc * sc,u_int rate,u_int wordsize,u_int sclk_fs)445 i2s_setup(struct i2s_softc *sc, u_int rate, u_int wordsize, u_int sclk_fs)
446 {
447 u_int mclk, mdiv, sdiv;
448 u_int reg = 0, x, wordformat;
449 u_int i;
450
451 /* Make sure the settings are consistent... */
452 if ((wordsize * 2) > sclk_fs)
453 return (EINVAL);
454
455 if (sclk_fs != 32 && sclk_fs != 64)
456 return (EINVAL);
457
458 /*
459 * Find a clock source to derive the master clock (MCLK)
460 * and the I2S bit block (SCLK) and set the divisors as
461 * appropriate.
462 */
463 mclk = rate * MCLK_FS;
464 sdiv = MCLK_FS / sclk_fs;
465
466 for (i = 0; i < NCLKS; ++i) {
467 if ((clksrc[i].cs_clock % mclk) == 0) {
468 reg = clksrc[i].cs_reg;
469 mdiv = clksrc[i].cs_clock / mclk;
470 break;
471 }
472 }
473 if (reg == 0)
474 return (EINVAL);
475
476 switch (mdiv) {
477 /* exception cases */
478 case 1:
479 x = 14;
480 break;
481 case 3:
482 x = 13;
483 break;
484 case 5:
485 x = 12;
486 break;
487 default:
488 x = (mdiv / 2) - 1;
489 break;
490 }
491 reg |= (x << 24) & MCLK_DIV_MASK;
492
493 switch (sdiv) {
494 case 1:
495 x = 8;
496 break;
497 case 3:
498 x = 9;
499 break;
500 default:
501 x = (sdiv / 2) - 1;
502 break;
503 }
504 reg |= (x << 20) & SCLK_DIV_MASK;
505
506 /*
507 * XXX use master mode for now. This needs to be
508 * revisited if we want to add recording from SPDIF some day.
509 */
510 reg |= SCLK_MASTER;
511
512 switch (sclk_fs) {
513 case 64:
514 reg |= SERIAL_64x;
515 break;
516 case 32:
517 reg |= SERIAL_32x;
518 break;
519 }
520
521 /* stereo input and output */
522 wordformat = INPUT_STEREO | OUTPUT_STEREO;
523
524 switch (wordsize) {
525 case 16:
526 wordformat |= INPUT_16BIT | OUTPUT_16BIT;
527 break;
528 case 24:
529 wordformat |= INPUT_24BIT | OUTPUT_24BIT;
530 break;
531 default:
532 return (EINVAL);
533 }
534
535 x = bus_read_4(sc->reg, I2S_WORDSIZE);
536 if (x != wordformat)
537 bus_write_4(sc->reg, I2S_WORDSIZE, wordformat);
538
539 x = bus_read_4(sc->reg, I2S_FORMAT);
540 if (x != reg) {
541 /*
542 * XXX to change the format we need to stop the clock
543 * via the FCR registers. For now, rely on the firmware
544 * to set sane defaults (44100).
545 */
546 printf("i2s_setup: changing format not supported yet.\n");
547 return (ENOTSUP);
548
549 #ifdef notyet
550 if (obio_fcr_isset(OBIO_FCR1, I2S0CLKEN)) {
551
552 bus_space_write_4(sc->sc_tag, sc->sc_bsh, I2S_INT,
553 I2S_INT_CLKSTOPPEND);
554
555 obio_fcr_clear(OBIO_FCR1, I2S0CLKEN);
556
557 for (timo = 1000; timo > 0; timo--) {
558 if (bus_space_read_4(sc->sc_tag, sc->sc_bsh,
559 I2S_INT) & I2S_INT_CLKSTOPPEND)
560 break;
561
562 DELAY(10);
563 }
564
565 if (timo == 0)
566 printf("%s: timeout waiting for clock to stop\n",
567 sc->sc_dev.dv_xname);
568 }
569
570 bus_space_write_4(sc->sc_tag, sc->sc_bsh, I2S_FORMAT, reg);
571
572 obio_fcr_set(OBIO_FCR1, I2S0CLKEN);
573 #endif
574 }
575
576 return (0);
577 }
578
579 /* XXX this does not belong here. */
580 static phandle_t
of_find_firstchild_byname(phandle_t node,const char * req_name)581 of_find_firstchild_byname(phandle_t node, const char *req_name)
582 {
583 char name[32]; /* max name len per OF spec. */
584 phandle_t n;
585
586 for (n = OF_child(node); n != -1; n = OF_peer(n)) {
587 bzero(name, sizeof(name));
588 OF_getprop(n, "name", name, sizeof(name));
589
590 if (strcmp(name, req_name) == 0)
591 return (n);
592 }
593
594 return (-1);
595 }
596
597 static u_int
gpio_read(enum gpio_ctrl ctrl)598 gpio_read(enum gpio_ctrl ctrl)
599 {
600 struct aoagpio_softc *sc;
601
602 if ((sc = gpio_ctrls[ctrl]) == NULL)
603 return (0);
604
605 return (macgpio_read(sc->dev) & GPIO_DATA);
606 }
607
608 static void
gpio_write(enum gpio_ctrl ctrl,u_int x)609 gpio_write(enum gpio_ctrl ctrl, u_int x)
610 {
611 struct aoagpio_softc *sc;
612 u_int reg;
613
614 if ((sc = gpio_ctrls[ctrl]) == NULL)
615 return;
616
617 reg = GPIO_DDR_OUTPUT;
618 if (x)
619 reg |= GPIO_DATA;
620
621 macgpio_write(sc->dev, reg);
622 }
623
624 static void
i2s_cint(struct i2s_softc * sc)625 i2s_cint(struct i2s_softc *sc)
626 {
627 u_int mask = 0;
628
629 if (gpio_ctrls[HEADPHONE_DETECT] &&
630 gpio_ctrls[HEADPHONE_DETECT]->level)
631 mask |= 1 << 1;
632
633 if (gpio_ctrls[LINEOUT_DETECT] &&
634 gpio_ctrls[LINEOUT_DETECT]->level)
635 mask |= 1 << 2;
636
637 if (mask == 0)
638 mask = 1 << 0; /* fall back to speakers. */
639
640 i2s_set_outputs(sc, mask);
641 }
642
643 #define reset_active 0
644
645 /* these values are in microseconds */
646 #define RESET_SETUP_TIME 5000
647 #define RESET_HOLD_TIME 20000
648 #define RESET_RELEASE_TIME 10000
649
650 static void
i2s_audio_hw_reset(struct i2s_softc * sc)651 i2s_audio_hw_reset(struct i2s_softc *sc)
652 {
653 if (gpio_ctrls[AUDIO_HW_RESET]) {
654 DPRINTF(("resetting codec\n"));
655
656 gpio_write(AUDIO_HW_RESET, !reset_active); /* Negate RESET */
657 DELAY(RESET_SETUP_TIME);
658
659 gpio_write(AUDIO_HW_RESET, reset_active); /* Assert RESET */
660 DELAY(RESET_HOLD_TIME);
661
662 gpio_write(AUDIO_HW_RESET, !reset_active); /* Negate RESET */
663 DELAY(RESET_RELEASE_TIME);
664
665 } else {
666 DPRINTF(("no audio_hw_reset\n"));
667 }
668 }
669
670 #define AMP_ACTIVE 0 /* XXX OF */
671 #define HEADPHONE_ACTIVE 0 /* XXX OF */
672 #define LINEOUT_ACTIVE 0 /* XXX OF */
673
674 #define MUTE_CONTROL(xxx, yyy) \
675 static void \
676 i2s_mute_##xxx(struct i2s_softc *sc, int mute) \
677 { \
678 int x; \
679 \
680 if (gpio_ctrls[yyy##_MUTE] == NULL) \
681 return; \
682 if (mute) \
683 x = yyy##_ACTIVE; \
684 else \
685 x = ! yyy##_ACTIVE; \
686 \
687 if (x != gpio_read(yyy##_MUTE)) \
688 gpio_write(yyy##_MUTE, x); \
689 }
690
MUTE_CONTROL(speaker,AMP)691 MUTE_CONTROL(speaker, AMP)
692 MUTE_CONTROL(headphone, HEADPHONE)
693 MUTE_CONTROL(lineout, LINEOUT)
694
695 static void
696 i2s_set_outputs(void *ptr, u_int mask)
697 {
698 struct i2s_softc *sc = ptr;
699
700 if (mask == sc->output_mask)
701 return;
702
703 mtx_lock(&sc->port_mtx);
704
705 i2s_mute_speaker(sc, 1);
706 i2s_mute_headphone(sc, 1);
707 i2s_mute_lineout(sc, 1);
708
709 DPRINTF(("enabled outputs: "));
710
711 if (mask & (1 << 0)) {
712 DPRINTF(("SPEAKER "));
713 i2s_mute_speaker(sc, 0);
714 }
715 if (mask & (1 << 1)) {
716 DPRINTF(("HEADPHONE "));
717 i2s_mute_headphone(sc, 0);
718 }
719 if (mask & (1 << 2)) {
720 DPRINTF(("LINEOUT "));
721 i2s_mute_lineout(sc, 0);
722 }
723
724 DPRINTF(("\n"));
725 sc->output_mask = mask;
726
727 mtx_unlock(&sc->port_mtx);
728 }
729
730 static void
i2s_postattach(void * xsc)731 i2s_postattach(void *xsc)
732 {
733 struct i2s_softc *sc = xsc;
734 device_t self;
735 int i;
736
737 self = sc->aoa.sc_dev;
738
739 /* Reset the codec. */
740 i2s_audio_hw_reset(sc);
741
742 /* If we have a codec, initialize it. */
743 if (i2s_mixer)
744 mixer_init(self, i2s_mixer_class, i2s_mixer);
745
746 /* Read initial port status. */
747 i2s_cint(sc);
748
749 /* Enable GPIO interrupt callback. */
750 for (i = 0; i < GPIO_CTRL_NUM; i++)
751 if (gpio_ctrls[i])
752 gpio_ctrls[i]->i2s = sc;
753
754 config_intrhook_disestablish(i2s_delayed_attach);
755 free(i2s_delayed_attach, M_TEMP);
756 }
757