Annotation of sys/arch/sparc64/dev/ce4231.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: ce4231.c,v 1.21 2005/09/08 15:25:54 martin Exp $ */
! 2:
! 3: /*
! 4: * Copyright (c) 1999 Jason L. Wright (jason@thought.net)
! 5: * 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: *
! 16: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
! 17: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
! 18: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
! 19: * DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
! 20: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
! 21: * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
! 22: * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 23: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
! 24: * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
! 25: * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
! 26: * POSSIBILITY OF SUCH DAMAGE.
! 27: */
! 28:
! 29: /*
! 30: * Driver for CS4231 based audio found in some sun4u systems (cs4231)
! 31: * based on ideas from the S/Linux project and the NetBSD project.
! 32: *
! 33: * Effort sponsored in part by the Defense Advanced Research Projects
! 34: * Agency (DARPA) and Air Force Research Laboratory, Air Force
! 35: * Materiel Command, USAF, under agreement number F30602-01-2-0537.
! 36: *
! 37: */
! 38:
! 39: #include <sys/param.h>
! 40: #include <sys/systm.h>
! 41: #include <sys/errno.h>
! 42: #include <sys/ioctl.h>
! 43: #include <sys/device.h>
! 44: #include <sys/proc.h>
! 45: #include <sys/malloc.h>
! 46:
! 47: #include <machine/cpu.h>
! 48: #include <machine/bus.h>
! 49: #include <machine/intr.h>
! 50: #include <machine/autoconf.h>
! 51:
! 52: #include <sys/audioio.h>
! 53: #include <dev/audio_if.h>
! 54: #include <dev/auconv.h>
! 55:
! 56: #include <sparc64/dev/ebusreg.h>
! 57: #include <sparc64/dev/ebusvar.h>
! 58: #include <sparc64/dev/ce4231var.h>
! 59:
! 60: #include <dev/ic/ad1848reg.h>
! 61: #include <dev/ic/cs4231reg.h>
! 62:
! 63: #define CSAUDIO_DAC_LVL 0
! 64: #define CSAUDIO_LINE_IN_LVL 1
! 65: #define CSAUDIO_MIC_LVL 2
! 66: #define CSAUDIO_CD_LVL 3
! 67: #define CSAUDIO_MONITOR_LVL 4
! 68: #define CSAUDIO_OUTPUT_LVL 5
! 69: #define CSAUDIO_LINE_IN_MUTE 6
! 70: #define CSAUDIO_DAC_MUTE 7
! 71: #define CSAUDIO_CD_MUTE 8
! 72: #define CSAUDIO_MIC_MUTE 9
! 73: #define CSAUDIO_MONITOR_MUTE 10
! 74: #define CSAUDIO_OUTPUT_MUTE 11
! 75: #define CSAUDIO_REC_LVL 12
! 76: #define CSAUDIO_RECORD_SOURCE 13
! 77: #define CSAUDIO_OUTPUT 14
! 78: #define CSAUDIO_INPUT_CLASS 15
! 79: #define CSAUDIO_OUTPUT_CLASS 16
! 80: #define CSAUDIO_RECORD_CLASS 17
! 81: #define CSAUDIO_MONITOR_CLASS 18
! 82:
! 83: #define CSPORT_AUX2 0
! 84: #define CSPORT_AUX1 1
! 85: #define CSPORT_DAC 2
! 86: #define CSPORT_LINEIN 3
! 87: #define CSPORT_MONO 4
! 88: #define CSPORT_MONITOR 5
! 89: #define CSPORT_SPEAKER 6
! 90: #define CSPORT_LINEOUT 7
! 91: #define CSPORT_HEADPHONE 8
! 92:
! 93: #define MIC_IN_PORT 0
! 94: #define LINE_IN_PORT 1
! 95: #define AUX1_IN_PORT 2
! 96: #define DAC_IN_PORT 3
! 97:
! 98: #ifdef AUDIO_DEBUG
! 99: #define DPRINTF(x) printf x
! 100: #else
! 101: #define DPRINTF(x)
! 102: #endif
! 103:
! 104: #define CS_TIMEOUT 90000
! 105:
! 106: #define CS_PC_LINEMUTE XCTL0_ENABLE
! 107: #define CS_PC_HDPHMUTE XCTL1_ENABLE
! 108: #define CS_AFS_PI 0x10
! 109:
! 110: /* Read/write CS4231 direct registers */
! 111: #define CS_WRITE(sc,r,v) \
! 112: bus_space_write_1((sc)->sc_bustag, (sc)->sc_cshandle, (r) << 2, (v))
! 113: #define CS_READ(sc,r) \
! 114: bus_space_read_1((sc)->sc_bustag, (sc)->sc_cshandle, (r) << 2)
! 115:
! 116: /* Read/write EBDMA playback registers */
! 117: #define P_WRITE(sc,r,v) \
! 118: bus_space_write_4((sc)->sc_bustag, (sc)->sc_pdmahandle, (r), (v))
! 119: #define P_READ(sc,r) \
! 120: bus_space_read_4((sc)->sc_bustag, (sc)->sc_pdmahandle, (r))
! 121:
! 122: /* Read/write EBDMA capture registers */
! 123: #define C_WRITE(sc,r,v) \
! 124: bus_space_write_4((sc)->sc_bustag, (sc)->sc_cdmahandle, (r), (v))
! 125: #define C_READ(sc,r) \
! 126: bus_space_read_4((sc)->sc_bustag, (sc)->sc_cdmahandle, (r))
! 127:
! 128: int ce4231_match(struct device *, void *, void *);
! 129: void ce4231_attach(struct device *, struct device *, void *);
! 130: int ce4231_cintr(void *);
! 131: int ce4231_pintr(void *);
! 132:
! 133: int ce4231_set_speed(struct ce4231_softc *, u_long *);
! 134: void ce4231_setup_output(struct ce4231_softc *sc);
! 135:
! 136: void ce4231_write(struct ce4231_softc *, u_int8_t, u_int8_t);
! 137: u_int8_t ce4231_read(struct ce4231_softc *, u_int8_t);
! 138:
! 139: /* Audio interface */
! 140: int ce4231_open(void *, int);
! 141: void ce4231_close(void *);
! 142: int ce4231_query_encoding(void *, struct audio_encoding *);
! 143: int ce4231_set_params(void *, int, int, struct audio_params *,
! 144: struct audio_params *);
! 145: int ce4231_round_blocksize(void *, int);
! 146: int ce4231_commit_settings(void *);
! 147: int ce4231_halt_output(void *);
! 148: int ce4231_halt_input(void *);
! 149: int ce4231_getdev(void *, struct audio_device *);
! 150: int ce4231_set_port(void *, mixer_ctrl_t *);
! 151: int ce4231_get_port(void *, mixer_ctrl_t *);
! 152: int ce4231_query_devinfo(void *addr, mixer_devinfo_t *);
! 153: void * ce4231_alloc(void *, int, size_t, int, int);
! 154: void ce4231_free(void *, void *, int);
! 155: int ce4231_get_props(void *);
! 156: int ce4231_trigger_output(void *, void *, void *, int,
! 157: void (*intr)(void *), void *arg, struct audio_params *);
! 158: int ce4231_trigger_input(void *, void *, void *, int,
! 159: void (*intr)(void *), void *arg, struct audio_params *);
! 160:
! 161: struct audio_hw_if ce4231_sa_hw_if = {
! 162: ce4231_open,
! 163: ce4231_close,
! 164: 0,
! 165: ce4231_query_encoding,
! 166: ce4231_set_params,
! 167: ce4231_round_blocksize,
! 168: ce4231_commit_settings,
! 169: 0,
! 170: 0,
! 171: 0,
! 172: 0,
! 173: ce4231_halt_output,
! 174: ce4231_halt_input,
! 175: 0,
! 176: ce4231_getdev,
! 177: 0,
! 178: ce4231_set_port,
! 179: ce4231_get_port,
! 180: ce4231_query_devinfo,
! 181: ce4231_alloc,
! 182: ce4231_free,
! 183: 0,
! 184: 0,
! 185: ce4231_get_props,
! 186: ce4231_trigger_output,
! 187: ce4231_trigger_input
! 188: };
! 189:
! 190: struct cfattach audioce_ca = {
! 191: sizeof (struct ce4231_softc), ce4231_match, ce4231_attach
! 192: };
! 193:
! 194: struct cfdriver audioce_cd = {
! 195: NULL, "audioce", DV_DULL
! 196: };
! 197:
! 198: struct audio_device ce4231_device = {
! 199: "SUNW,CS4231",
! 200: "b",
! 201: "onboard1",
! 202: };
! 203:
! 204: int
! 205: ce4231_match(parent, vcf, aux)
! 206: struct device *parent;
! 207: void *vcf, *aux;
! 208: {
! 209: struct ebus_attach_args *ea = aux;
! 210:
! 211: if (!strcmp("SUNW,CS4231", ea->ea_name) ||
! 212: !strcmp("audio", ea->ea_name))
! 213: return (1);
! 214: return (0);
! 215: }
! 216:
! 217: void
! 218: ce4231_attach(parent, self, aux)
! 219: struct device *parent, *self;
! 220: void *aux;
! 221: {
! 222: struct ebus_attach_args *ea = aux;
! 223: struct ce4231_softc *sc = (struct ce4231_softc *)self;
! 224: int node;
! 225:
! 226: node = ea->ea_node;
! 227:
! 228: sc->sc_last_format = 0xffffffff;
! 229:
! 230: /* Pass on the bus tags */
! 231: sc->sc_bustag = ea->ea_memtag;
! 232: sc->sc_dmatag = ea->ea_dmatag;
! 233:
! 234: /* Make sure things are sane. */
! 235: if (ea->ea_nintrs != 2) {
! 236: printf(": expected 2 interrupts, got %d\n", ea->ea_nintrs);
! 237: return;
! 238: }
! 239: if (ea->ea_nregs != 4) {
! 240: printf(": expected 4 register set, got %d\n",
! 241: ea->ea_nregs);
! 242: return;
! 243: }
! 244:
! 245: sc->sc_cih = bus_intr_establish(sc->sc_bustag, ea->ea_intrs[0],
! 246: IPL_AUDIO, 0, ce4231_cintr, sc, self->dv_xname);
! 247: if (sc->sc_cih == NULL) {
! 248: printf(": couldn't establish capture interrupt\n");
! 249: return;
! 250: }
! 251: sc->sc_pih = bus_intr_establish(sc->sc_bustag, ea->ea_intrs[1],
! 252: IPL_AUDIO, 0, ce4231_pintr, sc, self->dv_xname);
! 253: if (sc->sc_pih == NULL) {
! 254: printf(": couldn't establish play interrupt1\n");
! 255: return;
! 256: }
! 257:
! 258: /* XXX what if prom has already mapped?! */
! 259:
! 260: if (ebus_bus_map(sc->sc_bustag, 0,
! 261: EBUS_PADDR_FROM_REG(&ea->ea_regs[0]), ea->ea_regs[0].size,
! 262: BUS_SPACE_MAP_LINEAR, 0, &sc->sc_cshandle) != 0) {
! 263: printf(": couldn't map cs4231 registers\n");
! 264: return;
! 265: }
! 266:
! 267: if (ebus_bus_map(sc->sc_bustag, 0,
! 268: EBUS_PADDR_FROM_REG(&ea->ea_regs[1]), ea->ea_regs[1].size,
! 269: BUS_SPACE_MAP_LINEAR, 0, &sc->sc_pdmahandle) != 0) {
! 270: printf(": couldn't map dma1 registers\n");
! 271: return;
! 272: }
! 273:
! 274: if (ebus_bus_map(sc->sc_bustag, 0,
! 275: EBUS_PADDR_FROM_REG(&ea->ea_regs[2]), ea->ea_regs[2].size,
! 276: BUS_SPACE_MAP_LINEAR, 0, &sc->sc_cdmahandle) != 0) {
! 277: printf(": couldn't map dma2 registers\n");
! 278: return;
! 279: }
! 280:
! 281: if (ebus_bus_map(sc->sc_bustag, 0,
! 282: EBUS_PADDR_FROM_REG(&ea->ea_regs[3]), ea->ea_regs[3].size,
! 283: BUS_SPACE_MAP_LINEAR, 0, &sc->sc_auxhandle) != 0) {
! 284: printf(": couldn't map aux registers\n");
! 285: return;
! 286: }
! 287:
! 288: printf(": nvaddrs %d\n", ea->ea_nvaddrs);
! 289:
! 290: audio_attach_mi(&ce4231_sa_hw_if, sc, &sc->sc_dev);
! 291:
! 292: /* Default to speaker, unmuted, reasonable volume */
! 293: sc->sc_out_port = CSPORT_SPEAKER;
! 294: sc->sc_mute[CSPORT_SPEAKER] = 1;
! 295: sc->sc_mute[CSPORT_MONITOR] = 1;
! 296: sc->sc_volume[CSPORT_SPEAKER].left = 192;
! 297: sc->sc_volume[CSPORT_SPEAKER].right = 192;
! 298:
! 299: /* XXX get real burst... */
! 300: sc->sc_burst = EBDCSR_BURST_8;
! 301: }
! 302:
! 303: /*
! 304: * Write to one of the indexed registers of cs4231.
! 305: */
! 306: void
! 307: ce4231_write(sc, r, v)
! 308: struct ce4231_softc *sc;
! 309: u_int8_t r, v;
! 310: {
! 311: CS_WRITE(sc, AD1848_IADDR, r);
! 312: CS_WRITE(sc, AD1848_IDATA, v);
! 313: }
! 314:
! 315: /*
! 316: * Read from one of the indexed registers of cs4231.
! 317: */
! 318: u_int8_t
! 319: ce4231_read(sc, r)
! 320: struct ce4231_softc *sc;
! 321: u_int8_t r;
! 322: {
! 323: CS_WRITE(sc, AD1848_IADDR, r);
! 324: return (CS_READ(sc, AD1848_IDATA));
! 325: }
! 326:
! 327: int
! 328: ce4231_set_speed(sc, argp)
! 329: struct ce4231_softc *sc;
! 330: u_long *argp;
! 331:
! 332: {
! 333: /*
! 334: * The available speeds are in the following table. Keep the speeds in
! 335: * the increasing order.
! 336: */
! 337: typedef struct {
! 338: int speed;
! 339: u_char bits;
! 340: } speed_struct;
! 341: u_long arg = *argp;
! 342:
! 343: static speed_struct speed_table[] = {
! 344: {5510, (0 << 1) | CLOCK_XTAL2},
! 345: {5510, (0 << 1) | CLOCK_XTAL2},
! 346: {6620, (7 << 1) | CLOCK_XTAL2},
! 347: {8000, (0 << 1) | CLOCK_XTAL1},
! 348: {9600, (7 << 1) | CLOCK_XTAL1},
! 349: {11025, (1 << 1) | CLOCK_XTAL2},
! 350: {16000, (1 << 1) | CLOCK_XTAL1},
! 351: {18900, (2 << 1) | CLOCK_XTAL2},
! 352: {22050, (3 << 1) | CLOCK_XTAL2},
! 353: {27420, (2 << 1) | CLOCK_XTAL1},
! 354: {32000, (3 << 1) | CLOCK_XTAL1},
! 355: {33075, (6 << 1) | CLOCK_XTAL2},
! 356: {33075, (4 << 1) | CLOCK_XTAL2},
! 357: {44100, (5 << 1) | CLOCK_XTAL2},
! 358: {48000, (6 << 1) | CLOCK_XTAL1},
! 359: };
! 360:
! 361: int i, n, selected = -1;
! 362:
! 363: n = sizeof(speed_table) / sizeof(speed_struct);
! 364:
! 365: if (arg < speed_table[0].speed)
! 366: selected = 0;
! 367: if (arg > speed_table[n - 1].speed)
! 368: selected = n - 1;
! 369:
! 370: for (i = 1; selected == -1 && i < n; i++) {
! 371: if (speed_table[i].speed == arg)
! 372: selected = i;
! 373: else if (speed_table[i].speed > arg) {
! 374: int diff1, diff2;
! 375:
! 376: diff1 = arg - speed_table[i - 1].speed;
! 377: diff2 = speed_table[i].speed - arg;
! 378: if (diff1 < diff2)
! 379: selected = i - 1;
! 380: else
! 381: selected = i;
! 382: }
! 383: }
! 384:
! 385: if (selected == -1)
! 386: selected = 3;
! 387:
! 388: sc->sc_speed_bits = speed_table[selected].bits;
! 389: sc->sc_need_commit = 1;
! 390: *argp = speed_table[selected].speed;
! 391:
! 392: return (0);
! 393: }
! 394:
! 395: /*
! 396: * Audio interface functions
! 397: */
! 398: int
! 399: ce4231_open(addr, flags)
! 400: void *addr;
! 401: int flags;
! 402: {
! 403: struct ce4231_softc *sc = addr;
! 404: int tries;
! 405:
! 406: if (sc->sc_open)
! 407: return (EBUSY);
! 408: sc->sc_open = 1;
! 409: sc->sc_locked = 0;
! 410: sc->sc_rintr = 0;
! 411: sc->sc_rarg = 0;
! 412: sc->sc_pintr = 0;
! 413: sc->sc_parg = 0;
! 414:
! 415: P_WRITE(sc, EBDMA_DCSR, EBDCSR_RESET);
! 416: C_WRITE(sc, EBDMA_DCSR, EBDCSR_RESET);
! 417: P_WRITE(sc, EBDMA_DCSR, sc->sc_burst);
! 418: C_WRITE(sc, EBDMA_DCSR, sc->sc_burst);
! 419:
! 420: DELAY(20);
! 421:
! 422: for (tries = CS_TIMEOUT;
! 423: tries && CS_READ(sc, AD1848_IADDR) == SP_IN_INIT; tries--)
! 424: DELAY(10);
! 425: if (tries == 0)
! 426: printf("%s: timeout waiting for reset\n", sc->sc_dev.dv_xname);
! 427:
! 428: /* Turn on cs4231 mode */
! 429: ce4231_write(sc, SP_MISC_INFO,
! 430: ce4231_read(sc, SP_MISC_INFO) | MODE2);
! 431:
! 432: ce4231_setup_output(sc);
! 433:
! 434: ce4231_write(sc, SP_PIN_CONTROL,
! 435: ce4231_read(sc, SP_PIN_CONTROL) | INTERRUPT_ENABLE);
! 436:
! 437: return (0);
! 438: }
! 439:
! 440: void
! 441: ce4231_setup_output(sc)
! 442: struct ce4231_softc *sc;
! 443: {
! 444: u_int8_t pc, mi, rm, lm;
! 445:
! 446: pc = ce4231_read(sc, SP_PIN_CONTROL) | CS_PC_HDPHMUTE | CS_PC_LINEMUTE;
! 447:
! 448: mi = ce4231_read(sc, CS_MONO_IO_CONTROL) | MONO_OUTPUT_MUTE;
! 449:
! 450: lm = ce4231_read(sc, SP_LEFT_OUTPUT_CONTROL);
! 451: lm &= ~OUTPUT_ATTEN_BITS;
! 452: lm |= ((~(sc->sc_volume[CSPORT_SPEAKER].left >> 2)) &
! 453: OUTPUT_ATTEN_BITS) | OUTPUT_MUTE;
! 454:
! 455: rm = ce4231_read(sc, SP_RIGHT_OUTPUT_CONTROL);
! 456: rm &= ~OUTPUT_ATTEN_BITS;
! 457: rm |= ((~(sc->sc_volume[CSPORT_SPEAKER].right >> 2)) &
! 458: OUTPUT_ATTEN_BITS) | OUTPUT_MUTE;
! 459:
! 460: if (sc->sc_mute[CSPORT_MONITOR]) {
! 461: lm &= ~OUTPUT_MUTE;
! 462: rm &= ~OUTPUT_MUTE;
! 463: }
! 464:
! 465: switch (sc->sc_out_port) {
! 466: case CSPORT_HEADPHONE:
! 467: if (sc->sc_mute[CSPORT_SPEAKER])
! 468: pc &= ~CS_PC_HDPHMUTE;
! 469: break;
! 470: case CSPORT_SPEAKER:
! 471: if (sc->sc_mute[CSPORT_SPEAKER])
! 472: mi &= ~MONO_OUTPUT_MUTE;
! 473: break;
! 474: case CSPORT_LINEOUT:
! 475: if (sc->sc_mute[CSPORT_SPEAKER])
! 476: pc &= ~CS_PC_LINEMUTE;
! 477: break;
! 478: }
! 479:
! 480: ce4231_write(sc, SP_LEFT_OUTPUT_CONTROL, lm);
! 481: ce4231_write(sc, SP_RIGHT_OUTPUT_CONTROL, rm);
! 482: ce4231_write(sc, SP_PIN_CONTROL, pc);
! 483: ce4231_write(sc, CS_MONO_IO_CONTROL, mi);
! 484: }
! 485:
! 486: void
! 487: ce4231_close(addr)
! 488: void *addr;
! 489: {
! 490: struct ce4231_softc *sc = addr;
! 491:
! 492: ce4231_halt_input(sc);
! 493: ce4231_halt_output(sc);
! 494: ce4231_write(sc, SP_PIN_CONTROL,
! 495: ce4231_read(sc, SP_PIN_CONTROL) & (~INTERRUPT_ENABLE));
! 496: sc->sc_open = 0;
! 497: }
! 498:
! 499: int
! 500: ce4231_query_encoding(addr, fp)
! 501: void *addr;
! 502: struct audio_encoding *fp;
! 503: {
! 504: int err = 0;
! 505:
! 506: switch (fp->index) {
! 507: case 0:
! 508: strlcpy(fp->name, AudioEmulaw, sizeof fp->name);
! 509: fp->encoding = AUDIO_ENCODING_ULAW;
! 510: fp->precision = 8;
! 511: fp->flags = 0;
! 512: break;
! 513: case 1:
! 514: strlcpy(fp->name, AudioEalaw, sizeof fp->name);
! 515: fp->encoding = AUDIO_ENCODING_ALAW;
! 516: fp->precision = 8;
! 517: fp->flags = 0;
! 518: break;
! 519: case 2:
! 520: strlcpy(fp->name, AudioEslinear_le, sizeof fp->name);
! 521: fp->encoding = AUDIO_ENCODING_SLINEAR_LE;
! 522: fp->precision = 16;
! 523: fp->flags = 0;
! 524: break;
! 525: case 3:
! 526: strlcpy(fp->name, AudioEulinear, sizeof fp->name);
! 527: fp->encoding = AUDIO_ENCODING_ULINEAR;
! 528: fp->precision = 8;
! 529: fp->flags = 0;
! 530: break;
! 531: case 4:
! 532: strlcpy(fp->name, AudioEslinear_be, sizeof fp->name);
! 533: fp->encoding = AUDIO_ENCODING_SLINEAR_BE;
! 534: fp->precision = 16;
! 535: fp->flags = 0;
! 536: break;
! 537: case 5:
! 538: strlcpy(fp->name, AudioEslinear, sizeof fp->name);
! 539: fp->encoding = AUDIO_ENCODING_SLINEAR;
! 540: fp->precision = 8;
! 541: fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
! 542: break;
! 543: case 6:
! 544: strlcpy(fp->name, AudioEulinear_le, sizeof fp->name);
! 545: fp->encoding = AUDIO_ENCODING_ULINEAR_LE;
! 546: fp->precision = 16;
! 547: fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
! 548: break;
! 549: case 7:
! 550: strlcpy(fp->name, AudioEulinear_be, sizeof fp->name);
! 551: fp->encoding = AUDIO_ENCODING_ULINEAR_BE;
! 552: fp->precision = 16;
! 553: fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
! 554: break;
! 555: case 8:
! 556: strlcpy(fp->name, AudioEadpcm, sizeof fp->name);
! 557: fp->encoding = AUDIO_ENCODING_ADPCM;
! 558: fp->precision = 8;
! 559: fp->flags = 0;
! 560: break;
! 561: default:
! 562: err = EINVAL;
! 563: }
! 564: return (err);
! 565: }
! 566:
! 567: int
! 568: ce4231_set_params(addr, setmode, usemode, p, r)
! 569: void *addr;
! 570: int setmode, usemode;
! 571: struct audio_params *p, *r;
! 572: {
! 573: struct ce4231_softc *sc = (struct ce4231_softc *)addr;
! 574: int err, bits, enc = p->encoding;
! 575: void (*pswcode)(void *, u_char *, int cnt) = NULL;
! 576: void (*rswcode)(void *, u_char *, int cnt) = NULL;
! 577:
! 578: switch (enc) {
! 579: case AUDIO_ENCODING_ULAW:
! 580: if (p->precision != 8)
! 581: return (EINVAL);
! 582: bits = FMT_ULAW >> 5;
! 583: break;
! 584: case AUDIO_ENCODING_ALAW:
! 585: if (p->precision != 8)
! 586: return (EINVAL);
! 587: bits = FMT_ALAW >> 5;
! 588: break;
! 589: case AUDIO_ENCODING_SLINEAR_LE:
! 590: if (p->precision == 8) {
! 591: bits = FMT_PCM8 >> 5;
! 592: pswcode = rswcode = change_sign8;
! 593: } else if (p->precision == 16)
! 594: bits = FMT_TWOS_COMP >> 5;
! 595: else
! 596: return (EINVAL);
! 597: break;
! 598: case AUDIO_ENCODING_ULINEAR:
! 599: if (p->precision != 8)
! 600: return (EINVAL);
! 601: bits = FMT_PCM8 >> 5;
! 602: break;
! 603: case AUDIO_ENCODING_SLINEAR_BE:
! 604: if (p->precision == 8) {
! 605: bits = FMT_PCM8 >> 5;
! 606: pswcode = rswcode = change_sign8;
! 607: } else if (p->precision == 16)
! 608: bits = FMT_TWOS_COMP_BE >> 5;
! 609: else
! 610: return (EINVAL);
! 611: break;
! 612: case AUDIO_ENCODING_SLINEAR:
! 613: if (p->precision != 8)
! 614: return (EINVAL);
! 615: bits = FMT_PCM8 >> 5;
! 616: pswcode = rswcode = change_sign8;
! 617: break;
! 618: case AUDIO_ENCODING_ULINEAR_LE:
! 619: if (p->precision == 8)
! 620: bits = FMT_PCM8 >> 5;
! 621: else if (p->precision == 16) {
! 622: bits = FMT_TWOS_COMP >> 5;
! 623: pswcode = rswcode = change_sign16_le;
! 624: } else
! 625: return (EINVAL);
! 626: break;
! 627: case AUDIO_ENCODING_ULINEAR_BE:
! 628: if (p->precision == 8)
! 629: bits = FMT_PCM8 >> 5;
! 630: else if (p->precision == 16) {
! 631: bits = FMT_TWOS_COMP_BE >> 5;
! 632: pswcode = rswcode = change_sign16_be;
! 633: } else
! 634: return (EINVAL);
! 635: break;
! 636: case AUDIO_ENCODING_ADPCM:
! 637: if (p->precision != 8)
! 638: return (EINVAL);
! 639: bits = FMT_ADPCM >> 5;
! 640: break;
! 641: default:
! 642: return (EINVAL);
! 643: }
! 644:
! 645: if (p->channels != 1 && p->channels != 2)
! 646: return (EINVAL);
! 647:
! 648: err = ce4231_set_speed(sc, &p->sample_rate);
! 649: if (err)
! 650: return (err);
! 651:
! 652: p->sw_code = pswcode;
! 653: r->sw_code = rswcode;
! 654:
! 655: sc->sc_format_bits = bits;
! 656: sc->sc_channels = p->channels;
! 657: sc->sc_precision = p->precision;
! 658: sc->sc_need_commit = 1;
! 659: return (0);
! 660: }
! 661:
! 662: int
! 663: ce4231_round_blocksize(addr, blk)
! 664: void *addr;
! 665: int blk;
! 666: {
! 667: return ((blk + 3) & (-4));
! 668: }
! 669:
! 670: int
! 671: ce4231_commit_settings(addr)
! 672: void *addr;
! 673: {
! 674: struct ce4231_softc *sc = (struct ce4231_softc *)addr;
! 675: int s, tries;
! 676: u_int8_t r, fs;
! 677:
! 678: if (sc->sc_need_commit == 0)
! 679: return (0);
! 680:
! 681: fs = sc->sc_speed_bits | (sc->sc_format_bits << 5);
! 682: if (sc->sc_channels == 2)
! 683: fs |= FMT_STEREO;
! 684:
! 685: if (sc->sc_last_format == fs) {
! 686: sc->sc_need_commit = 0;
! 687: return (0);
! 688: }
! 689:
! 690: s = splaudio();
! 691:
! 692: r = ce4231_read(sc, SP_INTERFACE_CONFIG) | AUTO_CAL_ENABLE;
! 693: CS_WRITE(sc, AD1848_IADDR, MODE_CHANGE_ENABLE);
! 694: CS_WRITE(sc, AD1848_IADDR, MODE_CHANGE_ENABLE | SP_INTERFACE_CONFIG);
! 695: CS_WRITE(sc, AD1848_IDATA, r);
! 696:
! 697: CS_WRITE(sc, AD1848_IADDR, MODE_CHANGE_ENABLE | SP_CLOCK_DATA_FORMAT);
! 698: CS_WRITE(sc, AD1848_IDATA, fs);
! 699: CS_READ(sc, AD1848_IDATA);
! 700: CS_READ(sc, AD1848_IDATA);
! 701: tries = CS_TIMEOUT;
! 702: for (tries = CS_TIMEOUT;
! 703: tries && CS_READ(sc, AD1848_IADDR) == SP_IN_INIT; tries--)
! 704: DELAY(10);
! 705: if (tries == 0)
! 706: printf("%s: timeout committing fspb\n", sc->sc_dev.dv_xname);
! 707:
! 708: CS_WRITE(sc, AD1848_IADDR, MODE_CHANGE_ENABLE | CS_REC_FORMAT);
! 709: CS_WRITE(sc, AD1848_IDATA, fs);
! 710: CS_READ(sc, AD1848_IDATA);
! 711: CS_READ(sc, AD1848_IDATA);
! 712: for (tries = CS_TIMEOUT;
! 713: tries && CS_READ(sc, AD1848_IADDR) == SP_IN_INIT; tries--)
! 714: DELAY(10);
! 715: if (tries == 0)
! 716: printf("%s: timeout committing cdf\n", sc->sc_dev.dv_xname);
! 717:
! 718: CS_WRITE(sc, AD1848_IADDR, 0);
! 719: for (tries = CS_TIMEOUT;
! 720: tries && CS_READ(sc, AD1848_IADDR) == SP_IN_INIT; tries--)
! 721: DELAY(10);
! 722: if (tries == 0)
! 723: printf("%s: timeout waiting for !mce\n", sc->sc_dev.dv_xname);
! 724:
! 725: CS_WRITE(sc, AD1848_IADDR, SP_TEST_AND_INIT);
! 726: for (tries = CS_TIMEOUT;
! 727: tries && CS_READ(sc, AD1848_IDATA) & AUTO_CAL_IN_PROG; tries--)
! 728: DELAY(10);
! 729: if (tries == 0)
! 730: printf("%s: timeout waiting for autocalibration\n",
! 731: sc->sc_dev.dv_xname);
! 732:
! 733: splx(s);
! 734:
! 735: sc->sc_need_commit = 0;
! 736: return (0);
! 737: }
! 738:
! 739: int
! 740: ce4231_halt_output(addr)
! 741: void *addr;
! 742: {
! 743: struct ce4231_softc *sc = (struct ce4231_softc *)addr;
! 744:
! 745: P_WRITE(sc, EBDMA_DCSR,
! 746: P_READ(sc, EBDMA_DCSR) & ~EBDCSR_DMAEN);
! 747: ce4231_write(sc, SP_INTERFACE_CONFIG,
! 748: ce4231_read(sc, SP_INTERFACE_CONFIG) & (~PLAYBACK_ENABLE));
! 749: sc->sc_locked = 0;
! 750: return (0);
! 751: }
! 752:
! 753: int
! 754: ce4231_halt_input(addr)
! 755: void *addr;
! 756: {
! 757: struct ce4231_softc *sc = (struct ce4231_softc *)addr;
! 758:
! 759: C_WRITE(sc, EBDMA_DCSR,
! 760: C_READ(sc, EBDMA_DCSR) & ~EBDCSR_DMAEN);
! 761: ce4231_write(sc, SP_INTERFACE_CONFIG,
! 762: ce4231_read(sc, SP_INTERFACE_CONFIG) & (~CAPTURE_ENABLE));
! 763: sc->sc_locked = 0;
! 764: return (0);
! 765: }
! 766:
! 767: int
! 768: ce4231_getdev(addr, retp)
! 769: void *addr;
! 770: struct audio_device *retp;
! 771: {
! 772: *retp = ce4231_device;
! 773: return (0);
! 774: }
! 775:
! 776: int
! 777: ce4231_set_port(addr, cp)
! 778: void *addr;
! 779: mixer_ctrl_t *cp;
! 780: {
! 781: struct ce4231_softc *sc = (struct ce4231_softc *)addr;
! 782: int error = EINVAL;
! 783:
! 784: DPRINTF(("ce4231_set_port: port=%d type=%d\n", cp->dev, cp->type));
! 785:
! 786: switch (cp->dev) {
! 787: case CSAUDIO_DAC_LVL:
! 788: if (cp->type != AUDIO_MIXER_VALUE)
! 789: break;
! 790: if (cp->un.value.num_channels == 1)
! 791: ce4231_write(sc, SP_LEFT_AUX1_CONTROL,
! 792: cp->un.value.level[AUDIO_MIXER_LEVEL_MONO] &
! 793: LINE_INPUT_ATTEN_BITS);
! 794: else if (cp->un.value.num_channels == 2) {
! 795: ce4231_write(sc, SP_LEFT_AUX1_CONTROL,
! 796: cp->un.value.level[AUDIO_MIXER_LEVEL_LEFT] &
! 797: LINE_INPUT_ATTEN_BITS);
! 798: ce4231_write(sc, SP_RIGHT_AUX1_CONTROL,
! 799: cp->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] &
! 800: LINE_INPUT_ATTEN_BITS);
! 801: } else
! 802: break;
! 803: error = 0;
! 804: break;
! 805: case CSAUDIO_LINE_IN_LVL:
! 806: if (cp->type != AUDIO_MIXER_VALUE)
! 807: break;
! 808: if (cp->un.value.num_channels == 1)
! 809: ce4231_write(sc, CS_LEFT_LINE_CONTROL,
! 810: cp->un.value.level[AUDIO_MIXER_LEVEL_MONO] &
! 811: AUX_INPUT_ATTEN_BITS);
! 812: else if (cp->un.value.num_channels == 2) {
! 813: ce4231_write(sc, CS_LEFT_LINE_CONTROL,
! 814: cp->un.value.level[AUDIO_MIXER_LEVEL_LEFT] &
! 815: AUX_INPUT_ATTEN_BITS);
! 816: ce4231_write(sc, CS_RIGHT_LINE_CONTROL,
! 817: cp->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] &
! 818: AUX_INPUT_ATTEN_BITS);
! 819: } else
! 820: break;
! 821: error = 0;
! 822: break;
! 823: case CSAUDIO_MIC_LVL:
! 824: if (cp->type != AUDIO_MIXER_VALUE)
! 825: break;
! 826: if (cp->un.value.num_channels == 1) {
! 827: #if 0
! 828: ce4231_write(sc, CS_MONO_IO_CONTROL,
! 829: cp->un.value.level[AUDIO_MIXER_LEVEL_MONO] &
! 830: MONO_INPUT_ATTEN_BITS);
! 831: #endif
! 832: } else
! 833: break;
! 834: error = 0;
! 835: break;
! 836: case CSAUDIO_CD_LVL:
! 837: if (cp->type != AUDIO_MIXER_VALUE)
! 838: break;
! 839: if (cp->un.value.num_channels == 1) {
! 840: ce4231_write(sc, SP_LEFT_AUX2_CONTROL,
! 841: cp->un.value.level[AUDIO_MIXER_LEVEL_MONO] &
! 842: LINE_INPUT_ATTEN_BITS);
! 843: } else if (cp->un.value.num_channels == 2) {
! 844: ce4231_write(sc, SP_LEFT_AUX2_CONTROL,
! 845: cp->un.value.level[AUDIO_MIXER_LEVEL_LEFT] &
! 846: LINE_INPUT_ATTEN_BITS);
! 847: ce4231_write(sc, SP_RIGHT_AUX2_CONTROL,
! 848: cp->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] &
! 849: LINE_INPUT_ATTEN_BITS);
! 850: } else
! 851: break;
! 852: error = 0;
! 853: break;
! 854: case CSAUDIO_MONITOR_LVL:
! 855: if (cp->type != AUDIO_MIXER_VALUE)
! 856: break;
! 857: if (cp->un.value.num_channels == 1)
! 858: ce4231_write(sc, SP_DIGITAL_MIX,
! 859: cp->un.value.level[AUDIO_MIXER_LEVEL_MONO] << 2);
! 860: else
! 861: break;
! 862: error = 0;
! 863: break;
! 864: case CSAUDIO_OUTPUT_LVL:
! 865: if (cp->type != AUDIO_MIXER_VALUE)
! 866: break;
! 867: if (cp->un.value.num_channels == 1) {
! 868: sc->sc_volume[CSPORT_SPEAKER].left =
! 869: cp->un.value.level[AUDIO_MIXER_LEVEL_MONO];
! 870: sc->sc_volume[CSPORT_SPEAKER].right =
! 871: cp->un.value.level[AUDIO_MIXER_LEVEL_MONO];
! 872: }
! 873: else if (cp->un.value.num_channels == 2) {
! 874: sc->sc_volume[CSPORT_SPEAKER].left =
! 875: cp->un.value.level[AUDIO_MIXER_LEVEL_LEFT];
! 876: sc->sc_volume[CSPORT_SPEAKER].right =
! 877: cp->un.value.level[AUDIO_MIXER_LEVEL_RIGHT];
! 878: }
! 879: else
! 880: break;
! 881:
! 882: ce4231_setup_output(sc);
! 883: error = 0;
! 884: break;
! 885: case CSAUDIO_OUTPUT:
! 886: if (cp->type != AUDIO_MIXER_ENUM)
! 887: break;
! 888: if (cp->un.ord != CSPORT_LINEOUT &&
! 889: cp->un.ord != CSPORT_SPEAKER &&
! 890: cp->un.ord != CSPORT_HEADPHONE)
! 891: return (EINVAL);
! 892: sc->sc_out_port = cp->un.ord;
! 893: ce4231_setup_output(sc);
! 894: error = 0;
! 895: break;
! 896: case CSAUDIO_LINE_IN_MUTE:
! 897: if (cp->type != AUDIO_MIXER_ENUM)
! 898: break;
! 899: sc->sc_mute[CSPORT_LINEIN] = cp->un.ord ? 1 : 0;
! 900: error = 0;
! 901: break;
! 902: case CSAUDIO_DAC_MUTE:
! 903: if (cp->type != AUDIO_MIXER_ENUM)
! 904: break;
! 905: sc->sc_mute[CSPORT_AUX1] = cp->un.ord ? 1 : 0;
! 906: error = 0;
! 907: break;
! 908: case CSAUDIO_CD_MUTE:
! 909: if (cp->type != AUDIO_MIXER_ENUM)
! 910: break;
! 911: sc->sc_mute[CSPORT_AUX2] = cp->un.ord ? 1 : 0;
! 912: error = 0;
! 913: break;
! 914: case CSAUDIO_MIC_MUTE:
! 915: if (cp->type != AUDIO_MIXER_ENUM)
! 916: break;
! 917: sc->sc_mute[CSPORT_MONO] = cp->un.ord ? 1 : 0;
! 918: error = 0;
! 919: break;
! 920: case CSAUDIO_MONITOR_MUTE:
! 921: if (cp->type != AUDIO_MIXER_ENUM)
! 922: break;
! 923: sc->sc_mute[CSPORT_MONITOR] = cp->un.ord ? 1 : 0;
! 924: error = 0;
! 925: break;
! 926: case CSAUDIO_OUTPUT_MUTE:
! 927: if (cp->type != AUDIO_MIXER_ENUM)
! 928: break;
! 929: sc->sc_mute[CSPORT_SPEAKER] = cp->un.ord ? 1 : 0;
! 930: ce4231_setup_output(sc);
! 931: error = 0;
! 932: break;
! 933: case CSAUDIO_REC_LVL:
! 934: if (cp->type != AUDIO_MIXER_VALUE)
! 935: break;
! 936: break;
! 937: case CSAUDIO_RECORD_SOURCE:
! 938: if (cp->type != AUDIO_MIXER_ENUM)
! 939: break;
! 940: break;
! 941: }
! 942:
! 943: return (error);
! 944: }
! 945:
! 946: int
! 947: ce4231_get_port(addr, cp)
! 948: void *addr;
! 949: mixer_ctrl_t *cp;
! 950: {
! 951: struct ce4231_softc *sc = (struct ce4231_softc *)addr;
! 952: int error = EINVAL;
! 953:
! 954: DPRINTF(("ce4231_get_port: port=%d type=%d\n", cp->dev, cp->type));
! 955:
! 956: switch (cp->dev) {
! 957: case CSAUDIO_DAC_LVL:
! 958: if (cp->type != AUDIO_MIXER_VALUE)
! 959: break;
! 960: if (cp->un.value.num_channels == 1)
! 961: cp->un.value.level[AUDIO_MIXER_LEVEL_MONO]=
! 962: ce4231_read(sc, SP_LEFT_AUX1_CONTROL) &
! 963: LINE_INPUT_ATTEN_BITS;
! 964: else if (cp->un.value.num_channels == 2) {
! 965: cp->un.value.level[AUDIO_MIXER_LEVEL_LEFT] =
! 966: ce4231_read(sc, SP_LEFT_AUX1_CONTROL) &
! 967: LINE_INPUT_ATTEN_BITS;
! 968: cp->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] =
! 969: ce4231_read(sc, SP_RIGHT_AUX1_CONTROL) &
! 970: LINE_INPUT_ATTEN_BITS;
! 971: } else
! 972: break;
! 973: error = 0;
! 974: break;
! 975: case CSAUDIO_LINE_IN_LVL:
! 976: if (cp->type != AUDIO_MIXER_VALUE)
! 977: break;
! 978: if (cp->un.value.num_channels == 1)
! 979: cp->un.value.level[AUDIO_MIXER_LEVEL_MONO] =
! 980: ce4231_read(sc, CS_LEFT_LINE_CONTROL) & AUX_INPUT_ATTEN_BITS;
! 981: else if (cp->un.value.num_channels == 2) {
! 982: cp->un.value.level[AUDIO_MIXER_LEVEL_LEFT] =
! 983: ce4231_read(sc, CS_LEFT_LINE_CONTROL) & AUX_INPUT_ATTEN_BITS;
! 984: cp->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] =
! 985: ce4231_read(sc, CS_RIGHT_LINE_CONTROL) & AUX_INPUT_ATTEN_BITS;
! 986: } else
! 987: break;
! 988: error = 0;
! 989: break;
! 990: case CSAUDIO_MIC_LVL:
! 991: if (cp->type != AUDIO_MIXER_VALUE)
! 992: break;
! 993: if (cp->un.value.num_channels == 1) {
! 994: #if 0
! 995: cp->un.value.level[AUDIO_MIXER_LEVEL_MONO] =
! 996: ce4231_read(sc, CS_MONO_IO_CONTROL) &
! 997: MONO_INPUT_ATTEN_BITS;
! 998: #endif
! 999: } else
! 1000: break;
! 1001: error = 0;
! 1002: break;
! 1003: case CSAUDIO_CD_LVL:
! 1004: if (cp->type != AUDIO_MIXER_VALUE)
! 1005: break;
! 1006: if (cp->un.value.num_channels == 1)
! 1007: cp->un.value.level[AUDIO_MIXER_LEVEL_MONO] =
! 1008: ce4231_read(sc, SP_LEFT_AUX2_CONTROL) &
! 1009: LINE_INPUT_ATTEN_BITS;
! 1010: else if (cp->un.value.num_channels == 2) {
! 1011: cp->un.value.level[AUDIO_MIXER_LEVEL_LEFT] =
! 1012: ce4231_read(sc, SP_LEFT_AUX2_CONTROL) &
! 1013: LINE_INPUT_ATTEN_BITS;
! 1014: cp->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] =
! 1015: ce4231_read(sc, SP_RIGHT_AUX2_CONTROL) &
! 1016: LINE_INPUT_ATTEN_BITS;
! 1017: }
! 1018: else
! 1019: break;
! 1020: error = 0;
! 1021: break;
! 1022: case CSAUDIO_MONITOR_LVL:
! 1023: if (cp->type != AUDIO_MIXER_VALUE)
! 1024: break;
! 1025: if (cp->un.value.num_channels != 1)
! 1026: break;
! 1027: cp->un.value.level[AUDIO_MIXER_LEVEL_MONO] =
! 1028: ce4231_read(sc, SP_DIGITAL_MIX) >> 2;
! 1029: error = 0;
! 1030: break;
! 1031: case CSAUDIO_OUTPUT_LVL:
! 1032: if (cp->type != AUDIO_MIXER_VALUE)
! 1033: break;
! 1034: if (cp->un.value.num_channels == 1)
! 1035: cp->un.value.level[AUDIO_MIXER_LEVEL_MONO] =
! 1036: sc->sc_volume[CSPORT_SPEAKER].left;
! 1037: else if (cp->un.value.num_channels == 2) {
! 1038: cp->un.value.level[AUDIO_MIXER_LEVEL_LEFT] =
! 1039: sc->sc_volume[CSPORT_SPEAKER].left;
! 1040: cp->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] =
! 1041: sc->sc_volume[CSPORT_SPEAKER].right;
! 1042: }
! 1043: else
! 1044: break;
! 1045: error = 0;
! 1046: break;
! 1047: case CSAUDIO_LINE_IN_MUTE:
! 1048: if (cp->type != AUDIO_MIXER_ENUM)
! 1049: break;
! 1050: cp->un.ord = sc->sc_mute[CSPORT_LINEIN] ? 1 : 0;
! 1051: error = 0;
! 1052: break;
! 1053: case CSAUDIO_DAC_MUTE:
! 1054: if (cp->type != AUDIO_MIXER_ENUM)
! 1055: break;
! 1056: cp->un.ord = sc->sc_mute[CSPORT_AUX1] ? 1 : 0;
! 1057: error = 0;
! 1058: break;
! 1059: case CSAUDIO_CD_MUTE:
! 1060: if (cp->type != AUDIO_MIXER_ENUM)
! 1061: break;
! 1062: cp->un.ord = sc->sc_mute[CSPORT_AUX2] ? 1 : 0;
! 1063: error = 0;
! 1064: break;
! 1065: case CSAUDIO_MIC_MUTE:
! 1066: if (cp->type != AUDIO_MIXER_ENUM)
! 1067: break;
! 1068: cp->un.ord = sc->sc_mute[CSPORT_MONO] ? 1 : 0;
! 1069: error = 0;
! 1070: break;
! 1071: case CSAUDIO_MONITOR_MUTE:
! 1072: if (cp->type != AUDIO_MIXER_ENUM)
! 1073: break;
! 1074: cp->un.ord = sc->sc_mute[CSPORT_MONITOR] ? 1 : 0;
! 1075: error = 0;
! 1076: break;
! 1077: case CSAUDIO_OUTPUT_MUTE:
! 1078: if (cp->type != AUDIO_MIXER_ENUM)
! 1079: break;
! 1080: cp->un.ord = sc->sc_mute[CSPORT_SPEAKER] ? 1 : 0;
! 1081: error = 0;
! 1082: break;
! 1083: case CSAUDIO_REC_LVL:
! 1084: if (cp->type != AUDIO_MIXER_VALUE)
! 1085: break;
! 1086: if (cp->un.value.num_channels == 1) {
! 1087: cp->un.value.level[AUDIO_MIXER_LEVEL_MONO] =
! 1088: AUDIO_MIN_GAIN;
! 1089: } else if (cp->un.value.num_channels == 2) {
! 1090: cp->un.value.level[AUDIO_MIXER_LEVEL_LEFT] =
! 1091: AUDIO_MIN_GAIN;
! 1092: cp->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] =
! 1093: AUDIO_MIN_GAIN;
! 1094: } else
! 1095: break;
! 1096: error = 0;
! 1097: break;
! 1098: case CSAUDIO_RECORD_SOURCE:
! 1099: if (cp->type != AUDIO_MIXER_ENUM)
! 1100: break;
! 1101: cp->un.ord = MIC_IN_PORT;
! 1102: error = 0;
! 1103: break;
! 1104: case CSAUDIO_OUTPUT:
! 1105: if (cp->type != AUDIO_MIXER_ENUM)
! 1106: break;
! 1107: cp->un.ord = sc->sc_out_port;
! 1108: error = 0;
! 1109: break;
! 1110: }
! 1111: return (error);
! 1112: }
! 1113:
! 1114: int
! 1115: ce4231_query_devinfo(addr, dip)
! 1116: void *addr;
! 1117: mixer_devinfo_t *dip;
! 1118: {
! 1119: int err = 0;
! 1120:
! 1121: switch (dip->index) {
! 1122: case CSAUDIO_MIC_LVL: /* mono/microphone mixer */
! 1123: dip->type = AUDIO_MIXER_VALUE;
! 1124: dip->mixer_class = CSAUDIO_INPUT_CLASS;
! 1125: dip->prev = AUDIO_MIXER_LAST;
! 1126: dip->next = CSAUDIO_MIC_MUTE;
! 1127: strlcpy(dip->label.name, AudioNmicrophone, sizeof dip->label.name);
! 1128: dip->un.v.num_channels = 1;
! 1129: strlcpy(dip->un.v.units.name, AudioNvolume,
! 1130: sizeof dip->un.v.units.name);
! 1131: break;
! 1132: case CSAUDIO_DAC_LVL: /* dacout */
! 1133: dip->type = AUDIO_MIXER_VALUE;
! 1134: dip->mixer_class = CSAUDIO_INPUT_CLASS;
! 1135: dip->prev = AUDIO_MIXER_LAST;
! 1136: dip->next = CSAUDIO_DAC_MUTE;
! 1137: strlcpy(dip->label.name, AudioNdac, sizeof dip->label.name);
! 1138: dip->un.v.num_channels = 2;
! 1139: strlcpy(dip->un.v.units.name, AudioNvolume,
! 1140: sizeof dip->un.v.units.name);
! 1141: break;
! 1142: case CSAUDIO_LINE_IN_LVL: /* line */
! 1143: dip->type = AUDIO_MIXER_VALUE;
! 1144: dip->mixer_class = CSAUDIO_INPUT_CLASS;
! 1145: dip->prev = AUDIO_MIXER_LAST;
! 1146: dip->next = CSAUDIO_LINE_IN_MUTE;
! 1147: strlcpy(dip->label.name, AudioNline, sizeof dip->label.name);
! 1148: dip->un.v.num_channels = 2;
! 1149: strlcpy(dip->un.v.units.name, AudioNvolume,
! 1150: sizeof dip->un.v.units.name);
! 1151: break;
! 1152: case CSAUDIO_CD_LVL: /* cd */
! 1153: dip->type = AUDIO_MIXER_VALUE;
! 1154: dip->mixer_class = CSAUDIO_INPUT_CLASS;
! 1155: dip->prev = AUDIO_MIXER_LAST;
! 1156: dip->next = CSAUDIO_CD_MUTE;
! 1157: strlcpy(dip->label.name, AudioNcd, sizeof dip->label.name);
! 1158: dip->un.v.num_channels = 2;
! 1159: strlcpy(dip->un.v.units.name, AudioNvolume,
! 1160: sizeof dip->un.v.units.name);
! 1161: break;
! 1162: case CSAUDIO_MONITOR_LVL: /* monitor level */
! 1163: dip->type = AUDIO_MIXER_VALUE;
! 1164: dip->mixer_class = CSAUDIO_MONITOR_CLASS;
! 1165: dip->prev = AUDIO_MIXER_LAST;
! 1166: dip->next = CSAUDIO_MONITOR_MUTE;
! 1167: strlcpy(dip->label.name, AudioNmonitor, sizeof dip->label.name);
! 1168: dip->un.v.num_channels = 1;
! 1169: strlcpy(dip->un.v.units.name, AudioNvolume,
! 1170: sizeof dip->un.v.units.name);
! 1171: break;
! 1172: case CSAUDIO_OUTPUT_LVL:
! 1173: dip->type = AUDIO_MIXER_VALUE;
! 1174: dip->mixer_class = CSAUDIO_OUTPUT_CLASS;
! 1175: dip->prev = AUDIO_MIXER_LAST;
! 1176: dip->next = CSAUDIO_OUTPUT_MUTE;
! 1177: strlcpy(dip->label.name, AudioNoutput, sizeof dip->label.name);
! 1178: dip->un.v.num_channels = 2;
! 1179: strlcpy(dip->un.v.units.name, AudioNvolume,
! 1180: sizeof dip->un.v.units.name);
! 1181: break;
! 1182: case CSAUDIO_LINE_IN_MUTE:
! 1183: dip->type = AUDIO_MIXER_ENUM;
! 1184: dip->mixer_class = CSAUDIO_INPUT_CLASS;
! 1185: dip->prev = CSAUDIO_LINE_IN_LVL;
! 1186: dip->next = AUDIO_MIXER_LAST;
! 1187: goto mute;
! 1188: case CSAUDIO_DAC_MUTE:
! 1189: dip->type = AUDIO_MIXER_ENUM;
! 1190: dip->mixer_class = CSAUDIO_INPUT_CLASS;
! 1191: dip->prev = CSAUDIO_DAC_LVL;
! 1192: dip->next = AUDIO_MIXER_LAST;
! 1193: goto mute;
! 1194: case CSAUDIO_CD_MUTE:
! 1195: dip->type = AUDIO_MIXER_ENUM;
! 1196: dip->mixer_class = CSAUDIO_INPUT_CLASS;
! 1197: dip->prev = CSAUDIO_CD_LVL;
! 1198: dip->next = AUDIO_MIXER_LAST;
! 1199: goto mute;
! 1200: case CSAUDIO_MIC_MUTE:
! 1201: dip->type = AUDIO_MIXER_ENUM;
! 1202: dip->mixer_class = CSAUDIO_INPUT_CLASS;
! 1203: dip->prev = CSAUDIO_MIC_LVL;
! 1204: dip->next = AUDIO_MIXER_LAST;
! 1205: goto mute;
! 1206: case CSAUDIO_MONITOR_MUTE:
! 1207: dip->type = AUDIO_MIXER_ENUM;
! 1208: dip->mixer_class = CSAUDIO_OUTPUT_CLASS;
! 1209: dip->prev = CSAUDIO_MONITOR_LVL;
! 1210: dip->next = AUDIO_MIXER_LAST;
! 1211: goto mute;
! 1212: case CSAUDIO_OUTPUT_MUTE:
! 1213: dip->type = AUDIO_MIXER_ENUM;
! 1214: dip->mixer_class = CSAUDIO_OUTPUT_CLASS;
! 1215: dip->prev = CSAUDIO_OUTPUT_LVL;
! 1216: dip->next = AUDIO_MIXER_LAST;
! 1217: goto mute;
! 1218:
! 1219: mute:
! 1220: strlcpy(dip->label.name, AudioNmute, sizeof dip->label.name);
! 1221: dip->un.e.num_mem = 2;
! 1222: strlcpy(dip->un.e.member[0].label.name, AudioNon,
! 1223: sizeof dip->un.e.member[0].label.name);
! 1224: dip->un.e.member[0].ord = 0;
! 1225: strlcpy(dip->un.e.member[1].label.name, AudioNoff,
! 1226: sizeof dip->un.e.member[1].label.name);
! 1227: dip->un.e.member[1].ord = 1;
! 1228: break;
! 1229: case CSAUDIO_REC_LVL: /* record level */
! 1230: dip->type = AUDIO_MIXER_VALUE;
! 1231: dip->mixer_class = CSAUDIO_RECORD_CLASS;
! 1232: dip->prev = AUDIO_MIXER_LAST;
! 1233: dip->next = CSAUDIO_RECORD_SOURCE;
! 1234: strlcpy(dip->label.name, AudioNrecord, sizeof dip->label.name);
! 1235: dip->un.v.num_channels = 2;
! 1236: strlcpy(dip->un.v.units.name, AudioNvolume,
! 1237: sizeof dip->un.v.units.name);
! 1238: break;
! 1239: case CSAUDIO_RECORD_SOURCE:
! 1240: dip->type = AUDIO_MIXER_ENUM;
! 1241: dip->mixer_class = CSAUDIO_RECORD_CLASS;
! 1242: dip->prev = CSAUDIO_REC_LVL;
! 1243: dip->next = AUDIO_MIXER_LAST;
! 1244: strlcpy(dip->label.name, AudioNsource, sizeof dip->label.name);
! 1245: dip->un.e.num_mem = 3;
! 1246: strlcpy(dip->un.e.member[0].label.name, AudioNcd,
! 1247: sizeof dip->un.e.member[0].label.name);
! 1248: dip->un.e.member[0].ord = DAC_IN_PORT;
! 1249: strlcpy(dip->un.e.member[1].label.name, AudioNmicrophone,
! 1250: sizeof dip->un.e.member[1].label.name);
! 1251: dip->un.e.member[1].ord = MIC_IN_PORT;
! 1252: strlcpy(dip->un.e.member[2].label.name, AudioNdac,
! 1253: sizeof dip->un.e.member[2].label.name);
! 1254: dip->un.e.member[2].ord = AUX1_IN_PORT;
! 1255: strlcpy(dip->un.e.member[3].label.name, AudioNline,
! 1256: sizeof dip->un.e.member[3].label.name);
! 1257: dip->un.e.member[3].ord = LINE_IN_PORT;
! 1258: break;
! 1259: case CSAUDIO_OUTPUT:
! 1260: dip->type = AUDIO_MIXER_ENUM;
! 1261: dip->mixer_class = CSAUDIO_MONITOR_CLASS;
! 1262: dip->prev = dip->next = AUDIO_MIXER_LAST;
! 1263: strlcpy(dip->label.name, AudioNoutput, sizeof dip->label.name);
! 1264: dip->un.e.num_mem = 3;
! 1265: strlcpy(dip->un.e.member[0].label.name, AudioNspeaker,
! 1266: sizeof dip->un.e.member[0].label.name);
! 1267: dip->un.e.member[0].ord = CSPORT_SPEAKER;
! 1268: strlcpy(dip->un.e.member[1].label.name, AudioNline,
! 1269: sizeof dip->un.e.member[1].label.name);
! 1270: dip->un.e.member[1].ord = CSPORT_LINEOUT;
! 1271: strlcpy(dip->un.e.member[2].label.name, AudioNheadphone,
! 1272: sizeof dip->un.e.member[2].label.name);
! 1273: dip->un.e.member[2].ord = CSPORT_HEADPHONE;
! 1274: break;
! 1275: case CSAUDIO_INPUT_CLASS: /* input class descriptor */
! 1276: dip->type = AUDIO_MIXER_CLASS;
! 1277: dip->mixer_class = CSAUDIO_INPUT_CLASS;
! 1278: dip->prev = AUDIO_MIXER_LAST;
! 1279: dip->next = AUDIO_MIXER_LAST;
! 1280: strlcpy(dip->label.name, AudioCinputs, sizeof dip->label.name);
! 1281: break;
! 1282: case CSAUDIO_OUTPUT_CLASS: /* output class descriptor */
! 1283: dip->type = AUDIO_MIXER_CLASS;
! 1284: dip->mixer_class = CSAUDIO_OUTPUT_CLASS;
! 1285: dip->prev = AUDIO_MIXER_LAST;
! 1286: dip->next = AUDIO_MIXER_LAST;
! 1287: strlcpy(dip->label.name, AudioCoutputs, sizeof dip->label.name);
! 1288: break;
! 1289: case CSAUDIO_MONITOR_CLASS: /* monitor class descriptor */
! 1290: dip->type = AUDIO_MIXER_CLASS;
! 1291: dip->mixer_class = CSAUDIO_MONITOR_CLASS;
! 1292: dip->prev = AUDIO_MIXER_LAST;
! 1293: dip->next = AUDIO_MIXER_LAST;
! 1294: strlcpy(dip->label.name, AudioCmonitor, sizeof dip->label.name);
! 1295: break;
! 1296: case CSAUDIO_RECORD_CLASS: /* record class descriptor */
! 1297: dip->type = AUDIO_MIXER_CLASS;
! 1298: dip->mixer_class = CSAUDIO_RECORD_CLASS;
! 1299: dip->prev = AUDIO_MIXER_LAST;
! 1300: dip->next = AUDIO_MIXER_LAST;
! 1301: strlcpy(dip->label.name, AudioCrecord, sizeof dip->label.name);
! 1302: break;
! 1303: default:
! 1304: err = ENXIO;
! 1305: }
! 1306:
! 1307: return (err);
! 1308: }
! 1309:
! 1310: int
! 1311: ce4231_get_props(addr)
! 1312: void *addr;
! 1313: {
! 1314: return (AUDIO_PROP_FULLDUPLEX);
! 1315: }
! 1316:
! 1317: /*
! 1318: * Hardware interrupt handler
! 1319: */
! 1320: int
! 1321: ce4231_cintr(v)
! 1322: void *v;
! 1323: {
! 1324: return (0);
! 1325: }
! 1326:
! 1327: int
! 1328: ce4231_pintr(v)
! 1329: void *v;
! 1330: {
! 1331: struct ce4231_softc *sc = (struct ce4231_softc *)v;
! 1332: u_int32_t csr;
! 1333: u_int8_t reg, status;
! 1334: struct cs_dma *p;
! 1335: int r = 0;
! 1336:
! 1337: csr = P_READ(sc, EBDMA_DCSR);
! 1338: status = CS_READ(sc, AD1848_STATUS);
! 1339: if (status & (INTERRUPT_STATUS | SAMPLE_ERROR)) {
! 1340: reg = ce4231_read(sc, CS_IRQ_STATUS);
! 1341: if (reg & CS_AFS_PI) {
! 1342: ce4231_write(sc, SP_LOWER_BASE_COUNT, 0xff);
! 1343: ce4231_write(sc, SP_UPPER_BASE_COUNT, 0xff);
! 1344: }
! 1345: CS_WRITE(sc, AD1848_STATUS, 0);
! 1346: }
! 1347:
! 1348: P_WRITE(sc, EBDMA_DCSR, csr);
! 1349:
! 1350: if (csr & EBDCSR_INT)
! 1351: r = 1;
! 1352:
! 1353: if ((csr & EBDCSR_TC) || ((csr & EBDCSR_A_LOADED) == 0)) {
! 1354: u_long nextaddr, togo;
! 1355:
! 1356: p = sc->sc_nowplaying;
! 1357: togo = sc->sc_playsegsz - sc->sc_playcnt;
! 1358: if (togo == 0) {
! 1359: nextaddr = (u_int32_t)p->dmamap->dm_segs[0].ds_addr;
! 1360: sc->sc_playcnt = togo = sc->sc_blksz;
! 1361: } else {
! 1362: nextaddr = sc->sc_lastaddr;
! 1363: if (togo > sc->sc_blksz)
! 1364: togo = sc->sc_blksz;
! 1365: sc->sc_playcnt += togo;
! 1366: }
! 1367:
! 1368: P_WRITE(sc, EBDMA_DCNT, togo);
! 1369: P_WRITE(sc, EBDMA_DADDR, nextaddr);
! 1370: sc->sc_lastaddr = nextaddr + togo;
! 1371:
! 1372: if (sc->sc_pintr != NULL)
! 1373: (*sc->sc_pintr)(sc->sc_parg);
! 1374: r = 1;
! 1375: }
! 1376:
! 1377: return (r);
! 1378: }
! 1379:
! 1380: void *
! 1381: ce4231_alloc(addr, direction, size, pool, flags)
! 1382: void *addr;
! 1383: int direction;
! 1384: size_t size;
! 1385: int pool;
! 1386: int flags;
! 1387: {
! 1388: struct ce4231_softc *sc = (struct ce4231_softc *)addr;
! 1389: bus_dma_tag_t dmat = sc->sc_dmatag;
! 1390: struct cs_dma *p;
! 1391:
! 1392: p = (struct cs_dma *)malloc(sizeof(struct cs_dma), pool, flags);
! 1393: if (p == NULL)
! 1394: return (NULL);
! 1395:
! 1396: if (bus_dmamap_create(dmat, size, 1, size, 0,
! 1397: BUS_DMA_NOWAIT, &p->dmamap) != 0)
! 1398: goto fail;
! 1399:
! 1400: p->size = size;
! 1401:
! 1402: if (bus_dmamem_alloc(dmat, size, 64*1024, 0, p->segs,
! 1403: sizeof(p->segs)/sizeof(p->segs[0]), &p->nsegs,
! 1404: BUS_DMA_NOWAIT) != 0)
! 1405: goto fail1;
! 1406:
! 1407: if (bus_dmamem_map(dmat, p->segs, p->nsegs, p->size,
! 1408: &p->addr, BUS_DMA_NOWAIT | BUS_DMA_COHERENT) != 0)
! 1409: goto fail2;
! 1410:
! 1411: if (bus_dmamap_load(dmat, p->dmamap, p->addr, size, NULL,
! 1412: BUS_DMA_NOWAIT) != 0)
! 1413: goto fail3;
! 1414:
! 1415: p->next = sc->sc_dmas;
! 1416: sc->sc_dmas = p;
! 1417: return (p->addr);
! 1418:
! 1419: fail3:
! 1420: bus_dmamem_unmap(dmat, p->addr, p->size);
! 1421: fail2:
! 1422: bus_dmamem_free(dmat, p->segs, p->nsegs);
! 1423: fail1:
! 1424: bus_dmamap_destroy(dmat, p->dmamap);
! 1425: fail:
! 1426: free(p, pool);
! 1427: return (NULL);
! 1428: }
! 1429:
! 1430: void
! 1431: ce4231_free(addr, ptr, pool)
! 1432: void *addr;
! 1433: void *ptr;
! 1434: int pool;
! 1435: {
! 1436: struct ce4231_softc *sc = addr;
! 1437: bus_dma_tag_t dmat = sc->sc_dmatag;
! 1438: struct cs_dma *p, **pp;
! 1439:
! 1440: for (pp = &sc->sc_dmas; (p = *pp) != NULL; pp = &(*pp)->next) {
! 1441: if (p->addr != ptr)
! 1442: continue;
! 1443: bus_dmamap_unload(dmat, p->dmamap);
! 1444: bus_dmamem_unmap(dmat, p->addr, p->size);
! 1445: bus_dmamem_free(dmat, p->segs, p->nsegs);
! 1446: bus_dmamap_destroy(dmat, p->dmamap);
! 1447: *pp = p->next;
! 1448: free(p, pool);
! 1449: return;
! 1450: }
! 1451: printf("%s: attempt to free rogue pointer\n", sc->sc_dev.dv_xname);
! 1452: }
! 1453:
! 1454: int
! 1455: ce4231_trigger_output(addr, start, end, blksize, intr, arg, param)
! 1456: void *addr, *start, *end;
! 1457: int blksize;
! 1458: void (*intr)(void *);
! 1459: void *arg;
! 1460: struct audio_params *param;
! 1461: {
! 1462: struct ce4231_softc *sc = addr;
! 1463: struct cs_dma *p;
! 1464: u_int32_t csr;
! 1465: vaddr_t n;
! 1466:
! 1467: if (sc->sc_locked != 0) {
! 1468: printf("%s: trigger_output: already running\n",
! 1469: sc->sc_dev.dv_xname);
! 1470: return (EINVAL);
! 1471: }
! 1472:
! 1473: sc->sc_locked = 1;
! 1474: sc->sc_pintr = intr;
! 1475: sc->sc_parg = arg;
! 1476:
! 1477: for (p = sc->sc_dmas; p->addr != start; p = p->next)
! 1478: /*EMPTY*/;
! 1479: if (p == NULL) {
! 1480: printf("%s: trigger_output: bad addr: %p\n",
! 1481: sc->sc_dev.dv_xname, start);
! 1482: return (EINVAL);
! 1483: }
! 1484:
! 1485: n = (char *)end - (char *)start;
! 1486:
! 1487: /*
! 1488: * Do only `blksize' at a time, so audio_pint() is kept
! 1489: * synchronous with us...
! 1490: */
! 1491: sc->sc_blksz = blksize;
! 1492: sc->sc_nowplaying = p;
! 1493: sc->sc_playsegsz = n;
! 1494:
! 1495: if (n > sc->sc_blksz)
! 1496: n = sc->sc_blksz;
! 1497:
! 1498: sc->sc_playcnt = n;
! 1499:
! 1500: csr = P_READ(sc, EBDMA_DCSR);
! 1501: if (csr & EBDCSR_DMAEN) {
! 1502: P_WRITE(sc, EBDMA_DCNT, (u_long)n);
! 1503: P_WRITE(sc, EBDMA_DADDR,
! 1504: (u_long)p->dmamap->dm_segs[0].ds_addr);
! 1505: } else {
! 1506: P_WRITE(sc, EBDMA_DCSR, EBDCSR_RESET);
! 1507: P_WRITE(sc, EBDMA_DCSR, sc->sc_burst);
! 1508:
! 1509: P_WRITE(sc, EBDMA_DCNT, (u_long)n);
! 1510: P_WRITE(sc, EBDMA_DADDR,
! 1511: (u_long)p->dmamap->dm_segs[0].ds_addr);
! 1512:
! 1513: P_WRITE(sc, EBDMA_DCSR, sc->sc_burst | EBDCSR_DMAEN |
! 1514: EBDCSR_INTEN | EBDCSR_CNTEN | EBDCSR_NEXTEN);
! 1515:
! 1516: ce4231_write(sc, SP_LOWER_BASE_COUNT, 0xff);
! 1517: ce4231_write(sc, SP_UPPER_BASE_COUNT, 0xff);
! 1518: ce4231_write(sc, SP_INTERFACE_CONFIG,
! 1519: ce4231_read(sc, SP_INTERFACE_CONFIG) | PLAYBACK_ENABLE);
! 1520: }
! 1521: sc->sc_lastaddr = p->dmamap->dm_segs[0].ds_addr + n;
! 1522:
! 1523: return (0);
! 1524: }
! 1525:
! 1526: int
! 1527: ce4231_trigger_input(addr, start, end, blksize, intr, arg, param)
! 1528: void *addr, *start, *end;
! 1529: int blksize;
! 1530: void (*intr)(void *);
! 1531: void *arg;
! 1532: struct audio_params *param;
! 1533: {
! 1534: return (ENXIO);
! 1535: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to ce4231.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / sparc64 / dev