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