sys/dev/sound/macio/i2s.c

   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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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