1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 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 /* 31 * Apple DAVbus audio controller. 32 */ 33 34 #include <sys/param.h> 35 #include <sys/systm.h> 36 #include <sys/bus.h> 37 #include <sys/kernel.h> 38 #include <sys/lock.h> 39 #include <sys/malloc.h> 40 #include <sys/module.h> 41 #include <sys/mutex.h> 42 #include <sys/rman.h> 43 44 #include <dev/ofw/ofw_bus.h> 45 46 #ifdef HAVE_KERNEL_OPTION_HEADERS 47 #include "opt_snd.h" 48 #endif 49 50 #include <dev/sound/pcm/sound.h> 51 52 #include <dev/sound/macio/aoa.h> 53 #include <dev/sound/macio/davbusreg.h> 54 55 #include <machine/intr_machdep.h> 56 #include <machine/resource.h> 57 #include <machine/bus.h> 58 59 #include "mixer_if.h" 60 61 struct davbus_softc { 62 struct aoa_softc aoa; 63 phandle_t node; 64 phandle_t soundnode; 65 struct resource *reg; 66 struct mtx mutex; 67 int device_id; 68 u_int output_mask; 69 u_int (*read_status)(struct davbus_softc *, u_int); 70 void (*set_outputs)(struct davbus_softc *, u_int); 71 }; 72 73 static int davbus_probe(device_t); 74 static int davbus_attach(device_t); 75 static void davbus_cint(void *); 76 77 static device_method_t pcm_davbus_methods[] = { 78 /* Device interface. */ 79 DEVMETHOD(device_probe, davbus_probe), 80 DEVMETHOD(device_attach, davbus_attach), 81 { 0, 0 } 82 }; 83 84 static driver_t pcm_davbus_driver = { 85 "pcm", 86 pcm_davbus_methods, 87 PCM_SOFTC_SIZE 88 }; 89 90 DRIVER_MODULE(pcm_davbus, macio, pcm_davbus_driver, pcm_devclass, 0, 0); 91 MODULE_DEPEND(pcm_davbus, sound, SOUND_MINVER, SOUND_PREFVER, SOUND_MAXVER); 92 93 /***************************************************************************** 94 Probe and attachment routines. 95 *****************************************************************************/ 96 static int 97 davbus_probe(device_t self) 98 { 99 const char *name; 100 101 name = ofw_bus_get_name(self); 102 if (!name) 103 return (ENXIO); 104 105 if (strcmp(name, "davbus") != 0) 106 return (ENXIO); 107 108 device_set_desc(self, "Apple DAVBus Audio Controller"); 109 110 return (0); 111 } 112 113 /* 114 * Burgundy codec control 115 */ 116 117 static int burgundy_init(struct snd_mixer *m); 118 static int burgundy_uninit(struct snd_mixer *m); 119 static int burgundy_reinit(struct snd_mixer *m); 120 static void burgundy_write_locked(struct davbus_softc *, u_int, u_int); 121 static void burgundy_set_outputs(struct davbus_softc *d, u_int mask); 122 static u_int burgundy_read_status(struct davbus_softc *d, u_int status); 123 static int burgundy_set(struct snd_mixer *m, unsigned dev, unsigned left, 124 unsigned right); 125 static u_int32_t burgundy_setrecsrc(struct snd_mixer *m, u_int32_t src); 126 127 static kobj_method_t burgundy_mixer_methods[] = { 128 KOBJMETHOD(mixer_init, burgundy_init), 129 KOBJMETHOD(mixer_uninit, burgundy_uninit), 130 KOBJMETHOD(mixer_reinit, burgundy_reinit), 131 KOBJMETHOD(mixer_set, burgundy_set), 132 KOBJMETHOD(mixer_setrecsrc, burgundy_setrecsrc), 133 KOBJMETHOD_END 134 }; 135 136 MIXER_DECLARE(burgundy_mixer); 137 138 static int 139 burgundy_init(struct snd_mixer *m) 140 { 141 struct davbus_softc *d; 142 143 d = mix_getdevinfo(m); 144 145 d->read_status = burgundy_read_status; 146 d->set_outputs = burgundy_set_outputs; 147 148 /* 149 * We configure the Burgundy codec as follows: 150 * 151 * o Input subframe 0 is connected to input digital 152 * stream A (ISA). 153 * o Stream A (ISA) is mixed in mixer 2 (MIX2). 154 * o Output of mixer 2 (MIX2) is routed to output sources 155 * OS0 and OS1 which can be converted to analog. 156 * 157 */ 158 mtx_lock(&d->mutex); 159 160 burgundy_write_locked(d, 0x16700, 0x40); 161 162 burgundy_write_locked(d, BURGUNDY_MIX0_REG, 0); 163 burgundy_write_locked(d, BURGUNDY_MIX1_REG, 0); 164 burgundy_write_locked(d, BURGUNDY_MIX2_REG, BURGUNDY_MIX_ISA); 165 burgundy_write_locked(d, BURGUNDY_MIX3_REG, 0); 166 167 burgundy_write_locked(d, BURGUNDY_OS_REG, BURGUNDY_OS0_MIX2 | 168 BURGUNDY_OS1_MIX2); 169 170 burgundy_write_locked(d, BURGUNDY_SDIN_REG, BURGUNDY_ISA_SF0); 171 172 /* Set several digital scalers to unity gain. */ 173 burgundy_write_locked(d, BURGUNDY_MXS2L_REG, BURGUNDY_MXS_UNITY); 174 burgundy_write_locked(d, BURGUNDY_MXS2R_REG, BURGUNDY_MXS_UNITY); 175 burgundy_write_locked(d, BURGUNDY_OSS0L_REG, BURGUNDY_OSS_UNITY); 176 burgundy_write_locked(d, BURGUNDY_OSS0R_REG, BURGUNDY_OSS_UNITY); 177 burgundy_write_locked(d, BURGUNDY_OSS1L_REG, BURGUNDY_OSS_UNITY); 178 burgundy_write_locked(d, BURGUNDY_OSS1R_REG, BURGUNDY_OSS_UNITY); 179 burgundy_write_locked(d, BURGUNDY_ISSAL_REG, BURGUNDY_ISS_UNITY); 180 burgundy_write_locked(d, BURGUNDY_ISSAR_REG, BURGUNDY_ISS_UNITY); 181 182 burgundy_set_outputs(d, burgundy_read_status(d, 183 bus_read_4(d->reg, DAVBUS_CODEC_STATUS))); 184 185 mtx_unlock(&d->mutex); 186 187 mix_setdevs(m, SOUND_MASK_VOLUME); 188 189 return (0); 190 } 191 192 static int 193 burgundy_uninit(struct snd_mixer *m) 194 { 195 return (0); 196 } 197 198 static int 199 burgundy_reinit(struct snd_mixer *m) 200 { 201 return (0); 202 } 203 204 static void 205 burgundy_write_locked(struct davbus_softc *d, u_int reg, u_int val) 206 { 207 u_int size, addr, offset, data, i; 208 209 size = (reg & 0x00FF0000) >> 16; 210 addr = (reg & 0x0000FF00) >> 8; 211 offset = reg & 0xFF; 212 213 for (i = offset; i < offset + size; ++i) { 214 data = BURGUNDY_CTRL_WRITE | (addr << 12) | 215 ((size + offset - 1) << 10) | (i << 8) | (val & 0xFF); 216 if (i == offset) 217 data |= BURGUNDY_CTRL_RESET; 218 219 bus_write_4(d->reg, DAVBUS_CODEC_CTRL, data); 220 221 while (bus_read_4(d->reg, DAVBUS_CODEC_CTRL) & 222 DAVBUS_CODEC_BUSY) 223 DELAY(1); 224 225 val >>= 8; /* next byte. */ 226 } 227 } 228 229 /* Must be called with d->mutex held. */ 230 static void 231 burgundy_set_outputs(struct davbus_softc *d, u_int mask) 232 { 233 u_int x = 0; 234 235 if (mask == d->output_mask) 236 return; 237 238 /* 239 * Bordeaux card wirings: 240 * Port 15: RCA out 241 * Port 16: Minijack out 242 * Port 17: Internal speaker 243 * 244 * B&W G3 wirings: 245 * Port 14: Minijack out 246 * Port 17: Internal speaker 247 */ 248 249 DPRINTF(("Enabled outputs:")); 250 if (mask & (1 << 0)) { 251 DPRINTF((" SPEAKER")); 252 x |= BURGUNDY_P17M_EN; 253 } 254 if (mask & (1 << 1)) { 255 DPRINTF((" HEADPHONES")); 256 x |= BURGUNDY_P14L_EN | BURGUNDY_P14R_EN; 257 } 258 DPRINTF(("\n")); 259 260 burgundy_write_locked(d, BURGUNDY_MUTE_REG, x); 261 d->output_mask = mask; 262 } 263 264 static u_int 265 burgundy_read_status(struct davbus_softc *d, u_int status) 266 { 267 if (status & 0x4) 268 return (1 << 1); 269 else 270 return (1 << 0); 271 } 272 273 static int 274 burgundy_set(struct snd_mixer *m, unsigned dev, unsigned left, unsigned right) 275 { 276 struct davbus_softc *d; 277 int lval, rval; 278 279 lval = ((100 - left) * 15 / 100) & 0xf; 280 rval = ((100 - right) * 15 / 100) & 0xf; 281 DPRINTF(("volume %d %d\n", lval, rval)); 282 283 d = mix_getdevinfo(m); 284 285 switch (dev) { 286 case SOUND_MIXER_VOLUME: 287 mtx_lock(&d->mutex); 288 289 burgundy_write_locked(d, BURGUNDY_OL13_REG, lval); 290 burgundy_write_locked(d, BURGUNDY_OL14_REG, (rval << 4) | lval); 291 burgundy_write_locked(d, BURGUNDY_OL15_REG, (rval << 4) | lval); 292 burgundy_write_locked(d, BURGUNDY_OL16_REG, (rval << 4) | lval); 293 burgundy_write_locked(d, BURGUNDY_OL17_REG, lval); 294 295 mtx_unlock(&d->mutex); 296 297 return (left | (right << 8)); 298 } 299 300 return (0); 301 } 302 303 static u_int32_t 304 burgundy_setrecsrc(struct snd_mixer *m, u_int32_t src) 305 { 306 return (0); 307 } 308 309 /* 310 * Screamer Codec Control 311 */ 312 313 static int screamer_init(struct snd_mixer *m); 314 static int screamer_uninit(struct snd_mixer *m); 315 static int screamer_reinit(struct snd_mixer *m); 316 static void screamer_write_locked(struct davbus_softc *, u_int, u_int); 317 static void screamer_set_outputs(struct davbus_softc *d, u_int mask); 318 static u_int screamer_read_status(struct davbus_softc *d, u_int status); 319 static int screamer_set(struct snd_mixer *m, unsigned dev, unsigned left, 320 unsigned right); 321 static u_int32_t screamer_setrecsrc(struct snd_mixer *m, u_int32_t src); 322 323 static kobj_method_t screamer_mixer_methods[] = { 324 KOBJMETHOD(mixer_init, screamer_init), 325 KOBJMETHOD(mixer_uninit, screamer_uninit), 326 KOBJMETHOD(mixer_reinit, screamer_reinit), 327 KOBJMETHOD(mixer_set, screamer_set), 328 KOBJMETHOD(mixer_setrecsrc, screamer_setrecsrc), 329 KOBJMETHOD_END 330 }; 331 332 MIXER_DECLARE(screamer_mixer); 333 334 static int 335 screamer_init(struct snd_mixer *m) 336 { 337 struct davbus_softc *d; 338 339 d = mix_getdevinfo(m); 340 341 d->read_status = screamer_read_status; 342 d->set_outputs = screamer_set_outputs; 343 344 mtx_lock(&d->mutex); 345 346 screamer_write_locked(d, SCREAMER_CODEC_ADDR0, SCREAMER_INPUT_CD | 347 SCREAMER_DEFAULT_CD_GAIN); 348 349 screamer_set_outputs(d, screamer_read_status(d, 350 bus_read_4(d->reg, DAVBUS_CODEC_STATUS))); 351 352 screamer_write_locked(d, SCREAMER_CODEC_ADDR2, 0); 353 screamer_write_locked(d, SCREAMER_CODEC_ADDR4, 0); 354 screamer_write_locked(d, SCREAMER_CODEC_ADDR5, 0); 355 screamer_write_locked(d, SCREAMER_CODEC_ADDR6, 0); 356 357 mtx_unlock(&d->mutex); 358 359 mix_setdevs(m, SOUND_MASK_VOLUME); 360 361 return (0); 362 } 363 364 static int 365 screamer_uninit(struct snd_mixer *m) 366 { 367 return (0); 368 } 369 370 static int 371 screamer_reinit(struct snd_mixer *m) 372 { 373 return (0); 374 } 375 376 static void 377 screamer_write_locked(struct davbus_softc *d, u_int reg, u_int val) 378 { 379 u_int x; 380 381 KASSERT(val == (val & 0xfff), ("bad val")); 382 383 while (bus_read_4(d->reg, DAVBUS_CODEC_CTRL) & DAVBUS_CODEC_BUSY) 384 DELAY(100); 385 386 x = reg; 387 x |= SCREAMER_CODEC_EMSEL0; 388 x |= val; 389 bus_write_4(d->reg, DAVBUS_CODEC_CTRL, x); 390 391 while (bus_read_4(d->reg, DAVBUS_CODEC_CTRL) & DAVBUS_CODEC_BUSY) 392 DELAY(100); 393 } 394 395 /* Must be called with d->mutex held. */ 396 static void 397 screamer_set_outputs(struct davbus_softc *d, u_int mask) 398 { 399 u_int x; 400 401 if (mask == d->output_mask) { 402 return; 403 } 404 405 x = SCREAMER_MUTE_SPEAKER | SCREAMER_MUTE_HEADPHONES; 406 407 DPRINTF(("Enabled outputs: ")); 408 409 if (mask & (1 << 0)) { 410 DPRINTF(("SPEAKER ")); 411 x &= ~SCREAMER_MUTE_SPEAKER; 412 } 413 if (mask & (1 << 1)) { 414 DPRINTF(("HEADPHONES ")); 415 x &= ~SCREAMER_MUTE_HEADPHONES; 416 } 417 418 DPRINTF(("\n")); 419 420 if (d->device_id == 5 || d->device_id == 11) { 421 DPRINTF(("Enabling programmable output.\n")); 422 x |= SCREAMER_PROG_OUTPUT0; 423 } 424 if (d->device_id == 8 || d->device_id == 11) { 425 x &= ~SCREAMER_MUTE_SPEAKER; 426 427 if (mask & (1 << 0)) 428 x |= SCREAMER_PROG_OUTPUT1; /* enable speaker. */ 429 } 430 431 screamer_write_locked(d, SCREAMER_CODEC_ADDR1, x); 432 d->output_mask = mask; 433 } 434 435 static u_int 436 screamer_read_status(struct davbus_softc *d, u_int status) 437 { 438 int headphones; 439 440 switch (d->device_id) { 441 case 5: /* Sawtooth */ 442 headphones = (status & 0x4); 443 break; 444 445 case 8: 446 case 11: /* iMac DV */ 447 /* The iMac DV has 2 headphone outputs. */ 448 headphones = (status & 0x7); 449 break; 450 451 default: 452 headphones = (status & 0x8); 453 } 454 455 if (headphones) 456 return (1 << 1); 457 else 458 return (1 << 0); 459 } 460 461 static int 462 screamer_set(struct snd_mixer *m, unsigned dev, unsigned left, unsigned right) 463 { 464 struct davbus_softc *d; 465 int lval, rval; 466 467 lval = ((100 - left) * 15 / 100) & 0xf; 468 rval = ((100 - right) * 15 / 100) & 0xf; 469 DPRINTF(("volume %d %d\n", lval, rval)); 470 471 d = mix_getdevinfo(m); 472 473 switch (dev) { 474 case SOUND_MIXER_VOLUME: 475 mtx_lock(&d->mutex); 476 screamer_write_locked(d, SCREAMER_CODEC_ADDR2, (lval << 6) | 477 rval); 478 screamer_write_locked(d, SCREAMER_CODEC_ADDR4, (lval << 6) | 479 rval); 480 mtx_unlock(&d->mutex); 481 482 return (left | (right << 8)); 483 } 484 485 return (0); 486 } 487 488 static u_int32_t 489 screamer_setrecsrc(struct snd_mixer *m, u_int32_t src) 490 { 491 return (0); 492 } 493 494 static int 495 davbus_attach(device_t self) 496 { 497 struct davbus_softc *sc; 498 struct resource *dbdma_irq, *cintr; 499 void *cookie; 500 char compat[64]; 501 int rid, oirq, err; 502 503 sc = malloc(sizeof(*sc), M_DEVBUF, M_WAITOK | M_ZERO); 504 505 sc->aoa.sc_dev = self; 506 sc->node = ofw_bus_get_node(self); 507 sc->soundnode = OF_child(sc->node); 508 509 /* Map the controller register space. */ 510 rid = 0; 511 sc->reg = bus_alloc_resource_any(self, SYS_RES_MEMORY, &rid, RF_ACTIVE); 512 if (sc->reg == NULL) 513 return (ENXIO); 514 515 /* Map the DBDMA channel register space. */ 516 rid = 1; 517 sc->aoa.sc_odma = bus_alloc_resource_any(self, SYS_RES_MEMORY, 518 &rid, RF_ACTIVE); 519 if (sc->aoa.sc_odma == NULL) 520 return (ENXIO); 521 522 /* Establish the DBDMA channel edge-triggered interrupt. */ 523 rid = 1; 524 dbdma_irq = bus_alloc_resource_any(self, SYS_RES_IRQ, 525 &rid, RF_SHAREABLE | RF_ACTIVE); 526 if (dbdma_irq == NULL) 527 return (ENXIO); 528 529 oirq = rman_get_start(dbdma_irq); 530 531 DPRINTF(("interrupting at irq %d\n", oirq)); 532 533 err = powerpc_config_intr(oirq, INTR_TRIGGER_EDGE, INTR_POLARITY_LOW); 534 if (err != 0) 535 return (err); 536 537 snd_setup_intr(self, dbdma_irq, INTR_MPSAFE, aoa_interrupt, 538 sc, &cookie); 539 540 /* Now initialize the controller. */ 541 542 bzero(compat, sizeof(compat)); 543 OF_getprop(sc->soundnode, "compatible", compat, sizeof(compat)); 544 OF_getprop(sc->soundnode, "device-id", &sc->device_id, sizeof(u_int)); 545 546 mtx_init(&sc->mutex, "DAVbus", NULL, MTX_DEF); 547 548 device_printf(self, "codec: <%s>\n", compat); 549 550 /* Setup the control interrupt. */ 551 rid = 0; 552 cintr = bus_alloc_resource_any(self, SYS_RES_IRQ, 553 &rid, RF_SHAREABLE | RF_ACTIVE); 554 if (cintr != NULL) 555 bus_setup_intr(self, cintr, INTR_TYPE_MISC | INTR_MPSAFE, 556 NULL, davbus_cint, sc, &cookie); 557 558 /* Initialize controller registers. */ 559 bus_write_4(sc->reg, DAVBUS_SOUND_CTRL, DAVBUS_INPUT_SUBFRAME0 | 560 DAVBUS_OUTPUT_SUBFRAME0 | DAVBUS_RATE_44100 | DAVBUS_INTR_PORTCHG); 561 562 /* Attach DBDMA engine and PCM layer */ 563 err = aoa_attach(sc); 564 if (err) 565 return (err); 566 567 /* Install codec module */ 568 if (strcmp(compat, "screamer") == 0) 569 mixer_init(self, &screamer_mixer_class, sc); 570 else if (strcmp(compat, "burgundy") == 0) 571 mixer_init(self, &burgundy_mixer_class, sc); 572 573 return (0); 574 } 575 576 static void 577 davbus_cint(void *ptr) 578 { 579 struct davbus_softc *d = ptr; 580 u_int reg, status, mask; 581 582 mtx_lock(&d->mutex); 583 584 reg = bus_read_4(d->reg, DAVBUS_SOUND_CTRL); 585 if (reg & DAVBUS_PORTCHG) { 586 587 status = bus_read_4(d->reg, DAVBUS_CODEC_STATUS); 588 589 if (d->read_status && d->set_outputs) { 590 mask = (*d->read_status)(d, status); 591 (*d->set_outputs)(d, mask); 592 } 593 594 /* Clear the interrupt. */ 595 bus_write_4(d->reg, DAVBUS_SOUND_CTRL, reg); 596 } 597 598 mtx_unlock(&d->mutex); 599 } 600