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