1 /* $OpenBSD: i2s.c,v 1.32 2016/06/26 06:50:26 mglocker Exp $ */ 2 /* $NetBSD: i2s.c,v 1.1 2003/12/27 02:19:34 grant Exp $ */ 3 4 /*- 5 * Copyright (c) 2002 Tsubai Masanari. All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 3. The name of the author may not be used to endorse or promote products 16 * derived from this software without specific prior written permission. 17 * 18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR 19 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 20 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 21 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, 22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 23 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 24 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 25 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 26 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 27 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 28 */ 29 30 #include <sys/param.h> 31 #include <sys/audioio.h> 32 #include <sys/device.h> 33 #include <sys/malloc.h> 34 #include <sys/systm.h> 35 36 #include <dev/audio_if.h> 37 #include <dev/ofw/openfirm.h> 38 #include <macppc/dev/dbdma.h> 39 40 #include <uvm/uvm_extern.h> 41 42 #include <machine/autoconf.h> 43 #include <machine/pio.h> 44 45 #include <macppc/dev/i2svar.h> 46 #include <macppc/dev/i2sreg.h> 47 #include <macppc/pci/macobio.h> 48 49 #ifdef I2S_DEBUG 50 # define DPRINTF(x) printf x 51 #else 52 # define DPRINTF(x) 53 #endif 54 55 struct audio_params i2s_audio_default = { 56 44100, /* sample_rate */ 57 AUDIO_ENCODING_SLINEAR_BE, /* encoding */ 58 16, /* precision */ 59 2, /* bps */ 60 1, /* msb */ 61 2 /* channels */ 62 }; 63 64 void i2s_mute(u_int, int); 65 int i2s_cint(void *); 66 u_int i2s_gpio_offset(struct i2s_softc *, char *, int *); 67 void i2s_init(struct i2s_softc *, int); 68 69 int i2s_intr(void *); 70 int i2s_iintr(void *); 71 72 struct cfdriver i2s_cd = { 73 NULL, "i2s", DV_DULL 74 }; 75 76 void 77 i2s_attach(struct device *parent, struct i2s_softc *sc, struct confargs *ca) 78 { 79 int cirq, oirq, iirq, cirq_type, oirq_type, iirq_type; 80 u_int32_t reg[6], intr[6]; 81 char compat[32]; 82 int child; 83 84 sc->sc_node = OF_child(ca->ca_node); 85 sc->sc_baseaddr = ca->ca_baseaddr; 86 87 OF_getprop(sc->sc_node, "reg", reg, sizeof reg); 88 89 child = OF_child(sc->sc_node); 90 memset(compat, 0, sizeof(compat)); 91 OF_getprop(child, "compatible", compat, sizeof(compat)); 92 93 /* Deal with broken device-tree on PowerMac7,2 and 7,3. */ 94 if (strcmp(compat, "AOAK2") == 0) { 95 reg[0] += ca->ca_reg[0]; 96 reg[2] += ca->ca_reg[2]; 97 reg[4] += ca->ca_reg[2]; 98 } 99 100 reg[0] += sc->sc_baseaddr; 101 reg[2] += sc->sc_baseaddr; 102 reg[4] += sc->sc_baseaddr; 103 104 sc->sc_reg = mapiodev(reg[0], reg[1]); 105 106 sc->sc_dmat = ca->ca_dmat; 107 sc->sc_odma = mapiodev(reg[2], reg[3]); /* out */ 108 sc->sc_idma = mapiodev(reg[4], reg[5]); /* in */ 109 sc->sc_odbdma = dbdma_alloc(sc->sc_dmat, I2S_DMALIST_MAX); 110 sc->sc_odmacmd = sc->sc_odbdma->d_addr; 111 sc->sc_idbdma = dbdma_alloc(sc->sc_dmat, I2S_DMALIST_MAX); 112 sc->sc_idmacmd = sc->sc_idbdma->d_addr; 113 114 OF_getprop(sc->sc_node, "interrupts", intr, sizeof intr); 115 cirq = intr[0]; 116 oirq = intr[2]; 117 iirq = intr[4]; 118 cirq_type = (intr[1] & 1) ? IST_LEVEL : IST_EDGE; 119 oirq_type = (intr[3] & 1) ? IST_LEVEL : IST_EDGE; 120 iirq_type = (intr[5] & 1) ? IST_LEVEL : IST_EDGE; 121 122 /* intr_establish(cirq, cirq_type, IPL_AUDIO, i2s_intr, sc); */ 123 mac_intr_establish(parent, oirq, oirq_type, IPL_AUDIO | IPL_MPSAFE, 124 i2s_intr, sc, sc->sc_dev.dv_xname); 125 mac_intr_establish(parent, iirq, iirq_type, IPL_AUDIO | IPL_MPSAFE, 126 i2s_iintr, sc, sc->sc_dev.dv_xname); 127 128 printf(": irq %d,%d,%d\n", cirq, oirq, iirq); 129 130 /* Need to be explicitly turned on some G5. */ 131 macobio_enable(I2SClockOffset, I2S0CLKEN|I2S0EN); 132 133 i2s_set_rate(sc, 44100); 134 sc->sc_mute = 0; 135 i2s_gpio_init(sc, ca->ca_node, parent); 136 } 137 138 int 139 i2s_intr(v) 140 void *v; 141 { 142 struct i2s_softc *sc = v; 143 struct dbdma_command *cmd = sc->sc_odmap; 144 u_int16_t c, status; 145 146 mtx_enter(&audio_lock); 147 148 /* if not set we are not running */ 149 if (!cmd) { 150 mtx_leave(&audio_lock); 151 return (0); 152 } 153 DPRINTF(("i2s_intr: cmd %p\n", cmd)); 154 155 c = in16rb(&cmd->d_command); 156 status = in16rb(&cmd->d_status); 157 158 if (c >> 12 == DBDMA_CMD_OUT_LAST) 159 sc->sc_odmap = sc->sc_odmacmd; 160 else 161 sc->sc_odmap++; 162 163 if (c & (DBDMA_INT_ALWAYS << 4)) { 164 cmd->d_status = 0; 165 if (status) /* status == 0x8400 */ 166 if (sc->sc_ointr) 167 (*sc->sc_ointr)(sc->sc_oarg); 168 } 169 mtx_leave(&audio_lock); 170 return 1; 171 } 172 173 int 174 i2s_iintr(v) 175 void *v; 176 { 177 struct i2s_softc *sc = v; 178 struct dbdma_command *cmd = sc->sc_idmap; 179 u_int16_t c, status; 180 181 mtx_enter(&audio_lock); 182 183 /* if not set we are not running */ 184 if (!cmd) { 185 mtx_leave(&audio_lock); 186 return (0); 187 } 188 DPRINTF(("i2s_intr: cmd %p\n", cmd)); 189 190 c = in16rb(&cmd->d_command); 191 status = in16rb(&cmd->d_status); 192 193 if (c >> 12 == DBDMA_CMD_IN_LAST) 194 sc->sc_idmap = sc->sc_idmacmd; 195 else 196 sc->sc_idmap++; 197 198 if (c & (DBDMA_INT_ALWAYS << 4)) { 199 cmd->d_status = 0; 200 if (status) /* status == 0x8400 */ 201 if (sc->sc_iintr) 202 (*sc->sc_iintr)(sc->sc_iarg); 203 } 204 mtx_leave(&audio_lock); 205 return 1; 206 } 207 208 int 209 i2s_open(h, flags) 210 void *h; 211 int flags; 212 { 213 return 0; 214 } 215 216 /* 217 * Close function is called at splaudio(). 218 */ 219 void 220 i2s_close(h) 221 void *h; 222 { 223 struct i2s_softc *sc = h; 224 225 i2s_halt_output(sc); 226 i2s_halt_input(sc); 227 228 sc->sc_ointr = 0; 229 sc->sc_iintr = 0; 230 } 231 232 int 233 i2s_query_encoding(h, ae) 234 void *h; 235 struct audio_encoding *ae; 236 { 237 int err = 0; 238 239 switch (ae->index) { 240 case 0: 241 strlcpy(ae->name, AudioEslinear_be, sizeof(ae->name)); 242 ae->encoding = AUDIO_ENCODING_SLINEAR_BE; 243 ae->precision = 16; 244 ae->flags = 0; 245 break; 246 default: 247 err = EINVAL; 248 break; 249 } 250 ae->bps = AUDIO_BPS(ae->precision); 251 ae->msb = 1; 252 return (err); 253 } 254 255 256 int 257 i2s_set_params(h, setmode, usemode, play, rec) 258 void *h; 259 int setmode, usemode; 260 struct audio_params *play, *rec; 261 { 262 struct i2s_softc *sc = h; 263 struct audio_params *p; 264 int mode; 265 266 p = play; /* default to play */ 267 268 /* 269 * This device only has one clock, so make the sample rates match. 270 */ 271 if (play->sample_rate != rec->sample_rate && 272 usemode == (AUMODE_PLAY | AUMODE_RECORD)) { 273 if (setmode == AUMODE_PLAY) { 274 rec->sample_rate = play->sample_rate; 275 setmode |= AUMODE_RECORD; 276 } else if (setmode == AUMODE_RECORD) { 277 play->sample_rate = rec->sample_rate; 278 setmode |= AUMODE_PLAY; 279 } else 280 return EINVAL; 281 } 282 283 for (mode = AUMODE_RECORD; mode != -1; 284 mode = mode == AUMODE_RECORD ? AUMODE_PLAY : -1) { 285 if ((setmode & mode) == 0) 286 continue; 287 288 p = mode == AUMODE_PLAY ? play : rec; 289 290 if (p->sample_rate < 4000) 291 p->sample_rate = 4000; 292 if (p->sample_rate > 50000) 293 p->sample_rate = 50000; 294 if (p->precision > 16) 295 p->precision = 16; 296 if (p->channels > 2) 297 p->channels = 2; 298 299 switch (p->encoding) { 300 case AUDIO_ENCODING_SLINEAR_BE: 301 break; 302 default: 303 return (EINVAL); 304 } 305 } 306 307 /* Set the speed */ 308 if (i2s_set_rate(sc, play->sample_rate)) 309 return EINVAL; 310 311 p->sample_rate = sc->sc_rate; 312 313 p->bps = AUDIO_BPS(p->precision); 314 p->msb = 1; 315 316 return 0; 317 } 318 319 void 320 i2s_get_default_params(struct audio_params *params) 321 { 322 *params = i2s_audio_default; 323 } 324 325 int 326 i2s_round_blocksize(h, size) 327 void *h; 328 int size; 329 { 330 if (size < NBPG) 331 size = NBPG; 332 return size & ~PGOFSET; 333 } 334 335 int 336 i2s_halt_output(h) 337 void *h; 338 { 339 struct i2s_softc *sc = h; 340 341 dbdma_stop(sc->sc_odma); 342 dbdma_reset(sc->sc_odma); 343 return 0; 344 } 345 346 int 347 i2s_halt_input(h) 348 void *h; 349 { 350 struct i2s_softc *sc = h; 351 352 dbdma_stop(sc->sc_idma); 353 dbdma_reset(sc->sc_idma); 354 return 0; 355 } 356 357 enum { 358 I2S_OUTPUT_CLASS, 359 I2S_RECORD_CLASS, 360 I2S_OUTPUT_SELECT, 361 I2S_VOL_OUTPUT, 362 I2S_INPUT_SELECT, 363 I2S_VOL_INPUT, 364 I2S_MUTE, /* should be before bass/treble */ 365 I2S_BASS, 366 I2S_TREBLE, 367 I2S_ENUM_LAST 368 }; 369 370 int 371 i2s_set_port(void *h, mixer_ctrl_t *mc) 372 { 373 struct i2s_softc *sc = h; 374 int l, r; 375 376 DPRINTF(("i2s_set_port dev = %d, type = %d\n", mc->dev, mc->type)); 377 378 l = mc->un.value.level[AUDIO_MIXER_LEVEL_LEFT]; 379 r = mc->un.value.level[AUDIO_MIXER_LEVEL_RIGHT]; 380 381 switch (mc->dev) { 382 case I2S_OUTPUT_SELECT: 383 /* No change necessary? */ 384 if (mc->un.mask == sc->sc_output_mask) 385 return 0; 386 387 i2s_mute(sc->sc_spkr, 1); 388 i2s_mute(sc->sc_hp, 1); 389 i2s_mute(sc->sc_line, 1); 390 if (mc->un.mask & I2S_SELECT_SPEAKER) 391 i2s_mute(sc->sc_spkr, 0); 392 if (mc->un.mask & I2S_SELECT_HEADPHONE) 393 i2s_mute(sc->sc_hp, 0); 394 if (mc->un.mask & I2S_SELECT_LINEOUT) 395 i2s_mute(sc->sc_line, 0); 396 397 sc->sc_output_mask = mc->un.mask; 398 return 0; 399 400 case I2S_VOL_OUTPUT: 401 (*sc->sc_setvolume)(sc, l, r); 402 return 0; 403 404 case I2S_MUTE: 405 if (mc->type != AUDIO_MIXER_ENUM) 406 return (EINVAL); 407 408 sc->sc_mute = (mc->un.ord != 0); 409 410 if (sc->sc_mute) { 411 if (sc->sc_output_mask & I2S_SELECT_SPEAKER) 412 i2s_mute(sc->sc_spkr, 1); 413 if (sc->sc_output_mask & I2S_SELECT_HEADPHONE) 414 i2s_mute(sc->sc_hp, 1); 415 if (sc->sc_output_mask & I2S_SELECT_LINEOUT) 416 i2s_mute(sc->sc_line, 1); 417 } else { 418 if (sc->sc_output_mask & I2S_SELECT_SPEAKER) 419 i2s_mute(sc->sc_spkr, 0); 420 if (sc->sc_output_mask & I2S_SELECT_HEADPHONE) 421 i2s_mute(sc->sc_hp, 0); 422 if (sc->sc_output_mask & I2S_SELECT_LINEOUT) 423 i2s_mute(sc->sc_line, 0); 424 } 425 426 return (0); 427 428 case I2S_BASS: 429 if (sc->sc_setbass != NULL) 430 (*sc->sc_setbass)(sc, l); 431 return (0); 432 433 case I2S_TREBLE: 434 if (sc->sc_settreble != NULL) 435 (*sc->sc_settreble)(sc, l); 436 return (0); 437 438 case I2S_INPUT_SELECT: 439 /* no change necessary? */ 440 if (mc->un.mask == sc->sc_record_source) 441 return 0; 442 switch (mc->un.mask) { 443 case I2S_SELECT_SPEAKER: 444 case I2S_SELECT_HEADPHONE: 445 /* XXX TO BE DONE */ 446 break; 447 default: /* invalid argument */ 448 return EINVAL; 449 } 450 if (sc->sc_setinput != NULL) 451 (*sc->sc_setinput)(sc, mc->un.mask); 452 sc->sc_record_source = mc->un.mask; 453 return 0; 454 455 case I2S_VOL_INPUT: 456 /* XXX TO BE DONE */ 457 return 0; 458 } 459 460 return ENXIO; 461 } 462 463 int 464 i2s_get_port(void *h, mixer_ctrl_t *mc) 465 { 466 struct i2s_softc *sc = h; 467 468 DPRINTF(("i2s_get_port dev = %d, type = %d\n", mc->dev, mc->type)); 469 470 switch (mc->dev) { 471 case I2S_OUTPUT_SELECT: 472 mc->un.mask = sc->sc_output_mask; 473 return 0; 474 475 case I2S_VOL_OUTPUT: 476 mc->un.value.level[AUDIO_MIXER_LEVEL_LEFT] = sc->sc_vol_l; 477 mc->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] = sc->sc_vol_r; 478 return 0; 479 480 case I2S_MUTE: 481 mc->un.ord = sc->sc_mute; 482 return (0); 483 484 case I2S_INPUT_SELECT: 485 mc->un.mask = sc->sc_record_source; 486 return 0; 487 488 case I2S_BASS: 489 if (mc->un.value.num_channels != 1) 490 return ENXIO; 491 mc->un.value.level[AUDIO_MIXER_LEVEL_MONO] = sc->sc_bass; 492 return 0; 493 494 case I2S_TREBLE: 495 if (mc->un.value.num_channels != 1) 496 return ENXIO; 497 mc->un.value.level[AUDIO_MIXER_LEVEL_MONO] = sc->sc_treble; 498 return 0; 499 500 case I2S_VOL_INPUT: 501 /* XXX TO BE DONE */ 502 mc->un.value.level[AUDIO_MIXER_LEVEL_LEFT] = 0; 503 mc->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] = 0; 504 return 0; 505 506 default: 507 return ENXIO; 508 } 509 510 return 0; 511 } 512 513 int 514 i2s_query_devinfo(void *h, mixer_devinfo_t *dip) 515 { 516 struct i2s_softc *sc = h; 517 int n = 0; 518 519 switch (dip->index) { 520 521 case I2S_OUTPUT_SELECT: 522 dip->mixer_class = I2S_OUTPUT_CLASS; 523 strlcpy(dip->label.name, AudioNselect, sizeof(dip->label.name)); 524 dip->type = AUDIO_MIXER_SET; 525 dip->prev = dip->next = AUDIO_MIXER_LAST; 526 strlcpy(dip->un.s.member[n].label.name, AudioNspeaker, 527 sizeof(dip->un.s.member[n].label.name)); 528 dip->un.s.member[n++].mask = I2S_SELECT_SPEAKER; 529 if (sc->sc_hp) { 530 strlcpy(dip->un.s.member[n].label.name, 531 AudioNheadphone, 532 sizeof(dip->un.s.member[n].label.name)); 533 dip->un.s.member[n++].mask = I2S_SELECT_HEADPHONE; 534 } 535 if (sc->sc_line) { 536 strlcpy(dip->un.s.member[n].label.name, AudioNline, 537 sizeof(dip->un.s.member[n].label.name)); 538 dip->un.s.member[n++].mask = I2S_SELECT_LINEOUT; 539 } 540 dip->un.s.num_mem = n; 541 return 0; 542 543 case I2S_VOL_OUTPUT: 544 dip->mixer_class = I2S_OUTPUT_CLASS; 545 strlcpy(dip->label.name, AudioNmaster, sizeof(dip->label.name)); 546 dip->type = AUDIO_MIXER_VALUE; 547 dip->prev = AUDIO_MIXER_LAST; 548 dip->next = I2S_MUTE; 549 dip->un.v.num_channels = 2; 550 dip->un.v.delta = 8; 551 strlcpy(dip->un.v.units.name, AudioNvolume, 552 sizeof(dip->un.v.units.name)); 553 return 0; 554 555 case I2S_MUTE: 556 dip->mixer_class = I2S_OUTPUT_CLASS; 557 dip->prev = I2S_VOL_OUTPUT; 558 dip->next = AUDIO_MIXER_LAST; 559 strlcpy(dip->label.name, AudioNmute, sizeof(dip->label.name)); 560 dip->type = AUDIO_MIXER_ENUM; 561 dip->un.e.num_mem = 2; 562 strlcpy(dip->un.e.member[0].label.name, AudioNoff, 563 sizeof dip->un.e.member[0].label.name); 564 dip->un.e.member[0].ord = 0; 565 strlcpy(dip->un.e.member[1].label.name, AudioNon, 566 sizeof dip->un.e.member[1].label.name); 567 dip->un.e.member[1].ord = 1; 568 return (0); 569 570 case I2S_INPUT_SELECT: 571 dip->mixer_class = I2S_RECORD_CLASS; 572 strlcpy(dip->label.name, AudioNsource, sizeof(dip->label.name)); 573 dip->type = AUDIO_MIXER_SET; 574 dip->prev = dip->next = AUDIO_MIXER_LAST; 575 dip->un.s.num_mem = 2; 576 strlcpy(dip->un.s.member[0].label.name, AudioNmicrophone, 577 sizeof(dip->un.s.member[0].label.name)); 578 dip->un.s.member[0].mask = I2S_SELECT_SPEAKER; 579 strlcpy(dip->un.s.member[1].label.name, AudioNline, 580 sizeof(dip->un.s.member[1].label.name)); 581 dip->un.s.member[1].mask = I2S_SELECT_HEADPHONE; 582 return 0; 583 584 case I2S_VOL_INPUT: 585 dip->mixer_class = I2S_RECORD_CLASS; 586 strlcpy(dip->label.name, AudioNrecord, sizeof(dip->label.name)); 587 dip->type = AUDIO_MIXER_VALUE; 588 dip->prev = dip->next = AUDIO_MIXER_LAST; 589 dip->un.v.num_channels = 2; 590 strlcpy(dip->un.v.units.name, AudioNvolume, 591 sizeof(dip->un.v.units.name)); 592 return 0; 593 594 case I2S_OUTPUT_CLASS: 595 dip->mixer_class = I2S_OUTPUT_CLASS; 596 strlcpy(dip->label.name, AudioCoutputs, 597 sizeof(dip->label.name)); 598 dip->type = AUDIO_MIXER_CLASS; 599 dip->next = dip->prev = AUDIO_MIXER_LAST; 600 return 0; 601 602 case I2S_RECORD_CLASS: 603 dip->mixer_class = I2S_RECORD_CLASS; 604 strlcpy(dip->label.name, AudioCrecord, sizeof(dip->label.name)); 605 dip->type = AUDIO_MIXER_CLASS; 606 dip->next = dip->prev = AUDIO_MIXER_LAST; 607 return 0; 608 609 case I2S_BASS: 610 if (sc->sc_setbass == NULL) 611 return (ENXIO); 612 dip->mixer_class = I2S_OUTPUT_CLASS; 613 strlcpy(dip->label.name, AudioNbass, sizeof(dip->label.name)); 614 dip->type = AUDIO_MIXER_VALUE; 615 dip->prev = dip->next = AUDIO_MIXER_LAST; 616 dip->un.v.num_channels = 1; 617 return (0); 618 619 case I2S_TREBLE: 620 if (sc->sc_settreble == NULL) 621 return (ENXIO); 622 dip->mixer_class = I2S_OUTPUT_CLASS; 623 strlcpy(dip->label.name, AudioNtreble, sizeof(dip->label.name)); 624 dip->type = AUDIO_MIXER_VALUE; 625 dip->prev = dip->next = AUDIO_MIXER_LAST; 626 dip->un.v.num_channels = 1; 627 return (0); 628 } 629 630 return ENXIO; 631 } 632 633 size_t 634 i2s_round_buffersize(h, dir, size) 635 void *h; 636 int dir; 637 size_t size; 638 { 639 if (size > 65536) 640 size = 65536; 641 return size; 642 } 643 644 paddr_t 645 i2s_mappage(h, mem, off, prot) 646 void *h; 647 void *mem; 648 off_t off; 649 int prot; 650 { 651 if (off < 0) 652 return -1; 653 return -1; /* XXX */ 654 } 655 656 int 657 i2s_get_props(h) 658 void *h; 659 { 660 return AUDIO_PROP_FULLDUPLEX /* | AUDIO_PROP_MMAP */; 661 } 662 663 int 664 i2s_trigger_output(h, start, end, bsize, intr, arg, param) 665 void *h; 666 void *start, *end; 667 int bsize; 668 void (*intr)(void *); 669 void *arg; 670 struct audio_params *param; 671 { 672 struct i2s_softc *sc = h; 673 struct i2s_dma *p; 674 struct dbdma_command *cmd = sc->sc_odmacmd; 675 vaddr_t spa, pa, epa; 676 int c; 677 678 DPRINTF(("trigger_output %p %p 0x%x\n", start, end, bsize)); 679 680 for (p = sc->sc_dmas; p && p->addr != start; p = p->next); 681 if (!p) 682 return -1; 683 684 sc->sc_ointr = intr; 685 sc->sc_oarg = arg; 686 sc->sc_odmap = sc->sc_odmacmd; 687 688 spa = p->segs[0].ds_addr; 689 c = DBDMA_CMD_OUT_MORE; 690 for (pa = spa, epa = spa + (end - start); 691 pa < epa; pa += bsize, cmd++) { 692 693 if (pa + bsize == epa) 694 c = DBDMA_CMD_OUT_LAST; 695 696 DBDMA_BUILD(cmd, c, 0, bsize, pa, DBDMA_INT_ALWAYS, 697 DBDMA_WAIT_NEVER, DBDMA_BRANCH_NEVER); 698 } 699 700 DBDMA_BUILD(cmd, DBDMA_CMD_NOP, 0, 0, 0, 701 DBDMA_INT_NEVER, DBDMA_WAIT_NEVER, DBDMA_BRANCH_ALWAYS); 702 dbdma_st32(&cmd->d_cmddep, sc->sc_odbdma->d_paddr); 703 704 dbdma_start(sc->sc_odma, sc->sc_odbdma); 705 706 return 0; 707 } 708 709 int 710 i2s_trigger_input(h, start, end, bsize, intr, arg, param) 711 void *h; 712 void *start, *end; 713 int bsize; 714 void (*intr)(void *); 715 void *arg; 716 struct audio_params *param; 717 { 718 struct i2s_softc *sc = h; 719 struct i2s_dma *p; 720 struct dbdma_command *cmd = sc->sc_idmacmd; 721 vaddr_t spa, pa, epa; 722 int c; 723 724 DPRINTF(("trigger_input %p %p 0x%x\n", start, end, bsize)); 725 726 for (p = sc->sc_dmas; p && p->addr != start; p = p->next); 727 if (!p) 728 return -1; 729 730 sc->sc_iintr = intr; 731 sc->sc_iarg = arg; 732 sc->sc_idmap = sc->sc_idmacmd; 733 734 spa = p->segs[0].ds_addr; 735 c = DBDMA_CMD_IN_MORE; 736 for (pa = spa, epa = spa + (end - start); 737 pa < epa; pa += bsize, cmd++) { 738 739 if (pa + bsize == epa) 740 c = DBDMA_CMD_IN_LAST; 741 742 DBDMA_BUILD(cmd, c, 0, bsize, pa, DBDMA_INT_ALWAYS, 743 DBDMA_WAIT_NEVER, DBDMA_BRANCH_NEVER); 744 } 745 746 DBDMA_BUILD(cmd, DBDMA_CMD_NOP, 0, 0, 0, 747 DBDMA_INT_NEVER, DBDMA_WAIT_NEVER, DBDMA_BRANCH_ALWAYS); 748 dbdma_st32(&cmd->d_cmddep, sc->sc_idbdma->d_paddr); 749 750 dbdma_start(sc->sc_idma, sc->sc_idbdma); 751 752 return 0; 753 } 754 755 756 /* rate = fs = LRCLK 757 * SCLK = 64*LRCLK (I2S) 758 * MCLK = 256fs (typ. -- changeable) 759 * MCLK = clksrc / mdiv 760 * SCLK = MCLK / sdiv 761 * rate = SCLK / 64 ( = LRCLK = fs) 762 */ 763 int 764 i2s_set_rate(sc, rate) 765 struct i2s_softc *sc; 766 int rate; 767 { 768 u_int reg = 0; 769 int MCLK; 770 int clksrc, mdiv, sdiv; 771 int mclk_fs; 772 int timo; 773 774 /* sanify */ 775 if (rate > (48000 + 44100) / 2) 776 rate = 48000; 777 else 778 rate = 44100; 779 780 switch (rate) { 781 case 44100: 782 clksrc = 45158400; /* 45MHz */ 783 reg = CLKSRC_45MHz; 784 mclk_fs = 256; 785 break; 786 787 case 48000: 788 clksrc = 49152000; /* 49MHz */ 789 reg = CLKSRC_49MHz; 790 mclk_fs = 256; 791 break; 792 793 default: 794 return EINVAL; 795 } 796 797 MCLK = rate * mclk_fs; 798 mdiv = clksrc / MCLK; /* 4 */ 799 sdiv = mclk_fs / 64; /* 4 */ 800 801 switch (mdiv) { 802 case 1: 803 reg |= MCLK_DIV1; 804 break; 805 case 3: 806 reg |= MCLK_DIV3; 807 break; 808 case 5: 809 reg |= MCLK_DIV5; 810 break; 811 default: 812 reg |= ((mdiv / 2 - 1) << 24) & 0x1f000000; 813 break; 814 } 815 816 switch (sdiv) { 817 case 1: 818 reg |= SCLK_DIV1; 819 break; 820 case 3: 821 reg |= SCLK_DIV3; 822 break; 823 default: 824 reg |= ((sdiv / 2 - 1) << 20) & 0x00f00000; 825 break; 826 } 827 828 reg |= SCLK_MASTER; /* XXX master mode */ 829 830 reg |= SERIAL_64x; 831 832 if (sc->sc_rate == rate) 833 return (0); 834 835 /* stereo input and output */ 836 DPRINTF(("I2SSetDataWordSizeReg 0x%08x -> 0x%08x\n", 837 in32rb(sc->sc_reg + I2S_WORDSIZE), 0x02000200)); 838 out32rb(sc->sc_reg + I2S_WORDSIZE, 0x02000200); 839 840 /* Clear CLKSTOPPEND */ 841 out32rb(sc->sc_reg + I2S_INT, I2S_INT_CLKSTOPPEND); 842 843 macobio_disable(I2SClockOffset, I2S0CLKEN); 844 845 /* Wait until clock is stopped */ 846 for (timo = 50; timo > 0; timo--) { 847 if (in32rb(sc->sc_reg + I2S_INT) & I2S_INT_CLKSTOPPEND) 848 goto done; 849 delay(10); 850 } 851 852 printf("i2s_set_rate: timeout\n"); 853 854 done: 855 DPRINTF(("I2SSetSerialFormatReg 0x%x -> 0x%x\n", 856 in32rb(sc->sc_reg + I2S_FORMAT), reg)); 857 out32rb(sc->sc_reg + I2S_FORMAT, reg); 858 859 macobio_enable(I2SClockOffset, I2S0CLKEN); 860 861 sc->sc_rate = rate; 862 863 return 0; 864 } 865 866 void 867 i2s_mute(u_int offset, int mute) 868 { 869 if (offset == 0) 870 return; 871 872 DPRINTF(("gpio: %x, %d -> ", offset, macobio_read(offset) & GPIO_DATA)); 873 874 /* 0 means mute */ 875 if (mute == (macobio_read(offset) & GPIO_DATA)) 876 macobio_write(offset, !mute | GPIO_DDR_OUTPUT); 877 878 DPRINTF(("%d\n", macobio_read(offset) & GPIO_DATA)); 879 } 880 881 int 882 i2s_cint(void *v) 883 { 884 struct i2s_softc *sc = v; 885 u_int sense; 886 887 sc->sc_output_mask = 0; 888 i2s_mute(sc->sc_spkr, 1); 889 i2s_mute(sc->sc_hp, 1); 890 i2s_mute(sc->sc_line, 1); 891 892 if (sc->sc_hp_detect) 893 sense = macobio_read(sc->sc_hp_detect); 894 else 895 sense = !sc->sc_hp_active << 1; 896 DPRINTF(("headphone detect = 0x%x\n", sense)); 897 898 if (((sense & 0x02) >> 1) == sc->sc_hp_active) { 899 DPRINTF(("headphone is inserted\n")); 900 sc->sc_output_mask |= I2S_SELECT_HEADPHONE; 901 if (!sc->sc_mute) 902 i2s_mute(sc->sc_hp, 0); 903 } else { 904 DPRINTF(("headphone is NOT inserted\n")); 905 } 906 907 if (sc->sc_line_detect) 908 sense = macobio_read(sc->sc_line_detect); 909 else 910 sense = !sc->sc_line_active << 1; 911 DPRINTF(("lineout detect = 0x%x\n", sense)); 912 913 if (((sense & 0x02) >> 1) == sc->sc_line_active) { 914 DPRINTF(("lineout is inserted\n")); 915 sc->sc_output_mask |= I2S_SELECT_LINEOUT; 916 if (!sc->sc_mute) 917 i2s_mute(sc->sc_line, 0); 918 } else { 919 DPRINTF(("lineout is NOT inserted\n")); 920 } 921 922 if (sc->sc_output_mask == 0) { 923 sc->sc_output_mask |= I2S_SELECT_SPEAKER; 924 if (!sc->sc_mute) 925 i2s_mute(sc->sc_spkr, 0); 926 } 927 928 return 1; 929 } 930 931 u_int 932 i2s_gpio_offset(struct i2s_softc *sc, char *name, int *irq) 933 { 934 u_int32_t reg[2]; 935 u_int32_t intr[2]; 936 int gpio; 937 938 if (OF_getprop(sc->sc_node, name, &gpio, 939 sizeof(gpio)) != sizeof(gpio) || 940 OF_getprop(gpio, "reg", ®[0], 941 sizeof(reg[0])) != sizeof(reg[0]) || 942 OF_getprop(OF_parent(gpio), "reg", ®[1], 943 sizeof(reg[1])) != sizeof(reg[1])) 944 return (0); 945 946 if (irq && OF_getprop(gpio, "interrupts", 947 intr, sizeof(intr)) == sizeof(intr)) { 948 *irq = intr[0]; 949 } 950 951 return (reg[0] + reg[1]); 952 } 953 954 void 955 i2s_gpio_init(struct i2s_softc *sc, int node, struct device *parent) 956 { 957 int gpio; 958 int hp_detect_intr = -1, line_detect_intr = -1; 959 960 sc->sc_spkr = i2s_gpio_offset(sc, "platform-amp-mute", NULL); 961 sc->sc_hp = i2s_gpio_offset(sc, "platform-headphone-mute", NULL); 962 sc->sc_hp_detect = i2s_gpio_offset(sc, "platform-headphone-detect", 963 &hp_detect_intr); 964 sc->sc_line = i2s_gpio_offset(sc, "platform-lineout-mute", NULL); 965 sc->sc_line_detect = i2s_gpio_offset(sc, "platform-lineout-detect", 966 &line_detect_intr); 967 sc->sc_hw_reset = i2s_gpio_offset(sc, "platform-hw-reset", NULL); 968 969 gpio = OF_getnodebyname(OF_parent(node), "gpio"); 970 DPRINTF((" /gpio 0x%x\n", gpio)); 971 for (gpio = OF_child(gpio); gpio; gpio = OF_peer(gpio)) { 972 char name[64], audio_gpio[64]; 973 int intr[2]; 974 uint32_t reg; 975 976 reg = 0; 977 bzero(name, sizeof name); 978 bzero(audio_gpio, sizeof audio_gpio); 979 OF_getprop(gpio, "name", name, sizeof name); 980 OF_getprop(gpio, "audio-gpio", audio_gpio, sizeof audio_gpio); 981 if (OF_getprop(gpio, "reg", ®, sizeof(reg)) == -1) 982 OF_getprop(gpio, "AAPL,address", ®, sizeof(reg)); 983 984 if (reg > sc->sc_baseaddr) 985 reg = (reg - sc->sc_baseaddr); 986 987 /* gpio5 */ 988 if (sc->sc_hp == 0 && strcmp(audio_gpio, "headphone-mute") == 0) 989 sc->sc_hp = reg; 990 991 /* gpio6 */ 992 if (sc->sc_spkr == 0 && strcmp(audio_gpio, "amp-mute") == 0) 993 sc->sc_spkr = reg; 994 995 /* extint-gpio15 */ 996 if (sc->sc_hp_detect == 0 && 997 strcmp(audio_gpio, "headphone-detect") == 0) { 998 sc->sc_hp_detect = reg; 999 OF_getprop(gpio, "audio-gpio-active-state", 1000 &sc->sc_hp_active, 4); 1001 OF_getprop(gpio, "interrupts", intr, 8); 1002 hp_detect_intr = intr[0]; 1003 } 1004 1005 /* gpio11 (keywest-11) */ 1006 if (sc->sc_hw_reset == 0 && 1007 strcmp(audio_gpio, "audio-hw-reset") == 0) 1008 sc->sc_hw_reset = reg; 1009 } 1010 DPRINTF((" amp-mute 0x%x\n", sc->sc_spkr)); 1011 DPRINTF((" headphone-mute 0x%x\n", sc->sc_hp)); 1012 DPRINTF((" headphone-detect 0x%x\n", sc->sc_hp_detect)); 1013 DPRINTF((" headphone-detect active %x\n", sc->sc_hp_active)); 1014 DPRINTF((" headphone-detect intr %x\n", hp_detect_intr)); 1015 DPRINTF((" lineout-mute 0x%x\n", sc->sc_line)); 1016 DPRINTF((" lineout-detect 0x%x\n", sc->sc_line_detect)); 1017 DPRINTF((" lineout-detect active 0x%x\n", sc->sc_line_active)); 1018 DPRINTF((" lineout-detect intr 0x%x\n", line_detect_intr)); 1019 DPRINTF((" audio-hw-reset 0x%x\n", sc->sc_hw_reset)); 1020 1021 if (hp_detect_intr != -1) 1022 mac_intr_establish(parent, hp_detect_intr, IST_EDGE, 1023 IPL_AUDIO | IPL_MPSAFE, i2s_cint, sc, sc->sc_dev.dv_xname); 1024 1025 if (line_detect_intr != -1) 1026 mac_intr_establish(parent, line_detect_intr, IST_EDGE, 1027 IPL_AUDIO | IPL_MPSAFE, i2s_cint, sc, sc->sc_dev.dv_xname); 1028 1029 /* Enable headphone interrupt? */ 1030 macobio_write(sc->sc_hp_detect, 0x80); 1031 1032 /* Update headphone status. */ 1033 i2s_cint(sc); 1034 } 1035 1036 void * 1037 i2s_allocm(void *h, int dir, size_t size, int type, int flags) 1038 { 1039 struct i2s_softc *sc = h; 1040 struct i2s_dma *p; 1041 int error; 1042 1043 if (size > I2S_DMALIST_MAX * I2S_DMASEG_MAX) 1044 return (NULL); 1045 1046 p = malloc(sizeof(*p), type, flags | M_ZERO); 1047 if (!p) 1048 return (NULL); 1049 1050 /* convert to the bus.h style, not used otherwise */ 1051 if (flags & M_NOWAIT) 1052 flags = BUS_DMA_NOWAIT; 1053 1054 p->size = size; 1055 if ((error = bus_dmamem_alloc(sc->sc_dmat, p->size, NBPG, 0, p->segs, 1056 1, &p->nsegs, flags)) != 0) { 1057 printf("%s: unable to allocate dma, error = %d\n", 1058 sc->sc_dev.dv_xname, error); 1059 free(p, type, sizeof *p); 1060 return NULL; 1061 } 1062 1063 if ((error = bus_dmamem_map(sc->sc_dmat, p->segs, p->nsegs, p->size, 1064 &p->addr, flags | BUS_DMA_COHERENT)) != 0) { 1065 printf("%s: unable to map dma, error = %d\n", 1066 sc->sc_dev.dv_xname, error); 1067 bus_dmamem_free(sc->sc_dmat, p->segs, p->nsegs); 1068 free(p, type, sizeof *p); 1069 return NULL; 1070 } 1071 1072 if ((error = bus_dmamap_create(sc->sc_dmat, p->size, 1, 1073 p->size, 0, flags, &p->map)) != 0) { 1074 printf("%s: unable to create dma map, error = %d\n", 1075 sc->sc_dev.dv_xname, error); 1076 bus_dmamem_unmap(sc->sc_dmat, p->addr, size); 1077 bus_dmamem_free(sc->sc_dmat, p->segs, p->nsegs); 1078 free(p, type, sizeof *p); 1079 return NULL; 1080 } 1081 1082 if ((error = bus_dmamap_load(sc->sc_dmat, p->map, p->addr, p->size, 1083 NULL, flags)) != 0) { 1084 printf("%s: unable to load dma map, error = %d\n", 1085 sc->sc_dev.dv_xname, error); 1086 bus_dmamap_destroy(sc->sc_dmat, p->map); 1087 bus_dmamem_unmap(sc->sc_dmat, p->addr, size); 1088 bus_dmamem_free(sc->sc_dmat, p->segs, p->nsegs); 1089 free(p, type, sizeof *p); 1090 return NULL; 1091 } 1092 1093 p->next = sc->sc_dmas; 1094 sc->sc_dmas = p; 1095 1096 return p->addr; 1097 } 1098 1099 #define reset_active 0 1100 1101 int 1102 deq_reset(struct i2s_softc *sc) 1103 { 1104 if (sc->sc_hw_reset == 0) 1105 return (-1); 1106 1107 macobio_write(sc->sc_hw_reset, !reset_active | GPIO_DDR_OUTPUT); 1108 delay(1000000); 1109 1110 macobio_write(sc->sc_hw_reset, reset_active | GPIO_DDR_OUTPUT); 1111 delay(1); 1112 1113 macobio_write(sc->sc_hw_reset, !reset_active | GPIO_DDR_OUTPUT); 1114 delay(10000); 1115 1116 return (0); 1117 } 1118