cs4231_sbus.c revision 1.10
1 /* $NetBSD: cs4231_sbus.c,v 1.10 1999/03/19 02:32:48 eeh Exp $ */ 2 3 /*- 4 * Copyright (c) 1998, 1999 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Paul Kranenburg. 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 * 3. All advertising materials mentioning features or use of this software 19 * must display the following acknowledgement: 20 * This product includes software developed by the NetBSD 21 * Foundation, Inc. and its contributors. 22 * 4. Neither the name of The NetBSD Foundation nor the names of its 23 * contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 27 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 28 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 29 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 30 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 31 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 32 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 33 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 34 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 35 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 36 * POSSIBILITY OF SUCH DAMAGE. 37 */ 38 39 #include "audio.h" 40 #if NAUDIO > 0 41 42 #include <sys/param.h> 43 #include <sys/systm.h> 44 #include <sys/errno.h> 45 #include <sys/device.h> 46 #include <sys/malloc.h> 47 48 #include <machine/autoconf.h> 49 #include <machine/cpu.h> 50 51 #include <sys/audioio.h> 52 #include <dev/audio_if.h> 53 54 #include <dev/ic/ad1848reg.h> 55 #include <dev/ic/cs4231reg.h> 56 #include <dev/ic/ad1848var.h> 57 58 #if 0 59 /* XXX- put these elsewhere */ 60 #define SUNAUDIO_MIC_PORT 0 61 #define SUNAUDIO_SPEAKER 1 62 #define SUNAUDIO_HEADPHONES 2 63 #define SUNAUDIO_MONITOR 3 64 #define SUNAUDIO_SOURCE 4 65 #define SUNAUDIO_OUTPUT 5 66 #define SUNAUDIO_INPUT_CLASS 6 67 #define SUNAUDIO_OUTPUT_CLASS 7 68 #define SUNAUDIO_RECORD_CLASS 8 69 #define SUNAUDIO_MONITOR_CLASS 9 70 #endif 71 72 /*---*/ 73 #define CSAUDIO_DAC_LVL 0 74 #define CSAUDIO_LINE_IN_LVL 1 75 #define CSAUDIO_MONO_LVL 2 76 #define CSAUDIO_CD_LVL 3 77 #define CSAUDIO_MONITOR_LVL 4 78 #define CSAUDIO_OUT_LVL 5 79 #define CSAUDIO_LINE_IN_MUTE 6 80 #define CSAUDIO_DAC_MUTE 7 81 #define CSAUDIO_CD_MUTE 8 82 #define CSAUDIO_MONO_MUTE 9 83 #define CSAUDIO_MONITOR_MUTE 10 84 #define CSAUDIO_REC_LVL 11 85 #define CSAUDIO_RECORD_SOURCE 12 86 87 #define CSAUDIO_INPUT_CLASS 13 88 #define CSAUDIO_OUTPUT_CLASS 14 89 #define CSAUDIO_RECORD_CLASS 15 90 #define CSAUDIO_MONITOR_CLASS 16 91 92 #define AUDIO_ROM_NAME "SUNW,CS4231" 93 94 #ifdef AUDIO_DEBUG 95 int cs4231debug = 0; 96 #define DPRINTF(x) if (cs4231debug) printf x 97 #else 98 #define DPRINTF(x) 99 #endif 100 101 /* 102 * Layout of 4231 registers. 103 * 104 struct cs4231_reg { 105 volatile u_int8_t iar; // Index Address Register 106 volatile u_int8_t pad0[3]; 107 volatile u_int8_t idr; // Data Register 108 volatile u_int8_t pad1[3]; 109 volatile u_int8_t status; // Status Register 110 volatile u_int8_t pad2[3]; 111 volatile u_int8_t piodr; // PIO Data Register I/O 112 volatile u_int8_t pad3[3]; 113 }; 114 */ 115 #define CS4231_REG_SIZE 16 116 117 118 /* 119 * APC DMA hardware; from SunOS header 120 * Thanks to Derrick J. Brashear for additional info on the 121 * meaning of some of these bits. 122 */ 123 struct apc_dma { 124 volatile u_int32_t dmacsr; /* APC CSR */ 125 volatile u_int32_t lpad[3]; /* */ 126 volatile u_int32_t dmacva; /* Capture Virtual Address */ 127 volatile u_int32_t dmacc; /* Capture Count */ 128 volatile u_int32_t dmacnva; /* Capture Next Virtual Address */ 129 volatile u_int32_t dmacnc; /* Capture next count */ 130 volatile u_int32_t dmapva; /* Playback Virtual Address */ 131 volatile u_int32_t dmapc; /* Playback Count */ 132 volatile u_int32_t dmapnva; /* Playback Next VAddress */ 133 volatile u_int32_t dmapnc; /* Playback Next Count */ 134 }; 135 136 /* 137 * APC CSR Register bit definitions 138 */ 139 #define APC_IP 0x00800000 /* Interrupt Pending */ 140 #define APC_PI 0x00400000 /* Playback interrupt */ 141 #define APC_CI 0x00200000 /* Capture interrupt */ 142 #define APC_EI 0x00100000 /* General interrupt */ 143 #define APC_IE 0x00080000 /* General ext int. enable */ 144 #define APC_PIE 0x00040000 /* Playback ext intr */ 145 #define APC_CIE 0x00020000 /* Capture ext intr */ 146 #define APC_EIE 0x00010000 /* Error ext intr */ 147 #define APC_PMI 0x00008000 /* Pipe empty interrupt */ 148 #define APC_PM 0x00004000 /* Play pipe empty */ 149 #define APC_PD 0x00002000 /* Playback NVA dirty */ 150 #define APC_PMIE 0x00001000 /* play pipe empty Int enable */ 151 #define APC_CM 0x00000800 /* Cap data dropped on floor */ 152 #define APC_CD 0x00000400 /* Capture NVA dirty */ 153 #define APC_CMI 0x00000200 /* Capture pipe empty interrupt */ 154 #define APC_CMIE 0x00000100 /* Cap. pipe empty int enable */ 155 #define APC_PPAUSE 0x00000080 /* Pause the play DMA */ 156 #define APC_CPAUSE 0x00000040 /* Pause the capture DMA */ 157 #define APC_CODEC_PDN 0x00000020 /* CODEC RESET */ 158 #define PDMA_GO 0x00000008 159 #define CDMA_GO 0x00000004 /* bit 2 of the csr */ 160 #define APC_RESET 0x00000001 /* Reset the chip */ 161 162 #define APC_BITS \ 163 "\20\30IP\27PI\26CI\25EI\24IE" \ 164 "\23PIE\22CIE\21EIE\20PMI\17PM\16PD\15PMIE" \ 165 "\14CM\13CD\12CMI\11CMIE\10PPAUSE\7CPAUSE\6PDN\4PGO\3CGO" 166 167 /* 168 * To start DMA, you write to dma[cp]nva and dma[cp]nc and set [CP]DMA_GO 169 * in dmacsr. dma[cp]va and dma[cp]c, when read, appear to be the live 170 * counter as the DMA operation progresses. 171 * Supposedly, you get an interrupt with the "dirty" bits (APC_PD,APC_CD) 172 * set, when the next DMA buffer can be programmed, while the current one 173 * is still in progress. We don't currently use this feature, since I 174 * haven't been able to make it work.. instead the next buffer goes in 175 * as soon as we see a "pipe empty" (APC_PM) interrupt. 176 */ 177 178 /* It's not clear if there's a maximum DMA size.. */ 179 #define APC_MAX (sc->sc_blksz)/*(16*1024)*/ 180 181 /* 182 * List of device memory allocations (see cs4231_malloc/cs4231_free). 183 */ 184 struct cs_dma { 185 struct cs_dma *next; 186 caddr_t addr; 187 bus_dma_segment_t segs[1]; 188 int nsegs; 189 size_t size; 190 }; 191 192 193 /* 194 * Software state, per CS4231 audio chip. 195 */ 196 struct cs4231_softc { 197 struct ad1848_softc sc_ad1848; /* base device */ 198 struct sbusdev sc_sd; /* sbus device */ 199 bus_space_tag_t sc_bustag; 200 bus_dma_tag_t sc_dmatag; 201 struct evcnt sc_intrcnt; /* statistics */ 202 203 struct cs_dma *sc_dmas; 204 struct cs_dma *sc_nowplaying; /*XXX*/ 205 u_long sc_playsegsz; /*XXX*/ 206 u_long sc_playcnt; 207 u_long sc_blksz; 208 209 int sc_open; /* single use device */ 210 int sc_locked; /* true when transfering data */ 211 struct apc_dma *sc_dmareg; /* DMA registers */ 212 213 /* interfacing with the interrupt handlers */ 214 void (*sc_rintr)(void*); /* input completion intr handler */ 215 void *sc_rarg; /* arg for sc_rintr() */ 216 void (*sc_pintr)(void*); /* output completion intr handler */ 217 void *sc_parg; /* arg for sc_pintr() */ 218 }; 219 220 /* autoconfiguration driver */ 221 void cs4231attach __P((struct device *, struct device *, void *)); 222 int cs4231match __P((struct device *, struct cfdata *, void *)); 223 224 struct cfattach audiocs_ca = { 225 sizeof(struct cs4231_softc), cs4231match, cs4231attach 226 }; 227 228 struct audio_device cs4231_device = { 229 "cs4231", 230 "x", 231 "audio" 232 }; 233 234 235 /* 236 * Define our interface to the higher level audio driver. 237 */ 238 int cs4231_open __P((void *, int)); 239 void cs4231_close __P((void *)); 240 size_t cs4231_round_buffersize __P((void *, int, size_t)); 241 int cs4231_round_blocksize __P((void *, int)); 242 int cs4231_halt_output __P((void *)); 243 int cs4231_halt_input __P((void *)); 244 int cs4231_getdev __P((void *, struct audio_device *)); 245 int cs4231_set_port __P((void *, mixer_ctrl_t *)); 246 int cs4231_get_port __P((void *, mixer_ctrl_t *)); 247 int cs4231_query_devinfo __P((void *, mixer_devinfo_t *)); 248 int cs4231_get_props __P((void *)); 249 250 void *cs4231_malloc __P((void *, int, size_t, int, int)); 251 void cs4231_free __P((void *, void *, int)); 252 int cs4231_trigger_output __P((void *, void *, void *, int, 253 void (*)(void *), void *, 254 struct audio_params *)); 255 int cs4231_trigger_input __P((void *, void *, void *, int, 256 void (*)(void *), void *, 257 struct audio_params *)); 258 259 int cs4231_intr __P((void *)); 260 void cs4231_init __P((struct cs4231_softc *)); 261 262 #ifdef AUDIO_DEBUG 263 static void cs4231_regdump __P((char *, struct cs4231_softc *)); 264 #endif 265 266 static int cs_read __P((struct ad1848_softc *, int)); 267 static void cs_write __P((struct ad1848_softc *, int, int)); 268 269 static int 270 cs_read(sc, index) 271 struct ad1848_softc *sc; 272 int index; 273 { 274 return bus_space_read_1(sc->sc_iot, sc->sc_ioh, (index << 2)); 275 } 276 277 static void 278 cs_write(sc, index, value) 279 struct ad1848_softc *sc; 280 int index, value; 281 { 282 bus_space_write_1(sc->sc_iot, sc->sc_ioh, (index << 2), value); 283 } 284 285 static struct audio_hw_if hw_if = { 286 cs4231_open, 287 cs4231_close, 288 0, 289 ad1848_query_encoding, 290 ad1848_set_params, 291 cs4231_round_blocksize, 292 ad1848_commit_settings, 293 0, 294 0, 295 NULL, 296 NULL, 297 cs4231_halt_output, 298 cs4231_halt_input, 299 0, 300 cs4231_getdev, 301 0, 302 cs4231_set_port, 303 cs4231_get_port, 304 cs4231_query_devinfo, 305 cs4231_malloc, 306 cs4231_free, 307 cs4231_round_buffersize, 308 0, 309 cs4231_get_props, 310 cs4231_trigger_output, 311 cs4231_trigger_input 312 }; 313 314 /* autoconfig routines */ 315 316 int 317 cs4231match(parent, cf, aux) 318 struct device *parent; 319 struct cfdata *cf; 320 void *aux; 321 { 322 struct sbus_attach_args *sa = aux; 323 324 return (strcmp(AUDIO_ROM_NAME, sa->sa_name) == 0); 325 } 326 327 /* 328 * Audio chip found. 329 */ 330 void 331 cs4231attach(parent, self, aux) 332 struct device *parent, *self; 333 void *aux; 334 { 335 struct cs4231_softc *sc = (struct cs4231_softc *)self; 336 struct sbus_attach_args *sa = aux; 337 bus_space_handle_t bh; 338 339 sc->sc_bustag = sa->sa_bustag; 340 sc->sc_dmatag = sa->sa_dmatag; 341 342 sc->sc_ad1848.parent = sc; 343 sc->sc_ad1848.sc_iot = sc->sc_bustag; 344 sc->sc_ad1848.sc_readreg = cs_read; 345 sc->sc_ad1848.sc_writereg = cs_write; 346 347 /* 348 * Map my registers in, if they aren't already in virtual 349 * address space. 350 */ 351 if (sa->sa_npromvaddrs) { 352 bh = (bus_space_handle_t)sa->sa_promvaddrs[0]; 353 } else { 354 if (sbus_bus_map(sa->sa_bustag, sa->sa_slot, 355 sa->sa_offset, 356 sa->sa_size, 357 BUS_SPACE_MAP_LINEAR, 358 0, &bh) != 0) { 359 printf("%s @ sbus: cannot map registers\n", 360 self->dv_xname); 361 return; 362 } 363 } 364 365 sc->sc_ad1848.sc_ioh = bh; 366 sc->sc_dmareg = (struct apc_dma *)(bh + CS4231_REG_SIZE); 367 368 cs4231_init(sc); 369 370 /* Put ad1848 driver in `MODE 2' mode */ 371 sc->sc_ad1848.mode = 2; 372 ad1848_attach(&sc->sc_ad1848); 373 374 printf("\n"); 375 376 sbus_establish(&sc->sc_sd, &sc->sc_ad1848.sc_dev); 377 378 /* Establish interrupt channel */ 379 bus_intr_establish(sa->sa_bustag, 380 sa->sa_pri, 0, 381 cs4231_intr, sc); 382 383 evcnt_attach(&sc->sc_ad1848.sc_dev, "intr", &sc->sc_intrcnt); 384 audio_attach_mi(&hw_if, sc, &sc->sc_ad1848.sc_dev); 385 } 386 387 388 #ifdef AUDIO_DEBUG 389 static void 390 cs4231_regdump(label, sc) 391 char *label; 392 struct cs4231_softc *sc; 393 { 394 char bits[128]; 395 volatile struct apc_dma *dma = sc->sc_dmareg; 396 397 printf("cs4231regdump(%s): regs:", label); 398 printf("dmapva: 0x%x; ", dma->dmapva); 399 printf("dmapc: 0x%x; ", dma->dmapc); 400 printf("dmapnva: 0x%x; ", dma->dmapnva); 401 printf("dmapnc: 0x%x\n", dma->dmapnc); 402 printf("dmacva: 0x%x; ", dma->dmacva); 403 printf("dmacc: 0x%x; ", dma->dmacc); 404 printf("dmacnva: 0x%x; ", dma->dmacnva); 405 printf("dmacnc: 0x%x\n", dma->dmacnc); 406 407 printf("apc_dmacsr=%s\n", 408 bitmask_snprintf(dma->dmacsr, APC_BITS, bits, sizeof(bits)) ); 409 410 ad1848_dump_regs(&sc->sc_ad1848); 411 } 412 #endif 413 414 void 415 cs4231_init(sc) 416 register struct cs4231_softc *sc; 417 { 418 char *buf; 419 #if 0 420 volatile struct apc_dma *dma = sc->sc_dmareg; 421 #endif 422 int reg; 423 424 #if 0 425 dma->dmacsr = APC_CODEC_PDN; 426 delay(20); 427 dma->dmacsr &= ~APC_CODEC_PDN; 428 #endif 429 /* First, put chip in native mode */ 430 reg = ad_read(&sc->sc_ad1848, SP_MISC_INFO); 431 ad_write(&sc->sc_ad1848, SP_MISC_INFO, reg | MODE2); 432 433 /* Read version numbers from I25 */ 434 reg = ad_read(&sc->sc_ad1848, CS_VERSION_ID); 435 switch (reg & (CS_VERSION_NUMBER | CS_VERSION_CHIPID)) { 436 case 0xa0: 437 sc->sc_ad1848.chip_name = "CS4231A"; 438 break; 439 case 0x80: 440 sc->sc_ad1848.chip_name = "CS4231"; 441 break; 442 case 0x82: 443 sc->sc_ad1848.chip_name = "CS4232"; 444 break; 445 default: 446 if ((buf = malloc(32, M_TEMP, M_NOWAIT)) != NULL) { 447 sprintf(buf, "unknown rev: %x/%x", reg&0xe, reg&7); 448 sc->sc_ad1848.chip_name = buf; 449 } 450 } 451 } 452 453 void * 454 cs4231_malloc(addr, direction, size, pool, flags) 455 void *addr; 456 int direction; 457 size_t size; 458 int pool, flags; 459 { 460 struct cs4231_softc *sc = addr; 461 struct cs_dma *p; 462 int error; 463 464 p = malloc(sizeof(*p), pool, flags); 465 if (p == NULL) 466 return (NULL); 467 468 p->size = size; 469 error = bus_dmamem_alloc(sc->sc_dmatag, size, 64*1024, 0, 470 p->segs, sizeof(p->segs)/sizeof(p->segs[0]), 471 &p->nsegs, BUS_DMA_NOWAIT); 472 if (error) { 473 free(p, pool); 474 return (NULL); 475 } 476 477 error = bus_dmamem_map(sc->sc_dmatag, p->segs, p->nsegs, p->size, 478 &p->addr, BUS_DMA_NOWAIT|BUS_DMA_COHERENT); 479 if (error) { 480 bus_dmamem_free(sc->sc_dmatag, p->segs, p->nsegs); 481 free(p, pool); 482 return (NULL); 483 } 484 485 p->next = sc->sc_dmas; 486 sc->sc_dmas = p; 487 return (p->addr); 488 } 489 490 void 491 cs4231_free(addr, ptr, pool) 492 void *addr; 493 void *ptr; 494 int pool; 495 { 496 struct cs4231_softc *sc = addr; 497 struct cs_dma *p, **pp; 498 499 for (pp = &sc->sc_dmas; (p = *pp) != NULL; pp = &(*pp)->next) { 500 if (p->addr != ptr) 501 continue; 502 bus_dmamem_unmap(sc->sc_dmatag, p->addr, p->size); 503 bus_dmamem_free(sc->sc_dmatag, p->segs, p->nsegs); 504 *pp = p->next; 505 free(p, pool); 506 return; 507 } 508 printf("cs4231_free: rogue pointer\n"); 509 } 510 511 int 512 cs4231_open(addr, flags) 513 void *addr; 514 int flags; 515 { 516 struct cs4231_softc *sc = addr; 517 #if 0 518 struct apc_dma *dma = sc->sc_dmareg; 519 #endif 520 521 DPRINTF(("sa_open: unit %p\n", sc)); 522 523 if (sc->sc_open) 524 return (EBUSY); 525 sc->sc_open = 1; 526 sc->sc_locked = 0; 527 sc->sc_rintr = 0; 528 sc->sc_rarg = 0; 529 sc->sc_pintr = 0; 530 sc->sc_parg = 0; 531 #if 1 532 /*No interrupts from ad1848 */ 533 ad_write(&sc->sc_ad1848, SP_PIN_CONTROL, 0); 534 #endif 535 #if 0 536 dma->dmacsr = APC_RESET; 537 delay(10); 538 dma->dmacsr = 0; 539 delay(10); 540 ad1848_reset(&sc->sc_ad1848); 541 #endif 542 543 DPRINTF(("saopen: ok -> sc=%p\n", sc)); 544 return (0); 545 } 546 547 void 548 cs4231_close(addr) 549 void *addr; 550 { 551 register struct cs4231_softc *sc = addr; 552 553 DPRINTF(("sa_close: sc=%p\n", sc)); 554 /* 555 * halt i/o, clear open flag, and done. 556 */ 557 cs4231_halt_input(sc); 558 cs4231_halt_output(sc); 559 sc->sc_open = 0; 560 561 DPRINTF(("sa_close: closed.\n")); 562 } 563 564 size_t 565 cs4231_round_buffersize(addr, direction, size) 566 void *addr; 567 int direction; 568 size_t size; 569 { 570 #if 0 571 if (size > APC_MAX) 572 size = APC_MAX; 573 #endif 574 return (size); 575 } 576 577 int 578 cs4231_round_blocksize(addr, blk) 579 void *addr; 580 int blk; 581 { 582 return (blk & -4); 583 } 584 585 int 586 cs4231_getdev(addr, retp) 587 void *addr; 588 struct audio_device *retp; 589 { 590 *retp = cs4231_device; 591 return (0); 592 } 593 594 static ad1848_devmap_t csmapping[] = { 595 { CSAUDIO_DAC_LVL, AD1848_KIND_LVL, AD1848_AUX1_CHANNEL }, 596 { CSAUDIO_LINE_IN_LVL, AD1848_KIND_LVL, AD1848_LINE_CHANNEL }, 597 { CSAUDIO_MONO_LVL, AD1848_KIND_LVL, AD1848_MONO_CHANNEL }, 598 { CSAUDIO_CD_LVL, AD1848_KIND_LVL, AD1848_AUX2_CHANNEL }, 599 { CSAUDIO_MONITOR_LVL, AD1848_KIND_LVL, AD1848_MONITOR_CHANNEL }, 600 { CSAUDIO_OUT_LVL, AD1848_KIND_LVL, AD1848_DAC_CHANNEL }, 601 { CSAUDIO_DAC_MUTE, AD1848_KIND_MUTE, AD1848_AUX1_CHANNEL }, 602 { CSAUDIO_LINE_IN_MUTE, AD1848_KIND_MUTE, AD1848_LINE_CHANNEL }, 603 { CSAUDIO_MONO_MUTE, AD1848_KIND_MUTE, AD1848_MONO_CHANNEL }, 604 { CSAUDIO_CD_MUTE, AD1848_KIND_MUTE, AD1848_AUX2_CHANNEL }, 605 { CSAUDIO_MONITOR_MUTE, AD1848_KIND_MUTE, AD1848_MONITOR_CHANNEL }, 606 { CSAUDIO_REC_LVL, AD1848_KIND_RECORDGAIN, -1 }, 607 { CSAUDIO_RECORD_SOURCE, AD1848_KIND_RECORDSOURCE, -1 } 608 }; 609 610 static int nummap = sizeof(csmapping) / sizeof(csmapping[0]); 611 612 613 int 614 cs4231_set_port(addr, cp) 615 void *addr; 616 mixer_ctrl_t *cp; 617 { 618 struct ad1848_softc *ac = addr; 619 620 DPRINTF(("cs4231_set_port: port=%d", cp->dev)); 621 return (ad1848_mixer_set_port(ac, csmapping, nummap, cp)); 622 } 623 624 int 625 cs4231_get_port(addr, cp) 626 void *addr; 627 mixer_ctrl_t *cp; 628 { 629 struct ad1848_softc *ac = addr; 630 631 DPRINTF(("cs4231_get_port: port=%d", cp->dev)); 632 return (ad1848_mixer_get_port(ac, csmapping, nummap, cp)); 633 } 634 635 int 636 cs4231_get_props(addr) 637 void *addr; 638 { 639 return (AUDIO_PROP_FULLDUPLEX); 640 } 641 642 int 643 cs4231_query_devinfo(addr, dip) 644 void *addr; 645 register mixer_devinfo_t *dip; 646 { 647 648 switch(dip->index) { 649 #if 0 650 case CSAUDIO_MIC_IN_LVL: /* Microphone */ 651 dip->type = AUDIO_MIXER_VALUE; 652 dip->mixer_class = CSAUDIO_INPUT_CLASS; 653 dip->prev = AUDIO_MIXER_LAST; 654 dip->next = CSAUDIO_MIC_IN_MUTE; 655 strcpy(dip->label.name, AudioNmicrophone); 656 dip->un.v.num_channels = 2; 657 strcpy(dip->un.v.units.name, AudioNvolume); 658 break; 659 #endif 660 661 case CSAUDIO_MONO_LVL: /* mono/microphone mixer */ 662 dip->type = AUDIO_MIXER_VALUE; 663 dip->mixer_class = CSAUDIO_INPUT_CLASS; 664 dip->prev = AUDIO_MIXER_LAST; 665 dip->next = CSAUDIO_MONO_MUTE; 666 strcpy(dip->label.name, AudioNmicrophone); 667 dip->un.v.num_channels = 1; 668 strcpy(dip->un.v.units.name, AudioNvolume); 669 break; 670 671 case CSAUDIO_DAC_LVL: /* dacout */ 672 dip->type = AUDIO_MIXER_VALUE; 673 dip->mixer_class = CSAUDIO_INPUT_CLASS; 674 dip->prev = AUDIO_MIXER_LAST; 675 dip->next = CSAUDIO_DAC_MUTE; 676 strcpy(dip->label.name, AudioNdac); 677 dip->un.v.num_channels = 2; 678 strcpy(dip->un.v.units.name, AudioNvolume); 679 break; 680 681 case CSAUDIO_LINE_IN_LVL: /* line */ 682 dip->type = AUDIO_MIXER_VALUE; 683 dip->mixer_class = CSAUDIO_INPUT_CLASS; 684 dip->prev = AUDIO_MIXER_LAST; 685 dip->next = CSAUDIO_LINE_IN_MUTE; 686 strcpy(dip->label.name, AudioNline); 687 dip->un.v.num_channels = 2; 688 strcpy(dip->un.v.units.name, AudioNvolume); 689 break; 690 691 case CSAUDIO_CD_LVL: /* cd */ 692 dip->type = AUDIO_MIXER_VALUE; 693 dip->mixer_class = CSAUDIO_INPUT_CLASS; 694 dip->prev = AUDIO_MIXER_LAST; 695 dip->next = CSAUDIO_CD_MUTE; 696 strcpy(dip->label.name, AudioNcd); 697 dip->un.v.num_channels = 2; 698 strcpy(dip->un.v.units.name, AudioNvolume); 699 break; 700 701 702 case CSAUDIO_MONITOR_LVL: /* monitor level */ 703 dip->type = AUDIO_MIXER_VALUE; 704 dip->mixer_class = CSAUDIO_MONITOR_CLASS; 705 dip->next = CSAUDIO_MONITOR_MUTE; 706 dip->prev = AUDIO_MIXER_LAST; 707 strcpy(dip->label.name, AudioNmonitor); 708 dip->un.v.num_channels = 1; 709 strcpy(dip->un.v.units.name, AudioNvolume); 710 break; 711 712 case CSAUDIO_OUT_LVL: /* cs4231 output volume: not useful? */ 713 dip->type = AUDIO_MIXER_VALUE; 714 dip->mixer_class = CSAUDIO_MONITOR_CLASS; 715 dip->prev = dip->next = AUDIO_MIXER_LAST; 716 strcpy(dip->label.name, AudioNoutput); 717 dip->un.v.num_channels = 2; 718 strcpy(dip->un.v.units.name, AudioNvolume); 719 break; 720 721 case CSAUDIO_LINE_IN_MUTE: 722 dip->mixer_class = CSAUDIO_INPUT_CLASS; 723 dip->type = AUDIO_MIXER_ENUM; 724 dip->prev = CSAUDIO_LINE_IN_LVL; 725 dip->next = AUDIO_MIXER_LAST; 726 goto mute; 727 728 case CSAUDIO_DAC_MUTE: 729 dip->mixer_class = CSAUDIO_INPUT_CLASS; 730 dip->type = AUDIO_MIXER_ENUM; 731 dip->prev = CSAUDIO_DAC_LVL; 732 dip->next = AUDIO_MIXER_LAST; 733 goto mute; 734 735 case CSAUDIO_CD_MUTE: 736 dip->mixer_class = CSAUDIO_INPUT_CLASS; 737 dip->type = AUDIO_MIXER_ENUM; 738 dip->prev = CSAUDIO_CD_LVL; 739 dip->next = AUDIO_MIXER_LAST; 740 goto mute; 741 742 case CSAUDIO_MONO_MUTE: 743 dip->mixer_class = CSAUDIO_INPUT_CLASS; 744 dip->type = AUDIO_MIXER_ENUM; 745 dip->prev = CSAUDIO_MONO_LVL; 746 dip->next = AUDIO_MIXER_LAST; 747 goto mute; 748 749 case CSAUDIO_MONITOR_MUTE: 750 dip->mixer_class = CSAUDIO_OUTPUT_CLASS; 751 dip->type = AUDIO_MIXER_ENUM; 752 dip->prev = CSAUDIO_MONITOR_LVL; 753 dip->next = AUDIO_MIXER_LAST; 754 mute: 755 strcpy(dip->label.name, AudioNmute); 756 dip->un.e.num_mem = 2; 757 strcpy(dip->un.e.member[0].label.name, AudioNoff); 758 dip->un.e.member[0].ord = 0; 759 strcpy(dip->un.e.member[1].label.name, AudioNon); 760 dip->un.e.member[1].ord = 1; 761 break; 762 763 case CSAUDIO_REC_LVL: /* record level */ 764 dip->type = AUDIO_MIXER_VALUE; 765 dip->mixer_class = CSAUDIO_RECORD_CLASS; 766 dip->prev = AUDIO_MIXER_LAST; 767 dip->next = CSAUDIO_RECORD_SOURCE; 768 strcpy(dip->label.name, AudioNrecord); 769 dip->un.v.num_channels = 2; 770 strcpy(dip->un.v.units.name, AudioNvolume); 771 break; 772 773 case CSAUDIO_RECORD_SOURCE: 774 dip->mixer_class = CSAUDIO_RECORD_CLASS; 775 dip->type = AUDIO_MIXER_ENUM; 776 dip->prev = CSAUDIO_REC_LVL; 777 dip->next = AUDIO_MIXER_LAST; 778 strcpy(dip->label.name, AudioNsource); 779 dip->un.e.num_mem = 4; 780 strcpy(dip->un.e.member[0].label.name, AudioNoutput); 781 dip->un.e.member[0].ord = DAC_IN_PORT; 782 strcpy(dip->un.e.member[1].label.name, AudioNmicrophone); 783 dip->un.e.member[1].ord = MIC_IN_PORT; 784 strcpy(dip->un.e.member[2].label.name, AudioNdac); 785 dip->un.e.member[2].ord = AUX1_IN_PORT; 786 strcpy(dip->un.e.member[3].label.name, AudioNline); 787 dip->un.e.member[3].ord = LINE_IN_PORT; 788 break; 789 790 case CSAUDIO_INPUT_CLASS: /* input class descriptor */ 791 dip->type = AUDIO_MIXER_CLASS; 792 dip->mixer_class = CSAUDIO_INPUT_CLASS; 793 dip->next = dip->prev = AUDIO_MIXER_LAST; 794 strcpy(dip->label.name, AudioCinputs); 795 break; 796 797 case CSAUDIO_OUTPUT_CLASS: /* output class descriptor */ 798 dip->type = AUDIO_MIXER_CLASS; 799 dip->mixer_class = CSAUDIO_OUTPUT_CLASS; 800 dip->next = dip->prev = AUDIO_MIXER_LAST; 801 strcpy(dip->label.name, AudioCoutputs); 802 break; 803 804 case CSAUDIO_MONITOR_CLASS: /* monitor class descriptor */ 805 dip->type = AUDIO_MIXER_CLASS; 806 dip->mixer_class = CSAUDIO_MONITOR_CLASS; 807 dip->next = dip->prev = AUDIO_MIXER_LAST; 808 strcpy(dip->label.name, AudioCmonitor); 809 break; 810 811 case CSAUDIO_RECORD_CLASS: /* record source class */ 812 dip->type = AUDIO_MIXER_CLASS; 813 dip->mixer_class = CSAUDIO_RECORD_CLASS; 814 dip->next = dip->prev = AUDIO_MIXER_LAST; 815 strcpy(dip->label.name, AudioCrecord); 816 break; 817 818 default: 819 return ENXIO; 820 /*NOTREACHED*/ 821 } 822 DPRINTF(("AUDIO_MIXER_DEVINFO: name=%s\n", dip->label.name)); 823 824 return (0); 825 } 826 827 828 int 829 cs4231_trigger_output(addr, start, end, blksize, intr, arg, param) 830 void *addr; 831 void *start, *end; 832 int blksize; 833 void (*intr) __P((void *)); 834 void *arg; 835 struct audio_params *param; 836 { 837 struct cs4231_softc *sc = addr; 838 struct cs_dma *p; 839 volatile struct apc_dma *dma = sc->sc_dmareg; 840 int csr; 841 vsize_t n; 842 843 if (sc->sc_locked != 0) { 844 printf("cs4231_trigger_output: already running\n"); 845 return (EINVAL); 846 } 847 848 sc->sc_locked = 1; 849 sc->sc_pintr = intr; 850 sc->sc_parg = arg; 851 852 for (p = sc->sc_dmas; p != NULL && p->addr != start; p = p->next) 853 /*void*/; 854 if (p == NULL) { 855 printf("cs4231_trigger_output: bad addr %p\n", start); 856 return (EINVAL); 857 } 858 859 n = (char *)end - (char *)start; 860 861 /* XXX 862 * Do only `blksize' at a time, so audio_pint() is kept 863 * synchronous with us... 864 */ 865 /*XXX*/sc->sc_blksz = blksize; 866 /*XXX*/sc->sc_nowplaying = p; 867 /*XXX*/sc->sc_playsegsz = n; 868 869 if (n > APC_MAX) 870 n = APC_MAX; 871 872 sc->sc_playcnt = n; 873 874 DPRINTF(("trigger_out: start %p, end %p, size %lu; " 875 "dmaaddr 0x%lx, dmacnt %lu, segsize %lu\n", 876 start, end, (u_long)sc->sc_playsegsz, 877 (u_long)p->segs[0].ds_addr, 878 (u_long)n, (u_long)p->size)); 879 880 csr = dma->dmacsr; 881 dma->dmapnva = (u_long)p->segs[0].ds_addr; 882 dma->dmapnc = (u_long)n; 883 if ((csr & PDMA_GO) == 0 || (csr & APC_PPAUSE) != 0) { 884 int reg; 885 886 dma->dmacsr &= ~(APC_PIE|APC_PPAUSE); 887 dma->dmacsr |= APC_EI|APC_IE|APC_PIE|APC_EIE|APC_PMIE|PDMA_GO; 888 889 /* Start chip */ 890 891 /* Probably should just ignore this.. */ 892 ad_write(&sc->sc_ad1848, SP_LOWER_BASE_COUNT, 0xff); 893 ad_write(&sc->sc_ad1848, SP_UPPER_BASE_COUNT, 0xff); 894 895 reg = ad_read(&sc->sc_ad1848, SP_INTERFACE_CONFIG); 896 ad_write(&sc->sc_ad1848, SP_INTERFACE_CONFIG, 897 (PLAYBACK_ENABLE|reg)); 898 } 899 900 return (0); 901 } 902 903 int 904 cs4231_trigger_input(addr, start, end, blksize, intr, arg, param) 905 void *addr; 906 void *start, *end; 907 int blksize; 908 void (*intr) __P((void *)); 909 void *arg; 910 struct audio_params *param; 911 { 912 return (ENXIO); 913 } 914 915 int 916 cs4231_halt_output(addr) 917 void *addr; 918 { 919 struct cs4231_softc *sc = addr; 920 volatile struct apc_dma *dma = sc->sc_dmareg; 921 int reg; 922 923 dma->dmacsr &= ~(APC_EI | APC_IE | APC_PIE | APC_EIE | PDMA_GO | APC_PMIE); 924 reg = ad_read(&sc->sc_ad1848, SP_INTERFACE_CONFIG); 925 ad_write(&sc->sc_ad1848, SP_INTERFACE_CONFIG, (reg & ~PLAYBACK_ENABLE)); 926 sc->sc_locked = 0; 927 928 return (0); 929 } 930 931 int 932 cs4231_halt_input(addr) 933 void *addr; 934 { 935 struct cs4231_softc *sc = addr; 936 int reg; 937 938 reg = ad_read(&sc->sc_ad1848, SP_INTERFACE_CONFIG); 939 ad_write(&sc->sc_ad1848, SP_INTERFACE_CONFIG, (reg & ~CAPTURE_ENABLE)); 940 sc->sc_locked = 0; 941 942 return (0); 943 } 944 945 946 int 947 cs4231_intr(arg) 948 void *arg; 949 { 950 struct cs4231_softc *sc = arg; 951 volatile struct apc_dma *dma = sc->sc_dmareg; 952 struct cs_dma *p; 953 int ret = 0; 954 int csr; 955 int reg, status; 956 #if defined(DEBUG) || defined(AUDIO_DEBUG) 957 char bits[128]; 958 #endif 959 960 #ifdef AUDIO_DEBUG 961 if (cs4231debug > 1) 962 cs4231_regdump("audiointr", sc); 963 #endif 964 965 /* Read DMA status */ 966 csr = dma->dmacsr; 967 DPRINTF(( 968 "intr: csr=%s; dmapva=0x%lx,dmapc=%lu;dmapnva=0x%lx,dmapnc=%lu\n", 969 bitmask_snprintf(csr, APC_BITS, bits, sizeof(bits)), 970 (u_long)dma->dmapva, (u_long)dma->dmapc, 971 (u_long)dma->dmapnva, (u_long)dma->dmapnc)); 972 973 status = ADREAD(&sc->sc_ad1848, AD1848_STATUS); 974 DPRINTF(("%s: status: %s\n", sc->sc_ad1848.sc_dev.dv_xname, 975 bitmask_snprintf(status, AD_R2_BITS, bits, sizeof(bits)))); 976 if (status & (INTERRUPT_STATUS | SAMPLE_ERROR)) { 977 reg = ad_read(&sc->sc_ad1848, CS_IRQ_STATUS); 978 DPRINTF(("%s: i24: %s\n", sc->sc_ad1848.sc_dev.dv_xname, 979 bitmask_snprintf(reg, CS_I24_BITS, bits, sizeof(bits)))); 980 981 if (reg & CS_IRQ_PI) { 982 ad_write(&sc->sc_ad1848, SP_LOWER_BASE_COUNT, 0xff); 983 ad_write(&sc->sc_ad1848, SP_UPPER_BASE_COUNT, 0xff); 984 } 985 /* Clear interrupt bit */ 986 ADWRITE(&sc->sc_ad1848, AD1848_STATUS, 0); 987 } 988 989 /* Write back DMA status (clears interrupt) */ 990 dma->dmacsr = csr; 991 992 /* 993 * Simplistic.. if "play emtpy" is set advance to next chunk. 994 */ 995 #if 1 996 /* Ack all play interrupts*/ 997 if ((csr & (APC_PI|APC_PD|APC_PIE|APC_PMI)) != 0) 998 ret = 1; 999 #endif 1000 if (csr & APC_PM) { 1001 u_long nextaddr, togo; 1002 1003 p = sc->sc_nowplaying; 1004 1005 togo = sc->sc_playsegsz - sc->sc_playcnt; 1006 if (togo == 0) { 1007 /* Roll over */ 1008 nextaddr = (u_long)p->segs[0].ds_addr; 1009 sc->sc_playcnt = togo = APC_MAX; 1010 } else { 1011 nextaddr = dma->dmapnva + APC_MAX; 1012 if (togo > APC_MAX) 1013 togo = APC_MAX; 1014 sc->sc_playcnt += togo; 1015 } 1016 1017 dma->dmapnva = nextaddr; 1018 dma->dmapnc = togo; 1019 1020 if (sc->sc_pintr != NULL) 1021 (*sc->sc_pintr)(sc->sc_parg); 1022 1023 ret = 1; 1024 } 1025 1026 if (csr & APC_CI) { 1027 if (sc->sc_rintr != NULL) { 1028 ret = 1; 1029 (*sc->sc_rintr)(sc->sc_rarg); 1030 } 1031 } 1032 1033 #ifdef DEBUG 1034 if (ret == 0) { 1035 printf( 1036 "oops: csr=%s; dmapva=0x%lx,dmapc=%lu;dmapnva=0x%lx,dmapnc=%lu\n", 1037 bitmask_snprintf(csr, APC_BITS, bits, sizeof(bits)), 1038 (u_long)dma->dmapva, (u_long)dma->dmapc, 1039 (u_long)dma->dmapnva, (u_long)dma->dmapnc); 1040 ret = 1; 1041 } 1042 #endif 1043 1044 return (ret); 1045 } 1046 #endif /* NAUDIO > 0 */ 1047
Indexes created Wed Oct 01 19:09:53 GMT 2025