cs4231_sbus.c revision 1.8
1 /* $NetBSD: cs4231_sbus.c,v 1.8 1999/02/17 02:37:42 mycroft Exp $ */ 2 3 /*- 4 * Copyright (c) 1998 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 u_int8_t *p = (u_int8_t *)sc->sc_ioh + (index << 2); 275 int v; 276 277 v = *p; 278 return (v); 279 } 280 281 static void 282 cs_write(sc, index, value) 283 struct ad1848_softc *sc; 284 int index, value; 285 { 286 u_int8_t *p = (u_int8_t *)sc->sc_ioh + (index << 2); 287 288 *p = value; 289 } 290 291 static struct audio_hw_if hw_if = { 292 cs4231_open, 293 cs4231_close, 294 0, 295 ad1848_query_encoding, 296 ad1848_set_params, 297 cs4231_round_blocksize, 298 ad1848_commit_settings, 299 0, 300 0, 301 NULL, 302 NULL, 303 cs4231_halt_output, 304 cs4231_halt_input, 305 0, 306 cs4231_getdev, 307 0, 308 cs4231_set_port, 309 cs4231_get_port, 310 cs4231_query_devinfo, 311 cs4231_malloc, 312 cs4231_free, 313 cs4231_round_buffersize, 314 0, 315 cs4231_get_props, 316 cs4231_trigger_output, 317 cs4231_trigger_input 318 }; 319 320 /* autoconfig routines */ 321 322 int 323 cs4231match(parent, cf, aux) 324 struct device *parent; 325 struct cfdata *cf; 326 void *aux; 327 { 328 struct sbus_attach_args *sa = aux; 329 330 return (strcmp(AUDIO_ROM_NAME, sa->sa_name) == 0); 331 } 332 333 /* 334 * Audio chip found. 335 */ 336 void 337 cs4231attach(parent, self, aux) 338 struct device *parent, *self; 339 void *aux; 340 { 341 struct cs4231_softc *sc = (struct cs4231_softc *)self; 342 struct sbus_attach_args *sa = aux; 343 bus_space_handle_t bh; 344 345 sc->sc_bustag = sa->sa_bustag; 346 sc->sc_dmatag = sa->sa_dmatag; 347 348 sc->sc_ad1848.parent = sc; 349 sc->sc_ad1848.sc_readreg = cs_read; 350 sc->sc_ad1848.sc_writereg = cs_write; 351 352 /* 353 * Map my registers in, if they aren't already in virtual 354 * address space. 355 */ 356 if (sa->sa_npromvaddrs) { 357 bh = (bus_space_handle_t)sa->sa_promvaddrs[0]; 358 } else { 359 if (sbus_bus_map(sa->sa_bustag, sa->sa_slot, 360 sa->sa_offset, 361 sa->sa_size, 362 BUS_SPACE_MAP_LINEAR, 363 0, &bh) != 0) { 364 printf("%s @ sbus: cannot map registers\n", 365 self->dv_xname); 366 return; 367 } 368 } 369 370 sc->sc_ad1848.sc_ioh = bh; 371 sc->sc_dmareg = (struct apc_dma *)((int)bh + CS4231_REG_SIZE); 372 373 cs4231_init(sc); 374 375 /* Put ad1848 driver in `MODE 2' mode */ 376 sc->sc_ad1848.mode = 2; 377 ad1848_attach(&sc->sc_ad1848); 378 379 printf("\n"); 380 381 sbus_establish(&sc->sc_sd, &sc->sc_ad1848.sc_dev); 382 383 /* Establish interrupt channel */ 384 bus_intr_establish(sa->sa_bustag, 385 sa->sa_pri, 0, 386 cs4231_intr, sc); 387 388 evcnt_attach(&sc->sc_ad1848.sc_dev, "intr", &sc->sc_intrcnt); 389 audio_attach_mi(&hw_if, sc, &sc->sc_ad1848.sc_dev); 390 } 391 392 393 #ifdef AUDIO_DEBUG 394 static void 395 cs4231_regdump(label, sc) 396 char *label; 397 struct cs4231_softc *sc; 398 { 399 char bits[128]; 400 volatile struct apc_dma *dma = sc->sc_dmareg; 401 402 printf("cs4231regdump(%s): regs:", label); 403 printf("dmapva: 0x%lx; ", (u_long)dma->dmapva); 404 printf("dmapc: 0x%lx; ", (u_long)dma->dmapc); 405 printf("dmapnva: 0x%lx; ", (u_long)dma->dmapnva); 406 printf("dmapnc: 0x%lx\n", (u_long)dma->dmapnc); 407 printf("dmacva: 0x%lx; ", (u_long)dma->dmacva); 408 printf("dmacc: 0x%lx; ", (u_long)dma->dmacc); 409 printf("dmacnva: 0x%lx; ", (u_long)dma->dmacnva); 410 printf("dmacnc: 0x%lx\n", (u_long)dma->dmacnc); 411 412 printf("apc_dmacsr=%s\n", 413 bitmask_snprintf(dma->dmacsr, APC_BITS, bits, sizeof(bits)) ); 414 415 ad1848_dump_regs(&sc->sc_ad1848); 416 } 417 #endif 418 419 void 420 cs4231_init(sc) 421 register struct cs4231_softc *sc; 422 { 423 char *buf; 424 #if 0 425 volatile struct apc_dma *dma = sc->sc_dmareg; 426 #endif 427 int reg; 428 429 #if 0 430 dma->dmacsr = APC_CODEC_PDN; 431 delay(20); 432 dma->dmacsr &= ~APC_CODEC_PDN; 433 #endif 434 /* First, put chip in native mode */ 435 reg = ad_read(&sc->sc_ad1848, SP_MISC_INFO); 436 ad_write(&sc->sc_ad1848, SP_MISC_INFO, reg | MODE2); 437 438 /* Read version numbers from I25 */ 439 reg = ad_read(&sc->sc_ad1848, CS_VERSION_ID); 440 switch (reg & (CS_VERSION_NUMBER | CS_VERSION_CHIPID)) { 441 case 0xa0: 442 sc->sc_ad1848.chip_name = "CS4231A"; 443 break; 444 case 0x80: 445 sc->sc_ad1848.chip_name = "CS4231"; 446 break; 447 case 0x82: 448 sc->sc_ad1848.chip_name = "CS4232"; 449 break; 450 default: 451 if ((buf = malloc(32, M_TEMP, M_NOWAIT)) != NULL) { 452 sprintf(buf, "unknown rev: %x/%x", reg&0xe, reg&7); 453 sc->sc_ad1848.chip_name = buf; 454 } 455 } 456 } 457 458 void * 459 cs4231_malloc(addr, direction, size, pool, flags) 460 void *addr; 461 int direction; 462 size_t size; 463 int pool, flags; 464 { 465 struct cs4231_softc *sc = addr; 466 struct cs_dma *p; 467 int error; 468 469 p = malloc(sizeof(*p), pool, flags); 470 if (p == NULL) 471 return (NULL); 472 473 p->size = size; 474 error = bus_dmamem_alloc(sc->sc_dmatag, size, 64*1024, 0, 475 p->segs, sizeof(p->segs)/sizeof(p->segs[0]), 476 &p->nsegs, BUS_DMA_NOWAIT); 477 if (error) { 478 free(p, pool); 479 return (NULL); 480 } 481 482 error = bus_dmamem_map(sc->sc_dmatag, p->segs, p->nsegs, p->size, 483 &p->addr, BUS_DMA_NOWAIT|BUS_DMA_COHERENT); 484 if (error) { 485 bus_dmamem_free(sc->sc_dmatag, p->segs, p->nsegs); 486 free(p, pool); 487 return (NULL); 488 } 489 490 p->next = sc->sc_dmas; 491 sc->sc_dmas = p; 492 return (p->addr); 493 } 494 495 void 496 cs4231_free(addr, ptr, pool) 497 void *addr; 498 void *ptr; 499 int pool; 500 { 501 struct cs4231_softc *sc = addr; 502 struct cs_dma *p, **pp; 503 504 for (pp = &sc->sc_dmas; (p = *pp) != NULL; pp = &(*pp)->next) { 505 if (p->addr != ptr) 506 continue; 507 bus_dmamem_unmap(sc->sc_dmatag, p->addr, p->size); 508 bus_dmamem_free(sc->sc_dmatag, p->segs, p->nsegs); 509 *pp = p->next; 510 free(p, pool); 511 return; 512 } 513 printf("cs4231_free: rogue pointer\n"); 514 } 515 516 int 517 cs4231_open(addr, flags) 518 void *addr; 519 int flags; 520 { 521 struct cs4231_softc *sc = addr; 522 #if 0 523 struct apc_dma *dma = sc->sc_dmareg; 524 #endif 525 526 DPRINTF(("sa_open: unit %p\n", sc)); 527 528 if (sc->sc_open) 529 return (EBUSY); 530 sc->sc_open = 1; 531 sc->sc_locked = 0; 532 sc->sc_rintr = 0; 533 sc->sc_rarg = 0; 534 sc->sc_pintr = 0; 535 sc->sc_parg = 0; 536 #if 1 537 /*No interrupts from ad1848 */ 538 ad_write(&sc->sc_ad1848, SP_PIN_CONTROL, 0); 539 #endif 540 #if 0 541 dma->dmacsr = APC_RESET; 542 delay(10); 543 dma->dmacsr = 0; 544 delay(10); 545 ad1848_reset(&sc->sc_ad1848); 546 #endif 547 548 DPRINTF(("saopen: ok -> sc=%p\n", sc)); 549 return (0); 550 } 551 552 void 553 cs4231_close(addr) 554 void *addr; 555 { 556 register struct cs4231_softc *sc = addr; 557 558 DPRINTF(("sa_close: sc=%p\n", sc)); 559 /* 560 * halt i/o, clear open flag, and done. 561 */ 562 cs4231_halt_input(sc); 563 cs4231_halt_output(sc); 564 sc->sc_open = 0; 565 566 DPRINTF(("sa_close: closed.\n")); 567 } 568 569 size_t 570 cs4231_round_buffersize(addr, direction, size) 571 void *addr; 572 int direction; 573 size_t size; 574 { 575 #if 0 576 if (size > APC_MAX) 577 size = APC_MAX; 578 #endif 579 return (size); 580 } 581 582 int 583 cs4231_round_blocksize(addr, blk) 584 void *addr; 585 int blk; 586 { 587 return (blk & -4); 588 } 589 590 int 591 cs4231_getdev(addr, retp) 592 void *addr; 593 struct audio_device *retp; 594 { 595 *retp = cs4231_device; 596 return (0); 597 } 598 599 static ad1848_devmap_t csmapping[] = { 600 { CSAUDIO_DAC_LVL, AD1848_KIND_LVL, AD1848_AUX1_CHANNEL }, 601 { CSAUDIO_LINE_IN_LVL, AD1848_KIND_LVL, AD1848_LINE_CHANNEL }, 602 { CSAUDIO_MONO_LVL, AD1848_KIND_LVL, AD1848_MONO_CHANNEL }, 603 { CSAUDIO_CD_LVL, AD1848_KIND_LVL, AD1848_AUX2_CHANNEL }, 604 { CSAUDIO_MONITOR_LVL, AD1848_KIND_LVL, AD1848_MONITOR_CHANNEL }, 605 { CSAUDIO_OUT_LVL, AD1848_KIND_LVL, AD1848_DAC_CHANNEL }, 606 { CSAUDIO_DAC_MUTE, AD1848_KIND_MUTE, AD1848_AUX1_CHANNEL }, 607 { CSAUDIO_LINE_IN_MUTE, AD1848_KIND_MUTE, AD1848_LINE_CHANNEL }, 608 { CSAUDIO_MONO_MUTE, AD1848_KIND_MUTE, AD1848_MONO_CHANNEL }, 609 { CSAUDIO_CD_MUTE, AD1848_KIND_MUTE, AD1848_AUX2_CHANNEL }, 610 { CSAUDIO_MONITOR_MUTE, AD1848_KIND_MUTE, AD1848_MONITOR_CHANNEL }, 611 { CSAUDIO_REC_LVL, AD1848_KIND_RECORDGAIN, -1 }, 612 { CSAUDIO_RECORD_SOURCE, AD1848_KIND_RECORDSOURCE, -1 } 613 }; 614 615 static int nummap = sizeof(csmapping) / sizeof(csmapping[0]); 616 617 618 int 619 cs4231_set_port(addr, cp) 620 void *addr; 621 mixer_ctrl_t *cp; 622 { 623 struct ad1848_softc *ac = addr; 624 625 DPRINTF(("cs4231_set_port: port=%d", cp->dev)); 626 return (ad1848_mixer_set_port(ac, csmapping, nummap, cp)); 627 } 628 629 int 630 cs4231_get_port(addr, cp) 631 void *addr; 632 mixer_ctrl_t *cp; 633 { 634 struct ad1848_softc *ac = addr; 635 636 DPRINTF(("cs4231_get_port: port=%d", cp->dev)); 637 return (ad1848_mixer_get_port(ac, csmapping, nummap, cp)); 638 } 639 640 int 641 cs4231_get_props(addr) 642 void *addr; 643 { 644 return (AUDIO_PROP_FULLDUPLEX); 645 } 646 647 int 648 cs4231_query_devinfo(addr, dip) 649 void *addr; 650 register mixer_devinfo_t *dip; 651 { 652 653 switch(dip->index) { 654 #if 0 655 case CSAUDIO_MIC_IN_LVL: /* Microphone */ 656 dip->type = AUDIO_MIXER_VALUE; 657 dip->mixer_class = CSAUDIO_INPUT_CLASS; 658 dip->prev = AUDIO_MIXER_LAST; 659 dip->next = CSAUDIO_MIC_IN_MUTE; 660 strcpy(dip->label.name, AudioNmicrophone); 661 dip->un.v.num_channels = 2; 662 strcpy(dip->un.v.units.name, AudioNvolume); 663 break; 664 #endif 665 666 case CSAUDIO_MONO_LVL: /* mono/microphone mixer */ 667 dip->type = AUDIO_MIXER_VALUE; 668 dip->mixer_class = CSAUDIO_INPUT_CLASS; 669 dip->prev = AUDIO_MIXER_LAST; 670 dip->next = CSAUDIO_MONO_MUTE; 671 strcpy(dip->label.name, AudioNmicrophone); 672 dip->un.v.num_channels = 1; 673 strcpy(dip->un.v.units.name, AudioNvolume); 674 break; 675 676 case CSAUDIO_DAC_LVL: /* dacout */ 677 dip->type = AUDIO_MIXER_VALUE; 678 dip->mixer_class = CSAUDIO_INPUT_CLASS; 679 dip->prev = AUDIO_MIXER_LAST; 680 dip->next = CSAUDIO_DAC_MUTE; 681 strcpy(dip->label.name, AudioNdac); 682 dip->un.v.num_channels = 2; 683 strcpy(dip->un.v.units.name, AudioNvolume); 684 break; 685 686 case CSAUDIO_LINE_IN_LVL: /* line */ 687 dip->type = AUDIO_MIXER_VALUE; 688 dip->mixer_class = CSAUDIO_INPUT_CLASS; 689 dip->prev = AUDIO_MIXER_LAST; 690 dip->next = CSAUDIO_LINE_IN_MUTE; 691 strcpy(dip->label.name, AudioNline); 692 dip->un.v.num_channels = 2; 693 strcpy(dip->un.v.units.name, AudioNvolume); 694 break; 695 696 case CSAUDIO_CD_LVL: /* cd */ 697 dip->type = AUDIO_MIXER_VALUE; 698 dip->mixer_class = CSAUDIO_INPUT_CLASS; 699 dip->prev = AUDIO_MIXER_LAST; 700 dip->next = CSAUDIO_CD_MUTE; 701 strcpy(dip->label.name, AudioNcd); 702 dip->un.v.num_channels = 2; 703 strcpy(dip->un.v.units.name, AudioNvolume); 704 break; 705 706 707 case CSAUDIO_MONITOR_LVL: /* monitor level */ 708 dip->type = AUDIO_MIXER_VALUE; 709 dip->mixer_class = CSAUDIO_MONITOR_CLASS; 710 dip->next = CSAUDIO_MONITOR_MUTE; 711 dip->prev = AUDIO_MIXER_LAST; 712 strcpy(dip->label.name, AudioNmonitor); 713 dip->un.v.num_channels = 1; 714 strcpy(dip->un.v.units.name, AudioNvolume); 715 break; 716 717 case CSAUDIO_OUT_LVL: /* cs4231 output volume: not useful? */ 718 dip->type = AUDIO_MIXER_VALUE; 719 dip->mixer_class = CSAUDIO_MONITOR_CLASS; 720 dip->prev = dip->next = AUDIO_MIXER_LAST; 721 strcpy(dip->label.name, AudioNoutput); 722 dip->un.v.num_channels = 2; 723 strcpy(dip->un.v.units.name, AudioNvolume); 724 break; 725 726 case CSAUDIO_LINE_IN_MUTE: 727 dip->mixer_class = CSAUDIO_INPUT_CLASS; 728 dip->type = AUDIO_MIXER_ENUM; 729 dip->prev = CSAUDIO_LINE_IN_LVL; 730 dip->next = AUDIO_MIXER_LAST; 731 goto mute; 732 733 case CSAUDIO_DAC_MUTE: 734 dip->mixer_class = CSAUDIO_INPUT_CLASS; 735 dip->type = AUDIO_MIXER_ENUM; 736 dip->prev = CSAUDIO_DAC_LVL; 737 dip->next = AUDIO_MIXER_LAST; 738 goto mute; 739 740 case CSAUDIO_CD_MUTE: 741 dip->mixer_class = CSAUDIO_INPUT_CLASS; 742 dip->type = AUDIO_MIXER_ENUM; 743 dip->prev = CSAUDIO_CD_LVL; 744 dip->next = AUDIO_MIXER_LAST; 745 goto mute; 746 747 case CSAUDIO_MONO_MUTE: 748 dip->mixer_class = CSAUDIO_INPUT_CLASS; 749 dip->type = AUDIO_MIXER_ENUM; 750 dip->prev = CSAUDIO_MONO_LVL; 751 dip->next = AUDIO_MIXER_LAST; 752 goto mute; 753 754 case CSAUDIO_MONITOR_MUTE: 755 dip->mixer_class = CSAUDIO_OUTPUT_CLASS; 756 dip->type = AUDIO_MIXER_ENUM; 757 dip->prev = CSAUDIO_MONITOR_LVL; 758 dip->next = AUDIO_MIXER_LAST; 759 mute: 760 strcpy(dip->label.name, AudioNmute); 761 dip->un.e.num_mem = 2; 762 strcpy(dip->un.e.member[0].label.name, AudioNoff); 763 dip->un.e.member[0].ord = 0; 764 strcpy(dip->un.e.member[1].label.name, AudioNon); 765 dip->un.e.member[1].ord = 1; 766 break; 767 768 case CSAUDIO_REC_LVL: /* record level */ 769 dip->type = AUDIO_MIXER_VALUE; 770 dip->mixer_class = CSAUDIO_RECORD_CLASS; 771 dip->prev = AUDIO_MIXER_LAST; 772 dip->next = CSAUDIO_RECORD_SOURCE; 773 strcpy(dip->label.name, AudioNrecord); 774 dip->un.v.num_channels = 2; 775 strcpy(dip->un.v.units.name, AudioNvolume); 776 break; 777 778 case CSAUDIO_RECORD_SOURCE: 779 dip->mixer_class = CSAUDIO_RECORD_CLASS; 780 dip->type = AUDIO_MIXER_ENUM; 781 dip->prev = CSAUDIO_REC_LVL; 782 dip->next = AUDIO_MIXER_LAST; 783 strcpy(dip->label.name, AudioNsource); 784 dip->un.e.num_mem = 4; 785 strcpy(dip->un.e.member[0].label.name, AudioNoutput); 786 dip->un.e.member[0].ord = DAC_IN_PORT; 787 strcpy(dip->un.e.member[1].label.name, AudioNmicrophone); 788 dip->un.e.member[1].ord = MIC_IN_PORT; 789 strcpy(dip->un.e.member[2].label.name, AudioNdac); 790 dip->un.e.member[2].ord = AUX1_IN_PORT; 791 strcpy(dip->un.e.member[3].label.name, AudioNline); 792 dip->un.e.member[3].ord = LINE_IN_PORT; 793 break; 794 795 case CSAUDIO_INPUT_CLASS: /* input class descriptor */ 796 dip->type = AUDIO_MIXER_CLASS; 797 dip->mixer_class = CSAUDIO_INPUT_CLASS; 798 dip->next = dip->prev = AUDIO_MIXER_LAST; 799 strcpy(dip->label.name, AudioCinputs); 800 break; 801 802 case CSAUDIO_OUTPUT_CLASS: /* output class descriptor */ 803 dip->type = AUDIO_MIXER_CLASS; 804 dip->mixer_class = CSAUDIO_OUTPUT_CLASS; 805 dip->next = dip->prev = AUDIO_MIXER_LAST; 806 strcpy(dip->label.name, AudioCoutputs); 807 break; 808 809 case CSAUDIO_MONITOR_CLASS: /* monitor class descriptor */ 810 dip->type = AUDIO_MIXER_CLASS; 811 dip->mixer_class = CSAUDIO_MONITOR_CLASS; 812 dip->next = dip->prev = AUDIO_MIXER_LAST; 813 strcpy(dip->label.name, AudioCmonitor); 814 break; 815 816 case CSAUDIO_RECORD_CLASS: /* record source class */ 817 dip->type = AUDIO_MIXER_CLASS; 818 dip->mixer_class = CSAUDIO_RECORD_CLASS; 819 dip->next = dip->prev = AUDIO_MIXER_LAST; 820 strcpy(dip->label.name, AudioCrecord); 821 break; 822 823 default: 824 return ENXIO; 825 /*NOTREACHED*/ 826 } 827 DPRINTF(("AUDIO_MIXER_DEVINFO: name=%s\n", dip->label.name)); 828 829 return (0); 830 } 831 832 833 int 834 cs4231_trigger_output(addr, start, end, blksize, intr, arg, param) 835 void *addr; 836 void *start, *end; 837 int blksize; 838 void (*intr) __P((void *)); 839 void *arg; 840 struct audio_params *param; 841 { 842 struct cs4231_softc *sc = addr; 843 struct cs_dma *p; 844 volatile struct apc_dma *dma = sc->sc_dmareg; 845 int csr; 846 u_long n; 847 848 if (sc->sc_locked != 0) { 849 printf("cs4231_trigger_output: already running\n"); 850 return (EINVAL); 851 } 852 853 sc->sc_locked = 1; 854 sc->sc_pintr = intr; 855 sc->sc_parg = arg; 856 857 for (p = sc->sc_dmas; p != NULL && p->addr != start; p = p->next) 858 /*void*/; 859 if (p == NULL) { 860 printf("cs4231_trigger_output: bad addr %p\n", start); 861 return (EINVAL); 862 } 863 864 n = (char *)end - (char *)start; 865 866 /* XXX 867 * Do only `blksize' at a time, so audio_pint() is kept 868 * synchronous with us... 869 */ 870 /*XXX*/sc->sc_blksz = blksize; 871 /*XXX*/sc->sc_nowplaying = p; 872 /*XXX*/sc->sc_playsegsz = n; 873 874 if (n > APC_MAX) 875 n = APC_MAX; 876 877 sc->sc_playcnt = n; 878 879 DPRINTF(("trigger_out: start %p, end %p, size %lu; " 880 "dmaaddr 0x%lx, dmacnt %lu, segsize %lu\n", 881 start, end, sc->sc_playsegsz, p->segs[0].ds_addr, 882 n, (u_long)p->size)); 883 884 csr = dma->dmacsr; 885 dma->dmapnva = (u_long)p->segs[0].ds_addr; 886 dma->dmapnc = n; 887 if ((csr & PDMA_GO) == 0 || (csr & APC_PPAUSE) != 0) { 888 int reg; 889 890 dma->dmacsr &= ~(APC_PIE|APC_PPAUSE); 891 dma->dmacsr |= APC_EI|APC_IE|APC_PIE|APC_EIE|APC_PMIE|PDMA_GO; 892 893 /* Start chip */ 894 895 /* Probably should just ignore this.. */ 896 ad_write(&sc->sc_ad1848, SP_LOWER_BASE_COUNT, 0xff); 897 ad_write(&sc->sc_ad1848, SP_UPPER_BASE_COUNT, 0xff); 898 899 reg = ad_read(&sc->sc_ad1848, SP_INTERFACE_CONFIG); 900 ad_write(&sc->sc_ad1848, SP_INTERFACE_CONFIG, 901 (PLAYBACK_ENABLE|reg)); 902 } 903 904 return (0); 905 } 906 907 int 908 cs4231_trigger_input(addr, start, end, blksize, intr, arg, param) 909 void *addr; 910 void *start, *end; 911 int blksize; 912 void (*intr) __P((void *)); 913 void *arg; 914 struct audio_params *param; 915 { 916 return (ENXIO); 917 } 918 919 int 920 cs4231_halt_output(addr) 921 void *addr; 922 { 923 struct cs4231_softc *sc = addr; 924 volatile struct apc_dma *dma = sc->sc_dmareg; 925 int reg; 926 927 dma->dmacsr &= ~(APC_EI | APC_IE | APC_PIE | APC_EIE | PDMA_GO | APC_PMIE); 928 reg = ad_read(&sc->sc_ad1848, SP_INTERFACE_CONFIG); 929 ad_write(&sc->sc_ad1848, SP_INTERFACE_CONFIG, (reg & ~PLAYBACK_ENABLE)); 930 sc->sc_locked = 0; 931 932 return (0); 933 } 934 935 int 936 cs4231_halt_input(addr) 937 void *addr; 938 { 939 struct cs4231_softc *sc = addr; 940 int reg; 941 942 reg = ad_read(&sc->sc_ad1848, SP_INTERFACE_CONFIG); 943 ad_write(&sc->sc_ad1848, SP_INTERFACE_CONFIG, (reg & ~CAPTURE_ENABLE)); 944 sc->sc_locked = 0; 945 946 return (0); 947 } 948 949 950 int 951 cs4231_intr(arg) 952 void *arg; 953 { 954 struct cs4231_softc *sc = arg; 955 volatile struct apc_dma *dma = sc->sc_dmareg; 956 struct cs_dma *p; 957 int ret = 0; 958 int csr; 959 int reg, status; 960 #if defined(DEBUG) || defined(AUDIO_DEBUG) 961 char bits[128]; 962 #endif 963 964 #ifdef AUDIO_DEBUG 965 if (cs4231debug > 1) 966 cs4231_regdump("audiointr", sc); 967 #endif 968 969 /* Read DMA status */ 970 csr = dma->dmacsr; 971 DPRINTF(( 972 "intr: csr=%s; dmapva=0x%lx,dmapc=%lu;dmapnva=0x%lx,dmapnc=%lu\n", 973 bitmask_snprintf(csr, APC_BITS, bits, sizeof(bits)), 974 (u_long)dma->dmapva, (u_long)dma->dmapc, 975 (u_long)dma->dmapnva, (u_long)dma->dmapnc)); 976 977 status = ADREAD(&sc->sc_ad1848, AD1848_STATUS); 978 DPRINTF(("%s: status: %s\n", sc->sc_ad1848.sc_dev.dv_xname, 979 bitmask_snprintf(status, AD_R2_BITS, bits, sizeof(bits)))); 980 if (status & (INTERRUPT_STATUS | SAMPLE_ERROR)) { 981 reg = ad_read(&sc->sc_ad1848, CS_IRQ_STATUS); 982 DPRINTF(("%s: i24: %s\n", sc->sc_ad1848.sc_dev.dv_xname, 983 bitmask_snprintf(reg, CS_I24_BITS, bits, sizeof(bits)))); 984 985 if (reg & CS_IRQ_PI) { 986 ad_write(&sc->sc_ad1848, SP_LOWER_BASE_COUNT, 0xff); 987 ad_write(&sc->sc_ad1848, SP_UPPER_BASE_COUNT, 0xff); 988 } 989 /* Clear interrupt bit */ 990 ADWRITE(&sc->sc_ad1848, AD1848_STATUS, 0); 991 } 992 993 /* Write back DMA status (clears interrupt) */ 994 dma->dmacsr = csr; 995 996 /* 997 * Simplistic.. if "play emtpy" is set advance to next chunk. 998 */ 999 #if 1 1000 /* Ack all play interrupts*/ 1001 if ((csr & (APC_PI|APC_PD|APC_PIE|APC_PMI)) != 0) 1002 ret = 1; 1003 #endif 1004 if (csr & APC_PM) { 1005 u_long nextaddr, togo; 1006 1007 p = sc->sc_nowplaying; 1008 1009 togo = sc->sc_playsegsz - sc->sc_playcnt; 1010 if (togo == 0) { 1011 /* Roll over */ 1012 nextaddr = (u_long)p->segs[0].ds_addr; 1013 sc->sc_playcnt = togo = APC_MAX; 1014 } else { 1015 nextaddr = dma->dmapnva + APC_MAX; 1016 if (togo > APC_MAX) 1017 togo = APC_MAX; 1018 sc->sc_playcnt += togo; 1019 } 1020 1021 dma->dmapnva = nextaddr; 1022 dma->dmapnc = togo; 1023 1024 if (sc->sc_pintr != NULL) 1025 (*sc->sc_pintr)(sc->sc_parg); 1026 1027 ret = 1; 1028 } 1029 1030 if (csr & APC_CI) { 1031 if (sc->sc_rintr != NULL) { 1032 ret = 1; 1033 (*sc->sc_rintr)(sc->sc_rarg); 1034 } 1035 } 1036 1037 #ifdef DEBUG 1038 if (ret == 0) { 1039 printf( 1040 "oops: csr=%s; dmapva=0x%lx,dmapc=%lu;dmapnva=0x%lx,dmapnc=%lu\n", 1041 bitmask_snprintf(csr, APC_BITS, bits, sizeof(bits)), 1042 (u_long)dma->dmapva, (u_long)dma->dmapc, 1043 (u_long)dma->dmapnva, (u_long)dma->dmapnc); 1044 ret = 1; 1045 } 1046 #endif 1047 1048 return (ret); 1049 } 1050 #endif /* NAUDIO > 0 */ 1051
Indexes created Thu Oct 02 01:09:59 GMT 2025