cs4231_sbus.c revision 1.18
1 /* $NetBSD: cs4231_sbus.c,v 1.18 2002/03/12 04:48:29 uwe Exp $ */ 2 3 /*- 4 * Copyright (c) 1998, 1999, 2002 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 <sys/cdefs.h> 40 __KERNEL_RCSID(0, "$NetBSD: cs4231_sbus.c,v 1.18 2002/03/12 04:48:29 uwe Exp $"); 41 42 #include "audio.h" 43 #if NAUDIO > 0 44 45 #include <sys/param.h> 46 #include <sys/systm.h> 47 #include <sys/errno.h> 48 #include <sys/device.h> 49 #include <sys/malloc.h> 50 51 #include <machine/bus.h> 52 #include <machine/intr.h> 53 54 #include <dev/sbus/sbusvar.h> 55 56 #include <sys/audioio.h> 57 #include <dev/audio_if.h> 58 59 #include <dev/ic/ad1848reg.h> 60 #include <dev/ic/cs4231reg.h> 61 #include <dev/ic/ad1848var.h> 62 #include <dev/ic/cs4231var.h> 63 64 #include <dev/ic/apcdmareg.h> 65 66 #ifdef AUDIO_DEBUG 67 int cs4231_sbus_debug = 0; 68 #define DPRINTF(x) if (cs4231_sbus_debug) printf x 69 #else 70 #define DPRINTF(x) 71 #endif 72 73 /* where APC DMA registers are located */ 74 #define CS4231_APCDMA_OFFSET 16 75 76 /* interrupt enable bits except those specific for playback/capture */ 77 #define APC_ENABLE (APC_EI | APC_IE | APC_EIE) 78 79 struct cs4231_sbus_softc { 80 struct cs4231_softc sc_cs4231; 81 82 struct sbusdev sc_sd; /* sbus device */ 83 volatile struct apc_dma *sc_dmareg; /* DMA controller registers */ 84 }; 85 86 87 static int cs4231_sbus_match(struct device *, struct cfdata *, void *); 88 static void cs4231_sbus_attach(struct device *, struct device *, void *); 89 90 struct cfattach audiocs_sbus_ca = { 91 sizeof(struct cs4231_sbus_softc), cs4231_sbus_match, cs4231_sbus_attach 92 }; 93 94 95 96 /* audio_hw_if methods specific to apc dma */ 97 static int cs4231_sbus_trigger_output(void *, void *, void *, int, 98 void (*)(void *), void *, 99 struct audio_params *); 100 static int cs4231_sbus_trigger_input(void *, void *, void *, int, 101 void (*)(void *), void *, 102 struct audio_params *); 103 static int cs4231_sbus_halt_output(void *); 104 static int cs4231_sbus_halt_input(void *); 105 106 struct audio_hw_if audiocs_sbus_hw_if = { 107 cs4231_open, 108 cs4231_close, 109 NULL, /* drain */ 110 ad1848_query_encoding, 111 ad1848_set_params, 112 cs4231_round_blocksize, 113 ad1848_commit_settings, 114 NULL, /* init_output */ 115 NULL, /* init_input */ 116 NULL, /* start_output */ 117 NULL, /* start_input */ 118 cs4231_sbus_halt_output, 119 cs4231_sbus_halt_input, 120 NULL, /* speaker_ctl */ 121 cs4231_getdev, 122 NULL, /* setfd */ 123 cs4231_set_port, 124 cs4231_get_port, 125 cs4231_query_devinfo, 126 cs4231_malloc, 127 cs4231_free, 128 cs4231_round_buffersize, 129 NULL, /* mappage */ 130 cs4231_get_props, 131 cs4231_sbus_trigger_output, 132 cs4231_sbus_trigger_input, 133 NULL, /* dev_ioctl */ 134 }; 135 136 137 #ifdef AUDIO_DEBUG 138 static void cs4231_sbus_regdump(char *, struct cs4231_sbus_softc *); 139 #endif 140 141 static int cs4231_sbus_intr(void *); 142 143 144 145 static int 146 cs4231_sbus_match(parent, cf, aux) 147 struct device *parent; 148 struct cfdata *cf; 149 void *aux; 150 { 151 struct sbus_attach_args *sa = aux; 152 153 return (strcmp(sa->sa_name, AUDIOCS_PROM_NAME) == 0); 154 } 155 156 157 static void 158 cs4231_sbus_attach(parent, self, aux) 159 struct device *parent, *self; 160 void *aux; 161 { 162 struct cs4231_sbus_softc *sbsc = (struct cs4231_sbus_softc *)self; 163 struct cs4231_softc *sc = &sbsc->sc_cs4231; 164 struct sbus_attach_args *sa = aux; 165 bus_space_handle_t bh; 166 167 sc->sc_bustag = sa->sa_bustag; 168 sc->sc_dmatag = sa->sa_dmatag; 169 170 /* 171 * Map my registers in, if they aren't already in virtual 172 * address space. 173 */ 174 if (sa->sa_npromvaddrs) { 175 bh = (bus_space_handle_t)sa->sa_promvaddrs[0]; 176 } else { 177 if (sbus_bus_map(sa->sa_bustag, 178 sa->sa_slot, sa->sa_offset, sa->sa_size, 179 BUS_SPACE_MAP_LINEAR, &bh) != 0) { 180 printf("%s @ sbus: cannot map registers\n", 181 self->dv_xname); 182 return; 183 } 184 } 185 186 sbsc->sc_dmareg = 187 (volatile struct apc_dma *)(u_long)(bh + CS4231_APCDMA_OFFSET); 188 189 cs4231_common_attach(sc, bh); 190 printf("\n"); 191 192 sbus_establish(&sbsc->sc_sd, &sc->sc_ad1848.sc_dev); 193 194 /* Establish interrupt channel */ 195 if (sa->sa_nintr) 196 bus_intr_establish(sa->sa_bustag, 197 sa->sa_pri, IPL_AUDIO, 0, 198 cs4231_sbus_intr, sbsc); 199 200 audio_attach_mi(&audiocs_sbus_hw_if, sbsc, &sc->sc_ad1848.sc_dev); 201 } 202 203 204 #ifdef AUDIO_DEBUG 205 static void 206 cs4231_sbus_regdump(label, sc) 207 char *label; 208 struct cs4231_sbus_softc *sc; 209 { 210 char bits[128]; 211 volatile struct apc_dma *dma = sc->sc_dmareg; 212 213 printf("cs4231regdump(%s): regs:", label); 214 printf("dmapva: 0x%x; ", dma->dmapva); 215 printf("dmapc: 0x%x; ", dma->dmapc); 216 printf("dmapnva: 0x%x; ", dma->dmapnva); 217 printf("dmapnc: 0x%x\n", dma->dmapnc); 218 printf("dmacva: 0x%x; ", dma->dmacva); 219 printf("dmacc: 0x%x; ", dma->dmacc); 220 printf("dmacnva: 0x%x; ", dma->dmacnva); 221 printf("dmacnc: 0x%x\n", dma->dmacnc); 222 223 printf("apc_dmacsr=%s\n", 224 bitmask_snprintf(dma->dmacsr, APC_BITS, bits, sizeof(bits))); 225 226 ad1848_dump_regs(&sc->sc_cs4231.sc_ad1848); 227 } 228 #endif /* AUDIO_DEBUG */ 229 230 231 static int 232 cs4231_sbus_trigger_output(addr, start, end, blksize, intr, arg, param) 233 void *addr; 234 void *start, *end; 235 int blksize; 236 void (*intr)(void *); 237 void *arg; 238 struct audio_params *param; 239 { 240 struct cs4231_sbus_softc *sbsc = addr; 241 struct cs4231_softc *sc = &sbsc->sc_cs4231; 242 struct cs_transfer *t = &sc->sc_playback; 243 volatile struct apc_dma *dma = sbsc->sc_dmareg; 244 u_int32_t csr; 245 bus_addr_t dmaaddr; 246 bus_size_t dmasize; 247 int ret; 248 #ifdef AUDIO_DEBUG 249 char bits[128]; 250 #endif 251 252 ret = cs4231_transfer_init(sc, t, &dmaaddr, &dmasize, 253 start, end, blksize, intr, arg); 254 if (ret != 0) 255 return (ret); 256 257 DPRINTF(("trigger_output: csr=%s\n", 258 bitmask_snprintf(csr, APC_BITS, bits, sizeof(bits)))); 259 DPRINTF(("trigger_output: was: %x %d, %x %d\n", 260 dma->dmapva, dma->dmapc, dma->dmapnva, dma->dmapnc)); 261 262 /* load first block */ 263 dma->dmapnva = (u_int32_t)dmaaddr; 264 dma->dmapnc = (u_int32_t)dmasize; 265 266 DPRINTF(("trigger_output: 1st: %x %d, %x %d\n", 267 dma->dmapva, dma->dmapc, dma->dmapnva, dma->dmapnc)); 268 269 csr = dma->dmacsr; 270 if ((csr & PDMA_GO) == 0 || (csr & APC_PPAUSE) != 0) { 271 int cfg; 272 273 dma->dmacsr &= ~(APC_PPAUSE | APC_PMIE | APC_INTR_MASK); 274 275 csr = dma->dmacsr & ~APC_INTR_MASK; 276 csr |= APC_ENABLE | APC_PIE | APC_PMIE | PDMA_GO; 277 dma->dmacsr = csr; 278 279 ad_write(&sc->sc_ad1848, SP_LOWER_BASE_COUNT, 0xff); 280 ad_write(&sc->sc_ad1848, SP_UPPER_BASE_COUNT, 0xff); 281 282 cfg = ad_read(&sc->sc_ad1848, SP_INTERFACE_CONFIG); 283 ad_write(&sc->sc_ad1848, SP_INTERFACE_CONFIG, 284 (cfg | PLAYBACK_ENABLE)); 285 } else { 286 DPRINTF(("trigger_output: already: csr=%s\n", 287 bitmask_snprintf(csr, APC_BITS, bits, sizeof(bits)))); 288 } 289 290 /* load next block if we can */ 291 if (dma->dmacsr & APC_PD) { 292 cs4231_transfer_advance(t, &dmaaddr, &dmasize); 293 dma->dmapnva = (u_int32_t)dmaaddr; 294 dma->dmapnc = (u_int32_t)dmasize; 295 DPRINTF(("trigger_output: 2nd: %x %d, %x %d\n", 296 dma->dmapva, dma->dmapc, dma->dmapnva, dma->dmapnc)); 297 } 298 299 return (0); 300 } 301 302 303 static int 304 cs4231_sbus_halt_output(addr) 305 void *addr; 306 { 307 struct cs4231_sbus_softc *sbsc = addr; 308 struct cs4231_softc *sc = &sbsc->sc_cs4231; 309 volatile struct apc_dma *dma = sbsc->sc_dmareg; 310 u_int32_t csr; 311 int cfg; 312 #ifdef AUDIO_DEBUG 313 char bits[128]; 314 #endif 315 316 sc->sc_playback.t_active = 0; 317 318 csr = dma->dmacsr; 319 DPRINTF(("halt_output: csr=%s\n", 320 bitmask_snprintf(dma->dmacsr, APC_BITS, bits, sizeof(bits)))); 321 322 csr &= ~APC_INTR_MASK; /* do not clear interrupts accidentally */ 323 csr |= APC_PPAUSE; /* pause playback (let current complete) */ 324 dma->dmacsr = csr; 325 326 /* let the curernt transfer complete */ 327 if (csr & PDMA_GO) 328 do { 329 csr = dma->dmacsr; 330 DPRINTF(("halt_output: csr=%s\n", 331 bitmask_snprintf(dma->dmacsr, APC_BITS, 332 bits, sizeof(bits)))); 333 } while ((csr & APC_PM) == 0); 334 335 cfg = ad_read(&sc->sc_ad1848, SP_INTERFACE_CONFIG); 336 ad_write(&sc->sc_ad1848, SP_INTERFACE_CONFIG,(cfg & ~PLAYBACK_ENABLE)); 337 338 return (0); 339 } 340 341 342 /* NB: we don't enable APC_CMIE and won't use APC_CM */ 343 static int 344 cs4231_sbus_trigger_input(addr, start, end, blksize, intr, arg, param) 345 void *addr; 346 void *start, *end; 347 int blksize; 348 void (*intr)(void *); 349 void *arg; 350 struct audio_params *param; 351 { 352 struct cs4231_sbus_softc *sbsc = addr; 353 struct cs4231_softc *sc = &sbsc->sc_cs4231; 354 struct cs_transfer *t = &sc->sc_capture; 355 volatile struct apc_dma *dma = sbsc->sc_dmareg; 356 u_int32_t csr; 357 bus_addr_t dmaaddr; 358 bus_size_t dmasize; 359 int ret; 360 #ifdef AUDIO_DEBUG 361 char bits[128]; 362 #endif 363 364 ret = cs4231_transfer_init(sc, t, &dmaaddr, &dmasize, 365 start, end, blksize, intr, arg); 366 if (ret != 0) 367 return (ret); 368 369 DPRINTF(("trigger_input: csr=%s\n", 370 bitmask_snprintf(csr, APC_BITS, bits, sizeof(bits)))); 371 DPRINTF(("trigger_input: was: %x %d, %x %d\n", 372 dma->dmacva, dma->dmacc, dma->dmacnva, dma->dmacnc)); 373 374 /* supply first block */ 375 dma->dmacnva = (u_int32_t)dmaaddr; 376 dma->dmacnc = (u_int32_t)dmasize; 377 378 DPRINTF(("trigger_input: 1st: %x %d, %x %d\n", 379 dma->dmacva, dma->dmacc, dma->dmacnva, dma->dmacnc)); 380 381 csr = dma->dmacsr; 382 if ((csr & CDMA_GO) == 0 || (csr & APC_CPAUSE) != 0) { 383 int cfg; 384 385 dma->dmacsr &= ~(APC_CPAUSE | APC_CMIE | APC_INTR_MASK); 386 387 csr = dma->dmacsr & ~APC_INTR_MASK; 388 csr |= APC_ENABLE | APC_CIE | CDMA_GO; 389 dma->dmacsr = csr; 390 391 ad_write(&sc->sc_ad1848, CS_LOWER_REC_CNT, 0xff); 392 ad_write(&sc->sc_ad1848, CS_UPPER_REC_CNT, 0xff); 393 394 cfg = ad_read(&sc->sc_ad1848, SP_INTERFACE_CONFIG); 395 ad_write(&sc->sc_ad1848, SP_INTERFACE_CONFIG, 396 (cfg | CAPTURE_ENABLE)); 397 } else { 398 DPRINTF(("trigger_input: already: csr=%s\n", 399 bitmask_snprintf(csr, APC_BITS, bits, sizeof(bits)))); 400 } 401 402 /* supply next block if we can */ 403 if (dma->dmacsr & APC_CD) { 404 cs4231_transfer_advance(t, &dmaaddr, &dmasize); 405 dma->dmacnva = (u_int32_t)dmaaddr; 406 dma->dmacnc = (u_int32_t)dmasize; 407 DPRINTF(("trigger_input: 2nd: %x %d, %x %d\n", 408 dma->dmacva, dma->dmacc, dma->dmacnva, dma->dmacnc)); 409 } 410 411 return (0); 412 } 413 414 415 static int 416 cs4231_sbus_halt_input(addr) 417 void *addr; 418 { 419 struct cs4231_sbus_softc *sbsc = addr; 420 struct cs4231_softc *sc = &sbsc->sc_cs4231; 421 volatile struct apc_dma *dma = sbsc->sc_dmareg; 422 u_int32_t csr; 423 int cfg; 424 #ifdef AUDIO_DEBUG 425 char bits[128]; 426 #endif 427 428 sc->sc_capture.t_active = 0; 429 430 csr = dma->dmacsr; 431 DPRINTF(("halt_input: csr=%s\n", 432 bitmask_snprintf(dma->dmacsr, APC_BITS, bits, sizeof(bits)))); 433 434 csr &= ~APC_INTR_MASK; /* do not clear interrupts accidentally */ 435 csr |= APC_CPAUSE; 436 dma->dmacsr = csr; 437 438 /* let the curernt transfer complete */ 439 if (csr & CDMA_GO) 440 do { 441 csr = dma->dmacsr; 442 DPRINTF(("halt_input: csr=%s\n", 443 bitmask_snprintf(dma->dmacsr, APC_BITS, 444 bits, sizeof(bits)))); 445 } while ((csr & APC_CM) == 0); 446 447 cfg = ad_read(&sc->sc_ad1848, SP_INTERFACE_CONFIG); 448 ad_write(&sc->sc_ad1848, SP_INTERFACE_CONFIG, (cfg & ~CAPTURE_ENABLE)); 449 450 return (0); 451 } 452 453 454 static int 455 cs4231_sbus_intr(arg) 456 void *arg; 457 { 458 struct cs4231_sbus_softc *sbsc = arg; 459 struct cs4231_softc *sc = &sbsc->sc_cs4231; 460 volatile struct apc_dma *dma = sbsc->sc_dmareg; 461 u_int32_t csr; 462 int status; 463 bus_addr_t dmaaddr; 464 bus_size_t dmasize; 465 int served; 466 #if defined(AUDIO_DEBUG) || defined(DIAGNOSTIC) 467 char bits[128]; 468 #endif 469 470 csr = dma->dmacsr; 471 if ((csr & APC_INTR_MASK) == 0) /* any interrupt pedning? */ 472 return (0); 473 474 dma->dmacsr = csr; /* write back DMA status to clear interrupt */ 475 ++sc->sc_intrcnt.ev_count; 476 served = 0; 477 478 #ifdef AUDIO_DEBUG 479 if (cs4231_sbus_debug > 1) 480 cs4231_sbus_regdump("audiointr", sbsc); 481 #endif 482 483 status = ADREAD(&sc->sc_ad1848, AD1848_STATUS); 484 DPRINTF(("%s: status: %s\n", sc->sc_ad1848.sc_dev.dv_xname, 485 bitmask_snprintf(status, AD_R2_BITS, bits, sizeof(bits)))); 486 if (status & INTERRUPT_STATUS) { 487 #ifdef AUDIO_DEBUG 488 int reason; 489 490 reason = ad_read(&sc->sc_ad1848, CS_IRQ_STATUS); 491 DPRINTF(("%s: i24: %s\n", sc->sc_ad1848.sc_dev.dv_xname, 492 bitmask_snprintf(reason, CS_I24_BITS, bits, sizeof(bits)))); 493 #endif 494 /* clear ad1848 interrupt */ 495 ADWRITE(&sc->sc_ad1848, AD1848_STATUS, 0); 496 } 497 498 if (csr & APC_CI) { 499 if (csr & APC_CD) { /* can supply new block */ 500 struct cs_transfer *t = &sc->sc_capture; 501 502 cs4231_transfer_advance(t, &dmaaddr, &dmasize); 503 dma->dmacnva = (u_int32_t)dmaaddr; 504 dma->dmacnc = (u_int32_t)dmasize; 505 506 if (t->t_intr != NULL) 507 (*t->t_intr)(t->t_arg); 508 ++t->t_intrcnt.ev_count; 509 served = 1; 510 } 511 } 512 513 if (csr & APC_PMI) { 514 if (!sc->sc_playback.t_active) 515 served = 1; /* draining in halt_output() */ 516 } 517 518 if (csr & APC_PI) { 519 if (csr & APC_PD) { /* can load new block */ 520 struct cs_transfer *t = &sc->sc_playback; 521 522 if (t->t_active) { 523 cs4231_transfer_advance(t, &dmaaddr, &dmasize); 524 dma->dmapnva = (u_int32_t)dmaaddr; 525 dma->dmapnc = (u_int32_t)dmasize; 526 } 527 528 if (t->t_intr != NULL) 529 (*t->t_intr)(t->t_arg); 530 ++t->t_intrcnt.ev_count; 531 served = 1; 532 } 533 } 534 535 /* got an interrupt we don't know how to handle */ 536 if (!served) { 537 #ifdef DIAGNOSTIC 538 printf("%s: unhandled csr=%s\n", sc->sc_ad1848.sc_dev.dv_xname, 539 bitmask_snprintf(csr, APC_BITS, bits, sizeof(bits))); 540 #endif 541 /* evcnt? */ 542 } 543 544 return (1); 545 } 546 547 #endif /* NAUDIO > 0 */ 548
Indexes created Thu Oct 02 01:09:59 GMT 2025