![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to audio.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / chips|
Return to audio.c CVS log | Up to [GnuMach] / Gnu-Mach / chips |
1.1 ! root 1: /* ! 2: * Mach Operating System ! 3: * Copyright (c) 1993 Carnegie Mellon University ! 4: * All Rights Reserved. ! 5: * ! 6: * Permission to use, copy, modify and distribute this software and its ! 7: * documentation is hereby granted, provided that both the copyright ! 8: * notice and this permission notice appear in all copies of the ! 9: * software, derivative works or modified versions, and any portions ! 10: * thereof, and that both notices appear in supporting documentation. ! 11: * ! 12: * CARNEGIE MELLON ALLOWS FREE USE OF THIS SOFTWARE IN ITS "AS IS" ! 13: * CONDITION. CARNEGIE MELLON DISCLAIMS ANY LIABILITY OF ANY KIND FOR ! 14: * ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE. ! 15: * ! 16: * Carnegie Mellon requests users of this software to return to ! 17: * ! 18: * Software Distribution Coordinator or [email protected] ! 19: * School of Computer Science ! 20: * Carnegie Mellon University ! 21: * Pittsburgh PA 15213-3890 ! 22: * ! 23: * any improvements or extensions that they make and grant Carnegie Mellon ! 24: * the rights to redistribute these changes. ! 25: */ ! 26: /*- ! 27: * Copyright (c) 1991, 1992 The Regents of the University of California. ! 28: * All rights reserved. ! 29: * ! 30: * Redistribution and use in source and binary forms, with or without ! 31: * modification, are permitted provided that the following conditions ! 32: * are met: ! 33: * 1. Redistributions of source code must retain the above copyright ! 34: * notice, this list of conditions and the following disclaimer. ! 35: * 2. Redistributions in binary form must reproduce the above copyright ! 36: * notice, this list of conditions and the following disclaimer in the ! 37: * documentation and/or other materials provided with the distribution. ! 38: * 3. All advertising materials mentioning features or use of this software ! 39: * must display the following acknowledgement: ! 40: * This product includes software developed by the Computer Systems ! 41: * Engineering Group at Lawrence Berkeley Laboratory. ! 42: * 4. The name of the Laboratory may not be used to endorse or promote ! 43: * products derived from this software without specific prior written ! 44: * permission. ! 45: * ! 46: * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ! 47: * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE ! 48: * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ! 49: * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE ! 50: * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL ! 51: * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS ! 52: * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ! 53: * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT ! 54: * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY ! 55: * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF ! 56: * SUCH DAMAGE. ! 57: */ ! 58: ! 59: #include <audio.h> ! 60: #if NAUDIO > 0 ! 61: ! 62: #include <mach_kdb.h> ! 63: #include <platforms.h> ! 64: ! 65: #include <mach/std_types.h> ! 66: #include <machine/machspl.h> ! 67: #include <kern/kalloc.h> ! 68: #include <kern/sched_prim.h> ! 69: #include <chips/busses.h> ! 70: ! 71: #include <device/device_types.h> ! 72: #include <device/io_req.h> ! 73: #include <device/ds_routines.h> ! 74: #include <device/audio_status.h> /* user interface */ ! 75: #include <chips/audio_defs.h> /* chip interface */ ! 76: #include <chips/audio_config.h> /* machdep config */ ! 77: ! 78: #define private static ! 79: ! 80: /* ! 81: * Exported functions and data structures ! 82: * [see header file for listing] ! 83: */ ! 84: int audio_blocksize = DEFBLKSIZE; /* patchable */ ! 85: int audio_backlog = 400; /* 50ms in samples */ ! 86: ! 87: /* ! 88: * Software state, per AMD79C30 audio chip. ! 89: */ ! 90: private ! 91: struct audio_softc { ! 92: void *hw; /* chip status */ ! 93: audio_switch_t *ops; /* chip operations */ ! 94: au_io_t *sc_au; /* recv and xmit buffers, etc */ ! 95: ! 96: ! 97: unsigned int sc_wseek; /* timestamp of last frame written */ ! 98: unsigned int sc_rseek; /* timestamp of last frame read */ ! 99: #if 0 ! 100: struct selinfo sc_wsel; /* write selector */ ! 101: struct selinfo sc_rsel; /* read selector */ ! 102: #endif ! 103: ! 104: } audio_softc_data[NAUDIO]; ! 105: ! 106: #define unit_to_softc(u) &audio_softc_data[u] ! 107: ! 108: ! 109: /* forward declarations */ ! 110: private int audio_sleep (au_cb_t *cb, int thresh); ! 111: private void audio_swintr (struct audio_softc *sc); ! 112: ! 113: /* ! 114: * Audio chip found. ! 115: */ ! 116: void ! 117: audio_attach( ! 118: void *hw, /* IN, chip status */ ! 119: audio_switch_t *ops, ! 120: void **audio_status) /* OUT, audio status */ ! 121: { ! 122: register struct audio_softc *sc; ! 123: static int next = 0; ! 124: ! 125: if (next >= NAUDIO) ! 126: panic("Please configure more than %d audio devices\n", NAUDIO); ! 127: sc = &audio_softc_data[next++]; ! 128: ! 129: printf(" audio"); ! 130: ! 131: sc->hw = hw; ! 132: sc->ops = ops; ! 133: ! 134: *audio_status = (void *)sc; ! 135: } ! 136: ! 137: ! 138: private int audio_setinfo (struct audio_softc *, audio_info_t *); ! 139: private int audio_getinfo (struct audio_softc *, audio_info_t *); ! 140: ! 141: io_return_t ! 142: audio_open( ! 143: int unit, ! 144: int mode, ! 145: io_req_t req) ! 146: { ! 147: register struct audio_softc *sc; ! 148: register au_io_t *au; ! 149: ! 150: sc = unit_to_softc(unit); ! 151: if (unit > NAUDIO || (!sc->hw)) ! 152: return (D_NO_SUCH_DEVICE); ! 153: ! 154: if (!sc->sc_au) { ! 155: sc->sc_au = (au_io_t *) kalloc(sizeof(au_io_t)); ! 156: bzero(sc->sc_au, sizeof(au_io_t)); ! 157: } ! 158: au = sc->sc_au; ! 159: ! 160: au->au_lowat = audio_blocksize; ! 161: au->au_hiwat = AUCB_SIZE - au->au_lowat; ! 162: au->au_blksize = audio_blocksize; ! 163: au->au_backlog = audio_backlog; ! 164: ! 165: /* set up read and write blocks and `dead sound' zero value. */ ! 166: AUCB_INIT(&au->au_rb); ! 167: au->au_rb.cb_thresh = AUCB_SIZE; ! 168: AUCB_INIT(&au->au_wb); ! 169: au->au_wb.cb_thresh = -1; ! 170: ! 171: /* nothing read or written yet */ ! 172: sc->sc_rseek = 0; ! 173: sc->sc_wseek = 0; ! 174: ! 175: (*sc->ops->init)(sc->hw); ! 176: ! 177: return (0); ! 178: } ! 179: ! 180: private int ! 181: audio_drain( ! 182: register au_io_t *au) ! 183: { ! 184: register int error; ! 185: ! 186: while (!AUCB_EMPTY(&au->au_wb)) ! 187: if ((error = audio_sleep(&au->au_wb, 0)) != 0) ! 188: return (error); ! 189: return (0); ! 190: } ! 191: ! 192: /* ! 193: * Close an audio chip. ! 194: */ ! 195: /* ARGSUSED */ ! 196: io_return_t ! 197: audio_close( ! 198: int unit) ! 199: { ! 200: register struct audio_softc *sc = unit_to_softc(unit); ! 201: register au_cb_t *cb; ! 202: register spl_t s; ! 203: ! 204: /* ! 205: * Block until output drains, but allow ^C interrupt. ! 206: */ ! 207: sc->sc_au->au_lowat = 0; /* avoid excessive wakeups */ ! 208: ! 209: /* ! 210: * If there is pending output, let it drain (unless ! 211: * the output is paused). ! 212: */ ! 213: cb = &sc->sc_au->au_wb; ! 214: s = splaudio(); ! 215: if (!AUCB_EMPTY(cb) && !cb->cb_pause) ! 216: (void)audio_drain(sc->sc_au); ! 217: /* ! 218: * Disable interrupts, and done. ! 219: */ ! 220: (*sc->ops->close)(sc->hw); ! 221: splx(s); ! 222: return (D_SUCCESS); ! 223: } ! 224: ! 225: private int ! 226: audio_sleep( ! 227: register au_cb_t *cb, ! 228: register int thresh) ! 229: { ! 230: register spl_t s = splaudio(); ! 231: ! 232: cb->cb_thresh = thresh; ! 233: assert_wait((event_t)cb, TRUE); ! 234: splx(s); ! 235: thread_block((void (*)()) 0); ! 236: return (0); /* XXXX */ ! 237: } ! 238: ! 239: io_return_t ! 240: audio_read( ! 241: int unit, ! 242: io_req_t ior) ! 243: { ! 244: register struct audio_softc *sc = unit_to_softc(unit); ! 245: register au_cb_t *cb; ! 246: register int n, head, taildata; ! 247: register int blocksize = sc->sc_au->au_blksize; ! 248: io_return_t rc; ! 249: unsigned char *data; ! 250: ! 251: /* ! 252: * Allocate read buffer ! 253: */ ! 254: rc = device_read_alloc(ior, (vm_size_t)ior->io_count); ! 255: if (rc != KERN_SUCCESS) ! 256: return rc; ! 257: data = (unsigned char *) ior->io_data; ! 258: ior->io_residual = ior->io_count; ! 259: ! 260: cb = &sc->sc_au->au_rb; ! 261: cb->cb_drops = 0; ! 262: sc->sc_rseek = sc->sc_au->au_stamp - AUCB_LEN(cb); ! 263: do { ! 264: while (AUCB_LEN(cb) < blocksize) { ! 265: ! 266: if (ior->io_mode & D_NODELAY) ! 267: return (D_WOULD_BLOCK); ! 268: ! 269: if ((rc = audio_sleep(cb, blocksize)) != 0) ! 270: return(rc); ! 271: } ! 272: /* ! 273: * The space calculation can only err on the short ! 274: * side if an interrupt occurs during processing: ! 275: * only cb_tail is altered in the interrupt code. ! 276: */ ! 277: head = cb->cb_head; ! 278: if ((n = AUCB_LEN(cb)) > ior->io_residual) ! 279: n = ior->io_residual; ! 280: taildata = AUCB_SIZE - head; ! 281: ! 282: if (n > taildata) { ! 283: bcopy(cb->cb_data + head, data, taildata); ! 284: bcopy(cb->cb_data, data + taildata, n - taildata); ! 285: } else ! 286: bcopy(cb->cb_data + head, data, n); ! 287: data += n; ! 288: ior->io_residual -= n; ! 289: ! 290: head = AUCB_MOD(head + n); ! 291: cb->cb_head = head; ! 292: } while (ior->io_residual >= blocksize); ! 293: ! 294: return (rc); ! 295: } ! 296: ! 297: io_return_t ! 298: audio_write( ! 299: int unit, ! 300: io_req_t ior) ! 301: { ! 302: register struct audio_softc *sc = unit_to_softc(unit); ! 303: register au_io_t *au = sc->sc_au; ! 304: register au_cb_t *cb = &au->au_wb; ! 305: register int n, tail, tailspace, first, watermark; ! 306: io_return_t rc; ! 307: unsigned char *data; ! 308: vm_offset_t addr = 0; ! 309: ! 310: if (!(ior->io_op & IO_INBAND)) { ! 311: /* ! 312: * Copy out-of-line data into kernel address space. ! 313: * Since data is copied as page list, it will be ! 314: * accessible. ! 315: */ ! 316: vm_map_copy_t copy = (vm_map_copy_t) ior->io_data; ! 317: kern_return_t kr; ! 318: ! 319: kr = vm_map_copyout(device_io_map, &addr, copy); ! 320: if (kr != KERN_SUCCESS) ! 321: return kr; ! 322: data = (unsigned char *) addr; ! 323: } else ! 324: data = (unsigned char *) ior->io_data; ! 325: ior->io_residual = ior->io_count; ! 326: ! 327: rc = D_SUCCESS; ! 328: first = 1; ! 329: while (ior->io_residual > 0) { ! 330: watermark = au->au_hiwat; ! 331: while (AUCB_LEN(cb) > watermark) { ! 332: ! 333: if (ior->io_mode & D_NODELAY) { ! 334: rc = D_WOULD_BLOCK; ! 335: goto out; ! 336: } ! 337: ! 338: if ((rc = audio_sleep(cb, watermark)) != 0) ! 339: goto out; ! 340: ! 341: watermark = au->au_lowat; ! 342: } ! 343: /* ! 344: * The only value that can change on an interrupt is ! 345: * cb->cb_head. We only pull that out once to decide ! 346: * how much to write into cb_data; if we lose a race ! 347: * and cb_head changes, we will merely be overly ! 348: * conservative. For a legitimate time stamp, ! 349: * however, we need to synchronize the accesses to ! 350: * au_stamp and cb_head at a high ipl below. ! 351: */ ! 352: tail = cb->cb_tail; ! 353: if ((n = (AUCB_SIZE - 1) - AUCB_LEN(cb)) > ior->io_residual) { ! 354: n = ior->io_residual; ! 355: if (cb->cb_head == tail && ! 356: n <= au->au_blksize && ! 357: au->au_stamp - sc->sc_wseek > 400) { ! 358: /* ! 359: * the write is 'small', the buffer is empty ! 360: * and we have been silent for at least 50ms ! 361: * so we might be dealing with an application ! 362: * that writes frames synchronously with ! 363: * reading them. If so, we need an output ! 364: * backlog to cover scheduling delays or ! 365: * there will be gaps in the sound output. ! 366: * Also take this opportunity to reset the ! 367: * buffer pointers in case we ended up on ! 368: * a bad boundary (odd byte, blksize bytes ! 369: * from end, etc.). ! 370: */ ! 371: register unsigned long *ip; ! 372: register unsigned long muzero; ! 373: spl_t s; ! 374: register int i; ! 375: ! 376: s = splaudio(); ! 377: cb->cb_head = cb->cb_tail = 0; ! 378: splx(s); ! 379: ! 380: tail = au->au_backlog; ! 381: ip = (unsigned long *)cb->cb_data; ! 382: muzero = sample_rpt_long(0x7fL); ! 383: for (i = tail / sizeof muzero; --i >= 0; ) ! 384: *ip++ = muzero; ! 385: } ! 386: } ! 387: tailspace = AUCB_SIZE - tail; ! 388: if (n > tailspace) { ! 389: /* write first part at tail and rest at head */ ! 390: bcopy(data, cb->cb_data + tail, tailspace); ! 391: bcopy(data + tailspace, cb->cb_data, ! 392: n - tailspace); ! 393: } else ! 394: bcopy(data, cb->cb_data + tail, n); ! 395: data += n; ! 396: ior->io_residual -= n; ! 397: ! 398: tail = AUCB_MOD(tail + n); ! 399: if (first) { ! 400: register spl_t s = splaudio(); ! 401: sc->sc_wseek = AUCB_LEN(cb) + au->au_stamp + 1; ! 402: /* ! 403: * To guarantee that a write is contiguous in the ! 404: * sample space, we clear the drop count the first ! 405: * time through. If we later get drops, we will ! 406: * break out of the loop below, before writing ! 407: * a new frame. ! 408: */ ! 409: cb->cb_drops = 0; ! 410: cb->cb_tail = tail; ! 411: splx(s); ! 412: first = 0; ! 413: } else { ! 414: #if 0 ! 415: if (cb->cb_drops != 0) ! 416: break; ! 417: #endif ! 418: cb->cb_tail = tail; ! 419: } ! 420: } ! 421: out: ! 422: if (!(ior->io_op & IO_INBAND)) ! 423: (void) vm_deallocate(device_io_map, addr, ior->io_count); ! 424: return (rc); ! 425: } ! 426: ! 427: #include <sys/ioctl.h> ! 428: ! 429: io_return_t ! 430: audio_get_status( ! 431: int unit, ! 432: dev_flavor_t flavor, ! 433: dev_status_t status, ! 434: natural_t *status_count) ! 435: { ! 436: register struct audio_softc *sc = unit_to_softc(unit); ! 437: register au_io_t *au = sc->sc_au; ! 438: io_return_t rc = D_SUCCESS; ! 439: spl_t s; ! 440: ! 441: switch (flavor) { ! 442: ! 443: case AUDIO_GETMAP: ! 444: case AUDIOGETREG: ! 445: rc = (*sc->ops->getstate)(sc->hw, flavor, ! 446: (void *)status, status_count); ! 447: break; ! 448: ! 449: /* ! 450: * Number of read samples dropped. We don't know where or ! 451: * when they were dropped. ! 452: */ ! 453: case AUDIO_RERROR: ! 454: *(int *)status = au->au_rb.cb_drops; ! 455: *status_count = 1; ! 456: break; ! 457: ! 458: case AUDIO_WERROR: ! 459: *(int *)status = au->au_wb.cb_drops; ! 460: *status_count = 1; ! 461: break; ! 462: ! 463: /* ! 464: * How many samples will elapse until mike hears the first ! 465: * sample of what we last wrote? ! 466: */ ! 467: case AUDIO_WSEEK: ! 468: s = splaudio(); ! 469: *(unsigned int *)status = sc->sc_wseek - au->au_stamp ! 470: + AUCB_LEN(&au->au_rb); ! 471: splx(s); ! 472: *status_count = 1; ! 473: break; ! 474: ! 475: case AUDIO_GETINFO: ! 476: rc = audio_getinfo(sc, (audio_info_t *)status); ! 477: *status_count = sizeof(audio_info_t) / sizeof(int); ! 478: break; ! 479: ! 480: default: ! 481: rc = D_INVALID_OPERATION; ! 482: break; ! 483: } ! 484: return (rc); ! 485: } ! 486: ! 487: io_return_t ! 488: audio_set_status( ! 489: int unit, ! 490: dev_flavor_t flavor, ! 491: dev_status_t status, ! 492: natural_t status_count) ! 493: { ! 494: register struct audio_softc *sc = unit_to_softc(unit); ! 495: register au_io_t *au = sc->sc_au; ! 496: io_return_t rc = D_SUCCESS; ! 497: spl_t s; ! 498: ! 499: switch (flavor) { ! 500: ! 501: case AUDIO_SETMAP: ! 502: case AUDIOSETREG: ! 503: rc = (*sc->ops->setstate)(sc->hw, flavor, ! 504: (void *)status, status_count); ! 505: break; ! 506: ! 507: case AUDIO_FLUSH: ! 508: s = splaudio(); ! 509: AUCB_INIT(&au->au_rb); ! 510: AUCB_INIT(&au->au_wb); ! 511: au->au_stamp = 0; ! 512: splx(s); ! 513: sc->sc_wseek = 0; ! 514: sc->sc_rseek = 0; ! 515: break; ! 516: ! 517: case AUDIO_SETINFO: ! 518: rc = audio_setinfo(sc, (audio_info_t *)status); ! 519: break; ! 520: ! 521: case AUDIO_DRAIN: ! 522: rc = audio_drain(au); ! 523: break; ! 524: ! 525: default: ! 526: rc = D_INVALID_OPERATION; ! 527: break; ! 528: } ! 529: return (rc); ! 530: } ! 531: ! 532: ! 533: /* ! 534: * Interrupt routine ! 535: */ ! 536: boolean_t ! 537: audio_hwintr( ! 538: void *status, ! 539: unsigned int s_in, ! 540: unsigned int *s_out) ! 541: { ! 542: register au_io_t *au = ((struct audio_softc *) status)->sc_au; ! 543: register au_cb_t *cb; ! 544: register int h, t, k; ! 545: register boolean_t wakeit = FALSE; ! 546: ! 547: ++au->au_stamp; ! 548: ! 549: /* receive incoming data */ ! 550: cb = &au->au_rb; ! 551: h = cb->cb_head; ! 552: t = cb->cb_tail; ! 553: k = AUCB_MOD(t + 1); ! 554: if (h == k) ! 555: cb->cb_drops++; ! 556: else if (cb->cb_pause != 0) ! 557: cb->cb_pdrops++; ! 558: else { ! 559: cb->cb_data[t] = s_in; ! 560: cb->cb_tail = t = k; ! 561: } ! 562: if (AUCB_MOD(t - h) >= cb->cb_thresh) { ! 563: cb->cb_thresh = AUCB_SIZE; ! 564: cb->cb_waking = 1; ! 565: wakeit = TRUE; ! 566: } ! 567: /* send outgoing data */ ! 568: cb = &au->au_wb; ! 569: h = cb->cb_head; ! 570: t = cb->cb_tail; ! 571: k = 0; ! 572: if (h == t) ! 573: cb->cb_drops++; ! 574: else if (cb->cb_pause != 0) ! 575: cb->cb_pdrops++; ! 576: else { ! 577: cb->cb_head = h = AUCB_MOD(h + 1); ! 578: *s_out = cb->cb_data[h]; ! 579: k = 1; ! 580: } ! 581: if (AUCB_MOD(t - h) <= cb->cb_thresh) { ! 582: cb->cb_thresh = -1; ! 583: cb->cb_waking = 1; ! 584: wakeit = TRUE; ! 585: } ! 586: if (wakeit) ! 587: audio_swintr((struct audio_softc *) status); ! 588: return (k == 1); ! 589: } ! 590: ! 591: private void ! 592: audio_swintr( ! 593: register struct audio_softc *sc) ! 594: { ! 595: register au_io_t *au = sc->sc_au; ! 596: ! 597: if (au->au_rb.cb_waking != 0) { ! 598: au->au_rb.cb_waking = 0; ! 599: wakeup(&au->au_rb); ! 600: } ! 601: if (au->au_wb.cb_waking != 0) { ! 602: au->au_wb.cb_waking = 0; ! 603: wakeup(&au->au_wb); ! 604: } ! 605: } ! 606: ! 607: private int ! 608: audio_setinfo( ! 609: struct audio_softc *sc, ! 610: audio_info_t *ai) ! 611: { ! 612: struct audio_prinfo *r = &ai->record, *p = &ai->play; ! 613: register int bsize; ! 614: register au_io_t *au = sc->sc_au; ! 615: spl_t s; ! 616: ! 617: (*sc->ops->setgains)(sc->hw, p->gain, r->gain, ai->monitor_gain ); ! 618: ! 619: if (p->pause != (unsigned char)~0) ! 620: au->au_wb.cb_pause = p->pause; ! 621: if (r->pause != (unsigned char)~0) ! 622: au->au_rb.cb_pause = r->pause; ! 623: ! 624: if (p->port != ~0) ! 625: (*sc->ops->setport)(sc->hw, p->port); ! 626: ! 627: if (ai->blocksize != ~0) { ! 628: if (ai->blocksize == 0) ! 629: bsize = ai->blocksize = DEFBLKSIZE; ! 630: else if (ai->blocksize > MAXBLKSIZE) ! 631: bsize = ai->blocksize = MAXBLKSIZE; ! 632: else ! 633: bsize = ai->blocksize; ! 634: ! 635: s = splaudio(); ! 636: au->au_blksize = bsize; ! 637: /* AUDIO_FLUSH */ ! 638: AUCB_INIT(&au->au_rb); ! 639: AUCB_INIT(&au->au_wb); ! 640: splx(s); ! 641: ! 642: } ! 643: if (ai->hiwat != ~0 && (unsigned)ai->hiwat < AUCB_SIZE) ! 644: au->au_hiwat = ai->hiwat; ! 645: if (ai->lowat != ~0 && ai->lowat < AUCB_SIZE) ! 646: au->au_lowat = ai->lowat; ! 647: if (ai->backlog != ~0 && ai->backlog < (AUCB_SIZE/2)) ! 648: au->au_backlog = ai->backlog; ! 649: ! 650: return (0); ! 651: } ! 652: ! 653: private int ! 654: audio_getinfo( ! 655: struct audio_softc *sc, ! 656: audio_info_t *ai) ! 657: { ! 658: struct audio_prinfo *r = &ai->record, *p = &ai->play; ! 659: register au_io_t *au = sc->sc_au; ! 660: ! 661: p->sample_rate = r->sample_rate = 8000; ! 662: p->channels = r->channels = 1; ! 663: p->precision = r->precision = 8; ! 664: p->encoding = r->encoding = AUDIO_ENCODING_ULAW; ! 665: ! 666: (*sc->ops->getgains)(sc->hw, &p->gain, &r->gain, &ai->monitor_gain ); ! 667: ! 668: r->port = AUDIO_MIKE; ! 669: p->port = (*sc->ops->getport)(sc->hw); ! 670: ! 671: p->pause = au->au_wb.cb_pause; ! 672: r->pause = au->au_rb.cb_pause; ! 673: p->error = au->au_wb.cb_drops != 0; ! 674: r->error = au->au_rb.cb_drops != 0; ! 675: ! 676: /* Now this is funny. If you got here it means you must have ! 677: opened the device, so how could it possibly be closed ? ! 678: Unless we upgrade the berkeley code to check if the chip ! 679: is currently playing and/or recording... Later. */ ! 680: p->open = TRUE; ! 681: r->open = TRUE; ! 682: ! 683: p->samples = au->au_stamp - au->au_wb.cb_pdrops; ! 684: r->samples = au->au_stamp - au->au_rb.cb_pdrops; ! 685: ! 686: p->seek = sc->sc_wseek; ! 687: r->seek = sc->sc_rseek; ! 688: ! 689: ai->blocksize = au->au_blksize; ! 690: ai->hiwat = au->au_hiwat; ! 691: ai->lowat = au->au_lowat; ! 692: ai->backlog = au->au_backlog; ! 693: ! 694: return (0); ! 695: } ! 696: ! 697: #if MACH_KDB ! 698: #include <ddb/db_output.h> ! 699: ! 700: void audio_queue_status( au_cb_t *cb, char *logo) ! 701: { ! 702: db_printf("%s ring status:\n", logo); ! 703: db_printf(" h %x t %x sh %x w %d p %d d %x pd %x\n", ! 704: cb->cb_head, cb->cb_tail, cb->cb_thresh, ! 705: cb->cb_waking, cb->cb_pause, (long)cb->cb_drops, ! 706: (long)cb->cb_pdrops); ! 707: } ! 708: ! 709: int audio_status(int unit) ! 710: { ! 711: struct audio_softc *sc = unit_to_softc(unit); ! 712: au_io_t *au; ! 713: ! 714: if (!sc) { ! 715: db_printf("No such thing\n"); ! 716: return 0; ! 717: } ! 718: db_printf("@%lx: wseek %d rseek %d, au @%lx\n", ! 719: sc, sc->sc_wseek, sc->sc_rseek, sc->sc_au); ! 720: if (!(au = sc->sc_au)) return 0; ! 721: ! 722: db_printf("au: stamp %x lo %x hi %x blk %x blg %x\n", ! 723: au->au_stamp, au->au_lowat, au->au_hiwat, ! 724: au->au_blksize, au->au_backlog); ! 725: audio_queue_status(&au->au_rb, "read"); ! 726: audio_queue_status(&au->au_wb, "write"); ! 727: ! 728: return 0; ! 729: } ! 730: #endif /* MACH_KDB */ ! 731: ! 732: #endif /* NAUDIO > 0 */ ! 733:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.