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