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