Annotation of sys/dev/pci/cmpci.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: cmpci.c,v 1.14 2006/07/27 00:45:59 brad Exp $ */
! 2: /* $NetBSD: cmpci.c,v 1.25 2004/10/26 06:32:20 xtraeme Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 2000, 2001 The NetBSD Foundation, Inc.
! 6: * All rights reserved.
! 7: *
! 8: * This code is derived from software contributed to The NetBSD Foundation
! 9: * by Takuya SHIOZAKI <tshiozak@NetBSD.org> .
! 10: *
! 11: * This code is derived from software contributed to The NetBSD Foundation
! 12: * by ITOH Yasufumi.
! 13: *
! 14: * Redistribution and use in source and binary forms, with or without
! 15: * modification, are permitted provided that the following conditions
! 16: * are met:
! 17: * 1. Redistributions of source code must retain the above copyright
! 18: * notice, this list of conditions and the following disclaimer.
! 19: * 2. Redistributions in binary form must reproduce the above copyright
! 20: * notice, this list of conditions and the following disclaimer in the
! 21: * documentation and/or other materials provided with the distribution.
! 22: *
! 23: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
! 24: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 25: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 26: * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
! 27: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 28: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 29: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 30: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 31: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 32: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 33: * SUCH DAMAGE.
! 34: *
! 35: */
! 36:
! 37: /*
! 38: * C-Media CMI8x38 Audio Chip Support.
! 39: *
! 40: * TODO:
! 41: * - 4ch / 6ch support.
! 42: * - Joystick support.
! 43: *
! 44: */
! 45:
! 46: #if 0
! 47: #include <sys/cdefs.h>
! 48: __KERNEL_RCSID(0, "$NetBSD: cmpci.c,v 1.25 2004/10/26 06:32:20 xtraeme Exp $");
! 49: #endif
! 50:
! 51: #if defined(AUDIO_DEBUG) || defined(DEBUG)
! 52: #define DPRINTF(x) if (cmpcidebug) printf x
! 53: int cmpcidebug = 0;
! 54: #else
! 55: #define DPRINTF(x)
! 56: #endif
! 57:
! 58: #include <sys/param.h>
! 59: #include <sys/systm.h>
! 60: #include <sys/kernel.h>
! 61: #include <sys/malloc.h>
! 62: #include <sys/device.h>
! 63: #include <sys/proc.h>
! 64:
! 65: #include <dev/pci/pcidevs.h>
! 66: #include <dev/pci/pcivar.h>
! 67:
! 68: #include <sys/audioio.h>
! 69: #include <dev/audio_if.h>
! 70: #include <dev/midi_if.h>
! 71:
! 72: #include <dev/mulaw.h>
! 73: #include <dev/auconv.h>
! 74: #include <dev/pci/cmpcireg.h>
! 75: #include <dev/pci/cmpcivar.h>
! 76:
! 77: #include <dev/ic/mpuvar.h>
! 78: #include <machine/bus.h>
! 79: #include <machine/intr.h>
! 80:
! 81: /*
! 82: * Low-level HW interface
! 83: */
! 84: __inline uint8_t cmpci_mixerreg_read(struct cmpci_softc *,
! 85: uint8_t);
! 86: __inline void cmpci_mixerreg_write(struct cmpci_softc *,
! 87: uint8_t, uint8_t);
! 88: __inline void cmpci_reg_partial_write_1(struct cmpci_softc *,
! 89: int, int,
! 90: unsigned, unsigned);
! 91: __inline void cmpci_reg_partial_write_4(struct cmpci_softc *,
! 92: int, int,
! 93: uint32_t, uint32_t);
! 94: __inline void cmpci_reg_set_1(struct cmpci_softc *,
! 95: int, uint8_t);
! 96: __inline void cmpci_reg_clear_1(struct cmpci_softc *,
! 97: int, uint8_t);
! 98: __inline void cmpci_reg_set_4(struct cmpci_softc *,
! 99: int, uint32_t);
! 100: __inline void cmpci_reg_clear_4(struct cmpci_softc *,
! 101: int, uint32_t);
! 102: __inline void cmpci_reg_set_reg_misc(struct cmpci_softc *,
! 103: uint32_t);
! 104: __inline void cmpci_reg_clear_reg_misc(struct cmpci_softc *,
! 105: uint32_t);
! 106: int cmpci_rate_to_index(int);
! 107: __inline int cmpci_index_to_rate(int);
! 108: __inline int cmpci_index_to_divider(int);
! 109:
! 110: int cmpci_adjust(int, int);
! 111: void cmpci_set_mixer_gain(struct cmpci_softc *, int);
! 112: void cmpci_set_out_ports(struct cmpci_softc *);
! 113: int cmpci_set_in_ports(struct cmpci_softc *);
! 114:
! 115: /*
! 116: * autoconf interface
! 117: */
! 118: int cmpci_match(struct device *, void *, void *);
! 119: void cmpci_attach(struct device *, struct device *, void *);
! 120:
! 121: struct cfdriver cmpci_cd = {
! 122: NULL, "cmpci", DV_DULL
! 123: };
! 124:
! 125: struct cfattach cmpci_ca = {
! 126: sizeof (struct cmpci_softc), cmpci_match, cmpci_attach
! 127: };
! 128:
! 129: /* interrupt */
! 130: int cmpci_intr(void *);
! 131:
! 132: /*
! 133: * DMA stuff
! 134: */
! 135: int cmpci_alloc_dmamem(struct cmpci_softc *,
! 136: size_t, int,
! 137: int, caddr_t *);
! 138: int cmpci_free_dmamem(struct cmpci_softc *, caddr_t,
! 139: int);
! 140: struct cmpci_dmanode * cmpci_find_dmamem(struct cmpci_softc *,
! 141: caddr_t);
! 142:
! 143: /*
! 144: * Interface to machine independent layer
! 145: */
! 146: int cmpci_open(void *, int);
! 147: void cmpci_close(void *);
! 148: int cmpci_query_encoding(void *, struct audio_encoding *);
! 149: int cmpci_set_params(void *, int, int,
! 150: struct audio_params *,
! 151: struct audio_params *);
! 152: int cmpci_round_blocksize(void *, int);
! 153: int cmpci_halt_output(void *);
! 154: int cmpci_halt_input(void *);
! 155: int cmpci_getdev(void *, struct audio_device *);
! 156: int cmpci_set_port(void *, mixer_ctrl_t *);
! 157: int cmpci_get_port(void *, mixer_ctrl_t *);
! 158: int cmpci_query_devinfo(void *, mixer_devinfo_t *);
! 159: void *cmpci_malloc(void *, int, size_t, int, int);
! 160: void cmpci_free(void *, void *, int);
! 161: size_t cmpci_round_buffersize(void *, int, size_t);
! 162: paddr_t cmpci_mappage(void *, void *, off_t, int);
! 163: int cmpci_get_props(void *);
! 164: int cmpci_trigger_output(void *, void *, void *, int,
! 165: void (*)(void *), void *,
! 166: struct audio_params *);
! 167: int cmpci_trigger_input(void *, void *, void *, int,
! 168: void (*)(void *), void *,
! 169: struct audio_params *);
! 170:
! 171: struct audio_hw_if cmpci_hw_if = {
! 172: cmpci_open, /* open */
! 173: cmpci_close, /* close */
! 174: NULL, /* drain */
! 175: cmpci_query_encoding, /* query_encoding */
! 176: cmpci_set_params, /* set_params */
! 177: cmpci_round_blocksize, /* round_blocksize */
! 178: NULL, /* commit_settings */
! 179: NULL, /* init_output */
! 180: NULL, /* init_input */
! 181: NULL, /* start_output */
! 182: NULL, /* start_input */
! 183: cmpci_halt_output, /* halt_output */
! 184: cmpci_halt_input, /* halt_input */
! 185: NULL, /* speaker_ctl */
! 186: cmpci_getdev, /* getdev */
! 187: NULL, /* setfd */
! 188: cmpci_set_port, /* set_port */
! 189: cmpci_get_port, /* get_port */
! 190: cmpci_query_devinfo, /* query_devinfo */
! 191: cmpci_malloc, /* malloc */
! 192: cmpci_free, /* free */
! 193: cmpci_round_buffersize,/* round_buffersize */
! 194: cmpci_mappage, /* mappage */
! 195: cmpci_get_props, /* get_props */
! 196: cmpci_trigger_output, /* trigger_output */
! 197: cmpci_trigger_input, /* trigger_input */
! 198: };
! 199:
! 200: /*
! 201: * Low-level HW interface
! 202: */
! 203:
! 204: /* mixer register read/write */
! 205: __inline uint8_t
! 206: cmpci_mixerreg_read(struct cmpci_softc *sc, uint8_t no)
! 207: {
! 208: uint8_t ret;
! 209:
! 210: bus_space_write_1(sc->sc_iot, sc->sc_ioh, CMPCI_REG_SBADDR, no);
! 211: delay(10);
! 212: ret = bus_space_read_1(sc->sc_iot, sc->sc_ioh, CMPCI_REG_SBDATA);
! 213: delay(10);
! 214: return ret;
! 215: }
! 216:
! 217: __inline void
! 218: cmpci_mixerreg_write(struct cmpci_softc *sc, uint8_t no, uint8_t val)
! 219: {
! 220: bus_space_write_1(sc->sc_iot, sc->sc_ioh, CMPCI_REG_SBADDR, no);
! 221: delay(10);
! 222: bus_space_write_1(sc->sc_iot, sc->sc_ioh, CMPCI_REG_SBDATA, val);
! 223: delay(10);
! 224: }
! 225:
! 226: /* register partial write */
! 227: __inline void
! 228: cmpci_reg_partial_write_1(struct cmpci_softc *sc, int no, int shift,
! 229: unsigned mask, unsigned val)
! 230: {
! 231: bus_space_write_1(sc->sc_iot, sc->sc_ioh, no,
! 232: (val<<shift) |
! 233: (bus_space_read_1(sc->sc_iot, sc->sc_ioh, no) & ~(mask<<shift)));
! 234: delay(10);
! 235: }
! 236:
! 237: __inline void
! 238: cmpci_reg_partial_write_4(struct cmpci_softc *sc, int no, int shift,
! 239: uint32_t mask, uint32_t val)
! 240: {
! 241: bus_space_write_4(sc->sc_iot, sc->sc_ioh, no,
! 242: (val<<shift) |
! 243: (bus_space_read_4(sc->sc_iot, sc->sc_ioh, no) & ~(mask<<shift)));
! 244: delay(10);
! 245: }
! 246:
! 247: /* register set/clear bit */
! 248: __inline void
! 249: cmpci_reg_set_1(struct cmpci_softc *sc, int no, uint8_t mask)
! 250: {
! 251: bus_space_write_1(sc->sc_iot, sc->sc_ioh, no,
! 252: (bus_space_read_1(sc->sc_iot, sc->sc_ioh, no) | mask));
! 253: delay(10);
! 254: }
! 255:
! 256: __inline void
! 257: cmpci_reg_clear_1(struct cmpci_softc *sc, int no, uint8_t mask)
! 258: {
! 259: bus_space_write_1(sc->sc_iot, sc->sc_ioh, no,
! 260: (bus_space_read_1(sc->sc_iot, sc->sc_ioh, no) & ~mask));
! 261: delay(10);
! 262: }
! 263:
! 264: __inline void
! 265: cmpci_reg_set_4(struct cmpci_softc *sc, int no, uint32_t mask)
! 266: {
! 267: /* use cmpci_reg_set_reg_misc() for CMPCI_REG_MISC */
! 268: KDASSERT(no != CMPCI_REG_MISC);
! 269:
! 270: bus_space_write_4(sc->sc_iot, sc->sc_ioh, no,
! 271: (bus_space_read_4(sc->sc_iot, sc->sc_ioh, no) | mask));
! 272: delay(10);
! 273: }
! 274:
! 275: __inline void
! 276: cmpci_reg_clear_4(struct cmpci_softc *sc, int no, uint32_t mask)
! 277: {
! 278: /* use cmpci_reg_clear_reg_misc() for CMPCI_REG_MISC */
! 279: KDASSERT(no != CMPCI_REG_MISC);
! 280:
! 281: bus_space_write_4(sc->sc_iot, sc->sc_ioh, no,
! 282: (bus_space_read_4(sc->sc_iot, sc->sc_ioh, no) & ~mask));
! 283: delay(10);
! 284: }
! 285:
! 286: /*
! 287: * The CMPCI_REG_MISC register needs special handling, since one of
! 288: * its bits has different read/write values.
! 289: */
! 290: __inline void
! 291: cmpci_reg_set_reg_misc(struct cmpci_softc *sc, uint32_t mask)
! 292: {
! 293: sc->sc_reg_misc |= mask;
! 294: bus_space_write_4(sc->sc_iot, sc->sc_ioh, CMPCI_REG_MISC,
! 295: sc->sc_reg_misc);
! 296: delay(10);
! 297: }
! 298:
! 299: __inline void
! 300: cmpci_reg_clear_reg_misc(struct cmpci_softc *sc, uint32_t mask)
! 301: {
! 302: sc->sc_reg_misc &= ~mask;
! 303: bus_space_write_4(sc->sc_iot, sc->sc_ioh, CMPCI_REG_MISC,
! 304: sc->sc_reg_misc);
! 305: delay(10);
! 306: }
! 307:
! 308: /* rate */
! 309: static const struct {
! 310: int rate;
! 311: int divider;
! 312: } cmpci_rate_table[CMPCI_REG_NUMRATE] = {
! 313: #define _RATE(n) { n, CMPCI_REG_RATE_ ## n }
! 314: _RATE(5512),
! 315: _RATE(8000),
! 316: _RATE(11025),
! 317: _RATE(16000),
! 318: _RATE(22050),
! 319: _RATE(32000),
! 320: _RATE(44100),
! 321: _RATE(48000)
! 322: #undef _RATE
! 323: };
! 324:
! 325: int
! 326: cmpci_rate_to_index(int rate)
! 327: {
! 328: int i;
! 329:
! 330: for (i = 0; i < CMPCI_REG_NUMRATE - 1; i++)
! 331: if (rate <=
! 332: (cmpci_rate_table[i].rate + cmpci_rate_table[i+1].rate) / 2)
! 333: return i;
! 334: return i; /* 48000 */
! 335: }
! 336:
! 337: __inline int
! 338: cmpci_index_to_rate(int index)
! 339: {
! 340: return cmpci_rate_table[index].rate;
! 341: }
! 342:
! 343: __inline int
! 344: cmpci_index_to_divider(int index)
! 345: {
! 346: return cmpci_rate_table[index].divider;
! 347: }
! 348:
! 349: const struct pci_matchid cmpci_devices[] = {
! 350: { PCI_VENDOR_CMI, PCI_PRODUCT_CMI_CMI8338A },
! 351: { PCI_VENDOR_CMI, PCI_PRODUCT_CMI_CMI8338B },
! 352: { PCI_VENDOR_CMI, PCI_PRODUCT_CMI_CMI8738 },
! 353: { PCI_VENDOR_CMI, PCI_PRODUCT_CMI_CMI8738B }
! 354: };
! 355:
! 356: /*
! 357: * interface to configure the device.
! 358: */
! 359:
! 360: int
! 361: cmpci_match(struct device *parent, void *match, void *aux)
! 362: {
! 363: return (pci_matchbyid((struct pci_attach_args *)aux, cmpci_devices,
! 364: sizeof(cmpci_devices)/sizeof(cmpci_devices[0])));
! 365: }
! 366:
! 367: void
! 368: cmpci_attach(struct device *parent, struct device *self, void *aux)
! 369: {
! 370: struct cmpci_softc *sc = (struct cmpci_softc *)self;
! 371: struct pci_attach_args *pa = (struct pci_attach_args *)aux;
! 372: struct audio_attach_args aa;
! 373: pci_intr_handle_t ih;
! 374: char const *intrstr;
! 375: int i, v;
! 376:
! 377: sc->sc_id = pa->pa_id;
! 378: sc->sc_class = pa->pa_class;
! 379: switch (PCI_PRODUCT(sc->sc_id)) {
! 380: case PCI_PRODUCT_CMI_CMI8338A:
! 381: /*FALLTHROUGH*/
! 382: case PCI_PRODUCT_CMI_CMI8338B:
! 383: sc->sc_capable = CMPCI_CAP_CMI8338;
! 384: break;
! 385: case PCI_PRODUCT_CMI_CMI8738:
! 386: /*FALLTHROUGH*/
! 387: case PCI_PRODUCT_CMI_CMI8738B:
! 388: sc->sc_capable = CMPCI_CAP_CMI8738;
! 389: break;
! 390: }
! 391:
! 392: /* map I/O space */
! 393: if (pci_mapreg_map(pa, CMPCI_PCI_IOBASEREG, PCI_MAPREG_TYPE_IO, 0,
! 394: &sc->sc_iot, &sc->sc_ioh, NULL, NULL, 0)) {
! 395: printf(": failed to map I/O space\n");
! 396: return;
! 397: }
! 398:
! 399: /* interrupt */
! 400: if (pci_intr_map(pa, &ih)) {
! 401: printf(": failed to map interrupt\n");
! 402: return;
! 403: }
! 404: intrstr = pci_intr_string(pa->pa_pc, ih);
! 405: sc->sc_ih=pci_intr_establish(pa->pa_pc, ih, IPL_AUDIO, cmpci_intr, sc,
! 406: sc->sc_dev.dv_xname);
! 407: if (sc->sc_ih == NULL) {
! 408: printf(": failed to establish interrupt");
! 409: if (intrstr != NULL)
! 410: printf(" at %s", intrstr);
! 411: printf("\n");
! 412: return;
! 413: }
! 414: printf(": %s\n", intrstr);
! 415:
! 416: sc->sc_dmat = pa->pa_dmat;
! 417:
! 418: audio_attach_mi(&cmpci_hw_if, sc, &sc->sc_dev);
! 419:
! 420: /* attach OPL device */
! 421: aa.type = AUDIODEV_TYPE_OPL;
! 422: aa.hwif = NULL;
! 423: aa.hdl = NULL;
! 424: (void)config_found(&sc->sc_dev, &aa, audioprint);
! 425:
! 426: /* attach MPU-401 device */
! 427: aa.type = AUDIODEV_TYPE_MPU;
! 428: aa.hwif = NULL;
! 429: aa.hdl = NULL;
! 430: if (bus_space_subregion(sc->sc_iot, sc->sc_ioh,
! 431: CMPCI_REG_MPU_BASE, CMPCI_REG_MPU_SIZE, &sc->sc_mpu_ioh) == 0)
! 432: sc->sc_mpudev = config_found(&sc->sc_dev, &aa, audioprint);
! 433:
! 434: /* get initial value (this is 0 and may be omitted but just in case) */
! 435: sc->sc_reg_misc = bus_space_read_4(sc->sc_iot, sc->sc_ioh,
! 436: CMPCI_REG_MISC) & ~CMPCI_REG_SPDIF48K;
! 437:
! 438: cmpci_mixerreg_write(sc, CMPCI_SB16_MIXER_RESET, 0);
! 439: cmpci_mixerreg_write(sc, CMPCI_SB16_MIXER_ADCMIX_L, 0);
! 440: cmpci_mixerreg_write(sc, CMPCI_SB16_MIXER_ADCMIX_R, 0);
! 441: cmpci_mixerreg_write(sc, CMPCI_SB16_MIXER_OUTMIX,
! 442: CMPCI_SB16_SW_CD|CMPCI_SB16_SW_MIC|CMPCI_SB16_SW_LINE);
! 443: for (i = 0; i < CMPCI_NDEVS; i++) {
! 444: switch(i) {
! 445: /*
! 446: * CMI8738 defaults are
! 447: * master: 0xe0 (0x00 - 0xf8)
! 448: * FM, DAC: 0xc0 (0x00 - 0xf8)
! 449: * PC speaker: 0x80 (0x00 - 0xc0)
! 450: * others: 0
! 451: */
! 452: /* volume */
! 453: case CMPCI_MASTER_VOL:
! 454: v = 128; /* 224 */
! 455: break;
! 456: case CMPCI_FM_VOL:
! 457: case CMPCI_DAC_VOL:
! 458: v = 192;
! 459: break;
! 460: case CMPCI_PCSPEAKER:
! 461: v = 128;
! 462: break;
! 463:
! 464: /* booleans, set to true */
! 465: case CMPCI_CD_MUTE:
! 466: case CMPCI_MIC_MUTE:
! 467: case CMPCI_LINE_IN_MUTE:
! 468: case CMPCI_AUX_IN_MUTE:
! 469: v = 1;
! 470: break;
! 471:
! 472: /* volume with inital value 0 */
! 473: case CMPCI_CD_VOL:
! 474: case CMPCI_LINE_IN_VOL:
! 475: case CMPCI_AUX_IN_VOL:
! 476: case CMPCI_MIC_VOL:
! 477: case CMPCI_MIC_RECVOL:
! 478: /* FALLTHROUGH */
! 479:
! 480: /* others are cleared */
! 481: case CMPCI_MIC_PREAMP:
! 482: case CMPCI_RECORD_SOURCE:
! 483: case CMPCI_PLAYBACK_MODE:
! 484: case CMPCI_SPDIF_IN_SELECT:
! 485: case CMPCI_SPDIF_IN_PHASE:
! 486: case CMPCI_SPDIF_LOOP:
! 487: case CMPCI_SPDIF_OUT_PLAYBACK:
! 488: case CMPCI_SPDIF_OUT_VOLTAGE:
! 489: case CMPCI_MONITOR_DAC:
! 490: case CMPCI_REAR:
! 491: case CMPCI_INDIVIDUAL:
! 492: case CMPCI_REVERSE:
! 493: case CMPCI_SURROUND:
! 494: default:
! 495: v = 0;
! 496: break;
! 497: }
! 498: sc->sc_gain[i][CMPCI_LEFT] = sc->sc_gain[i][CMPCI_RIGHT] = v;
! 499: cmpci_set_mixer_gain(sc, i);
! 500: }
! 501: }
! 502:
! 503: int
! 504: cmpci_intr(void *handle)
! 505: {
! 506: struct cmpci_softc *sc = handle;
! 507: uint32_t intrstat;
! 508:
! 509: intrstat = bus_space_read_4(sc->sc_iot, sc->sc_ioh,
! 510: CMPCI_REG_INTR_STATUS);
! 511:
! 512: if (!(intrstat & CMPCI_REG_ANY_INTR))
! 513: return 0;
! 514:
! 515: delay(10);
! 516:
! 517: /* disable and reset intr */
! 518: if (intrstat & CMPCI_REG_CH0_INTR)
! 519: cmpci_reg_clear_4(sc, CMPCI_REG_INTR_CTRL,
! 520: CMPCI_REG_CH0_INTR_ENABLE);
! 521: if (intrstat & CMPCI_REG_CH1_INTR)
! 522: cmpci_reg_clear_4(sc, CMPCI_REG_INTR_CTRL,
! 523: CMPCI_REG_CH1_INTR_ENABLE);
! 524:
! 525: if (intrstat & CMPCI_REG_CH0_INTR) {
! 526: if (sc->sc_play.intr != NULL)
! 527: (*sc->sc_play.intr)(sc->sc_play.intr_arg);
! 528: }
! 529: if (intrstat & CMPCI_REG_CH1_INTR) {
! 530: if (sc->sc_rec.intr != NULL)
! 531: (*sc->sc_rec.intr)(sc->sc_rec.intr_arg);
! 532: }
! 533:
! 534: /* enable intr */
! 535: if (intrstat & CMPCI_REG_CH0_INTR)
! 536: cmpci_reg_set_4(sc, CMPCI_REG_INTR_CTRL,
! 537: CMPCI_REG_CH0_INTR_ENABLE);
! 538: if (intrstat & CMPCI_REG_CH1_INTR)
! 539: cmpci_reg_set_4(sc, CMPCI_REG_INTR_CTRL,
! 540: CMPCI_REG_CH1_INTR_ENABLE);
! 541:
! 542: #if 0
! 543: if (intrstat & CMPCI_REG_UART_INTR && sc->sc_mpudev != NULL)
! 544: mpu_intr(sc->sc_mpudev);
! 545: #endif
! 546:
! 547: return 1;
! 548: }
! 549:
! 550: /* open/close */
! 551: int
! 552: cmpci_open(void *handle, int flags)
! 553: {
! 554: return 0;
! 555: }
! 556:
! 557: void
! 558: cmpci_close(void *handle)
! 559: {
! 560: }
! 561:
! 562: int
! 563: cmpci_query_encoding(void *handle, struct audio_encoding *fp)
! 564: {
! 565: switch (fp->index) {
! 566: case 0:
! 567: strlcpy(fp->name, AudioEulinear, sizeof fp->name);
! 568: fp->encoding = AUDIO_ENCODING_ULINEAR;
! 569: fp->precision = 8;
! 570: fp->flags = 0;
! 571: break;
! 572: case 1:
! 573: strlcpy(fp->name, AudioEmulaw, sizeof fp->name);
! 574: fp->encoding = AUDIO_ENCODING_ULAW;
! 575: fp->precision = 8;
! 576: fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
! 577: break;
! 578: case 2:
! 579: strlcpy(fp->name, AudioEalaw, sizeof fp->name);
! 580: fp->encoding = AUDIO_ENCODING_ALAW;
! 581: fp->precision = 8;
! 582: fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
! 583: break;
! 584: case 3:
! 585: strlcpy(fp->name, AudioEslinear, sizeof fp->name);
! 586: fp->encoding = AUDIO_ENCODING_SLINEAR;
! 587: fp->precision = 8;
! 588: fp->flags = 0;
! 589: break;
! 590: case 4:
! 591: strlcpy(fp->name, AudioEslinear_le, sizeof fp->name);
! 592: fp->encoding = AUDIO_ENCODING_SLINEAR_LE;
! 593: fp->precision = 16;
! 594: fp->flags = 0;
! 595: break;
! 596: case 5:
! 597: strlcpy(fp->name, AudioEulinear_le, sizeof fp->name);
! 598: fp->encoding = AUDIO_ENCODING_ULINEAR_LE;
! 599: fp->precision = 16;
! 600: fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
! 601: break;
! 602: case 6:
! 603: strlcpy(fp->name, AudioEslinear_be, sizeof fp->name);
! 604: fp->encoding = AUDIO_ENCODING_SLINEAR_BE;
! 605: fp->precision = 16;
! 606: fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
! 607: break;
! 608: case 7:
! 609: strlcpy(fp->name, AudioEulinear_be, sizeof fp->name);
! 610: fp->encoding = AUDIO_ENCODING_ULINEAR_BE;
! 611: fp->precision = 16;
! 612: fp->flags = AUDIO_ENCODINGFLAG_EMULATED;
! 613: break;
! 614: default:
! 615: return EINVAL;
! 616: }
! 617: return 0;
! 618: }
! 619:
! 620: int
! 621: cmpci_set_params(void *handle, int setmode, int usemode,
! 622: struct audio_params *play, struct audio_params *rec)
! 623: {
! 624: int i;
! 625: struct cmpci_softc *sc = handle;
! 626:
! 627: for (i = 0; i < 2; i++) {
! 628: int md_format;
! 629: int md_divide;
! 630: int md_index;
! 631: int mode;
! 632: struct audio_params *p;
! 633:
! 634: switch (i) {
! 635: case 0:
! 636: mode = AUMODE_PLAY;
! 637: p = play;
! 638: break;
! 639: case 1:
! 640: mode = AUMODE_RECORD;
! 641: p = rec;
! 642: break;
! 643: default:
! 644: return EINVAL;
! 645: }
! 646:
! 647: if (!(setmode & mode))
! 648: continue;
! 649:
! 650: /* format */
! 651: p->sw_code = NULL;
! 652: switch (p->channels) {
! 653: case 1:
! 654: md_format = CMPCI_REG_FORMAT_MONO;
! 655: break;
! 656: case 2:
! 657: md_format = CMPCI_REG_FORMAT_STEREO;
! 658: break;
! 659: default:
! 660: return (EINVAL);
! 661: }
! 662: switch (p->encoding) {
! 663: case AUDIO_ENCODING_ULAW:
! 664: if (p->precision != 8)
! 665: return (EINVAL);
! 666: if (mode & AUMODE_PLAY) {
! 667: p->factor = 2;
! 668: p->sw_code = mulaw_to_slinear16_le;
! 669: md_format |= CMPCI_REG_FORMAT_16BIT;
! 670: } else {
! 671: p->sw_code = ulinear8_to_mulaw;
! 672: md_format |= CMPCI_REG_FORMAT_8BIT;
! 673: }
! 674: break;
! 675: case AUDIO_ENCODING_ALAW:
! 676: if (p->precision != 8)
! 677: return (EINVAL);
! 678: if (mode & AUMODE_PLAY) {
! 679: p->factor = 2;
! 680: p->sw_code = alaw_to_slinear16_le;
! 681: md_format |= CMPCI_REG_FORMAT_16BIT;
! 682: } else {
! 683: p->sw_code = ulinear8_to_alaw;
! 684: md_format |= CMPCI_REG_FORMAT_8BIT;
! 685: }
! 686: break;
! 687: case AUDIO_ENCODING_SLINEAR_LE:
! 688: switch (p->precision) {
! 689: case 8:
! 690: p->sw_code = change_sign8;
! 691: md_format |= CMPCI_REG_FORMAT_8BIT;
! 692: break;
! 693: case 16:
! 694: md_format |= CMPCI_REG_FORMAT_16BIT;
! 695: break;
! 696: default:
! 697: return (EINVAL);
! 698: }
! 699: break;
! 700: case AUDIO_ENCODING_SLINEAR_BE:
! 701: switch (p->precision) {
! 702: case 8:
! 703: md_format |= CMPCI_REG_FORMAT_8BIT;
! 704: p->sw_code = change_sign8;
! 705: break;
! 706: case 16:
! 707: md_format |= CMPCI_REG_FORMAT_16BIT;
! 708: p->sw_code = swap_bytes;
! 709: break;
! 710: default:
! 711: return (EINVAL);
! 712: }
! 713: break;
! 714: case AUDIO_ENCODING_ULINEAR_LE:
! 715: switch (p->precision) {
! 716: case 8:
! 717: md_format |= CMPCI_REG_FORMAT_8BIT;
! 718: break;
! 719: case 16:
! 720: md_format |= CMPCI_REG_FORMAT_16BIT;
! 721: p->sw_code = change_sign16_le;
! 722: break;
! 723: default:
! 724: return (EINVAL);
! 725: }
! 726: break;
! 727: case AUDIO_ENCODING_ULINEAR_BE:
! 728: switch (p->precision) {
! 729: case 8:
! 730: md_format |= CMPCI_REG_FORMAT_8BIT;
! 731: break;
! 732: case 16:
! 733: md_format |= CMPCI_REG_FORMAT_16BIT;
! 734: if (mode & AUMODE_PLAY)
! 735: p->sw_code =
! 736: swap_bytes_change_sign16_le;
! 737: else
! 738: p->sw_code =
! 739: change_sign16_swap_bytes_le;
! 740: break;
! 741: default:
! 742: return (EINVAL);
! 743: }
! 744: break;
! 745: default:
! 746: return (EINVAL);
! 747: }
! 748: if (mode & AUMODE_PLAY)
! 749: cmpci_reg_partial_write_4(sc,
! 750: CMPCI_REG_CHANNEL_FORMAT,
! 751: CMPCI_REG_CH0_FORMAT_SHIFT,
! 752: CMPCI_REG_CH0_FORMAT_MASK, md_format);
! 753: else
! 754: cmpci_reg_partial_write_4(sc,
! 755: CMPCI_REG_CHANNEL_FORMAT,
! 756: CMPCI_REG_CH1_FORMAT_SHIFT,
! 757: CMPCI_REG_CH1_FORMAT_MASK, md_format);
! 758: /* sample rate */
! 759: md_index = cmpci_rate_to_index(p->sample_rate);
! 760: md_divide = cmpci_index_to_divider(md_index);
! 761: p->sample_rate = cmpci_index_to_rate(md_index);
! 762: DPRINTF(("%s: sample:%d, divider=%d\n",
! 763: sc->sc_dev.dv_xname, (int)p->sample_rate, md_divide));
! 764: if (mode & AUMODE_PLAY) {
! 765: cmpci_reg_partial_write_4(sc,
! 766: CMPCI_REG_FUNC_1, CMPCI_REG_DAC_FS_SHIFT,
! 767: CMPCI_REG_DAC_FS_MASK, md_divide);
! 768: sc->sc_play.md_divide = md_divide;
! 769: } else {
! 770: cmpci_reg_partial_write_4(sc,
! 771: CMPCI_REG_FUNC_1, CMPCI_REG_ADC_FS_SHIFT,
! 772: CMPCI_REG_ADC_FS_MASK, md_divide);
! 773: sc->sc_rec.md_divide = md_divide;
! 774: }
! 775: cmpci_set_out_ports(sc);
! 776: cmpci_set_in_ports(sc);
! 777: }
! 778: return 0;
! 779: }
! 780:
! 781: /* ARGSUSED */
! 782: int
! 783: cmpci_round_blocksize(void *handle, int block)
! 784: {
! 785: return ((block + 3) & -4);
! 786: }
! 787:
! 788: int
! 789: cmpci_halt_output(void *handle)
! 790: {
! 791: struct cmpci_softc *sc = handle;
! 792: int s;
! 793:
! 794: s = splaudio();
! 795: sc->sc_play.intr = NULL;
! 796: cmpci_reg_clear_4(sc, CMPCI_REG_INTR_CTRL, CMPCI_REG_CH0_INTR_ENABLE);
! 797: cmpci_reg_clear_4(sc, CMPCI_REG_FUNC_0, CMPCI_REG_CH0_ENABLE);
! 798: /* wait for reset DMA */
! 799: cmpci_reg_set_4(sc, CMPCI_REG_FUNC_0, CMPCI_REG_CH0_RESET);
! 800: delay(10);
! 801: cmpci_reg_clear_4(sc, CMPCI_REG_FUNC_0, CMPCI_REG_CH0_RESET);
! 802: splx(s);
! 803:
! 804: return 0;
! 805: }
! 806:
! 807: int
! 808: cmpci_halt_input(void *handle)
! 809: {
! 810: struct cmpci_softc *sc = handle;
! 811: int s;
! 812:
! 813: s = splaudio();
! 814: sc->sc_rec.intr = NULL;
! 815: cmpci_reg_clear_4(sc, CMPCI_REG_INTR_CTRL, CMPCI_REG_CH1_INTR_ENABLE);
! 816: cmpci_reg_clear_4(sc, CMPCI_REG_FUNC_0, CMPCI_REG_CH1_ENABLE);
! 817: /* wait for reset DMA */
! 818: cmpci_reg_set_4(sc, CMPCI_REG_FUNC_0, CMPCI_REG_CH1_RESET);
! 819: delay(10);
! 820: cmpci_reg_clear_4(sc, CMPCI_REG_FUNC_0, CMPCI_REG_CH1_RESET);
! 821: splx(s);
! 822:
! 823: return 0;
! 824: }
! 825:
! 826: /* get audio device information */
! 827: int
! 828: cmpci_getdev(void *handle, struct audio_device *ad)
! 829: {
! 830: struct cmpci_softc *sc = handle;
! 831:
! 832: strncpy(ad->name, "CMI PCI Audio", sizeof(ad->name));
! 833: snprintf(ad->version, sizeof(ad->version), "0x%02x",
! 834: PCI_REVISION(sc->sc_class));
! 835: switch (PCI_PRODUCT(sc->sc_id)) {
! 836: case PCI_PRODUCT_CMI_CMI8338A:
! 837: strncpy(ad->config, "CMI8338A", sizeof(ad->config));
! 838: break;
! 839: case PCI_PRODUCT_CMI_CMI8338B:
! 840: strncpy(ad->config, "CMI8338B", sizeof(ad->config));
! 841: break;
! 842: case PCI_PRODUCT_CMI_CMI8738:
! 843: strncpy(ad->config, "CMI8738", sizeof(ad->config));
! 844: break;
! 845: case PCI_PRODUCT_CMI_CMI8738B:
! 846: strncpy(ad->config, "CMI8738B", sizeof(ad->config));
! 847: break;
! 848: default:
! 849: strncpy(ad->config, "unknown", sizeof(ad->config));
! 850: }
! 851:
! 852: return 0;
! 853: }
! 854:
! 855: /* mixer device information */
! 856: int
! 857: cmpci_query_devinfo(void *handle, mixer_devinfo_t *dip)
! 858: {
! 859: static const char *const mixer_port_names[] = {
! 860: AudioNdac, AudioNfmsynth, AudioNcd, AudioNline, AudioNaux,
! 861: AudioNmicrophone
! 862: };
! 863: static const char *const mixer_classes[] = {
! 864: AudioCinputs, AudioCoutputs, AudioCrecord, CmpciCplayback,
! 865: CmpciCspdif
! 866: };
! 867: struct cmpci_softc *sc = handle;
! 868: int i;
! 869:
! 870: dip->prev = dip->next = AUDIO_MIXER_LAST;
! 871:
! 872: switch (dip->index) {
! 873: case CMPCI_INPUT_CLASS:
! 874: case CMPCI_OUTPUT_CLASS:
! 875: case CMPCI_RECORD_CLASS:
! 876: case CMPCI_PLAYBACK_CLASS:
! 877: case CMPCI_SPDIF_CLASS:
! 878: dip->type = AUDIO_MIXER_CLASS;
! 879: dip->mixer_class = dip->index;
! 880: strlcpy(dip->label.name,
! 881: mixer_classes[dip->index - CMPCI_INPUT_CLASS],
! 882: sizeof dip->label.name);
! 883: return 0;
! 884:
! 885: case CMPCI_AUX_IN_VOL:
! 886: dip->un.v.delta = 1 << (8 - CMPCI_REG_AUX_VALBITS);
! 887: goto vol1;
! 888: case CMPCI_DAC_VOL:
! 889: case CMPCI_FM_VOL:
! 890: case CMPCI_CD_VOL:
! 891: case CMPCI_LINE_IN_VOL:
! 892: case CMPCI_MIC_VOL:
! 893: dip->un.v.delta = 1 << (8 - CMPCI_SB16_MIXER_VALBITS);
! 894: vol1: dip->mixer_class = CMPCI_INPUT_CLASS;
! 895: dip->next = dip->index + 6; /* CMPCI_xxx_MUTE */
! 896: strlcpy(dip->label.name, mixer_port_names[dip->index],
! 897: sizeof dip->label.name);
! 898: dip->un.v.num_channels = (dip->index == CMPCI_MIC_VOL ? 1 : 2);
! 899: vol:
! 900: dip->type = AUDIO_MIXER_VALUE;
! 901: strlcpy(dip->un.v.units.name, AudioNvolume,
! 902: sizeof dip->un.v.units.name);
! 903: return 0;
! 904:
! 905: case CMPCI_MIC_MUTE:
! 906: dip->next = CMPCI_MIC_PREAMP;
! 907: /* FALLTHROUGH */
! 908: case CMPCI_DAC_MUTE:
! 909: case CMPCI_FM_MUTE:
! 910: case CMPCI_CD_MUTE:
! 911: case CMPCI_LINE_IN_MUTE:
! 912: case CMPCI_AUX_IN_MUTE:
! 913: dip->prev = dip->index - 6; /* CMPCI_xxx_VOL */
! 914: dip->mixer_class = CMPCI_INPUT_CLASS;
! 915: strlcpy(dip->label.name, AudioNmute, sizeof dip->label.name);
! 916: goto on_off;
! 917: on_off:
! 918: dip->type = AUDIO_MIXER_ENUM;
! 919: dip->un.e.num_mem = 2;
! 920: strlcpy(dip->un.e.member[0].label.name, AudioNoff,
! 921: sizeof dip->un.e.member[0].label.name);
! 922: dip->un.e.member[0].ord = 0;
! 923: strlcpy(dip->un.e.member[1].label.name, AudioNon,
! 924: sizeof dip->un.e.member[1].label.name);
! 925: dip->un.e.member[1].ord = 1;
! 926: return 0;
! 927:
! 928: case CMPCI_MIC_PREAMP:
! 929: dip->mixer_class = CMPCI_INPUT_CLASS;
! 930: dip->prev = CMPCI_MIC_MUTE;
! 931: strlcpy(dip->label.name, AudioNpreamp, sizeof dip->label.name);
! 932: goto on_off;
! 933: case CMPCI_PCSPEAKER:
! 934: dip->mixer_class = CMPCI_INPUT_CLASS;
! 935: strlcpy(dip->label.name, AudioNspeaker, sizeof dip->label.name);
! 936: dip->un.v.num_channels = 1;
! 937: dip->un.v.delta = 1 << (8 - CMPCI_SB16_MIXER_SPEAKER_VALBITS);
! 938: goto vol;
! 939: case CMPCI_RECORD_SOURCE:
! 940: dip->mixer_class = CMPCI_RECORD_CLASS;
! 941: strlcpy(dip->label.name, AudioNsource, sizeof dip->label.name);
! 942: dip->type = AUDIO_MIXER_SET;
! 943: dip->un.s.num_mem = 7;
! 944: strlcpy(dip->un.s.member[0].label.name, AudioNmicrophone,
! 945: sizeof dip->un.s.member[0].label.name);
! 946: dip->un.s.member[0].mask = CMPCI_RECORD_SOURCE_MIC;
! 947: strlcpy(dip->un.s.member[1].label.name, AudioNcd,
! 948: sizeof dip->un.s.member[1].label.name);
! 949: dip->un.s.member[1].mask = CMPCI_RECORD_SOURCE_CD;
! 950: strlcpy(dip->un.s.member[2].label.name, AudioNline,
! 951: sizeof dip->un.s.member[2].label.name);
! 952: dip->un.s.member[2].mask = CMPCI_RECORD_SOURCE_LINE_IN;
! 953: strlcpy(dip->un.s.member[3].label.name, AudioNaux,
! 954: sizeof dip->un.s.member[3].label.name);
! 955: dip->un.s.member[3].mask = CMPCI_RECORD_SOURCE_AUX_IN;
! 956: strlcpy(dip->un.s.member[4].label.name, AudioNwave,
! 957: sizeof dip->un.s.member[4].label.name);
! 958: dip->un.s.member[4].mask = CMPCI_RECORD_SOURCE_WAVE;
! 959: strlcpy(dip->un.s.member[5].label.name, AudioNfmsynth,
! 960: sizeof dip->un.s.member[5].label.name);
! 961: dip->un.s.member[5].mask = CMPCI_RECORD_SOURCE_FM;
! 962: strlcpy(dip->un.s.member[6].label.name, CmpciNspdif,
! 963: sizeof dip->un.s.member[6].label.name);
! 964: dip->un.s.member[6].mask = CMPCI_RECORD_SOURCE_SPDIF;
! 965: return 0;
! 966: case CMPCI_MIC_RECVOL:
! 967: dip->mixer_class = CMPCI_RECORD_CLASS;
! 968: strlcpy(dip->label.name, AudioNmicrophone, sizeof dip->label.name);
! 969: dip->un.v.num_channels = 1;
! 970: dip->un.v.delta = 1 << (8 - CMPCI_REG_ADMIC_VALBITS);
! 971: goto vol;
! 972:
! 973: case CMPCI_PLAYBACK_MODE:
! 974: dip->mixer_class = CMPCI_PLAYBACK_CLASS;
! 975: dip->type = AUDIO_MIXER_ENUM;
! 976: strlcpy(dip->label.name, AudioNmode, sizeof dip->label.name);
! 977: dip->un.e.num_mem = 2;
! 978: strlcpy(dip->un.e.member[0].label.name, AudioNdac,
! 979: sizeof dip->un.e.member[0].label.name);
! 980: dip->un.e.member[0].ord = CMPCI_PLAYBACK_MODE_WAVE;
! 981: strlcpy(dip->un.e.member[1].label.name, CmpciNspdif,
! 982: sizeof dip->un.e.member[1].label.name);
! 983: dip->un.e.member[1].ord = CMPCI_PLAYBACK_MODE_SPDIF;
! 984: return 0;
! 985: case CMPCI_SPDIF_IN_SELECT:
! 986: dip->mixer_class = CMPCI_SPDIF_CLASS;
! 987: dip->type = AUDIO_MIXER_ENUM;
! 988: dip->next = CMPCI_SPDIF_IN_PHASE;
! 989: strlcpy(dip->label.name, AudioNinput, sizeof dip->label.name);
! 990: i = 0;
! 991: strlcpy(dip->un.e.member[i].label.name, CmpciNspdin1,
! 992: sizeof dip->un.e.member[i].label.name);
! 993: dip->un.e.member[i++].ord = CMPCI_SPDIF_IN_SPDIN1;
! 994: if (CMPCI_ISCAP(sc, 2ND_SPDIN)) {
! 995: strlcpy(dip->un.e.member[i].label.name, CmpciNspdin2,
! 996: sizeof dip->un.e.member[i].label.name);
! 997: dip->un.e.member[i++].ord = CMPCI_SPDIF_IN_SPDIN2;
! 998: }
! 999: strlcpy(dip->un.e.member[i].label.name, CmpciNspdout,
! 1000: sizeof dip->un.e.member[i].label.name);
! 1001: dip->un.e.member[i++].ord = CMPCI_SPDIF_IN_SPDOUT;
! 1002: dip->un.e.num_mem = i;
! 1003: return 0;
! 1004: case CMPCI_SPDIF_IN_PHASE:
! 1005: dip->mixer_class = CMPCI_SPDIF_CLASS;
! 1006: dip->prev = CMPCI_SPDIF_IN_SELECT;
! 1007: strlcpy(dip->label.name, CmpciNphase, sizeof dip->label.name);
! 1008: dip->type = AUDIO_MIXER_ENUM;
! 1009: dip->un.e.num_mem = 2;
! 1010: strlcpy(dip->un.e.member[0].label.name, CmpciNpositive,
! 1011: sizeof dip->un.e.member[0].label.name);
! 1012: dip->un.e.member[0].ord = CMPCI_SPDIF_IN_PHASE_POSITIVE;
! 1013: strlcpy(dip->un.e.member[1].label.name, CmpciNnegative,
! 1014: sizeof dip->un.e.member[1].label.name);
! 1015: dip->un.e.member[1].ord = CMPCI_SPDIF_IN_PHASE_NEGATIVE;
! 1016: return 0;
! 1017: case CMPCI_SPDIF_LOOP:
! 1018: dip->mixer_class = CMPCI_SPDIF_CLASS;
! 1019: dip->next = CMPCI_SPDIF_OUT_PLAYBACK;
! 1020: strlcpy(dip->label.name, AudioNoutput, sizeof dip->label.name);
! 1021: dip->type = AUDIO_MIXER_ENUM;
! 1022: dip->un.e.num_mem = 2;
! 1023: strlcpy(dip->un.e.member[0].label.name, CmpciNplayback,
! 1024: sizeof dip->un.e.member[0].label.name);
! 1025: dip->un.e.member[0].ord = CMPCI_SPDIF_LOOP_OFF;
! 1026: strlcpy(dip->un.e.member[1].label.name, CmpciNspdin,
! 1027: sizeof dip->un.e.member[1].label.name);
! 1028: dip->un.e.member[1].ord = CMPCI_SPDIF_LOOP_ON;
! 1029: return 0;
! 1030: case CMPCI_SPDIF_OUT_PLAYBACK:
! 1031: dip->mixer_class = CMPCI_SPDIF_CLASS;
! 1032: dip->prev = CMPCI_SPDIF_LOOP;
! 1033: dip->next = CMPCI_SPDIF_OUT_VOLTAGE;
! 1034: strlcpy(dip->label.name, CmpciNplayback, sizeof dip->label.name);
! 1035: dip->type = AUDIO_MIXER_ENUM;
! 1036: dip->un.e.num_mem = 2;
! 1037: strlcpy(dip->un.e.member[0].label.name, AudioNwave,
! 1038: sizeof dip->un.e.member[0].label.name);
! 1039: dip->un.e.member[0].ord = CMPCI_SPDIF_OUT_PLAYBACK_WAVE;
! 1040: strlcpy(dip->un.e.member[1].label.name, CmpciNlegacy,
! 1041: sizeof dip->un.e.member[1].label.name);
! 1042: dip->un.e.member[1].ord = CMPCI_SPDIF_OUT_PLAYBACK_LEGACY;
! 1043: return 0;
! 1044: case CMPCI_SPDIF_OUT_VOLTAGE:
! 1045: dip->mixer_class = CMPCI_SPDIF_CLASS;
! 1046: dip->prev = CMPCI_SPDIF_OUT_PLAYBACK;
! 1047: strlcpy(dip->label.name, CmpciNvoltage, sizeof dip->label.name);
! 1048: dip->type = AUDIO_MIXER_ENUM;
! 1049: dip->un.e.num_mem = 2;
! 1050: strlcpy(dip->un.e.member[0].label.name, CmpciNhigh_v,
! 1051: sizeof dip->un.e.member[0].label.name);
! 1052: dip->un.e.member[0].ord = CMPCI_SPDIF_OUT_VOLTAGE_HIGH;
! 1053: strlcpy(dip->un.e.member[1].label.name, CmpciNlow_v,
! 1054: sizeof dip->un.e.member[1].label.name);
! 1055: dip->un.e.member[1].ord = CMPCI_SPDIF_OUT_VOLTAGE_LOW;
! 1056: return 0;
! 1057: case CMPCI_MONITOR_DAC:
! 1058: dip->mixer_class = CMPCI_SPDIF_CLASS;
! 1059: strlcpy(dip->label.name, AudioNmonitor, sizeof dip->label.name);
! 1060: dip->type = AUDIO_MIXER_ENUM;
! 1061: dip->un.e.num_mem = 3;
! 1062: strlcpy(dip->un.e.member[0].label.name, AudioNoff,
! 1063: sizeof dip->un.e.member[0].label.name);
! 1064: dip->un.e.member[0].ord = CMPCI_MONITOR_DAC_OFF;
! 1065: strlcpy(dip->un.e.member[1].label.name, CmpciNspdin,
! 1066: sizeof dip->un.e.member[1].label.name);
! 1067: dip->un.e.member[1].ord = CMPCI_MONITOR_DAC_SPDIN;
! 1068: strlcpy(dip->un.e.member[2].label.name, CmpciNspdout,
! 1069: sizeof dip->un.e.member[2].label.name);
! 1070: dip->un.e.member[2].ord = CMPCI_MONITOR_DAC_SPDOUT;
! 1071: return 0;
! 1072:
! 1073: case CMPCI_MASTER_VOL:
! 1074: dip->mixer_class = CMPCI_OUTPUT_CLASS;
! 1075: strlcpy(dip->label.name, AudioNmaster, sizeof dip->label.name);
! 1076: dip->un.v.num_channels = 2;
! 1077: dip->un.v.delta = 1 << (8 - CMPCI_SB16_MIXER_VALBITS);
! 1078: goto vol;
! 1079: case CMPCI_REAR:
! 1080: dip->mixer_class = CMPCI_OUTPUT_CLASS;
! 1081: dip->next = CMPCI_INDIVIDUAL;
! 1082: strlcpy(dip->label.name, CmpciNrear, sizeof dip->label.name);
! 1083: goto on_off;
! 1084: case CMPCI_INDIVIDUAL:
! 1085: dip->mixer_class = CMPCI_OUTPUT_CLASS;
! 1086: dip->prev = CMPCI_REAR;
! 1087: dip->next = CMPCI_REVERSE;
! 1088: strlcpy(dip->label.name, CmpciNindividual, sizeof dip->label.name);
! 1089: goto on_off;
! 1090: case CMPCI_REVERSE:
! 1091: dip->mixer_class = CMPCI_OUTPUT_CLASS;
! 1092: dip->prev = CMPCI_INDIVIDUAL;
! 1093: strlcpy(dip->label.name, CmpciNreverse, sizeof dip->label.name);
! 1094: goto on_off;
! 1095: case CMPCI_SURROUND:
! 1096: dip->mixer_class = CMPCI_OUTPUT_CLASS;
! 1097: strlcpy(dip->label.name, CmpciNsurround, sizeof dip->label.name);
! 1098: goto on_off;
! 1099: }
! 1100:
! 1101: return ENXIO;
! 1102: }
! 1103:
! 1104: int
! 1105: cmpci_alloc_dmamem(struct cmpci_softc *sc, size_t size, int type, int flags,
! 1106: caddr_t *r_addr)
! 1107: {
! 1108: int error = 0;
! 1109: struct cmpci_dmanode *n;
! 1110: int w;
! 1111:
! 1112: n = malloc(sizeof(struct cmpci_dmanode), type, flags);
! 1113: if (n == NULL) {
! 1114: error = ENOMEM;
! 1115: goto quit;
! 1116: }
! 1117:
! 1118: w = (flags & M_NOWAIT) ? BUS_DMA_NOWAIT : BUS_DMA_WAITOK;
! 1119: #define CMPCI_DMABUF_ALIGN 0x4
! 1120: #define CMPCI_DMABUF_BOUNDARY 0x0
! 1121: n->cd_tag = sc->sc_dmat;
! 1122: n->cd_size = size;
! 1123: error = bus_dmamem_alloc(n->cd_tag, n->cd_size,
! 1124: CMPCI_DMABUF_ALIGN, CMPCI_DMABUF_BOUNDARY, n->cd_segs,
! 1125: sizeof(n->cd_segs)/sizeof(n->cd_segs[0]), &n->cd_nsegs, w);
! 1126: if (error)
! 1127: goto mfree;
! 1128: error = bus_dmamem_map(n->cd_tag, n->cd_segs, n->cd_nsegs, n->cd_size,
! 1129: &n->cd_addr, w | BUS_DMA_COHERENT);
! 1130: if (error)
! 1131: goto dmafree;
! 1132: error = bus_dmamap_create(n->cd_tag, n->cd_size, 1, n->cd_size, 0,
! 1133: w, &n->cd_map);
! 1134: if (error)
! 1135: goto unmap;
! 1136: error = bus_dmamap_load(n->cd_tag, n->cd_map, n->cd_addr, n->cd_size,
! 1137: NULL, w);
! 1138: if (error)
! 1139: goto destroy;
! 1140:
! 1141: n->cd_next = sc->sc_dmap;
! 1142: sc->sc_dmap = n;
! 1143: *r_addr = KVADDR(n);
! 1144: return 0;
! 1145:
! 1146: destroy:
! 1147: bus_dmamap_destroy(n->cd_tag, n->cd_map);
! 1148: unmap:
! 1149: bus_dmamem_unmap(n->cd_tag, n->cd_addr, n->cd_size);
! 1150: dmafree:
! 1151: bus_dmamem_free(n->cd_tag,
! 1152: n->cd_segs, sizeof(n->cd_segs)/sizeof(n->cd_segs[0]));
! 1153: mfree:
! 1154: free(n, type);
! 1155: quit:
! 1156: return error;
! 1157: }
! 1158:
! 1159: int
! 1160: cmpci_free_dmamem(struct cmpci_softc *sc, caddr_t addr, int type)
! 1161: {
! 1162: struct cmpci_dmanode **nnp;
! 1163:
! 1164: for (nnp = &sc->sc_dmap; *nnp; nnp = &(*nnp)->cd_next) {
! 1165: if ((*nnp)->cd_addr == addr) {
! 1166: struct cmpci_dmanode *n = *nnp;
! 1167: bus_dmamap_unload(n->cd_tag, n->cd_map);
! 1168: bus_dmamap_destroy(n->cd_tag, n->cd_map);
! 1169: bus_dmamem_unmap(n->cd_tag, n->cd_addr, n->cd_size);
! 1170: bus_dmamem_free(n->cd_tag, n->cd_segs,
! 1171: sizeof(n->cd_segs)/sizeof(n->cd_segs[0]));
! 1172: free(n, type);
! 1173: return 0;
! 1174: }
! 1175: }
! 1176: return -1;
! 1177: }
! 1178:
! 1179: struct cmpci_dmanode *
! 1180: cmpci_find_dmamem(struct cmpci_softc *sc, caddr_t addr)
! 1181: {
! 1182: struct cmpci_dmanode *p;
! 1183:
! 1184: for (p = sc->sc_dmap; p; p = p->cd_next) {
! 1185: if (KVADDR(p) == (void *)addr)
! 1186: break;
! 1187: }
! 1188: return p;
! 1189: }
! 1190:
! 1191: #if 0
! 1192: void cmpci_print_dmamem(struct cmpci_dmanode *p);
! 1193:
! 1194: void
! 1195: cmpci_print_dmamem(struct cmpci_dmanode *p)
! 1196: {
! 1197: DPRINTF(("DMA at virt:%p, dmaseg:%p, mapseg:%p, size:%p\n",
! 1198: (void *)p->cd_addr, (void *)p->cd_segs[0].ds_addr,
! 1199: (void *)DMAADDR(p), (void *)p->cd_size));
! 1200: }
! 1201: #endif /* DEBUG */
! 1202:
! 1203: void *
! 1204: cmpci_malloc(void *handle, int direction, size_t size, int type,
! 1205: int flags)
! 1206: {
! 1207: caddr_t addr;
! 1208:
! 1209: if (cmpci_alloc_dmamem(handle, size, type, flags, &addr))
! 1210: return NULL;
! 1211: return addr;
! 1212: }
! 1213:
! 1214: void
! 1215: cmpci_free(void *handle, void *addr, int type)
! 1216: {
! 1217: cmpci_free_dmamem(handle, addr, type);
! 1218: }
! 1219:
! 1220: #define MAXVAL 256
! 1221: int
! 1222: cmpci_adjust(int val, int mask)
! 1223: {
! 1224: val += (MAXVAL - mask) >> 1;
! 1225: if (val >= MAXVAL)
! 1226: val = MAXVAL-1;
! 1227: return val & mask;
! 1228: }
! 1229:
! 1230: void
! 1231: cmpci_set_mixer_gain(struct cmpci_softc *sc, int port)
! 1232: {
! 1233: int src;
! 1234: int bits, mask;
! 1235:
! 1236: switch (port) {
! 1237: case CMPCI_MIC_VOL:
! 1238: cmpci_mixerreg_write(sc, CMPCI_SB16_MIXER_MIC,
! 1239: CMPCI_ADJUST_MIC_GAIN(sc, sc->sc_gain[port][CMPCI_LR]));
! 1240: return;
! 1241: case CMPCI_MASTER_VOL:
! 1242: src = CMPCI_SB16_MIXER_MASTER_L;
! 1243: break;
! 1244: case CMPCI_LINE_IN_VOL:
! 1245: src = CMPCI_SB16_MIXER_LINE_L;
! 1246: break;
! 1247: case CMPCI_AUX_IN_VOL:
! 1248: bus_space_write_1(sc->sc_iot, sc->sc_ioh, CMPCI_REG_MIXER_AUX,
! 1249: CMPCI_ADJUST_AUX_GAIN(sc, sc->sc_gain[port][CMPCI_LEFT],
! 1250: sc->sc_gain[port][CMPCI_RIGHT]));
! 1251: return;
! 1252: case CMPCI_MIC_RECVOL:
! 1253: cmpci_reg_partial_write_1(sc, CMPCI_REG_MIXER25,
! 1254: CMPCI_REG_ADMIC_SHIFT, CMPCI_REG_ADMIC_MASK,
! 1255: CMPCI_ADJUST_ADMIC_GAIN(sc, sc->sc_gain[port][CMPCI_LR]));
! 1256: return;
! 1257: case CMPCI_DAC_VOL:
! 1258: src = CMPCI_SB16_MIXER_VOICE_L;
! 1259: break;
! 1260: case CMPCI_FM_VOL:
! 1261: src = CMPCI_SB16_MIXER_FM_L;
! 1262: break;
! 1263: case CMPCI_CD_VOL:
! 1264: src = CMPCI_SB16_MIXER_CDDA_L;
! 1265: break;
! 1266: case CMPCI_PCSPEAKER:
! 1267: cmpci_mixerreg_write(sc, CMPCI_SB16_MIXER_SPEAKER,
! 1268: CMPCI_ADJUST_2_GAIN(sc, sc->sc_gain[port][CMPCI_LR]));
! 1269: return;
! 1270: case CMPCI_MIC_PREAMP:
! 1271: if (sc->sc_gain[port][CMPCI_LR])
! 1272: cmpci_reg_clear_1(sc, CMPCI_REG_MIXER25,
! 1273: CMPCI_REG_MICGAINZ);
! 1274: else
! 1275: cmpci_reg_set_1(sc, CMPCI_REG_MIXER25,
! 1276: CMPCI_REG_MICGAINZ);
! 1277: return;
! 1278:
! 1279: case CMPCI_DAC_MUTE:
! 1280: if (sc->sc_gain[port][CMPCI_LR])
! 1281: cmpci_reg_set_1(sc, CMPCI_REG_MIXER24,
! 1282: CMPCI_REG_WSMUTE);
! 1283: else
! 1284: cmpci_reg_clear_1(sc, CMPCI_REG_MIXER24,
! 1285: CMPCI_REG_WSMUTE);
! 1286: return;
! 1287: case CMPCI_FM_MUTE:
! 1288: if (sc->sc_gain[port][CMPCI_LR])
! 1289: cmpci_reg_set_1(sc, CMPCI_REG_MIXER24,
! 1290: CMPCI_REG_FMMUTE);
! 1291: else
! 1292: cmpci_reg_clear_1(sc, CMPCI_REG_MIXER24,
! 1293: CMPCI_REG_FMMUTE);
! 1294: return;
! 1295: case CMPCI_AUX_IN_MUTE:
! 1296: if (sc->sc_gain[port][CMPCI_LR])
! 1297: cmpci_reg_clear_1(sc, CMPCI_REG_MIXER25,
! 1298: CMPCI_REG_VAUXRM|CMPCI_REG_VAUXLM);
! 1299: else
! 1300: cmpci_reg_set_1(sc, CMPCI_REG_MIXER25,
! 1301: CMPCI_REG_VAUXRM|CMPCI_REG_VAUXLM);
! 1302: return;
! 1303: case CMPCI_CD_MUTE:
! 1304: mask = CMPCI_SB16_SW_CD;
! 1305: goto sbmute;
! 1306: case CMPCI_MIC_MUTE:
! 1307: mask = CMPCI_SB16_SW_MIC;
! 1308: goto sbmute;
! 1309: case CMPCI_LINE_IN_MUTE:
! 1310: mask = CMPCI_SB16_SW_LINE;
! 1311: sbmute:
! 1312: bits = cmpci_mixerreg_read(sc, CMPCI_SB16_MIXER_OUTMIX);
! 1313: if (sc->sc_gain[port][CMPCI_LR])
! 1314: bits = bits & ~mask;
! 1315: else
! 1316: bits = bits | mask;
! 1317: cmpci_mixerreg_write(sc, CMPCI_SB16_MIXER_OUTMIX, bits);
! 1318: return;
! 1319:
! 1320: case CMPCI_SPDIF_IN_SELECT:
! 1321: case CMPCI_MONITOR_DAC:
! 1322: case CMPCI_PLAYBACK_MODE:
! 1323: case CMPCI_SPDIF_LOOP:
! 1324: case CMPCI_SPDIF_OUT_PLAYBACK:
! 1325: cmpci_set_out_ports(sc);
! 1326: return;
! 1327: case CMPCI_SPDIF_OUT_VOLTAGE:
! 1328: if (CMPCI_ISCAP(sc, SPDOUT_VOLTAGE)) {
! 1329: if (sc->sc_gain[CMPCI_SPDIF_OUT_VOLTAGE][CMPCI_LR]
! 1330: == CMPCI_SPDIF_OUT_VOLTAGE_HIGH)
! 1331: cmpci_reg_clear_reg_misc(sc, CMPCI_REG_5V);
! 1332: else
! 1333: cmpci_reg_set_reg_misc(sc, CMPCI_REG_5V);
! 1334: }
! 1335: return;
! 1336: case CMPCI_SURROUND:
! 1337: if (CMPCI_ISCAP(sc, SURROUND)) {
! 1338: if (sc->sc_gain[CMPCI_SURROUND][CMPCI_LR])
! 1339: cmpci_reg_set_1(sc, CMPCI_REG_MIXER24,
! 1340: CMPCI_REG_SURROUND);
! 1341: else
! 1342: cmpci_reg_clear_1(sc, CMPCI_REG_MIXER24,
! 1343: CMPCI_REG_SURROUND);
! 1344: }
! 1345: return;
! 1346: case CMPCI_REAR:
! 1347: if (CMPCI_ISCAP(sc, REAR)) {
! 1348: if (sc->sc_gain[CMPCI_REAR][CMPCI_LR])
! 1349: cmpci_reg_set_reg_misc(sc, CMPCI_REG_N4SPK3D);
! 1350: else
! 1351: cmpci_reg_clear_reg_misc(sc, CMPCI_REG_N4SPK3D);
! 1352: }
! 1353: return;
! 1354: case CMPCI_INDIVIDUAL:
! 1355: if (CMPCI_ISCAP(sc, INDIVIDUAL_REAR)) {
! 1356: if (sc->sc_gain[CMPCI_REAR][CMPCI_LR])
! 1357: cmpci_reg_set_1(sc, CMPCI_REG_MIXER24,
! 1358: CMPCI_REG_INDIVIDUAL);
! 1359: else
! 1360: cmpci_reg_clear_1(sc, CMPCI_REG_MIXER24,
! 1361: CMPCI_REG_INDIVIDUAL);
! 1362: }
! 1363: return;
! 1364: case CMPCI_REVERSE:
! 1365: if (CMPCI_ISCAP(sc, REVERSE_FR)) {
! 1366: if (sc->sc_gain[CMPCI_REVERSE][CMPCI_LR])
! 1367: cmpci_reg_set_1(sc, CMPCI_REG_MIXER24,
! 1368: CMPCI_REG_REVERSE_FR);
! 1369: else
! 1370: cmpci_reg_clear_1(sc, CMPCI_REG_MIXER24,
! 1371: CMPCI_REG_REVERSE_FR);
! 1372: }
! 1373: return;
! 1374: case CMPCI_SPDIF_IN_PHASE:
! 1375: if (CMPCI_ISCAP(sc, SPDIN_PHASE)) {
! 1376: if (sc->sc_gain[CMPCI_SPDIF_IN_PHASE][CMPCI_LR]
! 1377: == CMPCI_SPDIF_IN_PHASE_POSITIVE)
! 1378: cmpci_reg_clear_1(sc, CMPCI_REG_CHANNEL_FORMAT,
! 1379: CMPCI_REG_SPDIN_PHASE);
! 1380: else
! 1381: cmpci_reg_set_1(sc, CMPCI_REG_CHANNEL_FORMAT,
! 1382: CMPCI_REG_SPDIN_PHASE);
! 1383: }
! 1384: return;
! 1385: default:
! 1386: return;
! 1387: }
! 1388:
! 1389: cmpci_mixerreg_write(sc, src,
! 1390: CMPCI_ADJUST_GAIN(sc, sc->sc_gain[port][CMPCI_LEFT]));
! 1391: cmpci_mixerreg_write(sc, CMPCI_SB16_MIXER_L_TO_R(src),
! 1392: CMPCI_ADJUST_GAIN(sc, sc->sc_gain[port][CMPCI_RIGHT]));
! 1393: }
! 1394:
! 1395: void
! 1396: cmpci_set_out_ports(struct cmpci_softc *sc)
! 1397: {
! 1398: u_int8_t v;
! 1399: int enspdout = 0;
! 1400:
! 1401: if (!CMPCI_ISCAP(sc, SPDLOOP))
! 1402: return;
! 1403:
! 1404: /* SPDIF/out select */
! 1405: if (sc->sc_gain[CMPCI_SPDIF_LOOP][CMPCI_LR] == CMPCI_SPDIF_LOOP_OFF) {
! 1406: /* playback */
! 1407: cmpci_reg_clear_4(sc, CMPCI_REG_FUNC_1, CMPCI_REG_SPDIF_LOOP);
! 1408: } else {
! 1409: /* monitor SPDIF/in */
! 1410: cmpci_reg_set_4(sc, CMPCI_REG_FUNC_1, CMPCI_REG_SPDIF_LOOP);
! 1411: }
! 1412:
! 1413: /* SPDIF in select */
! 1414: v = sc->sc_gain[CMPCI_SPDIF_IN_SELECT][CMPCI_LR];
! 1415: if (v & CMPCI_SPDIFIN_SPDIFIN2)
! 1416: cmpci_reg_set_reg_misc(sc, CMPCI_REG_2ND_SPDIFIN);
! 1417: else
! 1418: cmpci_reg_clear_reg_misc(sc, CMPCI_REG_2ND_SPDIFIN);
! 1419: if (v & CMPCI_SPDIFIN_SPDIFOUT)
! 1420: cmpci_reg_set_reg_misc(sc, CMPCI_REG_SPDFLOOPI);
! 1421: else
! 1422: cmpci_reg_clear_reg_misc(sc, CMPCI_REG_SPDFLOOPI);
! 1423:
! 1424: /* playback to ... */
! 1425: if (CMPCI_ISCAP(sc, SPDOUT) &&
! 1426: sc->sc_gain[CMPCI_PLAYBACK_MODE][CMPCI_LR]
! 1427: == CMPCI_PLAYBACK_MODE_SPDIF &&
! 1428: (sc->sc_play.md_divide == CMPCI_REG_RATE_44100 ||
! 1429: (CMPCI_ISCAP(sc, SPDOUT_48K) &&
! 1430: sc->sc_play.md_divide==CMPCI_REG_RATE_48000))) {
! 1431: /* playback to SPDIF */
! 1432: cmpci_reg_set_4(sc, CMPCI_REG_FUNC_1, CMPCI_REG_SPDIF0_ENABLE);
! 1433: enspdout = 1;
! 1434: if (sc->sc_play.md_divide==CMPCI_REG_RATE_48000)
! 1435: cmpci_reg_set_reg_misc(sc,
! 1436: CMPCI_REG_SPDIFOUT_48K | CMPCI_REG_SPDIF48K);
! 1437: else
! 1438: cmpci_reg_clear_reg_misc(sc,
! 1439: CMPCI_REG_SPDIFOUT_48K | CMPCI_REG_SPDIF48K);
! 1440: } else {
! 1441: /* playback to DAC */
! 1442: cmpci_reg_clear_4(sc, CMPCI_REG_FUNC_1,
! 1443: CMPCI_REG_SPDIF0_ENABLE);
! 1444: if (CMPCI_ISCAP(sc, SPDOUT_48K))
! 1445: cmpci_reg_clear_reg_misc(sc,
! 1446: CMPCI_REG_SPDIFOUT_48K | CMPCI_REG_SPDIF48K);
! 1447: }
! 1448:
! 1449: /* legacy to SPDIF/out or not */
! 1450: if (CMPCI_ISCAP(sc, SPDLEGACY)) {
! 1451: if (sc->sc_gain[CMPCI_SPDIF_OUT_PLAYBACK][CMPCI_LR]
! 1452: == CMPCI_SPDIF_OUT_PLAYBACK_WAVE)
! 1453: cmpci_reg_clear_4(sc, CMPCI_REG_LEGACY_CTRL,
! 1454: CMPCI_REG_LEGACY_SPDIF_ENABLE);
! 1455: else {
! 1456: cmpci_reg_set_4(sc, CMPCI_REG_LEGACY_CTRL,
! 1457: CMPCI_REG_LEGACY_SPDIF_ENABLE);
! 1458: enspdout = 1;
! 1459: }
! 1460: }
! 1461:
! 1462: /* enable/disable SPDIF/out */
! 1463: if (CMPCI_ISCAP(sc, XSPDOUT) && enspdout)
! 1464: cmpci_reg_set_4(sc, CMPCI_REG_LEGACY_CTRL,
! 1465: CMPCI_REG_XSPDIF_ENABLE);
! 1466: else
! 1467: cmpci_reg_clear_4(sc, CMPCI_REG_LEGACY_CTRL,
! 1468: CMPCI_REG_XSPDIF_ENABLE);
! 1469:
! 1470: /* SPDIF monitor (digital to analog output) */
! 1471: if (CMPCI_ISCAP(sc, SPDIN_MONITOR)) {
! 1472: v = sc->sc_gain[CMPCI_MONITOR_DAC][CMPCI_LR];
! 1473: if (!(v & CMPCI_MONDAC_ENABLE))
! 1474: cmpci_reg_clear_1(sc, CMPCI_REG_MIXER24,
! 1475: CMPCI_REG_SPDIN_MONITOR);
! 1476: if (v & CMPCI_MONDAC_SPDOUT)
! 1477: cmpci_reg_set_4(sc, CMPCI_REG_FUNC_1,
! 1478: CMPCI_REG_SPDIFOUT_DAC);
! 1479: else
! 1480: cmpci_reg_clear_4(sc, CMPCI_REG_FUNC_1,
! 1481: CMPCI_REG_SPDIFOUT_DAC);
! 1482: if (v & CMPCI_MONDAC_ENABLE)
! 1483: cmpci_reg_set_1(sc, CMPCI_REG_MIXER24,
! 1484: CMPCI_REG_SPDIN_MONITOR);
! 1485: }
! 1486: }
! 1487:
! 1488: int
! 1489: cmpci_set_in_ports(struct cmpci_softc *sc)
! 1490: {
! 1491: int mask;
! 1492: int bitsl, bitsr;
! 1493:
! 1494: mask = sc->sc_in_mask;
! 1495:
! 1496: /*
! 1497: * Note CMPCI_RECORD_SOURCE_CD, CMPCI_RECORD_SOURCE_LINE_IN and
! 1498: * CMPCI_RECORD_SOURCE_FM are defined to the corresponding bit
! 1499: * of the mixer register.
! 1500: */
! 1501: bitsr = mask & (CMPCI_RECORD_SOURCE_CD | CMPCI_RECORD_SOURCE_LINE_IN |
! 1502: CMPCI_RECORD_SOURCE_FM);
! 1503:
! 1504: bitsl = CMPCI_SB16_MIXER_SRC_R_TO_L(bitsr);
! 1505: if (mask & CMPCI_RECORD_SOURCE_MIC) {
! 1506: bitsl |= CMPCI_SB16_MIXER_MIC_SRC;
! 1507: bitsr |= CMPCI_SB16_MIXER_MIC_SRC;
! 1508: }
! 1509: cmpci_mixerreg_write(sc, CMPCI_SB16_MIXER_ADCMIX_L, bitsl);
! 1510: cmpci_mixerreg_write(sc, CMPCI_SB16_MIXER_ADCMIX_R, bitsr);
! 1511:
! 1512: if (mask & CMPCI_RECORD_SOURCE_AUX_IN)
! 1513: cmpci_reg_set_1(sc, CMPCI_REG_MIXER25,
! 1514: CMPCI_REG_RAUXREN | CMPCI_REG_RAUXLEN);
! 1515: else
! 1516: cmpci_reg_clear_1(sc, CMPCI_REG_MIXER25,
! 1517: CMPCI_REG_RAUXREN | CMPCI_REG_RAUXLEN);
! 1518:
! 1519: if (mask & CMPCI_RECORD_SOURCE_WAVE)
! 1520: cmpci_reg_set_1(sc, CMPCI_REG_MIXER24,
! 1521: CMPCI_REG_WAVEINL | CMPCI_REG_WAVEINR);
! 1522: else
! 1523: cmpci_reg_clear_1(sc, CMPCI_REG_MIXER24,
! 1524: CMPCI_REG_WAVEINL | CMPCI_REG_WAVEINR);
! 1525:
! 1526: if (CMPCI_ISCAP(sc, SPDIN) &&
! 1527: (sc->sc_rec.md_divide == CMPCI_REG_RATE_44100 ||
! 1528: (CMPCI_ISCAP(sc, SPDOUT_48K) &&
! 1529: sc->sc_rec.md_divide == CMPCI_REG_RATE_48000/* XXX? */))) {
! 1530: if (mask & CMPCI_RECORD_SOURCE_SPDIF) {
! 1531: /* enable SPDIF/in */
! 1532: cmpci_reg_set_4(sc,
! 1533: CMPCI_REG_FUNC_1,
! 1534: CMPCI_REG_SPDIF1_ENABLE);
! 1535: } else {
! 1536: cmpci_reg_clear_4(sc,
! 1537: CMPCI_REG_FUNC_1,
! 1538: CMPCI_REG_SPDIF1_ENABLE);
! 1539: }
! 1540: }
! 1541:
! 1542: return 0;
! 1543: }
! 1544:
! 1545: int
! 1546: cmpci_set_port(void *handle, mixer_ctrl_t *cp)
! 1547: {
! 1548: struct cmpci_softc *sc = handle;
! 1549: int lgain, rgain;
! 1550:
! 1551: switch (cp->dev) {
! 1552: case CMPCI_MIC_VOL:
! 1553: case CMPCI_PCSPEAKER:
! 1554: case CMPCI_MIC_RECVOL:
! 1555: if (cp->un.value.num_channels != 1)
! 1556: return EINVAL;
! 1557: /* FALLTHROUGH */
! 1558: case CMPCI_DAC_VOL:
! 1559: case CMPCI_FM_VOL:
! 1560: case CMPCI_CD_VOL:
! 1561: case CMPCI_LINE_IN_VOL:
! 1562: case CMPCI_AUX_IN_VOL:
! 1563: case CMPCI_MASTER_VOL:
! 1564: if (cp->type != AUDIO_MIXER_VALUE)
! 1565: return EINVAL;
! 1566: switch (cp->un.value.num_channels) {
! 1567: case 1:
! 1568: lgain = rgain =
! 1569: cp->un.value.level[AUDIO_MIXER_LEVEL_MONO];
! 1570: break;
! 1571: case 2:
! 1572: lgain = cp->un.value.level[AUDIO_MIXER_LEVEL_LEFT];
! 1573: rgain = cp->un.value.level[AUDIO_MIXER_LEVEL_RIGHT];
! 1574: break;
! 1575: default:
! 1576: return EINVAL;
! 1577: }
! 1578: sc->sc_gain[cp->dev][CMPCI_LEFT] = lgain;
! 1579: sc->sc_gain[cp->dev][CMPCI_RIGHT] = rgain;
! 1580:
! 1581: cmpci_set_mixer_gain(sc, cp->dev);
! 1582: break;
! 1583:
! 1584: case CMPCI_RECORD_SOURCE:
! 1585: if (cp->type != AUDIO_MIXER_SET)
! 1586: return EINVAL;
! 1587:
! 1588: if (cp->un.mask & ~(CMPCI_RECORD_SOURCE_MIC |
! 1589: CMPCI_RECORD_SOURCE_CD | CMPCI_RECORD_SOURCE_LINE_IN |
! 1590: CMPCI_RECORD_SOURCE_AUX_IN | CMPCI_RECORD_SOURCE_WAVE |
! 1591: CMPCI_RECORD_SOURCE_FM | CMPCI_RECORD_SOURCE_SPDIF))
! 1592: return EINVAL;
! 1593:
! 1594: if (cp->un.mask & CMPCI_RECORD_SOURCE_SPDIF)
! 1595: cp->un.mask = CMPCI_RECORD_SOURCE_SPDIF;
! 1596:
! 1597: sc->sc_in_mask = cp->un.mask;
! 1598: return cmpci_set_in_ports(sc);
! 1599:
! 1600: /* boolean */
! 1601: case CMPCI_DAC_MUTE:
! 1602: case CMPCI_FM_MUTE:
! 1603: case CMPCI_CD_MUTE:
! 1604: case CMPCI_LINE_IN_MUTE:
! 1605: case CMPCI_AUX_IN_MUTE:
! 1606: case CMPCI_MIC_MUTE:
! 1607: case CMPCI_MIC_PREAMP:
! 1608: case CMPCI_PLAYBACK_MODE:
! 1609: case CMPCI_SPDIF_IN_PHASE:
! 1610: case CMPCI_SPDIF_LOOP:
! 1611: case CMPCI_SPDIF_OUT_PLAYBACK:
! 1612: case CMPCI_SPDIF_OUT_VOLTAGE:
! 1613: case CMPCI_REAR:
! 1614: case CMPCI_INDIVIDUAL:
! 1615: case CMPCI_REVERSE:
! 1616: case CMPCI_SURROUND:
! 1617: if (cp->type != AUDIO_MIXER_ENUM)
! 1618: return EINVAL;
! 1619: sc->sc_gain[cp->dev][CMPCI_LR] = cp->un.ord != 0;
! 1620: cmpci_set_mixer_gain(sc, cp->dev);
! 1621: break;
! 1622:
! 1623: case CMPCI_SPDIF_IN_SELECT:
! 1624: switch (cp->un.ord) {
! 1625: case CMPCI_SPDIF_IN_SPDIN1:
! 1626: case CMPCI_SPDIF_IN_SPDIN2:
! 1627: case CMPCI_SPDIF_IN_SPDOUT:
! 1628: break;
! 1629: default:
! 1630: return EINVAL;
! 1631: }
! 1632: goto xenum;
! 1633: case CMPCI_MONITOR_DAC:
! 1634: switch (cp->un.ord) {
! 1635: case CMPCI_MONITOR_DAC_OFF:
! 1636: case CMPCI_MONITOR_DAC_SPDIN:
! 1637: case CMPCI_MONITOR_DAC_SPDOUT:
! 1638: break;
! 1639: default:
! 1640: return EINVAL;
! 1641: }
! 1642: xenum:
! 1643: if (cp->type != AUDIO_MIXER_ENUM)
! 1644: return EINVAL;
! 1645: sc->sc_gain[cp->dev][CMPCI_LR] = cp->un.ord;
! 1646: cmpci_set_mixer_gain(sc, cp->dev);
! 1647: break;
! 1648:
! 1649: default:
! 1650: return EINVAL;
! 1651: }
! 1652:
! 1653: return 0;
! 1654: }
! 1655:
! 1656: int
! 1657: cmpci_get_port(void *handle, mixer_ctrl_t *cp)
! 1658: {
! 1659: struct cmpci_softc *sc = handle;
! 1660:
! 1661: switch (cp->dev) {
! 1662: case CMPCI_MIC_VOL:
! 1663: case CMPCI_PCSPEAKER:
! 1664: case CMPCI_MIC_RECVOL:
! 1665: if (cp->un.value.num_channels != 1)
! 1666: return EINVAL;
! 1667: /*FALLTHROUGH*/
! 1668: case CMPCI_DAC_VOL:
! 1669: case CMPCI_FM_VOL:
! 1670: case CMPCI_CD_VOL:
! 1671: case CMPCI_LINE_IN_VOL:
! 1672: case CMPCI_AUX_IN_VOL:
! 1673: case CMPCI_MASTER_VOL:
! 1674: switch (cp->un.value.num_channels) {
! 1675: case 1:
! 1676: cp->un.value.level[AUDIO_MIXER_LEVEL_MONO] =
! 1677: sc->sc_gain[cp->dev][CMPCI_LEFT];
! 1678: break;
! 1679: case 2:
! 1680: cp->un.value.level[AUDIO_MIXER_LEVEL_LEFT] =
! 1681: sc->sc_gain[cp->dev][CMPCI_LEFT];
! 1682: cp->un.value.level[AUDIO_MIXER_LEVEL_RIGHT] =
! 1683: sc->sc_gain[cp->dev][CMPCI_RIGHT];
! 1684: break;
! 1685: default:
! 1686: return EINVAL;
! 1687: }
! 1688: break;
! 1689:
! 1690: case CMPCI_RECORD_SOURCE:
! 1691: cp->un.mask = sc->sc_in_mask;
! 1692: break;
! 1693:
! 1694: case CMPCI_DAC_MUTE:
! 1695: case CMPCI_FM_MUTE:
! 1696: case CMPCI_CD_MUTE:
! 1697: case CMPCI_LINE_IN_MUTE:
! 1698: case CMPCI_AUX_IN_MUTE:
! 1699: case CMPCI_MIC_MUTE:
! 1700: case CMPCI_MIC_PREAMP:
! 1701: case CMPCI_PLAYBACK_MODE:
! 1702: case CMPCI_SPDIF_IN_SELECT:
! 1703: case CMPCI_SPDIF_IN_PHASE:
! 1704: case CMPCI_SPDIF_LOOP:
! 1705: case CMPCI_SPDIF_OUT_PLAYBACK:
! 1706: case CMPCI_SPDIF_OUT_VOLTAGE:
! 1707: case CMPCI_MONITOR_DAC:
! 1708: case CMPCI_REAR:
! 1709: case CMPCI_INDIVIDUAL:
! 1710: case CMPCI_REVERSE:
! 1711: case CMPCI_SURROUND:
! 1712: cp->un.ord = sc->sc_gain[cp->dev][CMPCI_LR];
! 1713: break;
! 1714:
! 1715: default:
! 1716: return EINVAL;
! 1717: }
! 1718:
! 1719: return 0;
! 1720: }
! 1721:
! 1722: /* ARGSUSED */
! 1723: size_t
! 1724: cmpci_round_buffersize(void *handle, int direction, size_t bufsize)
! 1725: {
! 1726: if (bufsize > 0x10000)
! 1727: bufsize = 0x10000;
! 1728:
! 1729: return bufsize;
! 1730: }
! 1731:
! 1732: paddr_t
! 1733: cmpci_mappage(void *handle, void *addr, off_t offset, int prot)
! 1734: {
! 1735: struct cmpci_softc *sc = handle;
! 1736: struct cmpci_dmanode *p;
! 1737:
! 1738: if (offset < 0 || NULL == (p = cmpci_find_dmamem(sc, addr)))
! 1739: return -1;
! 1740:
! 1741: return bus_dmamem_mmap(p->cd_tag, p->cd_segs,
! 1742: sizeof(p->cd_segs)/sizeof(p->cd_segs[0]),
! 1743: offset, prot, BUS_DMA_WAITOK);
! 1744: }
! 1745:
! 1746: /* ARGSUSED */
! 1747: int
! 1748: cmpci_get_props(void *handle)
! 1749: {
! 1750: return AUDIO_PROP_MMAP | AUDIO_PROP_INDEPENDENT | AUDIO_PROP_FULLDUPLEX;
! 1751: }
! 1752:
! 1753: int
! 1754: cmpci_trigger_output(void *handle, void *start, void *end, int blksize,
! 1755: void (*intr)(void *), void *arg, struct audio_params *param)
! 1756: {
! 1757: struct cmpci_softc *sc = handle;
! 1758: struct cmpci_dmanode *p;
! 1759: int bps;
! 1760:
! 1761: sc->sc_play.intr = intr;
! 1762: sc->sc_play.intr_arg = arg;
! 1763: bps = param->channels * param->precision * param->factor / 8;
! 1764: if (!bps)
! 1765: return EINVAL;
! 1766:
! 1767: /* set DMA frame */
! 1768: if (!(p = cmpci_find_dmamem(sc, start)))
! 1769: return EINVAL;
! 1770: bus_space_write_4(sc->sc_iot, sc->sc_ioh, CMPCI_REG_DMA0_BASE,
! 1771: DMAADDR(p));
! 1772: delay(10);
! 1773: bus_space_write_2(sc->sc_iot, sc->sc_ioh, CMPCI_REG_DMA0_BYTES,
! 1774: ((caddr_t)end - (caddr_t)start + 1) / bps - 1);
! 1775: delay(10);
! 1776:
! 1777: /* set interrupt count */
! 1778: bus_space_write_2(sc->sc_iot, sc->sc_ioh, CMPCI_REG_DMA0_SAMPLES,
! 1779: (blksize + bps - 1) / bps - 1);
! 1780: delay(10);
! 1781:
! 1782: /* start DMA */
! 1783: cmpci_reg_clear_4(sc, CMPCI_REG_FUNC_0, CMPCI_REG_CH0_DIR); /* PLAY */
! 1784: cmpci_reg_set_4(sc, CMPCI_REG_INTR_CTRL, CMPCI_REG_CH0_INTR_ENABLE);
! 1785: cmpci_reg_set_4(sc, CMPCI_REG_FUNC_0, CMPCI_REG_CH0_ENABLE);
! 1786:
! 1787: return 0;
! 1788: }
! 1789:
! 1790: int
! 1791: cmpci_trigger_input(void *handle, void *start, void *end, int blksize,
! 1792: void (*intr)(void *), void *arg, struct audio_params *param)
! 1793: {
! 1794: struct cmpci_softc *sc = handle;
! 1795: struct cmpci_dmanode *p;
! 1796: int bps;
! 1797:
! 1798: sc->sc_rec.intr = intr;
! 1799: sc->sc_rec.intr_arg = arg;
! 1800: bps = param->channels*param->precision*param->factor/8;
! 1801: if (!bps)
! 1802: return EINVAL;
! 1803:
! 1804: /* set DMA frame */
! 1805: if (!(p = cmpci_find_dmamem(sc, start)))
! 1806: return EINVAL;
! 1807: bus_space_write_4(sc->sc_iot, sc->sc_ioh, CMPCI_REG_DMA1_BASE,
! 1808: DMAADDR(p));
! 1809: delay(10);
! 1810: bus_space_write_2(sc->sc_iot, sc->sc_ioh, CMPCI_REG_DMA1_BYTES,
! 1811: ((caddr_t)end - (caddr_t)start + 1) / bps - 1);
! 1812: delay(10);
! 1813:
! 1814: /* set interrupt count */
! 1815: bus_space_write_2(sc->sc_iot, sc->sc_ioh, CMPCI_REG_DMA1_SAMPLES,
! 1816: (blksize + bps - 1) / bps - 1);
! 1817: delay(10);
! 1818:
! 1819: /* start DMA */
! 1820: cmpci_reg_set_4(sc, CMPCI_REG_FUNC_0, CMPCI_REG_CH1_DIR); /* REC */
! 1821: cmpci_reg_set_4(sc, CMPCI_REG_INTR_CTRL, CMPCI_REG_CH1_INTR_ENABLE);
! 1822: cmpci_reg_set_4(sc, CMPCI_REG_FUNC_0, CMPCI_REG_CH1_ENABLE);
! 1823:
! 1824: return 0;
! 1825: }
! 1826:
! 1827: /* end of file */
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to cmpci.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / pci