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