Annotation of sys/dev/isa/pss.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: pss.c,v 1.22 2003/04/27 11:22:53 ho Exp $ */
! 2: /* $NetBSD: pss.c,v 1.38 1998/01/12 09:43:44 thorpej Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 1994 John Brezak
! 6: * Copyright (c) 1991-1993 Regents of the University of California.
! 7: * All rights reserved.
! 8: *
! 9: * Redistribution and use in source and binary forms, with or without
! 10: * modification, are permitted provided that the following conditions
! 11: * are met:
! 12: * 1. Redistributions of source code must retain the above copyright
! 13: * notice, this list of conditions and the following disclaimer.
! 14: * 2. Redistributions in binary form must reproduce the above copyright
! 15: * notice, this list of conditions and the following disclaimer in the
! 16: * documentation and/or other materials provided with the distribution.
! 17: * 3. All advertising materials mentioning features or use of this software
! 18: * must display the following acknowledgement:
! 19: * This product includes software developed by the Computer Systems
! 20: * Engineering Group at Lawrence Berkeley Laboratory.
! 21: * 4. Neither the name of the University nor of the Laboratory may be used
! 22: * to endorse or promote products derived from this software without
! 23: * specific prior written permission.
! 24: *
! 25: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
! 26: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
! 27: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
! 28: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
! 29: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
! 30: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
! 31: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
! 32: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! 33: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
! 34: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
! 35: * SUCH DAMAGE.
! 36: *
! 37: */
! 38:
! 39: /*
! 40: * Copyright (c) 1993 Analog Devices Inc. All rights reserved
! 41: *
! 42: * Portions provided by Marc.Hoffman@analog.com and
! 43: * Greg.Yukna@analog.com .
! 44: *
! 45: */
! 46:
! 47: /*
! 48: * Todo:
! 49: * - Provide PSS driver to access DSP
! 50: * - Provide MIDI driver to access MPU
! 51: * - Finish support for CD drive (Sony and SCSI)
! 52: */
! 53:
! 54: #include <sys/param.h>
! 55: #include <sys/systm.h>
! 56: #include <sys/errno.h>
! 57: #include <sys/ioctl.h>
! 58: #include <sys/syslog.h>
! 59: #include <sys/device.h>
! 60: #include <sys/proc.h>
! 61: #include <sys/buf.h>
! 62:
! 63: #include <machine/cpu.h>
! 64: #include <machine/intr.h>
! 65: #include <machine/bus.h>
! 66:
! 67: #include <sys/audioio.h>
! 68: #include <dev/audio_if.h>
! 69:
! 70: #include <dev/isa/isavar.h>
! 71: #include <dev/isa/isadmavar.h>
! 72:
! 73: #include <dev/isa/ad1848var.h>
! 74: #include <dev/isa/wssreg.h>
! 75: #include <dev/isa/pssreg.h>
! 76:
! 77: /* XXX Default WSS base */
! 78: #define WSS_BASE_ADDRESS 0x0530
! 79:
! 80: /*
! 81: * Mixer devices
! 82: */
! 83: #define PSS_MIC_IN_LVL 0
! 84: #define PSS_LINE_IN_LVL 1
! 85: #define PSS_DAC_LVL 2
! 86: #define PSS_REC_LVL 3
! 87: #define PSS_MON_LVL 4
! 88: #define PSS_MASTER_VOL 5
! 89: #define PSS_MASTER_TREBLE 6
! 90: #define PSS_MASTER_BASS 7
! 91: #define PSS_MIC_IN_MUTE 8
! 92: #define PSS_LINE_IN_MUTE 9
! 93: #define PSS_DAC_MUTE 10
! 94:
! 95: #define PSS_OUTPUT_MODE 11
! 96: #define PSS_SPKR_MONO 0
! 97: #define PSS_SPKR_STEREO 1
! 98: #define PSS_SPKR_PSEUDO 2
! 99: #define PSS_SPKR_SPATIAL 3
! 100:
! 101: #define PSS_RECORD_SOURCE 12
! 102:
! 103: /* Classes */
! 104: #define PSS_INPUT_CLASS 13
! 105: #define PSS_RECORD_CLASS 14
! 106: #define PSS_MONITOR_CLASS 15
! 107: #define PSS_OUTPUT_CLASS 16
! 108:
! 109:
! 110: struct pss_softc {
! 111: struct device sc_dev; /* base device */
! 112: void *sc_ih; /* interrupt vectoring */
! 113:
! 114: int sc_iobase; /* I/O port base address */
! 115: int sc_drq; /* dma channel */
! 116:
! 117: struct ad1848_softc *ad1848_sc;
! 118:
! 119: int out_port;
! 120:
! 121: struct ad1848_volume master_volume;
! 122: int master_mode;
! 123:
! 124: int monitor_treble;
! 125: int monitor_bass;
! 126:
! 127: int mic_mute, cd_mute, dac_mute;
! 128: };
! 129:
! 130: #ifdef notyet
! 131: struct mpu_softc {
! 132: struct device sc_dev; /* base device */
! 133: void *sc_ih; /* interrupt vectoring */
! 134:
! 135: int sc_iobase; /* MIDI I/O port base address */
! 136: int sc_irq; /* MIDI interrupt */
! 137: };
! 138:
! 139: struct pcd_softc {
! 140: struct device sc_dev; /* base device */
! 141: void *sc_ih; /* interrupt vectoring */
! 142:
! 143: int sc_iobase; /* CD I/O port base address */
! 144: int sc_irq; /* CD interrupt */
! 145: };
! 146: #endif
! 147:
! 148: #ifdef AUDIO_DEBUG
! 149: #define DPRINTF(x) if (pssdebug) printf x
! 150: int pssdebug = 0;
! 151: #else
! 152: #define DPRINTF(x)
! 153: #endif
! 154:
! 155: int pssprobe(struct device *, void *, void *);
! 156: void pssattach(struct device *, struct device *, void *);
! 157:
! 158: int spprobe(struct device *, void *, void *);
! 159: void spattach(struct device *, struct device *, void *);
! 160:
! 161: #ifdef notyet
! 162: int mpuprobe(struct device *, void *, void *);
! 163: void mpuattach(struct device *, struct device *, void *);
! 164:
! 165: int pcdprobe(struct device *, void *, void *);
! 166: void pcdattach(struct device *, struct device *, void *);
! 167: #endif
! 168:
! 169: int pssintr(void *);
! 170: #ifdef notyet
! 171: int mpuintr(void *);
! 172: #endif
! 173:
! 174: int pss_speaker_ctl(void *, int);
! 175:
! 176: int pss_getdev(void *, struct audio_device *);
! 177:
! 178: int pss_mixer_set_port(void *, mixer_ctrl_t *);
! 179: int pss_mixer_get_port(void *, mixer_ctrl_t *);
! 180: int pss_query_devinfo(void *, mixer_devinfo_t *);
! 181:
! 182: #ifdef PSS_DSP
! 183: void pss_dspwrite(struct pss_softc *, int);
! 184: #endif
! 185: void pss_setaddr(int, int);
! 186: int pss_setint(int, int);
! 187: int pss_setdma(int, int);
! 188: int pss_testirq(struct pss_softc *, int);
! 189: int pss_testdma(struct pss_softc *, int);
! 190: #ifdef notyet
! 191: int pss_reset_dsp(struct pss_softc *);
! 192: int pss_download_dsp(struct pss_softc *, u_char *, int);
! 193: #endif
! 194: #ifdef AUDIO_DEBUG
! 195: void pss_dump_regs(struct pss_softc *);
! 196: #endif
! 197: int pss_set_master_gain(struct pss_softc *, struct ad1848_volume *);
! 198: int pss_set_master_mode(struct pss_softc *, int);
! 199: int pss_set_treble(struct pss_softc *, u_int);
! 200: int pss_set_bass(struct pss_softc *, u_int);
! 201: int pss_get_master_gain(struct pss_softc *, struct ad1848_volume *);
! 202: int pss_get_master_mode(struct pss_softc *, u_int *);
! 203: int pss_get_treble(struct pss_softc *, u_char *);
! 204: int pss_get_bass(struct pss_softc *, u_char *);
! 205:
! 206: #ifdef AUDIO_DEBUG
! 207: void wss_dump_regs(struct ad1848_softc *);
! 208: #endif
! 209:
! 210: /*
! 211: * Define our interface to the higher level audio driver.
! 212: */
! 213:
! 214: struct audio_hw_if pss_audio_if = {
! 215: ad1848_open,
! 216: ad1848_close,
! 217: NULL,
! 218: ad1848_query_encoding,
! 219: ad1848_set_params,
! 220: ad1848_round_blocksize,
! 221: ad1848_commit_settings,
! 222: ad1848_dma_init_output,
! 223: ad1848_dma_init_input,
! 224: ad1848_dma_output,
! 225: ad1848_dma_input,
! 226: ad1848_halt_out_dma,
! 227: ad1848_halt_in_dma,
! 228: pss_speaker_ctl,
! 229: pss_getdev,
! 230: NULL,
! 231: pss_mixer_set_port,
! 232: pss_mixer_get_port,
! 233: pss_query_devinfo,
! 234: ad1848_malloc,
! 235: ad1848_free,
! 236: ad1848_round,
! 237: ad1848_mappage,
! 238: ad1848_get_props,
! 239: NULL,
! 240: NULL
! 241: };
! 242:
! 243:
! 244: /* Interrupt translation for WSS config */
! 245: static u_char wss_interrupt_bits[16] = {
! 246: 0xff, 0xff, 0xff, 0xff,
! 247: 0xff, 0xff, 0xff, 0x08,
! 248: 0xff, 0x10, 0x18, 0x20,
! 249: 0xff, 0xff, 0xff, 0xff
! 250: };
! 251: /* ditto for WSS DMA channel */
! 252: static u_char wss_dma_bits[4] = {1, 2, 0, 3};
! 253:
! 254: struct cfattach pss_ca = {
! 255: sizeof(struct pss_softc), pssprobe, pssattach
! 256: };
! 257:
! 258: struct cfdriver pss_cd = {
! 259: NULL, "pss", DV_DULL, 1
! 260: };
! 261:
! 262: struct cfattach sp_ca = {
! 263: sizeof(struct ad1848_softc), spprobe, spattach
! 264: };
! 265:
! 266: struct cfdriver sp_cd = {
! 267: NULL, "sp", DV_DULL
! 268: };
! 269:
! 270: #ifdef notyet
! 271: struct cfattach mpu_ca = {
! 272: sizeof(struct mpu_softc), mpuprobe, mpuattach
! 273: };
! 274:
! 275: struct cfdriver mpu_cd = {
! 276: NULL, "mpu", DV_DULL
! 277: };
! 278:
! 279: struct cfattach pcd_ca = {
! 280: sizeof(struct pcd_softc), pcdprobe, pcdattach
! 281: };
! 282:
! 283: struct cfdriver pcd_cd = {
! 284: NULL, "pcd", DV_DULL
! 285: };
! 286: #endif
! 287:
! 288: struct audio_device pss_device = {
! 289: "pss,ad1848",
! 290: "",
! 291: "PSS"
! 292: };
! 293:
! 294: #ifdef PSS_DSP
! 295: void
! 296: pss_dspwrite(sc, data)
! 297: struct pss_softc *sc;
! 298: int data;
! 299: {
! 300: int i;
! 301: int pss_base = sc->sc_iobase;
! 302:
! 303: /*
! 304: * Note! the i<5000000 is an emergency exit. The dsp_command() is sometimes
! 305: * called while interrupts are disabled. This means that the timer is
! 306: * disabled also. However the timeout situation is a abnormal condition.
! 307: * Normally the DSP should be ready to accept commands after just couple of
! 308: * loops.
! 309: */
! 310: for (i = 0; i < 5000000; i++) {
! 311: if (inw(pss_base+PSS_STATUS) & PSS_WRITE_EMPTY) {
! 312: outw(pss_base+PSS_DATA, data);
! 313: return;
! 314: }
! 315: }
! 316: printf ("pss: DSP Command (%04x) Timeout.\n", data);
! 317: }
! 318: #endif /* PSS_DSP */
! 319:
! 320: void
! 321: pss_setaddr(addr, configAddr)
! 322: int addr;
! 323: int configAddr;
! 324: {
! 325: int val;
! 326:
! 327: val = inw(configAddr);
! 328: val &= ADDR_MASK;
! 329: val |= (addr << 4);
! 330: outw(configAddr,val);
! 331: }
! 332:
! 333: /* pss_setint
! 334: * This function sets the correct bits in the
! 335: * configuration register to
! 336: * enable the chosen interrupt.
! 337: */
! 338: int
! 339: pss_setint(intNum, configAddress)
! 340: int intNum;
! 341: int configAddress;
! 342: {
! 343: int val;
! 344:
! 345: switch(intNum) {
! 346: case 3:
! 347: val = inw(configAddress);
! 348: val &= INT_MASK;
! 349: val |= INT_3_BITS;
! 350: break;
! 351: case 5:
! 352: val = inw(configAddress);
! 353: val &= INT_MASK;
! 354: val |= INT_5_BITS;
! 355: break;
! 356: case 7:
! 357: val = inw(configAddress);
! 358: val &= INT_MASK;
! 359: val |= INT_7_BITS;
! 360: break;
! 361: case 9:
! 362: val = inw(configAddress);
! 363: val &= INT_MASK;
! 364: val |= INT_9_BITS;
! 365: break;
! 366: case 10:
! 367: val = inw(configAddress);
! 368: val &= INT_MASK;
! 369: val |= INT_10_BITS;
! 370: break;
! 371: case 11:
! 372: val = inw(configAddress);
! 373: val &= INT_MASK;
! 374: val |= INT_11_BITS;
! 375: break;
! 376: case 12:
! 377: val = inw(configAddress);
! 378: val &= INT_MASK;
! 379: val |= INT_12_BITS;
! 380: break;
! 381: default:
! 382: DPRINTF(("pss_setint: invalid irq (%d)\n", intNum));
! 383: return 1;
! 384: }
! 385: outw(configAddress,val);
! 386: return 0;
! 387: }
! 388:
! 389: int
! 390: pss_setdma(dmaNum, configAddress)
! 391: int dmaNum;
! 392: int configAddress;
! 393: {
! 394: int val;
! 395:
! 396: switch(dmaNum) {
! 397: case 0:
! 398: val = inw(configAddress);
! 399: val &= DMA_MASK;
! 400: val |= DMA_0_BITS;
! 401: break;
! 402: case 1:
! 403: val = inw(configAddress);
! 404: val &= DMA_MASK;
! 405: val |= DMA_1_BITS;
! 406: break;
! 407: case 3:
! 408: val = inw(configAddress);
! 409: val &= DMA_MASK;
! 410: val |= DMA_3_BITS;
! 411: break;
! 412: case 5:
! 413: val = inw(configAddress);
! 414: val &= DMA_MASK;
! 415: val |= DMA_5_BITS;
! 416: break;
! 417: case 6:
! 418: val = inw(configAddress);
! 419: val &= DMA_MASK;
! 420: val |= DMA_6_BITS;
! 421: break;
! 422: case 7:
! 423: val = inw(configAddress);
! 424: val &= DMA_MASK;
! 425: val |= DMA_7_BITS;
! 426: break;
! 427: default:
! 428: DPRINTF(("pss_setdma: invalid drq (%d)\n", dmaNum));
! 429: return 1;
! 430: }
! 431: outw(configAddress, val);
! 432: return 0;
! 433: }
! 434:
! 435: /*
! 436: * This function tests an interrupt number to see if
! 437: * it is available. It takes the interrupt button
! 438: * as its argument and returns TRUE if the interrupt
! 439: * is ok.
! 440: */
! 441: int
! 442: pss_testirq(struct pss_softc *sc, int intNum)
! 443: {
! 444: int config = sc->sc_iobase + PSS_CONFIG;
! 445: int val;
! 446: int ret;
! 447: int i;
! 448:
! 449: /* Set the interrupt bits */
! 450: switch(intNum) {
! 451: case 3:
! 452: val = inw(config);
! 453: val &= INT_MASK; /* Special: 0 */
! 454: break;
! 455: case 5:
! 456: val = inw(config);
! 457: val &= INT_MASK;
! 458: val |= INT_TEST_BIT | INT_5_BITS;
! 459: break;
! 460: case 7:
! 461: val = inw(config);
! 462: val &= INT_MASK;
! 463: val |= INT_TEST_BIT | INT_7_BITS;
! 464: break;
! 465: case 9:
! 466: val = inw(config);
! 467: val &= INT_MASK;
! 468: val |= INT_TEST_BIT | INT_9_BITS;
! 469: break;
! 470: case 10:
! 471: val = inw(config);
! 472: val &= INT_MASK;
! 473: val |= INT_TEST_BIT | INT_10_BITS;
! 474: break;
! 475: case 11:
! 476: val = inw(config);
! 477: val &= INT_MASK;
! 478: val |= INT_TEST_BIT | INT_11_BITS;
! 479: break;
! 480: case 12:
! 481: val = inw(config);
! 482: val &= INT_MASK;
! 483: val |= INT_TEST_BIT | INT_12_BITS;
! 484: break;
! 485: default:
! 486: DPRINTF(("pss_testirq: invalid irq (%d)\n", intNum));
! 487: return 0;
! 488: }
! 489: outw(config, val);
! 490:
! 491: /* Check if the interrupt is in use */
! 492: /* Do it a few times in case there is a delay */
! 493: ret = 0;
! 494: for (i = 0; i < 5; i++) {
! 495: val = inw(config);
! 496: if (val & INT_TEST_PASS) {
! 497: ret = 1;
! 498: break;
! 499: }
! 500: }
! 501:
! 502: /* Clear the Test bit and the interrupt bits */
! 503: val = inw(config);
! 504: val &= INT_TEST_BIT_MASK & INT_MASK;
! 505: outw(config, val);
! 506: return(ret);
! 507: }
! 508:
! 509: /*
! 510: * This function tests a dma channel to see if
! 511: * it is available. It takes the DMA channel button
! 512: * as its argument and returns TRUE if the channel
! 513: * is ok.
! 514: */
! 515: int
! 516: pss_testdma(sc, dmaNum)
! 517: struct pss_softc *sc;
! 518: int dmaNum;
! 519: {
! 520: int config = sc->sc_iobase + PSS_CONFIG;
! 521: int val;
! 522: int i, ret;
! 523:
! 524: switch (dmaNum) {
! 525: case 0:
! 526: val = inw(config);
! 527: val &= DMA_MASK;
! 528: val |= DMA_TEST_BIT | DMA_0_BITS;
! 529: break;
! 530: case 1:
! 531: val = inw(config);
! 532: val &= DMA_MASK;
! 533: val |= DMA_TEST_BIT | DMA_1_BITS;
! 534: break;
! 535: case 3:
! 536: val = inw(config);
! 537: val &= DMA_MASK;
! 538: val |= DMA_TEST_BIT | DMA_3_BITS;
! 539: break;
! 540: case 5:
! 541: val = inw(config);
! 542: val &= DMA_MASK;
! 543: val |= DMA_TEST_BIT | DMA_5_BITS;
! 544: break;
! 545: case 6:
! 546: val = inw(config);
! 547: val &= DMA_MASK;
! 548: val |= DMA_TEST_BIT | DMA_6_BITS;
! 549: break;
! 550: case 7:
! 551: val = inw(config);
! 552: val &= DMA_MASK;
! 553: val |= DMA_TEST_BIT | DMA_7_BITS;
! 554: break;
! 555: default:
! 556: DPRINTF(("pss_testdma: invalid drq (%d)\n", dmaNum));
! 557: return 0;
! 558: }
! 559: outw(config, val);
! 560:
! 561: /* Check if the DMA channel is in use */
! 562: /* Do it a few times in case there is a delay */
! 563: ret = 0;
! 564: for (i = 0; i < 3; i++) {
! 565: val = inw(config);
! 566: if (val & DMA_TEST_PASS) {
! 567: ret = 1;
! 568: break;
! 569: }
! 570: }
! 571:
! 572: /* Clear the Test bit and the DMA bits */
! 573: val = inw(config);
! 574: val &= DMA_TEST_BIT_MASK & DMA_MASK;
! 575: outw(config, val);
! 576: return(ret);
! 577: }
! 578:
! 579: #ifdef notyet
! 580: int
! 581: pss_reset_dsp(sc)
! 582: struct pss_softc *sc;
! 583: {
! 584: u_long i;
! 585: int pss_base = sc->sc_iobase;
! 586:
! 587: outw(pss_base+PSS_CONTROL, PSS_RESET);
! 588:
! 589: for (i = 0; i < 32768; i++)
! 590: inw(pss_base+PSS_CONTROL);
! 591:
! 592: outw(pss_base+PSS_CONTROL, 0);
! 593:
! 594: return 1;
! 595: }
! 596:
! 597: /*
! 598: * This function loads an image into the PSS
! 599: * card. The function loads the file by
! 600: * resetting the dsp and feeding it the boot bytes.
! 601: * First you feed the ASIC the first byte of
! 602: * the boot sequence. The ASIC waits until it
! 603: * detects a BMS and RD and asserts BR
! 604: * and outputs the byte. The host must poll for
! 605: * the BG signal. It then feeds the ASIC another
! 606: * byte which removes BR.
! 607: */
! 608: int
! 609: pss_download_dsp(sc, block, size)
! 610: struct pss_softc *sc;
! 611: u_char *block;
! 612: int size;
! 613: {
! 614: int i, val, count;
! 615: int pss_base = sc->sc_iobase;
! 616:
! 617: DPRINTF(("pss: downloading boot code..."));
! 618:
! 619: /* Warn DSP software that a boot is coming */
! 620: outw(pss_base+PSS_DATA, 0x00fe);
! 621:
! 622: for (i = 0; i < 32768; i++)
! 623: if (inw(pss_base+PSS_DATA) == 0x5500)
! 624: break;
! 625: outw(pss_base+PSS_DATA, *block++);
! 626:
! 627: pss_reset_dsp(sc);
! 628:
! 629: DPRINTF(("start "));
! 630:
! 631: count = 1;
! 632: while(1) {
! 633: int j;
! 634: for (j=0; j<327670; j++) {
! 635: /* Wait for BG to appear */
! 636: if (inw(pss_base+PSS_STATUS) & PSS_FLAG3)
! 637: break;
! 638: }
! 639:
! 640: if (j==327670) {
! 641: /* It's ok we timed out when the file was empty */
! 642: if (count >= size)
! 643: break;
! 644: else {
! 645: printf("\npss: DownLoad timeout problems, byte %d=%d\n",
! 646: count, size);
! 647: return 0;
! 648: }
! 649: }
! 650: /* Send the next byte */
! 651: outw(pss_base+PSS_DATA, *block++);
! 652: count++;
! 653: }
! 654:
! 655: outw(pss_base+PSS_DATA, 0);
! 656: for (i = 0; i < 32768; i++)
! 657: (void) inw(pss_base+PSS_STATUS);
! 658:
! 659: DPRINTF(("downloaded\n"));
! 660:
! 661: for (i = 0; i < 32768; i++) {
! 662: val = inw(pss_base+PSS_STATUS);
! 663: if (val & PSS_READ_FULL)
! 664: break;
! 665: }
! 666:
! 667: /* now read the version */
! 668: for (i = 0; i < 32000; i++) {
! 669: val = inw(pss_base+PSS_STATUS);
! 670: if (val & PSS_READ_FULL)
! 671: break;
! 672: }
! 673: if (i == 32000)
! 674: return 0;
! 675:
! 676: (void) inw(pss_base+PSS_DATA);
! 677:
! 678: return 1;
! 679: }
! 680: #endif /* notyet */
! 681:
! 682: #ifdef AUDIO_DEBUG
! 683: void
! 684: wss_dump_regs(sc)
! 685: struct ad1848_softc *sc;
! 686: {
! 687:
! 688: printf("WSS reg: status=%02x\n",
! 689: (u_char)inb(sc->sc_iobase-WSS_CODEC+WSS_STATUS));
! 690: }
! 691:
! 692: void
! 693: pss_dump_regs(sc)
! 694: struct pss_softc *sc;
! 695: {
! 696:
! 697: printf("PSS regs: status=%04x vers=%04x ",
! 698: (u_short)inw(sc->sc_iobase+PSS_STATUS),
! 699: (u_short)inw(sc->sc_iobase+PSS_ID_VERS));
! 700:
! 701: printf("config=%04x wss_config=%04x\n",
! 702: (u_short)inw(sc->sc_iobase+PSS_CONFIG),
! 703: (u_short)inw(sc->sc_iobase+PSS_WSS_CONFIG));
! 704: }
! 705: #endif
! 706:
! 707: /*
! 708: * Probe for the PSS hardware.
! 709: */
! 710: int
! 711: pssprobe(parent, self, aux)
! 712: struct device *parent;
! 713: void *self;
! 714: void *aux;
! 715: {
! 716: struct pss_softc *sc = self;
! 717: struct isa_attach_args *ia = aux;
! 718: int iobase = ia->ia_iobase;
! 719:
! 720: if (!PSS_BASE_VALID(iobase)) {
! 721: DPRINTF(("pss: configured iobase %x invalid\n", iobase));
! 722: return 0;
! 723: }
! 724:
! 725: /* Need to probe for iobase when IOBASEUNK {0x220 0x240} */
! 726: if (iobase == IOBASEUNK) {
! 727:
! 728: iobase = 0x220;
! 729: if ((inw(iobase+PSS_ID_VERS) & 0xff00) == 0x4500)
! 730: goto pss_found;
! 731:
! 732: iobase = 0x240;
! 733: if ((inw(iobase+PSS_ID_VERS) & 0xff00) == 0x4500)
! 734: goto pss_found;
! 735:
! 736: DPRINTF(("pss: no PSS found (at 0x220 or 0x240)\n"));
! 737: return 0;
! 738: }
! 739: else if ((inw(iobase+PSS_ID_VERS) & 0xff00) != 0x4500) {
! 740: DPRINTF(("pss: not a PSS - %x\n", inw(iobase+PSS_ID_VERS)));
! 741: return 0;
! 742: }
! 743:
! 744: pss_found:
! 745: sc->sc_iobase = iobase;
! 746:
! 747: /* Clear WSS config */
! 748: pss_setaddr(WSS_BASE_ADDRESS, sc->sc_iobase+PSS_WSS_CONFIG); /* XXX! */
! 749: outb(WSS_BASE_ADDRESS+WSS_CONFIG, 0);
! 750:
! 751: /* Clear config registers (POR reset state) */
! 752: outw(sc->sc_iobase+PSS_CONFIG, 0);
! 753: outw(sc->sc_iobase+PSS_WSS_CONFIG, 0);
! 754: outw(sc->sc_iobase+SB_CONFIG, 0);
! 755: outw(sc->sc_iobase+MIDI_CONFIG, 0);
! 756: outw(sc->sc_iobase+CD_CONFIG, 0);
! 757:
! 758: if (ia->ia_irq == IRQUNK) {
! 759: int i;
! 760: for (i = 0; i < 16; i++) {
! 761: if (pss_testirq(sc, i) != 0)
! 762: break;
! 763: }
! 764: if (i == 16) {
! 765: DPRINTF(("pss: unable to locate free IRQ channel\n"));
! 766: return 0;
! 767: }
! 768: else {
! 769: ia->ia_irq = i;
! 770: DPRINTF(("pss: found IRQ %d free\n", i));
! 771: }
! 772: }
! 773: else {
! 774: if (pss_testirq(sc, ia->ia_irq) == 0) {
! 775: DPRINTF(("pss: configured IRQ unavailable (%d)\n", ia->ia_irq));
! 776: return 0;
! 777: }
! 778: }
! 779:
! 780: /* XXX Need to deal with DRQUNK */
! 781: if (pss_testdma(sc, ia->ia_drq) == 0) {
! 782: DPRINTF(("pss: configured DMA channel unavailable (%d)\n", ia->ia_drq));
! 783: return 0;
! 784: }
! 785:
! 786: ia->ia_iosize = PSS_NPORT;
! 787:
! 788: /* Initialize PSS irq and dma */
! 789: pss_setint(ia->ia_irq, sc->sc_iobase+PSS_CONFIG);
! 790: pss_setdma(sc->sc_drq, sc->sc_iobase+PSS_CONFIG);
! 791:
! 792: #ifdef notyet
! 793: /* Setup the Game port */
! 794: #ifdef PSS_GAMEPORT
! 795: DPRINTF(("Turning Game Port On.\n"));
! 796: outw(sc->sc_iobase+PSS_STATUS, inw(sc->sc_iobase+PSS_STATUS) | GAME_BIT);
! 797: #else
! 798: outw(sc->sc_iobase+PSS_STATUS, inw(sc->sc_iobase+PSS_STATUS) & GAME_BIT_MASK);
! 799: #endif
! 800:
! 801: /* Reset DSP */
! 802: pss_reset_dsp(sc);
! 803: #endif /* notyet */
! 804:
! 805: return 1;
! 806: }
! 807:
! 808: /*
! 809: * Probe for the Soundport (ad1848)
! 810: */
! 811: int
! 812: spprobe(parent, match, aux)
! 813: struct device *parent;
! 814: void *match, *aux;
! 815: {
! 816: struct ad1848_softc *sc = match;
! 817: struct pss_softc *pc = (void *) parent;
! 818: struct cfdata *cf = (void *)sc->sc_dev.dv_cfdata;
! 819: struct isa_attach_args *ia = aux;
! 820: u_char bits;
! 821: int i;
! 822:
! 823: sc->sc_iot = ia->ia_iot;
! 824: sc->sc_iobase = cf->cf_iobase + WSS_CODEC;
! 825:
! 826: /* Set WSS io address */
! 827: pss_setaddr(cf->cf_iobase, pc->sc_iobase+PSS_WSS_CONFIG);
! 828:
! 829: /* Is there an ad1848 chip at the WSS iobase ? */
! 830: if (ad1848_probe(sc) == 0) {
! 831: DPRINTF(("sp: no ad1848 ? iobase=%x\n", sc->sc_iobase));
! 832: return 0;
! 833: }
! 834:
! 835: /* Setup WSS interrupt and DMA if auto */
! 836: if (cf->cf_irq == IRQUNK) {
! 837:
! 838: /* Find unused IRQ for WSS */
! 839: for (i = 0; i < 12; i++) {
! 840: if (wss_interrupt_bits[i] != 0xff) {
! 841: if (pss_testirq(pc, i))
! 842: break;
! 843: }
! 844: }
! 845: if (i == 12) {
! 846: DPRINTF(("sp: unable to locate free IRQ for WSS\n"));
! 847: return 0;
! 848: }
! 849: else {
! 850: cf->cf_irq = i;
! 851: sc->sc_irq = i;
! 852: DPRINTF(("sp: found IRQ %d free\n", i));
! 853: }
! 854: }
! 855: else {
! 856: sc->sc_irq = cf->cf_irq;
! 857: if (pss_testirq(pc, sc->sc_irq) == 0) {
! 858: DPRINTF(("sp: configured IRQ unavailable (%d)\n", sc->sc_irq));
! 859: return 0;
! 860: }
! 861: }
! 862:
! 863: if (cf->cf_drq == DRQUNK) {
! 864: /* Find unused DMA channel for WSS */
! 865: for (i = 0; i < 4; i++) {
! 866: if (wss_dma_bits[i]) {
! 867: if (pss_testdma(pc, i))
! 868: break;
! 869: }
! 870: }
! 871: if (i == 4) {
! 872: DPRINTF(("sp: unable to locate free DMA channel for WSS\n"));
! 873: return 0;
! 874: }
! 875: else {
! 876: sc->sc_drq = cf->cf_drq = i;
! 877: DPRINTF(("sp: found DMA %d free\n", i));
! 878: }
! 879: }
! 880: else {
! 881: if (pss_testdma(pc, sc->sc_drq) == 0) {
! 882: DPRINTF(("sp: configured DMA channel unavailable (%d)\n", sc->sc_drq));
! 883: return 0;
! 884: }
! 885: sc->sc_drq = cf->cf_drq;
! 886: }
! 887: sc->sc_recdrq = sc->sc_drq;
! 888:
! 889: /* Set WSS config registers */
! 890: if ((bits = wss_interrupt_bits[sc->sc_irq]) == 0xff) {
! 891: DPRINTF(("sp: invalid interrupt configuration (irq=%d)\n", sc->sc_irq));
! 892: return 0;
! 893: }
! 894:
! 895: outb(sc->sc_iobase+WSS_CONFIG, (bits | 0x40));
! 896: if ((inb(sc->sc_iobase+WSS_STATUS) & 0x40) == 0) /* XXX What do these bits mean ? */
! 897: DPRINTF(("sp: IRQ %x\n", inb(sc->sc_iobase+WSS_STATUS)));
! 898:
! 899: outb(sc->sc_iobase+WSS_CONFIG, (bits | wss_dma_bits[sc->sc_drq]));
! 900:
! 901: pc->ad1848_sc = sc;
! 902: sc->parent = pc;
! 903:
! 904: return 1;
! 905: }
! 906:
! 907: #ifdef notyet
! 908: int
! 909: mpuprobe(parent, match, aux)
! 910: struct device *parent;
! 911: void *match, *aux;
! 912: {
! 913: struct mpu_softc *sc = match;
! 914: struct pss_softc *pc = (void *) parent;
! 915: struct cfdata *cf = (void *)sc->sc_dev.dv_cfdata;
! 916:
! 917: /* Check if midi is enabled; if it is check the interrupt */
! 918: sc->sc_iobase = cf->cf_iobase;
! 919:
! 920: if (cf->cf_irq == IRQUNK) {
! 921: int i;
! 922: for (i = 0; i < 16; i++) {
! 923: if (pss_testirq(pc, i) != 0)
! 924: break;
! 925: }
! 926: if (i == 16) {
! 927: printf("mpu: unable to locate free IRQ channel for MIDI\n");
! 928: return 0;
! 929: }
! 930: else {
! 931: cf->cf_irq = i;
! 932: sc->sc_irq = i;
! 933: DPRINTF(("mpu: found IRQ %d free\n", i));
! 934: }
! 935: }
! 936: else {
! 937: sc->sc_irq = cf->cf_irq;
! 938:
! 939: if (pss_testirq(pc, sc->sc_irq) == 0) {
! 940: printf("pss: configured MIDI IRQ unavailable (%d)\n", sc->sc_irq);
! 941: return 0;
! 942: }
! 943: }
! 944:
! 945: outw(pc->sc_iobase+MIDI_CONFIG,0);
! 946: DPRINTF(("pss: mpu port 0x%x irq %d\n", sc->sc_iobase, sc->sc_irq));
! 947: pss_setaddr(sc->sc_iobase, pc->sc_iobase+MIDI_CONFIG);
! 948: pss_setint(sc->sc_irq, pc->sc_iobase+MIDI_CONFIG);
! 949:
! 950: return 1;
! 951: }
! 952:
! 953: int
! 954: pcdprobe(parent, match, aux)
! 955: struct device *parent;
! 956: void *match, *aux;
! 957: {
! 958: struct pcd_softc *sc = match;
! 959: struct pss_softc *pc = (void *) parent;
! 960: struct cfdata *cf = (void *)sc->sc_dev.dv_cfdata;
! 961: u_short val;
! 962:
! 963: sc->sc_iobase = cf->cf_iobase;
! 964:
! 965: pss_setaddr(sc->sc_iobase, pc->sc_iobase+CD_CONFIG);
! 966:
! 967: /* Set the correct irq polarity. */
! 968: val = inw(pc->sc_iobase+CD_CONFIG);
! 969: outw(pc->sc_iobase+CD_CONFIG, 0);
! 970: val &= CD_POL_MASK;
! 971: val |= CD_POL_BIT; /* XXX if (pol) */
! 972: outw(pc->sc_iobase+CD_CONFIG, val);
! 973:
! 974: if (cf->cf_irq == IRQUNK) {
! 975: int i;
! 976: for (i = 0; i < 16; i++) {
! 977: if (pss_testirq(pc, i) != 0)
! 978: break;
! 979: }
! 980: if (i == 16) {
! 981: printf("pcd: unable to locate free IRQ channel for CD\n");
! 982: return 0;
! 983: }
! 984: else {
! 985: cf->cf_irq = i;
! 986: sc->sc_irq = i;
! 987: DPRINTF(("pcd: found IRQ %d free\n", i));
! 988: }
! 989: }
! 990: else {
! 991: sc->sc_irq = cf->cf_irq;
! 992:
! 993: if (pss_testirq(pc, sc->sc_irq) == 0) {
! 994: printf("pcd: configured CD IRQ unavailable (%d)\n", sc->sc_irq);
! 995: return 0;
! 996: }
! 997: return 1;
! 998: }
! 999: pss_setint(sc->sc_irq, pc->sc_iobase+CD_CONFIG);
! 1000:
! 1001: return 1;
! 1002: }
! 1003: #endif /* notyet */
! 1004:
! 1005: /*
! 1006: * Attach hardware to driver, attach hardware driver to audio
! 1007: * pseudo-device driver .
! 1008: */
! 1009: void
! 1010: pssattach(parent, self, aux)
! 1011: struct device *parent, *self;
! 1012: void *aux;
! 1013: {
! 1014: struct pss_softc *sc = (struct pss_softc *)self;
! 1015: struct isa_attach_args *ia = (struct isa_attach_args *)aux;
! 1016: int iobase = ia->ia_iobase;
! 1017: u_char vers;
! 1018: struct ad1848_volume vol = {150, 150};
! 1019:
! 1020: sc->sc_iobase = iobase;
! 1021: sc->sc_drq = ia->ia_drq;
! 1022:
! 1023: /* Setup interrupt handler for PSS */
! 1024: sc->sc_ih = isa_intr_establish(ia->ia_ic, ia->ia_irq, IST_EDGE, IPL_AUDIO,
! 1025: pssintr, sc, sc->sc_dev.dv_xname);
! 1026:
! 1027: vers = (inw(sc->sc_iobase+PSS_ID_VERS)&0xff) - 1;
! 1028: printf(": ESC614%c\n", (vers > 0)?'A'+vers:' ');
! 1029:
! 1030: (void)config_found(self, ia->ia_ic, NULL); /* XXX */
! 1031:
! 1032: sc->out_port = PSS_MASTER_VOL;
! 1033:
! 1034: (void)pss_set_master_mode(sc, PSS_SPKR_STEREO);
! 1035: (void)pss_set_master_gain(sc, &vol);
! 1036: (void)pss_set_treble(sc, AUDIO_MAX_GAIN/2);
! 1037: (void)pss_set_bass(sc, AUDIO_MAX_GAIN/2);
! 1038:
! 1039: audio_attach_mi(&pss_audio_if, sc->ad1848_sc, &sc->ad1848_sc->sc_dev);
! 1040: }
! 1041:
! 1042: void
! 1043: spattach(parent, self, aux)
! 1044: struct device *parent, *self;
! 1045: void *aux;
! 1046: {
! 1047: struct ad1848_softc *sc = (struct ad1848_softc *)self;
! 1048: struct cfdata *cf = (void *)sc->sc_dev.dv_cfdata;
! 1049: isa_chipset_tag_t ic = aux; /* XXX */
! 1050: int iobase = cf->cf_iobase;
! 1051:
! 1052: sc->sc_iobase = iobase;
! 1053: sc->sc_drq = cf->cf_drq;
! 1054:
! 1055: sc->sc_ih = isa_intr_establish(ic, cf->cf_irq, IST_EDGE, IPL_AUDIO,
! 1056: ad1848_intr, sc, sc->sc_dev.dv_xname);
! 1057:
! 1058: sc->sc_isa = parent->dv_parent;
! 1059:
! 1060: ad1848_attach(sc);
! 1061:
! 1062: printf("\n");
! 1063: }
! 1064:
! 1065: #ifdef notyet
! 1066: void
! 1067: mpuattach(parent, self, aux)
! 1068: struct device *parent, *self;
! 1069: void *aux;
! 1070: {
! 1071: struct mpu_softc *sc = (struct mpu_softc *)self;
! 1072: struct cfdata *cf = (void *)sc->sc_dev.dv_cfdata;
! 1073: isa_chipset_tag_t ic = aux; /* XXX */
! 1074: int iobase = cf->cf_iobase;
! 1075:
! 1076: sc->sc_iobase = iobase;
! 1077:
! 1078: sc->sc_ih = isa_intr_establish(ic, cf->cf_irq, IST_EDGE, IPL_AUDIO,
! 1079: mpuintr, sc, sc->sc_dev.dv_xname);
! 1080:
! 1081: /* XXX might use pssprint func ?? */
! 1082: printf(" port 0x%x/%d irq %d\n",
! 1083: sc->sc_iobase, MIDI_NPORT, cf->cf_irq);
! 1084: }
! 1085:
! 1086: void
! 1087: pcdattach(parent, self, aux)
! 1088: struct device *parent, *self;
! 1089: void *aux;
! 1090: {
! 1091: struct pcd_softc *sc = (struct pcd_softc *)self;
! 1092: struct cfdata *cf = (void *)sc->sc_dev.dv_cfdata;
! 1093: int iobase = cf->cf_iobase;
! 1094:
! 1095: /*
! 1096: * The pss driver simply enables the cd interface. The CD
! 1097: * appropriate driver - scsi (aic6360) or Sony needs to be
! 1098: * used after this to handle the device.
! 1099: */
! 1100: sc->sc_iobase = iobase;
! 1101:
! 1102: /* XXX might use pssprint func ?? */
! 1103: printf(" port 0x%x/%d irq %d\n",
! 1104: sc->sc_iobase, 2, cf->cf_irq);
! 1105: }
! 1106: #endif /* notyet */
! 1107:
! 1108:
! 1109: int
! 1110: pss_set_master_gain(sc, gp)
! 1111: struct pss_softc *sc;
! 1112: struct ad1848_volume *gp;
! 1113: {
! 1114: DPRINTF(("pss_set_master_gain: %d:%d\n", gp->left, gp->right));
! 1115:
! 1116: #ifdef PSS_DSP
! 1117: if (gp->left > PHILLIPS_VOL_MAX)
! 1118: gp->left = PHILLIPS_VOL_MAX;
! 1119: if (gp->left < PHILLIPS_VOL_MIN)
! 1120: gp->left = PHILLIPS_VOL_MIN;
! 1121: if (gp->right > PHILLIPS_VOL_MAX)
! 1122: gp->right = PHILLIPS_VOL_MAX;
! 1123: if (gp->right < PHILLIPS_VOL_MIN)
! 1124: gp->right = PHILLIPS_VOL_MIN;
! 1125:
! 1126: pss_dspwrite(sc, SET_MASTER_COMMAND);
! 1127: pss_dspwrite(sc, MASTER_VOLUME_LEFT|(PHILLIPS_VOL_CONSTANT + gp->left / PHILLIPS_VOL_STEP));
! 1128: pss_dspwrite(sc, SET_MASTER_COMMAND);
! 1129: pss_dspwrite(sc, MASTER_VOLUME_RIGHT|(PHILLIPS_VOL_CONSTANT + gp->right / PHILLIPS_VOL_STEP));
! 1130: #endif
! 1131:
! 1132: sc->master_volume = *gp;
! 1133: return(0);
! 1134: }
! 1135:
! 1136: int
! 1137: pss_set_master_mode(sc, mode)
! 1138: struct pss_softc *sc;
! 1139: int mode;
! 1140: {
! 1141: short phillips_mode;
! 1142:
! 1143: DPRINTF(("pss_set_master_mode: %d\n", mode));
! 1144:
! 1145: if (mode == PSS_SPKR_STEREO)
! 1146: phillips_mode = PSS_STEREO;
! 1147: else if (mode == PSS_SPKR_PSEUDO)
! 1148: phillips_mode = PSS_PSEUDO;
! 1149: else if (mode == PSS_SPKR_SPATIAL)
! 1150: phillips_mode = PSS_SPATIAL;
! 1151: else if (mode == PSS_SPKR_MONO)
! 1152: phillips_mode = PSS_MONO;
! 1153: else
! 1154: return (EINVAL);
! 1155:
! 1156: #ifdef PSS_DSP
! 1157: pss_dspwrite(sc, SET_MASTER_COMMAND);
! 1158: pss_dspwrite(sc, MASTER_SWITCH | mode);
! 1159: #endif
! 1160:
! 1161: sc->master_mode = mode;
! 1162:
! 1163: return(0);
! 1164: }
! 1165:
! 1166: int
! 1167: pss_set_treble(sc, treb)
! 1168: struct pss_softc *sc;
! 1169: u_int treb;
! 1170: {
! 1171: DPRINTF(("pss_set_treble: %d\n", treb));
! 1172:
! 1173: #ifdef PSS_DSP
! 1174: if (treb > PHILLIPS_TREBLE_MAX)
! 1175: treb = PHILLIPS_TREBLE_MAX;
! 1176: if (treb < PHILLIPS_TREBLE_MIN)
! 1177: treb = PHILLIPS_TREBLE_MIN;
! 1178: pss_dspwrite(sc, SET_MASTER_COMMAND);
! 1179: pss_dspwrite(sc, MASTER_TREBLE|(PHILLIPS_TREBLE_CONSTANT + treb / PHILLIPS_TREBLE_STEP));
! 1180: #endif
! 1181:
! 1182: sc->monitor_treble = treb;
! 1183:
! 1184: return(0);
! 1185: }
! 1186:
! 1187: int
! 1188: pss_set_bass(sc, bass)
! 1189: struct pss_softc *sc;
! 1190: u_int bass;
! 1191: {
! 1192: DPRINTF(("pss_set_bass: %d\n", bass));
! 1193:
! 1194: #ifdef PSS_DSP
! 1195: if (bass > PHILLIPS_BASS_MAX)
! 1196: bass = PHILLIPS_BASS_MAX;
! 1197: if (bass < PHILLIPS_BASS_MIN)
! 1198: bass = PHILLIPS_BASS_MIN;
! 1199: pss_dspwrite(sc, SET_MASTER_COMMAND);
! 1200: pss_dspwrite(sc, MASTER_BASS|(PHILLIPS_BASS_CONSTANT + bass / PHILLIPS_BASS_STEP));
! 1201: #endif
! 1202:
! 1203: sc->monitor_bass = bass;
! 1204:
! 1205: return(0);
! 1206: }
! 1207:
! 1208: int
! 1209: pss_get_master_gain(sc, gp)
! 1210: struct pss_softc *sc;
! 1211: struct ad1848_volume *gp;
! 1212: {
! 1213: *gp = sc->master_volume;
! 1214: return(0);
! 1215: }
! 1216:
! 1217: int
! 1218: pss_get_master_mode(sc, mode)
! 1219: struct pss_softc *sc;
! 1220: u_int *mode;
! 1221: {
! 1222: *mode = sc->master_mode;
! 1223: return(0);
! 1224: }
! 1225:
! 1226: int
! 1227: pss_get_treble(sc, tp)
! 1228: struct pss_softc *sc;
! 1229: u_char *tp;
! 1230: {
! 1231: *tp = sc->monitor_treble;
! 1232: return(0);
! 1233: }
! 1234:
! 1235: int
! 1236: pss_get_bass(sc, bp)
! 1237: struct pss_softc *sc;
! 1238: u_char *bp;
! 1239: {
! 1240: *bp = sc->monitor_bass;
! 1241: return(0);
! 1242: }
! 1243:
! 1244: int
! 1245: pss_speaker_ctl(addr, newstate)
! 1246: void *addr;
! 1247: int newstate;
! 1248: {
! 1249: return(0);
! 1250: }
! 1251:
! 1252: int
! 1253: pssintr(arg)
! 1254: void *arg;
! 1255: {
! 1256: struct pss_softc *sc = arg;
! 1257: u_short sr;
! 1258:
! 1259: sr = inw(sc->sc_iobase+PSS_STATUS);
! 1260:
! 1261: DPRINTF(("pssintr: sc=%p st=%x\n", sc, sr));
! 1262:
! 1263: /* Acknowledge intr */
! 1264: outw(sc->sc_iobase+PSS_IRQ_ACK, 0);
! 1265:
! 1266: /* Is it one of ours ? */
! 1267: if (sr & (PSS_WRITE_EMPTY|PSS_READ_FULL|PSS_IRQ|PSS_DMQ_TC)) {
! 1268: /* XXX do something */
! 1269: return 1;
! 1270: }
! 1271:
! 1272: return 0;
! 1273: }
! 1274:
! 1275: #ifdef notyet
! 1276: int
! 1277: mpuintr(arg)
! 1278: void *arg;
! 1279: {
! 1280: struct mpu_softc *sc = arg;
! 1281: u_char sr;
! 1282:
! 1283: sr = inb(sc->sc_iobase+MIDI_STATUS_REG);
! 1284:
! 1285: printf("mpuintr: sc=%p sr=%x\n", sc, sr);
! 1286:
! 1287: /* XXX Need to clear intr */
! 1288: return 1;
! 1289: }
! 1290: #endif
! 1291:
! 1292: int
! 1293: pss_getdev(addr, retp)
! 1294: void *addr;
! 1295: struct audio_device *retp;
! 1296: {
! 1297: DPRINTF(("pss_getdev: retp=%p\n", retp));
! 1298:
! 1299: *retp = pss_device;
! 1300: return 0;
! 1301: }
! 1302:
! 1303: static ad1848_devmap_t mappings[] = {
! 1304: { PSS_MIC_IN_LVL, AD1848_KIND_LVL, AD1848_AUX2_CHANNEL },
! 1305: { PSS_LINE_IN_LVL, AD1848_KIND_LVL, AD1848_AUX1_CHANNEL },
! 1306: { PSS_DAC_LVL, AD1848_KIND_LVL, AD1848_DAC_CHANNEL },
! 1307: { PSS_MON_LVL, AD1848_KIND_LVL, AD1848_MONO_CHANNEL },
! 1308: { PSS_MIC_IN_MUTE, AD1848_KIND_MUTE, AD1848_AUX2_CHANNEL },
! 1309: { PSS_LINE_IN_MUTE, AD1848_KIND_MUTE, AD1848_AUX1_CHANNEL },
! 1310: { PSS_DAC_MUTE, AD1848_KIND_MUTE, AD1848_DAC_CHANNEL },
! 1311: { PSS_REC_LVL, AD1848_KIND_RECORDGAIN, -1 },
! 1312: { PSS_RECORD_SOURCE, AD1848_KIND_RECORDSOURCE, -1}
! 1313: };
! 1314:
! 1315: static int nummap = sizeof(mappings) / sizeof(mappings[0]);
! 1316:
! 1317: int
! 1318: pss_mixer_set_port(addr, cp)
! 1319: void *addr;
! 1320: mixer_ctrl_t *cp;
! 1321: {
! 1322: struct ad1848_softc *ac = addr;
! 1323: struct pss_softc *sc = ac->parent;
! 1324: struct ad1848_volume vol;
! 1325: int error = ad1848_mixer_set_port(ac, mappings, nummap, cp);
! 1326:
! 1327: if (error != ENXIO)
! 1328: return (error);
! 1329:
! 1330: switch (cp->dev) {
! 1331: case PSS_MASTER_VOL: /* master volume */
! 1332: if (cp->type == AUDIO_MIXER_VALUE) {
! 1333: if (ad1848_to_vol(cp, &vol))
! 1334: error = pss_set_master_gain(sc, &vol);
! 1335: }
! 1336: break;
! 1337:
! 1338: case PSS_OUTPUT_MODE:
! 1339: if (cp->type == AUDIO_MIXER_ENUM)
! 1340: error = pss_set_master_mode(sc, cp->un.ord);
! 1341: break;
! 1342:
! 1343: case PSS_MASTER_TREBLE: /* master treble */
! 1344: if (cp->type == AUDIO_MIXER_VALUE && cp->un.value.num_channels == 1)
! 1345: error = pss_set_treble(sc, (u_char)cp->un.value.level[AUDIO_MIXER_LEVEL_MONO]);
! 1346: break;
! 1347:
! 1348: case PSS_MASTER_BASS: /* master bass */
! 1349: if (cp->type == AUDIO_MIXER_VALUE && cp->un.value.num_channels == 1)
! 1350: error = pss_set_bass(sc, (u_char)cp->un.value.level[AUDIO_MIXER_LEVEL_MONO]);
! 1351: break;
! 1352:
! 1353: default:
! 1354: return ENXIO;
! 1355: /*NOTREACHED*/
! 1356: }
! 1357:
! 1358: return 0;
! 1359: }
! 1360:
! 1361: int
! 1362: pss_mixer_get_port(addr, cp)
! 1363: void *addr;
! 1364: mixer_ctrl_t *cp;
! 1365: {
! 1366: struct ad1848_softc *ac = addr;
! 1367: struct pss_softc *sc = ac->parent;
! 1368: struct ad1848_volume vol;
! 1369: u_char eq;
! 1370: int error = ad1848_mixer_get_port(ac, mappings, nummap, cp);
! 1371:
! 1372: if (error != ENXIO)
! 1373: return (error);
! 1374:
! 1375: error = EINVAL;
! 1376:
! 1377: switch (cp->dev) {
! 1378: case PSS_MASTER_VOL: /* master volume */
! 1379: if (cp->type == AUDIO_MIXER_VALUE) {
! 1380: error = pss_get_master_gain(sc, &vol);
! 1381: if (!error)
! 1382: ad1848_from_vol(cp, &vol);
! 1383: }
! 1384: break;
! 1385:
! 1386: case PSS_MASTER_TREBLE: /* master treble */
! 1387: if (cp->type == AUDIO_MIXER_VALUE && cp->un.value.num_channels == 1) {
! 1388: error = pss_get_treble(sc, &eq);
! 1389: if (!error)
! 1390: cp->un.value.level[AUDIO_MIXER_LEVEL_MONO] = eq;
! 1391: }
! 1392: break;
! 1393:
! 1394: case PSS_MASTER_BASS: /* master bass */
! 1395: if (cp->type == AUDIO_MIXER_VALUE && cp->un.value.num_channels == 1) {
! 1396: error = pss_get_bass(sc, &eq);
! 1397: if (!error)
! 1398: cp->un.value.level[AUDIO_MIXER_LEVEL_MONO] = eq;
! 1399: }
! 1400: break;
! 1401:
! 1402: case PSS_OUTPUT_MODE:
! 1403: if (cp->type == AUDIO_MIXER_ENUM)
! 1404: error = pss_get_master_mode(sc, &cp->un.ord);
! 1405: break;
! 1406:
! 1407: default:
! 1408: error = ENXIO;
! 1409: break;
! 1410: }
! 1411:
! 1412: return(error);
! 1413: }
! 1414:
! 1415: int
! 1416: pss_query_devinfo(addr, dip)
! 1417: void *addr;
! 1418: mixer_devinfo_t *dip;
! 1419: {
! 1420: DPRINTF(("pss_query_devinfo: index=%d\n", dip->index));
! 1421:
! 1422: switch(dip->index) {
! 1423: case PSS_MIC_IN_LVL: /* Microphone */
! 1424: dip->type = AUDIO_MIXER_VALUE;
! 1425: dip->mixer_class = PSS_INPUT_CLASS;
! 1426: dip->prev = AUDIO_MIXER_LAST;
! 1427: dip->next = PSS_MIC_IN_MUTE;
! 1428: strlcpy(dip->label.name, AudioNmicrophone, sizeof dip->label.name);
! 1429: dip->un.v.num_channels = 2;
! 1430: strlcpy(dip->un.v.units.name, AudioNvolume,
! 1431: sizeof dip->un.v.units.name);
! 1432: break;
! 1433:
! 1434: case PSS_LINE_IN_LVL: /* line/CD */
! 1435: dip->type = AUDIO_MIXER_VALUE;
! 1436: dip->mixer_class = PSS_INPUT_CLASS;
! 1437: dip->prev = AUDIO_MIXER_LAST;
! 1438: dip->next = PSS_LINE_IN_MUTE;
! 1439: strlcpy(dip->label.name, AudioNcd, sizeof dip->label.name);
! 1440: dip->un.v.num_channels = 2;
! 1441: strlcpy(dip->un.v.units.name, AudioNvolume,
! 1442: sizeof dip->un.v.units.name);
! 1443: break;
! 1444:
! 1445: case PSS_DAC_LVL: /* dacout */
! 1446: dip->type = AUDIO_MIXER_VALUE;
! 1447: dip->mixer_class = PSS_INPUT_CLASS;
! 1448: dip->prev = AUDIO_MIXER_LAST;
! 1449: dip->next = PSS_DAC_MUTE;
! 1450: strlcpy(dip->label.name, AudioNdac, sizeof dip->label.name);
! 1451: dip->un.v.num_channels = 2;
! 1452: strlcpy(dip->un.v.units.name, AudioNvolume,
! 1453: sizeof dip->un.v.units.name);
! 1454: break;
! 1455:
! 1456: case PSS_REC_LVL: /* record level */
! 1457: dip->type = AUDIO_MIXER_VALUE;
! 1458: dip->mixer_class = PSS_RECORD_CLASS;
! 1459: dip->prev = AUDIO_MIXER_LAST;
! 1460: dip->next = PSS_RECORD_SOURCE;
! 1461: strlcpy(dip->label.name, AudioNrecord, sizeof dip->label.name);
! 1462: dip->un.v.num_channels = 2;
! 1463: strlcpy(dip->un.v.units.name, AudioNvolume,
! 1464: sizeof dip->un.v.units.name);
! 1465: break;
! 1466:
! 1467: case PSS_MON_LVL: /* monitor level */
! 1468: dip->type = AUDIO_MIXER_VALUE;
! 1469: dip->mixer_class = PSS_MONITOR_CLASS;
! 1470: dip->next = dip->prev = AUDIO_MIXER_LAST;
! 1471: strlcpy(dip->label.name, AudioNmonitor, sizeof dip->label.name);
! 1472: dip->un.v.num_channels = 1;
! 1473: strlcpy(dip->un.v.units.name, AudioNvolume,
! 1474: sizeof dip->un.v.units.name);
! 1475: break;
! 1476:
! 1477: case PSS_MASTER_VOL: /* master volume */
! 1478: dip->type = AUDIO_MIXER_VALUE;
! 1479: dip->mixer_class = PSS_OUTPUT_CLASS;
! 1480: dip->prev = AUDIO_MIXER_LAST;
! 1481: dip->next = PSS_OUTPUT_MODE;
! 1482: strlcpy(dip->label.name, AudioNmaster, sizeof dip->label.name);
! 1483: dip->un.v.num_channels = 2;
! 1484: strlcpy(dip->un.v.units.name, AudioNvolume,
! 1485: sizeof dip->un.v.units.name);
! 1486: break;
! 1487:
! 1488: case PSS_MASTER_TREBLE: /* master treble */
! 1489: dip->type = AUDIO_MIXER_VALUE;
! 1490: dip->mixer_class = PSS_OUTPUT_CLASS;
! 1491: dip->next = dip->prev = AUDIO_MIXER_LAST;
! 1492: strlcpy(dip->label.name, AudioNtreble, sizeof dip->label.name);
! 1493: dip->un.v.num_channels = 1;
! 1494: strlcpy(dip->un.v.units.name, AudioNtreble,
! 1495: sizeof dip->un.v.units.name);
! 1496: break;
! 1497:
! 1498: case PSS_MASTER_BASS: /* master bass */
! 1499: dip->type = AUDIO_MIXER_VALUE;
! 1500: dip->mixer_class = PSS_OUTPUT_CLASS;
! 1501: dip->next = dip->prev = AUDIO_MIXER_LAST;
! 1502: strlcpy(dip->label.name, AudioNbass, sizeof dip->label.name);
! 1503: dip->un.v.num_channels = 1;
! 1504: strlcpy(dip->un.v.units.name, AudioNbass, sizeof dip->un.v.units.name);
! 1505: break;
! 1506:
! 1507: case PSS_OUTPUT_CLASS: /* output class descriptor */
! 1508: dip->type = AUDIO_MIXER_CLASS;
! 1509: dip->mixer_class = PSS_OUTPUT_CLASS;
! 1510: dip->next = dip->prev = AUDIO_MIXER_LAST;
! 1511: strlcpy(dip->label.name, AudioCoutputs, sizeof dip->label.name);
! 1512: break;
! 1513:
! 1514: case PSS_INPUT_CLASS: /* input class descriptor */
! 1515: dip->type = AUDIO_MIXER_CLASS;
! 1516: dip->mixer_class = PSS_INPUT_CLASS;
! 1517: dip->next = dip->prev = AUDIO_MIXER_LAST;
! 1518: strlcpy(dip->label.name, AudioCinputs, sizeof dip->label.name);
! 1519: break;
! 1520:
! 1521: case PSS_MONITOR_CLASS: /* monitor class descriptor */
! 1522: dip->type = AUDIO_MIXER_CLASS;
! 1523: dip->mixer_class = PSS_MONITOR_CLASS;
! 1524: dip->next = dip->prev = AUDIO_MIXER_LAST;
! 1525: strlcpy(dip->label.name, AudioCmonitor, sizeof dip->label.name);
! 1526: break;
! 1527:
! 1528: case PSS_RECORD_CLASS: /* record source class */
! 1529: dip->type = AUDIO_MIXER_CLASS;
! 1530: dip->mixer_class = PSS_RECORD_CLASS;
! 1531: dip->next = dip->prev = AUDIO_MIXER_LAST;
! 1532: strlcpy(dip->label.name, AudioCrecord, sizeof dip->label.name);
! 1533: break;
! 1534:
! 1535: case PSS_MIC_IN_MUTE:
! 1536: dip->mixer_class = PSS_INPUT_CLASS;
! 1537: dip->type = AUDIO_MIXER_ENUM;
! 1538: dip->prev = PSS_MIC_IN_LVL;
! 1539: dip->next = AUDIO_MIXER_LAST;
! 1540: goto mute;
! 1541:
! 1542: case PSS_LINE_IN_MUTE:
! 1543: dip->mixer_class = PSS_INPUT_CLASS;
! 1544: dip->type = AUDIO_MIXER_ENUM;
! 1545: dip->prev = PSS_LINE_IN_LVL;
! 1546: dip->next = AUDIO_MIXER_LAST;
! 1547: goto mute;
! 1548:
! 1549: case PSS_DAC_MUTE:
! 1550: dip->mixer_class = PSS_INPUT_CLASS;
! 1551: dip->type = AUDIO_MIXER_ENUM;
! 1552: dip->prev = PSS_DAC_LVL;
! 1553: dip->next = AUDIO_MIXER_LAST;
! 1554: mute:
! 1555: strlcpy(dip->label.name, AudioNmute, sizeof dip->label.name);
! 1556: dip->un.e.num_mem = 2;
! 1557: strlcpy(dip->un.e.member[0].label.name, AudioNoff,
! 1558: sizeof dip->un.e.member[0].label.name);
! 1559: dip->un.e.member[0].ord = 0;
! 1560: strlcpy(dip->un.e.member[1].label.name, AudioNon,
! 1561: sizeof dip->un.e.member[1].label.name);
! 1562: dip->un.e.member[1].ord = 1;
! 1563: break;
! 1564:
! 1565: case PSS_OUTPUT_MODE:
! 1566: dip->mixer_class = PSS_OUTPUT_CLASS;
! 1567: dip->type = AUDIO_MIXER_ENUM;
! 1568: dip->prev = PSS_MASTER_VOL;
! 1569: dip->next = AUDIO_MIXER_LAST;
! 1570: strlcpy(dip->label.name, AudioNmode, sizeof dip->label.name);
! 1571: dip->un.e.num_mem = 4;
! 1572: strlcpy(dip->un.e.member[0].label.name, AudioNmono,
! 1573: sizeof dip->un.e.member[0].label.name);
! 1574: dip->un.e.member[0].ord = PSS_SPKR_MONO;
! 1575: strlcpy(dip->un.e.member[1].label.name, AudioNstereo,
! 1576: sizeof dip->un.e.member[1].label.name);
! 1577: dip->un.e.member[1].ord = PSS_SPKR_STEREO;
! 1578: strlcpy(dip->un.e.member[2].label.name, AudioNpseudo,
! 1579: sizeof dip->un.e.member[2].label.name);
! 1580: dip->un.e.member[2].ord = PSS_SPKR_PSEUDO;
! 1581: strlcpy(dip->un.e.member[3].label.name, AudioNspatial,
! 1582: sizeof dip->un.e.member[3].label.name);
! 1583: dip->un.e.member[3].ord = PSS_SPKR_SPATIAL;
! 1584: break;
! 1585:
! 1586: case PSS_RECORD_SOURCE:
! 1587: dip->mixer_class = PSS_RECORD_CLASS;
! 1588: dip->type = AUDIO_MIXER_ENUM;
! 1589: dip->prev = PSS_REC_LVL;
! 1590: dip->next = AUDIO_MIXER_LAST;
! 1591: strlcpy(dip->label.name, AudioNsource, sizeof dip->label.name);
! 1592: dip->un.e.num_mem = 3;
! 1593: strlcpy(dip->un.e.member[0].label.name, AudioNmicrophone,
! 1594: sizeof dip->un.e.member[0].label.name);
! 1595: dip->un.e.member[0].ord = PSS_MIC_IN_LVL;
! 1596: strlcpy(dip->un.e.member[1].label.name, AudioNcd,
! 1597: sizeof dip->un.e.member[1].label.name);
! 1598: dip->un.e.member[1].ord = PSS_LINE_IN_LVL;
! 1599: strlcpy(dip->un.e.member[2].label.name, AudioNdac,
! 1600: sizeof dip->un.e.member[2].label.name);
! 1601: dip->un.e.member[2].ord = PSS_DAC_LVL;
! 1602: break;
! 1603:
! 1604: default:
! 1605: return ENXIO;
! 1606: /*NOTREACHED*/
! 1607: }
! 1608: DPRINTF(("AUDIO_MIXER_DEVINFO: name=%s\n", dip->label.name));
! 1609:
! 1610: return 0;
! 1611: }
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to pss.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / isa