cs4231_sbus.c revision 1.6
1 /* $NetBSD: cs4231_sbus.c,v 1.6 1998/09/25 14:19:20 pk 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 u_long cs4231_round_buffersize __P((void *, u_long)); 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 *, u_long, 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, size, pool, flags) 460 void *addr; 461 u_long size; 462 int pool; 463 int 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 u_long 570 cs4231_round_buffersize(addr, size) 571 void *addr; 572 u_long size; 573 { 574 #if 0 575 if (size > APC_MAX) 576 size = APC_MAX; 577 #endif 578 return (size); 579 } 580 581 int 582 cs4231_round_blocksize(addr, blk) 583 void *addr; 584 int blk; 585 { 586 return (blk & -4); 587 } 588 589 int 590 cs4231_getdev(addr, retp) 591 void *addr; 592 struct audio_device *retp; 593 { 594 *retp = cs4231_device; 595 return (0); 596 } 597 598 static ad1848_devmap_t csmapping[] = { 599 { CSAUDIO_DAC_LVL, AD1848_KIND_LVL, AD1848_AUX1_CHANNEL }, 600 { CSAUDIO_LINE_IN_LVL, AD1848_KIND_LVL, AD1848_LINE_CHANNEL }, 601 { CSAUDIO_MONO_LVL, AD1848_KIND_LVL, AD1848_MONO_CHANNEL }, 602 { CSAUDIO_CD_LVL, AD1848_KIND_LVL, AD1848_AUX2_CHANNEL }, 603 { CSAUDIO_MONITOR_LVL, AD1848_KIND_LVL, AD1848_MONITOR_CHANNEL }, 604 { CSAUDIO_OUT_LVL, AD1848_KIND_LVL, AD1848_DAC_CHANNEL }, 605 { CSAUDIO_DAC_MUTE, AD1848_KIND_MUTE, AD1848_AUX1_CHANNEL }, 606 { CSAUDIO_LINE_IN_MUTE, AD1848_KIND_MUTE, AD1848_LINE_CHANNEL }, 607 { CSAUDIO_MONO_MUTE, AD1848_KIND_MUTE, AD1848_MONO_CHANNEL }, 608 { CSAUDIO_CD_MUTE, AD1848_KIND_MUTE, AD1848_AUX2_CHANNEL }, 609 { CSAUDIO_MONITOR_MUTE, AD1848_KIND_MUTE, AD1848_MONITOR_CHANNEL }, 610 { CSAUDIO_REC_LVL, AD1848_KIND_RECORDGAIN, -1 }, 611 { CSAUDIO_RECORD_SOURCE, AD1848_KIND_RECORDSOURCE, -1 } 612 }; 613 614 static int nummap = sizeof(csmapping) / sizeof(csmapping[0]); 615 616 617 int 618 cs4231_set_port(addr, cp) 619 void *addr; 620 mixer_ctrl_t *cp; 621 { 622 struct ad1848_softc *ac = addr; 623 624 DPRINTF(("cs4231_set_port: port=%d", cp->dev)); 625 return (ad1848_mixer_set_port(ac, csmapping, nummap, cp)); 626 } 627 628 int 629 cs4231_get_port(addr, cp) 630 void *addr; 631 mixer_ctrl_t *cp; 632 { 633 struct ad1848_softc *ac = addr; 634 635 DPRINTF(("cs4231_get_port: port=%d", cp->dev)); 636 return (ad1848_mixer_get_port(ac, csmapping, nummap, cp)); 637 } 638 639 int 640 cs4231_get_props(addr) 641 void *addr; 642 { 643 return (AUDIO_PROP_FULLDUPLEX); 644 } 645 646 int 647 cs4231_query_devinfo(addr, dip) 648 void *addr; 649 register mixer_devinfo_t *dip; 650 { 651 652 switch(dip->index) { 653 #if 0 654 case CSAUDIO_MIC_IN_LVL: /* Microphone */ 655 dip->type = AUDIO_MIXER_VALUE; 656 dip->mixer_class = CSAUDIO_INPUT_CLASS; 657 dip->prev = AUDIO_MIXER_LAST; 658 dip->next = CSAUDIO_MIC_IN_MUTE; 659 strcpy(dip->label.name, AudioNmicrophone); 660 dip->un.v.num_channels = 2; 661 strcpy(dip->un.v.units.name, AudioNvolume); 662 break; 663 #endif 664 665 case CSAUDIO_MONO_LVL: /* mono/microphone mixer */ 666 dip->type = AUDIO_MIXER_VALUE; 667 dip->mixer_class = CSAUDIO_INPUT_CLASS; 668 dip->prev = AUDIO_MIXER_LAST; 669 dip->next = CSAUDIO_MONO_MUTE; 670 strcpy(dip->label.name, AudioNmicrophone); 671 dip->un.v.num_channels = 1; 672 strcpy(dip->un.v.units.name, AudioNvolume); 673 break; 674 675 case CSAUDIO_DAC_LVL: /* dacout */ 676 dip->type = AUDIO_MIXER_VALUE; 677 dip->mixer_class = CSAUDIO_INPUT_CLASS; 678 dip->prev = AUDIO_MIXER_LAST; 679 dip->next = CSAUDIO_DAC_MUTE; 680 strcpy(dip->label.name, AudioNdac); 681 dip->un.v.num_channels = 2; 682 strcpy(dip->un.v.units.name, AudioNvolume); 683 break; 684 685 case CSAUDIO_LINE_IN_LVL: /* line */ 686 dip->type = AUDIO_MIXER_VALUE; 687 dip->mixer_class = CSAUDIO_INPUT_CLASS; 688 dip->prev = AUDIO_MIXER_LAST; 689 dip->next = CSAUDIO_LINE_IN_MUTE; 690 strcpy(dip->label.name, AudioNline); 691 dip->un.v.num_channels = 2; 692 strcpy(dip->un.v.units.name, AudioNvolume); 693 break; 694 695 case CSAUDIO_CD_LVL: /* cd */ 696 dip->type = AUDIO_MIXER_VALUE; 697 dip->mixer_class = CSAUDIO_INPUT_CLASS; 698 dip->prev = AUDIO_MIXER_LAST; 699 dip->next = CSAUDIO_CD_MUTE; 700 strcpy(dip->label.name, AudioNcd); 701 dip->un.v.num_channels = 2; 702 strcpy(dip->un.v.units.name, AudioNvolume); 703 break; 704 705 706 case CSAUDIO_MONITOR_LVL: /* monitor level */ 707 dip->type = AUDIO_MIXER_VALUE; 708 dip->mixer_class = CSAUDIO_MONITOR_CLASS; 709 dip->next = CSAUDIO_MONITOR_MUTE; 710 dip->prev = AUDIO_MIXER_LAST; 711 strcpy(dip->label.name, AudioNmonitor); 712 dip->un.v.num_channels = 1; 713 strcpy(dip->un.v.units.name, AudioNvolume); 714 break; 715 716 case CSAUDIO_OUT_LVL: /* cs4231 output volume: not useful? */ 717 dip->type = AUDIO_MIXER_VALUE; 718 dip->mixer_class = CSAUDIO_MONITOR_CLASS; 719 dip->prev = dip->next = AUDIO_MIXER_LAST; 720 strcpy(dip->label.name, AudioNoutput); 721 dip->un.v.num_channels = 2; 722 strcpy(dip->un.v.units.name, AudioNvolume); 723 break; 724 725 case CSAUDIO_LINE_IN_MUTE: 726 dip->mixer_class = CSAUDIO_INPUT_CLASS; 727 dip->type = AUDIO_MIXER_ENUM; 728 dip->prev = CSAUDIO_LINE_IN_LVL; 729 dip->next = AUDIO_MIXER_LAST; 730 goto mute; 731 732 case CSAUDIO_DAC_MUTE: 733 dip->mixer_class = CSAUDIO_INPUT_CLASS; 734 dip->type = AUDIO_MIXER_ENUM; 735 dip->prev = CSAUDIO_DAC_LVL; 736 dip->next = AUDIO_MIXER_LAST; 737 goto mute; 738 739 case CSAUDIO_CD_MUTE: 740 dip->mixer_class = CSAUDIO_INPUT_CLASS; 741 dip->type = AUDIO_MIXER_ENUM; 742 dip->prev = CSAUDIO_CD_LVL; 743 dip->next = AUDIO_MIXER_LAST; 744 goto mute; 745 746 case CSAUDIO_MONO_MUTE: 747 dip->mixer_class = CSAUDIO_INPUT_CLASS; 748 dip->type = AUDIO_MIXER_ENUM; 749 dip->prev = CSAUDIO_MONO_LVL; 750 dip->next = AUDIO_MIXER_LAST; 751 goto mute; 752 753 case CSAUDIO_MONITOR_MUTE: 754 dip->mixer_class = CSAUDIO_OUTPUT_CLASS; 755 dip->type = AUDIO_MIXER_ENUM; 756 dip->prev = CSAUDIO_MONITOR_LVL; 757 dip->next = AUDIO_MIXER_LAST; 758 mute: 759 strcpy(dip->label.name, AudioNmute); 760 dip->un.e.num_mem = 2; 761 strcpy(dip->un.e.member[0].label.name, AudioNoff); 762 dip->un.e.member[0].ord = 0; 763 strcpy(dip->un.e.member[1].label.name, AudioNon); 764 dip->un.e.member[1].ord = 1; 765 break; 766 767 case CSAUDIO_REC_LVL: /* record level */ 768 dip->type = AUDIO_MIXER_VALUE; 769 dip->mixer_class = CSAUDIO_RECORD_CLASS; 770 dip->prev = AUDIO_MIXER_LAST; 771 dip->next = CSAUDIO_RECORD_SOURCE; 772 strcpy(dip->label.name, AudioNrecord); 773 dip->un.v.num_channels = 2; 774 strcpy(dip->un.v.units.name, AudioNvolume); 775 break; 776 777 case CSAUDIO_RECORD_SOURCE: 778 dip->mixer_class = CSAUDIO_RECORD_CLASS; 779 dip->type = AUDIO_MIXER_ENUM; 780 dip->prev = CSAUDIO_REC_LVL; 781 dip->next = AUDIO_MIXER_LAST; 782 strcpy(dip->label.name, AudioNsource); 783 dip->un.e.num_mem = 4; 784 strcpy(dip->un.e.member[0].label.name, AudioNoutput); 785 dip->un.e.member[0].ord = DAC_IN_PORT; 786 strcpy(dip->un.e.member[1].label.name, AudioNmicrophone); 787 dip->un.e.member[1].ord = MIC_IN_PORT; 788 strcpy(dip->un.e.member[2].label.name, AudioNdac); 789 dip->un.e.member[2].ord = AUX1_IN_PORT; 790 strcpy(dip->un.e.member[3].label.name, AudioNline); 791 dip->un.e.member[3].ord = LINE_IN_PORT; 792 break; 793 794 case CSAUDIO_INPUT_CLASS: /* input class descriptor */ 795 dip->type = AUDIO_MIXER_CLASS; 796 dip->mixer_class = CSAUDIO_INPUT_CLASS; 797 dip->next = dip->prev = AUDIO_MIXER_LAST; 798 strcpy(dip->label.name, AudioCinputs); 799 break; 800 801 case CSAUDIO_OUTPUT_CLASS: /* output class descriptor */ 802 dip->type = AUDIO_MIXER_CLASS; 803 dip->mixer_class = CSAUDIO_OUTPUT_CLASS; 804 dip->next = dip->prev = AUDIO_MIXER_LAST; 805 strcpy(dip->label.name, AudioCoutputs); 806 break; 807 808 case CSAUDIO_MONITOR_CLASS: /* monitor class descriptor */ 809 dip->type = AUDIO_MIXER_CLASS; 810 dip->mixer_class = CSAUDIO_MONITOR_CLASS; 811 dip->next = dip->prev = AUDIO_MIXER_LAST; 812 strcpy(dip->label.name, AudioCmonitor); 813 break; 814 815 case CSAUDIO_RECORD_CLASS: /* record source class */ 816 dip->type = AUDIO_MIXER_CLASS; 817 dip->mixer_class = CSAUDIO_RECORD_CLASS; 818 dip->next = dip->prev = AUDIO_MIXER_LAST; 819 strcpy(dip->label.name, AudioCrecord); 820 break; 821 822 default: 823 return ENXIO; 824 /*NOTREACHED*/ 825 } 826 DPRINTF(("AUDIO_MIXER_DEVINFO: name=%s\n", dip->label.name)); 827 828 return (0); 829 } 830 831 832 int 833 cs4231_trigger_output(addr, start, end, blksize, intr, arg, param) 834 void *addr; 835 void *start, *end; 836 int blksize; 837 void (*intr) __P((void *)); 838 void *arg; 839 struct audio_params *param; 840 { 841 struct cs4231_softc *sc = addr; 842 struct cs_dma *p; 843 volatile struct apc_dma *dma = sc->sc_dmareg; 844 int csr; 845 u_long n; 846 847 if (sc->sc_locked != 0) { 848 printf("cs4231_trigger_output: already running\n"); 849 return (EINVAL); 850 } 851 852 sc->sc_locked = 1; 853 sc->sc_pintr = intr; 854 sc->sc_parg = arg; 855 856 for (p = sc->sc_dmas; p != NULL && p->addr != start; p = p->next) 857 /*void*/; 858 if (p == NULL) { 859 printf("cs4231_trigger_output: bad addr %p\n", start); 860 return (EINVAL); 861 } 862 863 n = end - start; 864 865 /* XXX 866 * Do only `blksize' at a time, so audio_pint() is kept 867 * synchronous with us... 868 */ 869 /*XXX*/sc->sc_blksz = blksize; 870 /*XXX*/sc->sc_nowplaying = p; 871 /*XXX*/sc->sc_playsegsz = n; 872 873 if (n > APC_MAX) 874 n = APC_MAX; 875 876 sc->sc_playcnt = n; 877 878 DPRINTF(("trigger_out: start %p, end %p, size %lu; " 879 "dmaaddr 0x%lx, dmacnt %lu, segsize %lu\n", 880 start, end, sc->sc_playsegsz, p->segs[0].ds_addr, 881 n, (u_long)p->size)); 882 883 csr = dma->dmacsr; 884 dma->dmapnva = (u_long)p->segs[0].ds_addr; 885 dma->dmapnc = n; 886 if ((csr & PDMA_GO) == 0 || (csr & APC_PPAUSE) != 0) { 887 int reg; 888 889 dma->dmacsr &= ~(APC_PIE|APC_PPAUSE); 890 dma->dmacsr |= APC_EI|APC_IE|APC_PIE|APC_EIE|APC_PMIE|PDMA_GO; 891 892 /* Start chip */ 893 894 /* Probably should just ignore this.. */ 895 ad_write(&sc->sc_ad1848, SP_LOWER_BASE_COUNT, 0xff); 896 ad_write(&sc->sc_ad1848, SP_UPPER_BASE_COUNT, 0xff); 897 898 reg = ad_read(&sc->sc_ad1848, SP_INTERFACE_CONFIG); 899 ad_write(&sc->sc_ad1848, SP_INTERFACE_CONFIG, 900 (PLAYBACK_ENABLE|reg)); 901 } 902 903 return (0); 904 } 905 906 int 907 cs4231_trigger_input(addr, start, end, blksize, intr, arg, param) 908 void *addr; 909 void *start, *end; 910 int blksize; 911 void (*intr) __P((void *)); 912 void *arg; 913 struct audio_params *param; 914 { 915 return (ENXIO); 916 } 917 918 int 919 cs4231_halt_output(addr) 920 void *addr; 921 { 922 struct cs4231_softc *sc = addr; 923 volatile struct apc_dma *dma = sc->sc_dmareg; 924 int reg; 925 926 dma->dmacsr &= ~(APC_EI | APC_IE | APC_PIE | APC_EIE | PDMA_GO | APC_PMIE); 927 reg = ad_read(&sc->sc_ad1848, SP_INTERFACE_CONFIG); 928 ad_write(&sc->sc_ad1848, SP_INTERFACE_CONFIG, (reg & ~PLAYBACK_ENABLE)); 929 sc->sc_locked = 0; 930 931 return (0); 932 } 933 934 int 935 cs4231_halt_input(addr) 936 void *addr; 937 { 938 struct cs4231_softc *sc = addr; 939 int reg; 940 941 reg = ad_read(&sc->sc_ad1848, SP_INTERFACE_CONFIG); 942 ad_write(&sc->sc_ad1848, SP_INTERFACE_CONFIG, (reg & ~CAPTURE_ENABLE)); 943 sc->sc_locked = 0; 944 945 return (0); 946 } 947 948 949 int 950 cs4231_intr(arg) 951 void *arg; 952 { 953 struct cs4231_softc *sc = arg; 954 volatile struct apc_dma *dma = sc->sc_dmareg; 955 struct cs_dma *p; 956 int ret = 0; 957 int csr; 958 int reg, status; 959 #if defined(DEBUG) || defined(AUDIO_DEBUG) 960 char bits[128]; 961 #endif 962 963 #ifdef AUDIO_DEBUG 964 if (cs4231debug > 1) 965 cs4231_regdump("audiointr", sc); 966 #endif 967 968 /* Read DMA status */ 969 csr = dma->dmacsr; 970 DPRINTF(( 971 "intr: csr=%s; dmapva=0x%lx,dmapc=%lu;dmapnva=0x%lx,dmapnc=%lu\n", 972 bitmask_snprintf(csr, APC_BITS, bits, sizeof(bits)), 973 (u_long)dma->dmapva, (u_long)dma->dmapc, 974 (u_long)dma->dmapnva, (u_long)dma->dmapnc)); 975 976 status = ADREAD(&sc->sc_ad1848, AD1848_STATUS); 977 DPRINTF(("%s: status: %s\n", sc->sc_ad1848.sc_dev.dv_xname, 978 bitmask_snprintf(status, AD_R2_BITS, bits, sizeof(bits)))); 979 if (status & (INTERRUPT_STATUS | SAMPLE_ERROR)) { 980 reg = ad_read(&sc->sc_ad1848, CS_IRQ_STATUS); 981 DPRINTF(("%s: i24: %s\n", sc->sc_ad1848.sc_dev.dv_xname, 982 bitmask_snprintf(reg, CS_I24_BITS, bits, sizeof(bits)))); 983 984 if (reg & CS_IRQ_PI) { 985 ad_write(&sc->sc_ad1848, SP_LOWER_BASE_COUNT, 0xff); 986 ad_write(&sc->sc_ad1848, SP_UPPER_BASE_COUNT, 0xff); 987 } 988 /* Clear interrupt bit */ 989 ADWRITE(&sc->sc_ad1848, AD1848_STATUS, 0); 990 } 991 992 /* Write back DMA status (clears interrupt) */ 993 dma->dmacsr = csr; 994 995 /* 996 * Simplistic.. if "play emtpy" is set advance to next chunk. 997 */ 998 #if 1 999 /* Ack all play interrupts*/ 1000 if ((csr & (APC_PI|APC_PD|APC_PIE|APC_PMI)) != 0) 1001 ret = 1; 1002 #endif 1003 if (csr & APC_PM) { 1004 u_long nextaddr, togo; 1005 1006 p = sc->sc_nowplaying; 1007 1008 togo = sc->sc_playsegsz - sc->sc_playcnt; 1009 if (togo == 0) { 1010 /* Roll over */ 1011 nextaddr = (u_long)p->segs[0].ds_addr; 1012 sc->sc_playcnt = togo = APC_MAX; 1013 } else { 1014 nextaddr = dma->dmapnva + APC_MAX; 1015 if (togo > APC_MAX) 1016 togo = APC_MAX; 1017 sc->sc_playcnt += togo; 1018 } 1019 1020 dma->dmapnva = nextaddr; 1021 dma->dmapnc = togo; 1022 1023 if (sc->sc_pintr != NULL) 1024 (*sc->sc_pintr)(sc->sc_parg); 1025 1026 ret = 1; 1027 } 1028 1029 if (csr & APC_CI) { 1030 if (sc->sc_rintr != NULL) { 1031 ret = 1; 1032 (*sc->sc_rintr)(sc->sc_rarg); 1033 } 1034 } 1035 1036 #ifdef DEBUG 1037 if (ret == 0) { 1038 printf( 1039 "oops: csr=%s; dmapva=0x%lx,dmapc=%lu;dmapnva=0x%lx,dmapnc=%lu\n", 1040 bitmask_snprintf(csr, APC_BITS, bits, sizeof(bits)), 1041 (u_long)dma->dmapva, (u_long)dma->dmapc, 1042 (u_long)dma->dmapnva, (u_long)dma->dmapnc); 1043 ret = 1; 1044 } 1045 #endif 1046 1047 return (ret); 1048 } 1049 #endif /* NAUDIO > 0 */ 1050
Indexes created Thu Oct 02 01:09:59 GMT 2025