Annotation of sys/arch/macppc/dev/i2s.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: i2s.c,v 1.8 2007/04/22 22:31:14 deraadt 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/auconv.h>
! 37: #include <dev/audio_if.h>
! 38: #include <dev/mulaw.h>
! 39: #include <dev/ofw/openfirm.h>
! 40: #include <macppc/dev/dbdma.h>
! 41:
! 42: #include <uvm/uvm_extern.h>
! 43:
! 44: #include <machine/autoconf.h>
! 45: #include <machine/pio.h>
! 46:
! 47: #include <macppc/dev/i2svar.h>
! 48: #include <macppc/dev/i2sreg.h>
! 49:
! 50: #ifdef I2S_DEBUG
! 51: # define DPRINTF(x) printf x
! 52: #else
! 53: # define DPRINTF(x)
! 54: #endif
! 55:
! 56: struct i2s_mode *i2s_find_mode(u_int, u_int, u_int);
! 57: void i2s_cs16mts(void *, u_char *, int);
! 58:
! 59: static int gpio_read(char *);
! 60: static void gpio_write(char *, int);
! 61: void i2s_mute_speaker(struct i2s_softc *, int);
! 62: void i2s_mute_headphone(struct i2s_softc *, int);
! 63: void i2s_mute_lineout(struct i2s_softc *, int);
! 64: int i2s_cint(void *);
! 65: u_char *i2s_gpio_map(struct i2s_softc *, char *, int *);
! 66: void i2s_init(struct i2s_softc *, int);
! 67:
! 68: static void mono16_to_stereo16(void *, u_char *, int);
! 69: static void swap_bytes_mono16_to_stereo16(void *, u_char *, int);
! 70:
! 71: /* XXX */
! 72: void keylargo_fcr_enable(int, u_int32_t);
! 73: void keylargo_fcr_disable(int, u_int32_t);
! 74:
! 75: struct cfdriver i2s_cd = {
! 76: NULL, "i2s", DV_DULL
! 77: };
! 78:
! 79: static u_char *amp_mute;
! 80: static u_char *headphone_mute;
! 81: static u_char *lineout_mute;
! 82: static u_char *audio_hw_reset;
! 83: static u_char *headphone_detect;
! 84: static int headphone_detect_active;
! 85: static u_char *lineout_detect;
! 86: static int lineout_detect_active;
! 87:
! 88: /* GPIO bits */
! 89: #define GPIO_OUTSEL 0xf0 /* Output select */
! 90: /* 0x00 GPIO bit0 is output
! 91: 0x10 media-bay power
! 92: 0x20 reserved
! 93: 0x30 MPIC */
! 94:
! 95: #define GPIO_ALTOE 0x08 /* Alternate output enable */
! 96: /* 0x00 Use DDR
! 97: 0x08 Use output select */
! 98:
! 99: #define GPIO_DDR 0x04 /* Data direction */
! 100: #define GPIO_DDR_OUTPUT 0x04 /* Output */
! 101: #define GPIO_DDR_INPUT 0x00 /* Input */
! 102:
! 103: #define GPIO_LEVEL 0x02 /* Pin level (RO) */
! 104:
! 105: #define GPIO_DATA 0x01 /* Data */
! 106:
! 107: void
! 108: i2s_attach(struct device *parent, struct i2s_softc *sc, struct confargs *ca)
! 109: {
! 110: int cirq, oirq, iirq, cirq_type, oirq_type, iirq_type;
! 111: u_int32_t reg[6], intr[6];
! 112:
! 113: sc->sc_node = OF_child(ca->ca_node);
! 114: sc->sc_baseaddr = ca->ca_baseaddr;
! 115:
! 116: OF_getprop(sc->sc_node, "reg", reg, sizeof reg);
! 117: reg[0] += sc->sc_baseaddr;
! 118: reg[2] += sc->sc_baseaddr;
! 119: reg[4] += sc->sc_baseaddr;
! 120:
! 121: sc->sc_reg = mapiodev(reg[0], reg[1]);
! 122:
! 123: sc->sc_dmat = ca->ca_dmat;
! 124: sc->sc_odma = mapiodev(reg[2], reg[3]); /* out */
! 125: sc->sc_idma = mapiodev(reg[4], reg[5]); /* in */
! 126: sc->sc_odbdma = dbdma_alloc(sc->sc_dmat, I2S_DMALIST_MAX);
! 127: sc->sc_odmacmd = sc->sc_odbdma->d_addr;
! 128: sc->sc_idbdma = dbdma_alloc(sc->sc_dmat, I2S_DMALIST_MAX);
! 129: sc->sc_idmacmd = sc->sc_idbdma->d_addr;
! 130:
! 131: OF_getprop(sc->sc_node, "interrupts", intr, sizeof intr);
! 132: cirq = intr[0];
! 133: oirq = intr[2];
! 134: iirq = intr[4];
! 135: cirq_type = intr[1] ? IST_LEVEL : IST_EDGE;
! 136: oirq_type = intr[3] ? IST_LEVEL : IST_EDGE;
! 137: iirq_type = intr[5] ? IST_LEVEL : IST_EDGE;
! 138:
! 139: /* intr_establish(cirq, cirq_type, IPL_AUDIO, i2s_intr, sc); */
! 140: mac_intr_establish(parent, oirq, oirq_type, IPL_AUDIO, i2s_intr,
! 141: sc, sc->sc_dev.dv_xname);
! 142: /* intr_establish(iirq, iirq_type, IPL_AUDIO, i2s_intr, sc); */
! 143:
! 144: printf(": irq %d,%d,%d\n", cirq, oirq, iirq);
! 145:
! 146: i2s_set_rate(sc, 44100);
! 147: i2s_gpio_init(sc, ca->ca_node, parent);
! 148: }
! 149:
! 150: int
! 151: i2s_intr(v)
! 152: void *v;
! 153: {
! 154: struct i2s_softc *sc = v;
! 155: struct dbdma_command *cmd = sc->sc_odmap;
! 156: u_int16_t c, status;
! 157:
! 158: /* if not set we are not running */
! 159: if (!cmd)
! 160: return (0);
! 161: DPRINTF(("i2s_intr: cmd %x\n", cmd));
! 162:
! 163: c = in16rb(&cmd->d_command);
! 164: status = in16rb(&cmd->d_status);
! 165:
! 166: if (c >> 12 == DBDMA_CMD_OUT_LAST)
! 167: sc->sc_odmap = sc->sc_odmacmd;
! 168: else
! 169: sc->sc_odmap++;
! 170:
! 171: if (c & (DBDMA_INT_ALWAYS << 4)) {
! 172: cmd->d_status = 0;
! 173: if (status) /* status == 0x8400 */
! 174: if (sc->sc_ointr)
! 175: (*sc->sc_ointr)(sc->sc_oarg);
! 176: }
! 177:
! 178: return 1;
! 179: }
! 180:
! 181: int
! 182: i2s_open(h, flags)
! 183: void *h;
! 184: int flags;
! 185: {
! 186: return 0;
! 187: }
! 188:
! 189: /*
! 190: * Close function is called at splaudio().
! 191: */
! 192: void
! 193: i2s_close(h)
! 194: void *h;
! 195: {
! 196: struct i2s_softc *sc = h;
! 197:
! 198: i2s_halt_output(sc);
! 199: i2s_halt_input(sc);
! 200:
! 201: sc->sc_ointr = 0;
! 202: sc->sc_iintr = 0;
! 203: }
! 204:
! 205: int
! 206: i2s_query_encoding(h, ae)
! 207: void *h;
! 208: struct audio_encoding *ae;
! 209: {
! 210: int err = 0;
! 211:
! 212: switch (ae->index) {
! 213: case 0:
! 214: strlcpy(ae->name, AudioEslinear, sizeof(ae->name));
! 215: ae->encoding = AUDIO_ENCODING_SLINEAR;
! 216: ae->precision = 16;
! 217: ae->flags = 0;
! 218: break;
! 219: case 1:
! 220: strlcpy(ae->name, AudioEslinear_be, sizeof(ae->name));
! 221: ae->encoding = AUDIO_ENCODING_SLINEAR_BE;
! 222: ae->precision = 16;
! 223: ae->flags = 0;
! 224: break;
! 225: case 2:
! 226: strlcpy(ae->name, AudioEslinear_le, sizeof(ae->name));
! 227: ae->encoding = AUDIO_ENCODING_SLINEAR_LE;
! 228: ae->precision = 16;
! 229: ae->flags = AUDIO_ENCODINGFLAG_EMULATED;
! 230: break;
! 231: case 3:
! 232: strlcpy(ae->name, AudioEulinear_be, sizeof(ae->name));
! 233: ae->encoding = AUDIO_ENCODING_ULINEAR_BE;
! 234: ae->precision = 16;
! 235: ae->flags = AUDIO_ENCODINGFLAG_EMULATED;
! 236: break;
! 237: case 4:
! 238: strlcpy(ae->name, AudioEulinear_le, sizeof(ae->name));
! 239: ae->encoding = AUDIO_ENCODING_ULINEAR_LE;
! 240: ae->precision = 16;
! 241: ae->flags = AUDIO_ENCODINGFLAG_EMULATED;
! 242: break;
! 243: case 5:
! 244: strlcpy(ae->name, AudioEmulaw, sizeof(ae->name));
! 245: ae->encoding = AUDIO_ENCODING_ULAW;
! 246: ae->precision = 8;
! 247: ae->flags = AUDIO_ENCODINGFLAG_EMULATED;
! 248: break;
! 249: case 6:
! 250: strlcpy(ae->name, AudioEalaw, sizeof(ae->name));
! 251: ae->encoding = AUDIO_ENCODING_ALAW;
! 252: ae->precision = 8;
! 253: ae->flags = AUDIO_ENCODINGFLAG_EMULATED;
! 254: break;
! 255: case 7:
! 256: strlcpy(ae->name, AudioEslinear, sizeof(ae->name));
! 257: ae->encoding = AUDIO_ENCODING_SLINEAR;
! 258: ae->precision = 8;
! 259: ae->flags = AUDIO_ENCODINGFLAG_EMULATED;
! 260: break;
! 261: case 8:
! 262: strlcpy(ae->name, AudioEulinear, sizeof(ae->name));
! 263: ae->encoding = AUDIO_ENCODING_ULINEAR;
! 264: ae->precision = 8;
! 265: ae->flags = AUDIO_ENCODINGFLAG_EMULATED;
! 266: break;
! 267: default:
! 268: err = EINVAL;
! 269: break;
! 270: }
! 271: return (err);
! 272: }
! 273:
! 274: static void
! 275: mono16_to_stereo16(v, p, cc)
! 276: void *v;
! 277: u_char *p;
! 278: int cc;
! 279: {
! 280: int x;
! 281: int16_t *src, *dst;
! 282:
! 283: src = (void *)(p + cc);
! 284: dst = (void *)(p + cc * 2);
! 285: while (cc > 0) {
! 286: x = *--src;
! 287: *--dst = x;
! 288: *--dst = x;
! 289: cc -= 2;
! 290: }
! 291: }
! 292:
! 293: static void
! 294: swap_bytes_mono16_to_stereo16(v, p, cc)
! 295: void *v;
! 296: u_char *p;
! 297: int cc;
! 298: {
! 299: swap_bytes(v, p, cc);
! 300: mono16_to_stereo16(v, p, cc);
! 301: }
! 302:
! 303: void
! 304: i2s_cs16mts(void *v, u_char *p, int cc)
! 305: {
! 306: mono16_to_stereo16(v, p, cc);
! 307: change_sign16_be(v, p, cc * 2);
! 308: }
! 309:
! 310: struct i2s_mode {
! 311: u_int encoding;
! 312: u_int precision;
! 313: u_int channels;
! 314: void (*sw_code)(void *, u_char *, int);
! 315: int factor;
! 316: } i2s_modes[] = {
! 317: { AUDIO_ENCODING_SLINEAR_LE, 8, 1, linear8_to_linear16_be_mts, 4 },
! 318: { AUDIO_ENCODING_SLINEAR_LE, 8, 2, linear8_to_linear16_be, 2 },
! 319: { AUDIO_ENCODING_SLINEAR_LE, 16, 1, swap_bytes_mono16_to_stereo16, 2 },
! 320: { AUDIO_ENCODING_SLINEAR_LE, 16, 2, swap_bytes, 1 },
! 321: { AUDIO_ENCODING_SLINEAR_BE, 8, 1, linear8_to_linear16_be_mts, 4 },
! 322: { AUDIO_ENCODING_SLINEAR_BE, 8, 2, linear8_to_linear16_be, 2 },
! 323: { AUDIO_ENCODING_SLINEAR_BE, 16, 1, mono16_to_stereo16, 2 },
! 324: { AUDIO_ENCODING_SLINEAR_BE, 16, 2, NULL, 1 },
! 325: { AUDIO_ENCODING_ULINEAR_LE, 8, 1, ulinear8_to_linear16_be_mts, 4 },
! 326: { AUDIO_ENCODING_ULINEAR_LE, 8, 2, ulinear8_to_linear16_be, 2 },
! 327: { AUDIO_ENCODING_ULINEAR_LE, 16, 1, change_sign16_swap_bytes_le_mts, 2 },
! 328: { AUDIO_ENCODING_ULINEAR_LE, 16, 2, swap_bytes_change_sign16_be, 1 },
! 329: { AUDIO_ENCODING_ULINEAR_BE, 8, 1, ulinear8_to_linear16_be_mts, 4 },
! 330: { AUDIO_ENCODING_ULINEAR_BE, 8, 2, ulinear8_to_linear16_be, 2 },
! 331: { AUDIO_ENCODING_ULINEAR_BE, 16, 1, i2s_cs16mts, 2 },
! 332: { AUDIO_ENCODING_ULINEAR_BE, 16, 2, change_sign16_be, 1 }
! 333: };
! 334:
! 335:
! 336: struct i2s_mode *
! 337: i2s_find_mode(u_int encoding, u_int precision, u_int channels)
! 338: {
! 339: struct i2s_mode *m;
! 340: int i;
! 341:
! 342: for (i = 0; i < sizeof(i2s_modes)/sizeof(i2s_modes[0]); i++) {
! 343: m = &i2s_modes[i];
! 344: if (m->encoding == encoding &&
! 345: m->precision == precision &&
! 346: m->channels == channels)
! 347: return (m);
! 348: }
! 349: return (NULL);
! 350: }
! 351:
! 352: int
! 353: i2s_set_params(h, setmode, usemode, play, rec)
! 354: void *h;
! 355: int setmode, usemode;
! 356: struct audio_params *play, *rec;
! 357: {
! 358: struct i2s_mode *m;
! 359: struct i2s_softc *sc = h;
! 360: struct audio_params *p;
! 361: int mode;
! 362:
! 363: p = play; /* default to play */
! 364:
! 365: /*
! 366: * This device only has one clock, so make the sample rates match.
! 367: */
! 368: if (play->sample_rate != rec->sample_rate &&
! 369: usemode == (AUMODE_PLAY | AUMODE_RECORD)) {
! 370: if (setmode == AUMODE_PLAY) {
! 371: rec->sample_rate = play->sample_rate;
! 372: setmode |= AUMODE_RECORD;
! 373: } else if (setmode == AUMODE_RECORD) {
! 374: play->sample_rate = rec->sample_rate;
! 375: setmode |= AUMODE_PLAY;
! 376: } else
! 377: return EINVAL;
! 378: }
! 379:
! 380: for (mode = AUMODE_RECORD; mode != -1;
! 381: mode = mode == AUMODE_RECORD ? AUMODE_PLAY : -1) {
! 382: if ((setmode & mode) == 0)
! 383: continue;
! 384:
! 385: p = mode == AUMODE_PLAY ? play : rec;
! 386:
! 387: if (p->sample_rate < 4000 || p->sample_rate > 50000 ||
! 388: (p->precision != 8 && p->precision != 16) ||
! 389: (p->channels != 1 && p->channels != 2))
! 390: return EINVAL;
! 391:
! 392: switch (p->encoding) {
! 393: case AUDIO_ENCODING_SLINEAR_LE:
! 394: case AUDIO_ENCODING_SLINEAR_BE:
! 395: case AUDIO_ENCODING_ULINEAR_LE:
! 396: case AUDIO_ENCODING_ULINEAR_BE:
! 397: m = i2s_find_mode(p->encoding, p->precision,
! 398: p->channels);
! 399: if (m == NULL) {
! 400: printf("mode not found: %u/%u/%u\n",
! 401: p->encoding, p->precision, p->channels);
! 402: return (EINVAL);
! 403: }
! 404: p->factor = m->factor;
! 405: p->sw_code = m->sw_code;
! 406: break;
! 407:
! 408: case AUDIO_ENCODING_ULAW:
! 409: if (mode == AUMODE_PLAY) {
! 410: if (p->channels == 1) {
! 411: p->factor = 4;
! 412: p->sw_code = mulaw_to_slinear16_be_mts;
! 413: break;
! 414: }
! 415: if (p->channels == 2) {
! 416: p->factor = 2;
! 417: p->sw_code = mulaw_to_slinear16_be;
! 418: break;
! 419: }
! 420: } else
! 421: break; /* XXX */
! 422: return (EINVAL);
! 423:
! 424: case AUDIO_ENCODING_ALAW:
! 425: if (mode == AUMODE_PLAY) {
! 426: if (p->channels == 1) {
! 427: p->factor = 4;
! 428: p->sw_code = alaw_to_slinear16_be_mts;
! 429: break;
! 430: }
! 431: if (p->channels == 2) {
! 432: p->factor = 2;
! 433: p->sw_code = alaw_to_slinear16_be;
! 434: break;
! 435: }
! 436: } else
! 437: break; /* XXX */
! 438: return (EINVAL);
! 439:
! 440: default:
! 441: return (EINVAL);
! 442: }
! 443: }
! 444:
! 445: /* Set the speed */
! 446: if (i2s_set_rate(sc, play->sample_rate))
! 447: return EINVAL;
! 448:
! 449: p->sample_rate = sc->sc_rate;
! 450:
! 451: return 0;
! 452: }
! 453:
! 454: int
! 455: i2s_round_blocksize(h, size)
! 456: void *h;
! 457: int size;
! 458: {
! 459: if (size < NBPG)
! 460: size = NBPG;
! 461: return size & ~PGOFSET;
! 462: }
! 463:
! 464: int
! 465: i2s_halt_output(h)
! 466: void *h;
! 467: {
! 468: struct i2s_softc *sc = h;
! 469:
! 470: dbdma_stop(sc->sc_odma);
! 471: dbdma_reset(sc->sc_odma);
! 472: return 0;
! 473: }
! 474:
! 475: int
! 476: i2s_halt_input(h)
! 477: void *h;
! 478: {
! 479: struct i2s_softc *sc = h;
! 480:
! 481: dbdma_stop(sc->sc_idma);
! 482: dbdma_reset(sc->sc_idma);
! 483: return 0;
! 484: }
! 485:
! 486: enum {
! 487: I2S_OUTPUT_CLASS,
! 488: I2S_RECORD_CLASS,
! 489: I2S_OUTPUT_SELECT,
! 490: I2S_VOL_OUTPUT,
! 491: I2S_INPUT_SELECT,
! 492: I2S_VOL_INPUT,
! 493: I2S_BASS,
! 494: I2S_TREBLE,
! 495: I2S_ENUM_LAST
! 496: };
! 497:
! 498: int
! 499: i2s_set_port(h, mc)
! 500: void *h;
! 501: mixer_ctrl_t *mc;
! 502: {
! 503: struct i2s_softc *sc = h;
! 504: int l, r;
! 505:
! 506: DPRINTF(("i2s_set_port dev = %d, type = %d\n", mc->dev, mc->type));
! 507:
! 508: l = mc->un.value.level[AUDIO_MIXER_LEVEL_LEFT];
! 509: r = mc->un.value.level[AUDIO_MIXER_LEVEL_RIGHT];
! 510:
! 511: switch (mc->dev) {
! 512: case I2S_OUTPUT_SELECT:
! 513: /* No change necessary? */
! 514: if (mc->un.mask == sc->sc_output_mask)
! 515: return 0;
! 516:
! 517: i2s_mute_speaker(sc, 1);
! 518: i2s_mute_headphone(sc, 1);
! 519: i2s_mute_lineout(sc, 1);
! 520: if (mc->un.mask & 1 << 0)
! 521: i2s_mute_speaker(sc, 0);
! 522: if (mc->un.mask & 1 << 1)
! 523: i2s_mute_headphone(sc, 0);
! 524: if (mc->un.mask & 1 << 2)
! 525: i2s_mute_lineout(sc, 0);
! 526:
! 527: sc->sc_output_mask = mc->un.mask;
! 528: return 0;
! 529:
! 530: case I2S_VOL_OUTPUT:
! 531: (*sc->sc_setvolume)(sc, l, r);
! 532: return 0;
! 533:
! 534: case I2S_BASS:
! 535: if (sc->sc_setbass != NULL)
! 536: (*sc->sc_setbass)(sc, l);
! 537: return (0);
! 538:
! 539: case I2S_TREBLE:
! 540: if (sc->sc_settreble != NULL)
! 541: (*sc->sc_settreble)(sc, l);
! 542: return (0);
! 543:
! 544: case I2S_INPUT_SELECT:
! 545: /* no change necessary? */
! 546: if (mc->un.mask == sc->sc_record_source)
! 547: return 0;
! 548: switch (mc->un.mask) {
! 549: case 1 << 0: /* CD */
! 550: case 1 << 1: /* microphone */
! 551: case 1 << 2: /* line in */
! 552: /* XXX TO BE DONE */
! 553: break;
! 554: default: /* invalid argument */
! 555: return EINVAL;
! 556: }
! 557: sc->sc_record_source = mc->un.mask;
! 558: return 0;
! 559:
! 560: case I2S_VOL_INPUT:
! 561: /* XXX TO BE DONE */
! 562: return 0;
! 563: }
! 564:
! 565: return ENXIO;
! 566: }
! 567:
! 568: int
! 569: i2s_get_port(h, mc)
! 570: void *h;
! 571: mixer_ctrl_t *mc;
! 572: {
! 573: struct i2s_softc *sc = h;
! 574:
! 575: DPRINTF(("i2s_get_port dev = %d, type = %d\n", mc->dev, mc->type));
! 576:
! 577: switch (mc->dev) {
! 578: case I2S_OUTPUT_SELECT:
! 579: mc->un.mask = sc->sc_output_mask;
! 580: return 0;
! 581:
! 582: case I2S_VOL_OUTPUT:
! 583: mc->un.value.level[AUDIO_MIXER_LEVEL_LEFT] = sc->sc_vol_l;
! 584: mc->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] = sc->sc_vol_r;
! 585: return 0;
! 586:
! 587: case I2S_INPUT_SELECT:
! 588: mc->un.mask = sc->sc_record_source;
! 589: return 0;
! 590:
! 591: case I2S_BASS:
! 592: mc->un.value.level[AUDIO_MIXER_LEVEL_MONO] = sc->sc_bass;
! 593: return (0);
! 594:
! 595: case I2S_TREBLE:
! 596: mc->un.value.level[AUDIO_MIXER_LEVEL_MONO] = sc->sc_treble;
! 597: return (0);
! 598:
! 599: case I2S_VOL_INPUT:
! 600: /* XXX TO BE DONE */
! 601: mc->un.value.level[AUDIO_MIXER_LEVEL_LEFT] = 0;
! 602: mc->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] = 0;
! 603: return 0;
! 604:
! 605: default:
! 606: return ENXIO;
! 607: }
! 608:
! 609: return 0;
! 610: }
! 611:
! 612: int
! 613: i2s_query_devinfo(h, dip)
! 614: void *h;
! 615: mixer_devinfo_t *dip;
! 616: {
! 617: struct i2s_softc *sc = h;
! 618: int n = 0;
! 619:
! 620: switch (dip->index) {
! 621:
! 622: case I2S_OUTPUT_SELECT:
! 623: dip->mixer_class = I2S_OUTPUT_CLASS;
! 624: strlcpy(dip->label.name, AudioNselect, sizeof(dip->label.name));
! 625: dip->type = AUDIO_MIXER_SET;
! 626: dip->prev = dip->next = AUDIO_MIXER_LAST;
! 627: strlcpy(dip->un.s.member[n].label.name, AudioNspeaker,
! 628: sizeof(dip->un.s.member[n].label.name));
! 629: dip->un.s.member[n++].mask = 1 << 0;
! 630: if (headphone_mute) {
! 631: strlcpy(dip->un.s.member[n].label.name,
! 632: AudioNheadphone,
! 633: sizeof(dip->un.s.member[n].label.name));
! 634: dip->un.s.member[n++].mask = 1 << 1;
! 635: }
! 636: if (lineout_mute) {
! 637: strlcpy(dip->un.s.member[n].label.name, AudioNline,
! 638: sizeof(dip->un.s.member[n].label.name));
! 639: dip->un.s.member[n++].mask = 1 << 2;
! 640: }
! 641: dip->un.s.num_mem = n;
! 642: return 0;
! 643:
! 644: case I2S_VOL_OUTPUT:
! 645: dip->mixer_class = I2S_OUTPUT_CLASS;
! 646: strlcpy(dip->label.name, AudioNmaster, sizeof(dip->label.name));
! 647: dip->type = AUDIO_MIXER_VALUE;
! 648: dip->prev = dip->next = AUDIO_MIXER_LAST;
! 649: dip->un.v.num_channels = 2;
! 650: strlcpy(dip->un.v.units.name, AudioNvolume,
! 651: sizeof(dip->un.v.units.name));
! 652: return 0;
! 653:
! 654: case I2S_INPUT_SELECT:
! 655: dip->mixer_class = I2S_RECORD_CLASS;
! 656: strlcpy(dip->label.name, AudioNsource, sizeof(dip->label.name));
! 657: dip->type = AUDIO_MIXER_SET;
! 658: dip->prev = dip->next = AUDIO_MIXER_LAST;
! 659: dip->un.s.num_mem = 3;
! 660: strlcpy(dip->un.s.member[0].label.name, AudioNcd,
! 661: sizeof(dip->un.s.member[0].label.name));
! 662: dip->un.s.member[0].mask = 1 << 0;
! 663: strlcpy(dip->un.s.member[1].label.name, AudioNmicrophone,
! 664: sizeof(dip->un.s.member[1].label.name));
! 665: dip->un.s.member[1].mask = 1 << 1;
! 666: strlcpy(dip->un.s.member[2].label.name, AudioNline,
! 667: sizeof(dip->un.s.member[2].label.name));
! 668: dip->un.s.member[2].mask = 1 << 2;
! 669: return 0;
! 670:
! 671: case I2S_VOL_INPUT:
! 672: dip->mixer_class = I2S_RECORD_CLASS;
! 673: strlcpy(dip->label.name, AudioNrecord, sizeof(dip->label.name));
! 674: dip->type = AUDIO_MIXER_VALUE;
! 675: dip->prev = dip->next = AUDIO_MIXER_LAST;
! 676: dip->un.v.num_channels = 2;
! 677: strlcpy(dip->un.v.units.name, AudioNvolume,
! 678: sizeof(dip->un.v.units.name));
! 679: return 0;
! 680:
! 681: case I2S_OUTPUT_CLASS:
! 682: dip->mixer_class = I2S_OUTPUT_CLASS;
! 683: strlcpy(dip->label.name, AudioCoutputs,
! 684: sizeof(dip->label.name));
! 685: dip->type = AUDIO_MIXER_CLASS;
! 686: dip->next = dip->prev = AUDIO_MIXER_LAST;
! 687: return 0;
! 688:
! 689: case I2S_RECORD_CLASS:
! 690: dip->mixer_class = I2S_RECORD_CLASS;
! 691: strlcpy(dip->label.name, AudioCrecord, sizeof(dip->label.name));
! 692: dip->type = AUDIO_MIXER_CLASS;
! 693: dip->next = dip->prev = AUDIO_MIXER_LAST;
! 694: return 0;
! 695:
! 696: case I2S_BASS:
! 697: if (sc->sc_setbass == NULL)
! 698: return (ENXIO);
! 699: dip->mixer_class = I2S_OUTPUT_CLASS;
! 700: strlcpy(dip->label.name, AudioNbass, sizeof(dip->label.name));
! 701: dip->type = AUDIO_MIXER_VALUE;
! 702: dip->prev = dip->next = AUDIO_MIXER_LAST;
! 703: dip->un.v.num_channels = 1;
! 704: return (0);
! 705:
! 706: case I2S_TREBLE:
! 707: if (sc->sc_settreble == NULL)
! 708: return (ENXIO);
! 709: dip->mixer_class = I2S_OUTPUT_CLASS;
! 710: strlcpy(dip->label.name, AudioNtreble, sizeof(dip->label.name));
! 711: dip->type = AUDIO_MIXER_VALUE;
! 712: dip->prev = dip->next = AUDIO_MIXER_LAST;
! 713: dip->un.v.num_channels = 1;
! 714: return (0);
! 715: }
! 716:
! 717: return ENXIO;
! 718: }
! 719:
! 720: size_t
! 721: i2s_round_buffersize(h, dir, size)
! 722: void *h;
! 723: int dir;
! 724: size_t size;
! 725: {
! 726: if (size > 65536)
! 727: size = 65536;
! 728: return size;
! 729: }
! 730:
! 731: paddr_t
! 732: i2s_mappage(h, mem, off, prot)
! 733: void *h;
! 734: void *mem;
! 735: off_t off;
! 736: int prot;
! 737: {
! 738: if (off < 0)
! 739: return -1;
! 740: return -1; /* XXX */
! 741: }
! 742:
! 743: int
! 744: i2s_get_props(h)
! 745: void *h;
! 746: {
! 747: return AUDIO_PROP_FULLDUPLEX /* | AUDIO_PROP_MMAP */;
! 748: }
! 749:
! 750: int
! 751: i2s_trigger_output(h, start, end, bsize, intr, arg, param)
! 752: void *h;
! 753: void *start, *end;
! 754: int bsize;
! 755: void (*intr)(void *);
! 756: void *arg;
! 757: struct audio_params *param;
! 758: {
! 759: struct i2s_softc *sc = h;
! 760: struct i2s_dma *p;
! 761: struct dbdma_command *cmd = sc->sc_odmacmd;
! 762: vaddr_t spa, pa, epa;
! 763: int c;
! 764:
! 765: DPRINTF(("trigger_output %p %p 0x%x\n", start, end, bsize));
! 766:
! 767: for (p = sc->sc_dmas; p && p->addr != start; p = p->next);
! 768: if (!p)
! 769: return -1;
! 770:
! 771: sc->sc_ointr = intr;
! 772: sc->sc_oarg = arg;
! 773: sc->sc_odmap = sc->sc_odmacmd;
! 774:
! 775: spa = p->segs[0].ds_addr;
! 776: c = DBDMA_CMD_OUT_MORE;
! 777: for (pa = spa, epa = spa + (end - start);
! 778: pa < epa; pa += bsize, cmd++) {
! 779:
! 780: if (pa + bsize == epa)
! 781: c = DBDMA_CMD_OUT_LAST;
! 782:
! 783: DBDMA_BUILD(cmd, c, 0, bsize, pa, DBDMA_INT_ALWAYS,
! 784: DBDMA_WAIT_NEVER, DBDMA_BRANCH_NEVER);
! 785: }
! 786:
! 787: DBDMA_BUILD(cmd, DBDMA_CMD_NOP, 0, 0, 0,
! 788: DBDMA_INT_NEVER, DBDMA_WAIT_NEVER, DBDMA_BRANCH_ALWAYS);
! 789: dbdma_st32(&cmd->d_cmddep, sc->sc_odbdma->d_paddr);
! 790:
! 791: dbdma_start(sc->sc_odma, sc->sc_odbdma);
! 792:
! 793: return 0;
! 794: }
! 795:
! 796: int
! 797: i2s_trigger_input(h, start, end, bsize, intr, arg, param)
! 798: void *h;
! 799: void *start, *end;
! 800: int bsize;
! 801: void (*intr)(void *);
! 802: void *arg;
! 803: struct audio_params *param;
! 804: {
! 805: DPRINTF(("i2s_trigger_input called\n"));
! 806:
! 807: return 1;
! 808: }
! 809:
! 810:
! 811: /* rate = fs = LRCLK
! 812: * SCLK = 64*LRCLK (I2S)
! 813: * MCLK = 256fs (typ. -- changeable)
! 814: * MCLK = clksrc / mdiv
! 815: * SCLK = MCLK / sdiv
! 816: * rate = SCLK / 64 ( = LRCLK = fs)
! 817: */
! 818: int
! 819: i2s_set_rate(sc, rate)
! 820: struct i2s_softc *sc;
! 821: int rate;
! 822: {
! 823: u_int reg = 0;
! 824: int MCLK;
! 825: int clksrc, mdiv, sdiv;
! 826: int mclk_fs;
! 827: int timo;
! 828:
! 829: /* sanify */
! 830: if (rate > 48000)
! 831: rate = 48000;
! 832: else if (rate < 8000)
! 833: rate = 8000;
! 834:
! 835: switch (rate) {
! 836: case 8000:
! 837: clksrc = 18432000; /* 18MHz */
! 838: reg = CLKSRC_18MHz;
! 839: mclk_fs = 256;
! 840: break;
! 841:
! 842: case 44100:
! 843: clksrc = 45158400; /* 45MHz */
! 844: reg = CLKSRC_45MHz;
! 845: mclk_fs = 256;
! 846: break;
! 847:
! 848: case 48000:
! 849: clksrc = 49152000; /* 49MHz */
! 850: reg = CLKSRC_49MHz;
! 851: mclk_fs = 256;
! 852: break;
! 853:
! 854: default:
! 855: return EINVAL;
! 856: }
! 857:
! 858: MCLK = rate * mclk_fs;
! 859: mdiv = clksrc / MCLK; /* 4 */
! 860: sdiv = mclk_fs / 64; /* 4 */
! 861:
! 862: switch (mdiv) {
! 863: case 1:
! 864: reg |= MCLK_DIV1;
! 865: break;
! 866: case 3:
! 867: reg |= MCLK_DIV3;
! 868: break;
! 869: case 5:
! 870: reg |= MCLK_DIV5;
! 871: break;
! 872: default:
! 873: reg |= ((mdiv / 2 - 1) << 24) & 0x1f000000;
! 874: break;
! 875: }
! 876:
! 877: switch (sdiv) {
! 878: case 1:
! 879: reg |= SCLK_DIV1;
! 880: break;
! 881: case 3:
! 882: reg |= SCLK_DIV3;
! 883: break;
! 884: default:
! 885: reg |= ((sdiv / 2 - 1) << 20) & 0x00f00000;
! 886: break;
! 887: }
! 888:
! 889: reg |= SCLK_MASTER; /* XXX master mode */
! 890:
! 891: reg |= SERIAL_64x;
! 892:
! 893: if (sc->sc_rate == rate)
! 894: return (0);
! 895:
! 896: /* stereo input and output */
! 897: DPRINTF(("I2SSetDataWordSizeReg 0x%08x -> 0x%08x\n",
! 898: in32rb(sc->sc_reg + I2S_WORDSIZE), 0x02000200));
! 899: out32rb(sc->sc_reg + I2S_WORDSIZE, 0x02000200);
! 900:
! 901: /* Clear CLKSTOPPEND */
! 902: out32rb(sc->sc_reg + I2S_INT, I2S_INT_CLKSTOPPEND);
! 903:
! 904: keylargo_fcr_disable(I2SClockOffset, I2S0CLKEN);
! 905:
! 906: /* Wait until clock is stopped */
! 907: for (timo = 1000; timo > 0; timo--) {
! 908: if (in32rb(sc->sc_reg + I2S_INT) & I2S_INT_CLKSTOPPEND)
! 909: goto done;
! 910: delay(1);
! 911: }
! 912:
! 913: printf("i2s_set_rate: timeout\n");
! 914:
! 915: done:
! 916: DPRINTF(("I2SSetSerialFormatReg 0x%x -> 0x%x\n",
! 917: in32rb(sc->sc_reg + I2S_FORMAT), reg));
! 918: out32rb(sc->sc_reg + I2S_FORMAT, reg);
! 919:
! 920: keylargo_fcr_enable(I2SClockOffset, I2S0CLKEN);
! 921:
! 922: sc->sc_rate = rate;
! 923:
! 924: return 0;
! 925: }
! 926:
! 927: int
! 928: gpio_read(addr)
! 929: char *addr;
! 930: {
! 931: if (*addr & GPIO_DATA)
! 932: return 1;
! 933: return 0;
! 934: }
! 935:
! 936: void
! 937: gpio_write(addr, val)
! 938: char *addr;
! 939: int val;
! 940: {
! 941: u_int data = GPIO_DDR_OUTPUT;
! 942:
! 943: if (val)
! 944: data |= GPIO_DATA;
! 945: *addr = data;
! 946: asm volatile ("eieio" ::: "memory");
! 947: }
! 948:
! 949: #define amp_active 0 /* XXX OF */
! 950: #define headphone_active 0 /* XXX OF */
! 951: #define lineout_active 0 /* XXX OF */
! 952:
! 953: void
! 954: i2s_mute_speaker(sc, mute)
! 955: struct i2s_softc *sc;
! 956: int mute;
! 957: {
! 958: u_int x;
! 959:
! 960: if (amp_mute == NULL)
! 961: return;
! 962:
! 963: DPRINTF(("ampmute %d --> ", gpio_read(amp_mute)));
! 964:
! 965: if (mute)
! 966: x = amp_active; /* mute */
! 967: else
! 968: x = !amp_active; /* unmute */
! 969: if (x != gpio_read(amp_mute))
! 970: gpio_write(amp_mute, x);
! 971:
! 972: DPRINTF(("%d\n", gpio_read(amp_mute)));
! 973: }
! 974:
! 975: void
! 976: i2s_mute_headphone(sc, mute)
! 977: struct i2s_softc *sc;
! 978: int mute;
! 979: {
! 980: u_int x;
! 981:
! 982: if (headphone_mute == NULL)
! 983: return;
! 984:
! 985: DPRINTF(("headphonemute %d --> ", gpio_read(headphone_mute)));
! 986:
! 987: if (mute)
! 988: x = headphone_active; /* mute */
! 989: else
! 990: x = !headphone_active; /* unmute */
! 991: if (x != gpio_read(headphone_mute))
! 992: gpio_write(headphone_mute, x);
! 993:
! 994: DPRINTF(("%d\n", gpio_read(headphone_mute)));
! 995: }
! 996:
! 997: void
! 998: i2s_mute_lineout(sc, mute)
! 999: struct i2s_softc *sc;
! 1000: int mute;
! 1001: {
! 1002: u_int x;
! 1003:
! 1004: if (lineout_mute == NULL)
! 1005: return;
! 1006:
! 1007: DPRINTF(("lineout %d --> ", gpio_read(lineout_mute)));
! 1008:
! 1009: if (mute)
! 1010: x = lineout_active; /* mute */
! 1011: else
! 1012: x = !lineout_active; /* unmute */
! 1013: if (x != gpio_read(lineout_mute))
! 1014: gpio_write(lineout_mute, x);
! 1015:
! 1016: DPRINTF(("%d\n", gpio_read(lineout_mute)));
! 1017: }
! 1018:
! 1019: int
! 1020: i2s_cint(v)
! 1021: void *v;
! 1022: {
! 1023: struct i2s_softc *sc = v;
! 1024: u_int sense;
! 1025:
! 1026: sc->sc_output_mask = 0;
! 1027: i2s_mute_speaker(sc, 1);
! 1028: i2s_mute_headphone(sc, 1);
! 1029: i2s_mute_lineout(sc, 1);
! 1030:
! 1031: if (headphone_detect)
! 1032: sense = *headphone_detect;
! 1033: else
! 1034: sense = !headphone_detect_active << 1;
! 1035: DPRINTF(("headphone detect = 0x%x\n", sense));
! 1036:
! 1037: if (((sense & 0x02) >> 1) == headphone_detect_active) {
! 1038: DPRINTF(("headphone is inserted\n"));
! 1039: sc->sc_output_mask |= 1 << 1;
! 1040: i2s_mute_headphone(sc, 0);
! 1041: } else {
! 1042: DPRINTF(("headphone is NOT inserted\n"));
! 1043: }
! 1044:
! 1045: if (lineout_detect)
! 1046: sense = *lineout_detect;
! 1047: else
! 1048: sense = !lineout_detect_active << 1;
! 1049: DPRINTF(("lineout detect = 0x%x\n", sense));
! 1050:
! 1051: if (((sense & 0x02) >> 1) == lineout_detect_active) {
! 1052: DPRINTF(("lineout is inserted\n"));
! 1053: sc->sc_output_mask |= 1 << 2;
! 1054: i2s_mute_lineout(sc, 0);
! 1055: } else {
! 1056: DPRINTF(("lineout is NOT inserted\n"));
! 1057: }
! 1058:
! 1059: if (sc->sc_output_mask == 0) {
! 1060: sc->sc_output_mask |= 1 << 0;
! 1061: i2s_mute_speaker(sc, 0);
! 1062: }
! 1063:
! 1064: return 1;
! 1065: }
! 1066:
! 1067: u_char *
! 1068: i2s_gpio_map(struct i2s_softc *sc, char *name, int *irq)
! 1069: {
! 1070: u_int32_t reg[2];
! 1071: u_int32_t intr[2];
! 1072: int gpio;
! 1073:
! 1074: if (OF_getprop(sc->sc_node, name, &gpio,
! 1075: sizeof(gpio)) != sizeof(gpio) ||
! 1076: OF_getprop(gpio, "reg", ®[0],
! 1077: sizeof(reg[0])) != sizeof(reg[0]) ||
! 1078: OF_getprop(OF_parent(gpio), "reg", ®[1],
! 1079: sizeof(reg[1])) != sizeof(reg[1]))
! 1080: return NULL;
! 1081:
! 1082: if (irq && OF_getprop(gpio, "interrupts",
! 1083: intr, sizeof(intr)) == sizeof(intr)) {
! 1084: *irq = intr[0];
! 1085: }
! 1086:
! 1087: return mapiodev(sc->sc_baseaddr + reg[0] + reg[1], 1);
! 1088: }
! 1089:
! 1090: void
! 1091: i2s_gpio_init(sc, node, parent)
! 1092: struct i2s_softc *sc;
! 1093: int node;
! 1094: struct device *parent;
! 1095: {
! 1096: int gpio;
! 1097: int headphone_detect_intr = -1, headphone_detect_intrtype;
! 1098: int lineout_detect_intr = -1;
! 1099:
! 1100: /* Map gpios. */
! 1101: amp_mute = i2s_gpio_map(sc, "platform-amp-mute", NULL);
! 1102: headphone_mute = i2s_gpio_map(sc, "platform-headphone-mute", NULL);
! 1103: headphone_detect = i2s_gpio_map(sc, "platform-headphone-detect",
! 1104: &headphone_detect_intr);
! 1105: lineout_mute = i2s_gpio_map(sc, "platform-lineout-mute", NULL);
! 1106: lineout_detect = i2s_gpio_map(sc, "platform-lineout-detect",
! 1107: &lineout_detect_intr);
! 1108: audio_hw_reset = i2s_gpio_map(sc, "platform-hw-reset", NULL);
! 1109:
! 1110: gpio = OF_getnodebyname(OF_parent(node), "gpio");
! 1111: DPRINTF((" /gpio 0x%x\n", gpio));
! 1112: gpio = OF_child(gpio);
! 1113: while (gpio) {
! 1114: char name[64], audio_gpio[64];
! 1115: int intr[2];
! 1116: paddr_t addr;
! 1117:
! 1118: bzero(name, sizeof name);
! 1119: bzero(audio_gpio, sizeof audio_gpio);
! 1120: addr = 0;
! 1121: OF_getprop(gpio, "name", name, sizeof name);
! 1122: OF_getprop(gpio, "audio-gpio", audio_gpio, sizeof audio_gpio);
! 1123: OF_getprop(gpio, "AAPL,address", &addr, sizeof addr);
! 1124: /* printf("0x%x %s %s\n", gpio, name, audio_gpio); */
! 1125:
! 1126: /* gpio5 */
! 1127: if (headphone_mute == NULL &&
! 1128: strcmp(audio_gpio, "headphone-mute") == 0)
! 1129: headphone_mute = mapiodev(addr,1);
! 1130:
! 1131: /* gpio6 */
! 1132: if (amp_mute == NULL &&
! 1133: strcmp(audio_gpio, "amp-mute") == 0)
! 1134: amp_mute = mapiodev(addr,1);
! 1135:
! 1136: /* extint-gpio15 */
! 1137: if (headphone_detect == NULL &&
! 1138: strcmp(audio_gpio, "headphone-detect") == 0) {
! 1139: headphone_detect = mapiodev(addr,1);
! 1140: OF_getprop(gpio, "audio-gpio-active-state",
! 1141: &headphone_detect_active, 4);
! 1142: OF_getprop(gpio, "interrupts", intr, 8);
! 1143: headphone_detect_intr = intr[0];
! 1144: headphone_detect_intrtype = intr[1];
! 1145: }
! 1146:
! 1147: /* gpio11 (keywest-11) */
! 1148: if (audio_hw_reset == NULL &&
! 1149: strcmp(audio_gpio, "audio-hw-reset") == 0)
! 1150: audio_hw_reset = mapiodev(addr,1);
! 1151:
! 1152: gpio = OF_peer(gpio);
! 1153: }
! 1154: DPRINTF((" amp-mute %p\n", amp_mute));
! 1155: DPRINTF((" headphone-mute %p\n", headphone_mute));
! 1156: DPRINTF((" headphone-detect %p\n", headphone_detect));
! 1157: DPRINTF((" headphone-detect active %x\n", headphone_detect_active));
! 1158: DPRINTF((" headphone-detect intr %x\n", headphone_detect_intr));
! 1159: DPRINTF((" lineout-mute %p\n", lineout_mute));
! 1160: DPRINTF((" lineout-detect %p\n", lineout_detect));
! 1161: DPRINTF((" lineout-detect active %x\n", lineout_detect_active));
! 1162: DPRINTF((" lineout-detect intr %x\n", lineout_detect_intr));
! 1163: DPRINTF((" audio-hw-reset %p\n", audio_hw_reset));
! 1164:
! 1165: if (headphone_detect_intr != -1)
! 1166: mac_intr_establish(parent, headphone_detect_intr, IST_EDGE,
! 1167: IPL_AUDIO, i2s_cint, sc, sc->sc_dev.dv_xname);
! 1168:
! 1169: if (lineout_detect_intr != -1)
! 1170: mac_intr_establish(parent, lineout_detect_intr, IST_EDGE,
! 1171: IPL_AUDIO, i2s_cint, sc, sc->sc_dev.dv_xname);
! 1172:
! 1173: /* Enable headphone interrupt? */
! 1174: *headphone_detect |= 0x80;
! 1175: asm volatile("eieio");
! 1176:
! 1177: /* Update headphone status. */
! 1178: i2s_cint(sc);
! 1179: }
! 1180:
! 1181: void *
! 1182: i2s_allocm(void *h, int dir, size_t size, int type, int flags)
! 1183: {
! 1184: struct i2s_softc *sc = h;
! 1185: struct i2s_dma *p;
! 1186: int error;
! 1187:
! 1188: if (size > I2S_DMALIST_MAX * I2S_DMASEG_MAX)
! 1189: return (NULL);
! 1190:
! 1191: p = malloc(sizeof(*p), type, flags);
! 1192: if (!p)
! 1193: return (NULL);
! 1194: bzero(p, sizeof(*p));
! 1195:
! 1196: /* convert to the bus.h style, not used otherwise */
! 1197: if (flags & M_NOWAIT)
! 1198: flags = BUS_DMA_NOWAIT;
! 1199:
! 1200: p->size = size;
! 1201: if ((error = bus_dmamem_alloc(sc->sc_dmat, p->size, NBPG, 0, p->segs,
! 1202: 1, &p->nsegs, flags)) != 0) {
! 1203: printf("%s: unable to allocate dma, error = %d\n",
! 1204: sc->sc_dev.dv_xname, error);
! 1205: free(p, type);
! 1206: return NULL;
! 1207: }
! 1208:
! 1209: if ((error = bus_dmamem_map(sc->sc_dmat, p->segs, p->nsegs, p->size,
! 1210: &p->addr, flags | BUS_DMA_COHERENT)) != 0) {
! 1211: printf("%s: unable to map dma, error = %d\n",
! 1212: sc->sc_dev.dv_xname, error);
! 1213: bus_dmamem_free(sc->sc_dmat, p->segs, p->nsegs);
! 1214: free(p, type);
! 1215: return NULL;
! 1216: }
! 1217:
! 1218: if ((error = bus_dmamap_create(sc->sc_dmat, p->size, 1,
! 1219: p->size, 0, flags, &p->map)) != 0) {
! 1220: printf("%s: unable to create dma map, error = %d\n",
! 1221: sc->sc_dev.dv_xname, error);
! 1222: bus_dmamem_unmap(sc->sc_dmat, p->addr, size);
! 1223: bus_dmamem_free(sc->sc_dmat, p->segs, p->nsegs);
! 1224: free(p, type);
! 1225: return NULL;
! 1226: }
! 1227:
! 1228: if ((error = bus_dmamap_load(sc->sc_dmat, p->map, p->addr, p->size,
! 1229: NULL, flags)) != 0) {
! 1230: printf("%s: unable to load dma map, error = %d\n",
! 1231: sc->sc_dev.dv_xname, error);
! 1232: bus_dmamap_destroy(sc->sc_dmat, p->map);
! 1233: bus_dmamem_unmap(sc->sc_dmat, p->addr, size);
! 1234: bus_dmamem_free(sc->sc_dmat, p->segs, p->nsegs);
! 1235: free(p, type);
! 1236: return NULL;
! 1237: }
! 1238:
! 1239: p->next = sc->sc_dmas;
! 1240: sc->sc_dmas = p;
! 1241:
! 1242: return p->addr;
! 1243: }
! 1244:
! 1245: #define reset_active 0
! 1246:
! 1247: int
! 1248: deq_reset(struct i2s_softc *sc)
! 1249: {
! 1250: if (audio_hw_reset == NULL)
! 1251: return (-1);
! 1252:
! 1253: gpio_write(audio_hw_reset, !reset_active);
! 1254: delay(1000000);
! 1255:
! 1256: gpio_write(audio_hw_reset, reset_active);
! 1257: delay(1);
! 1258:
! 1259: gpio_write(audio_hw_reset, !reset_active);
! 1260: delay(10000);
! 1261:
! 1262: return (0);
! 1263: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to i2s.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / macppc / dev