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