1 /* $OpenBSD: audio.c,v 1.187 2020/02/13 21:00:48 ratchov Exp $ */ 2 /* 3 * Copyright (c) 2015 Alexandre Ratchov <alex@caoua.org> 4 * 5 * Permission to use, copy, modify, and distribute this software for any 6 * purpose with or without fee is hereby granted, provided that the above 7 * copyright notice and this permission notice appear in all copies. 8 * 9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 10 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 11 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 12 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 13 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 14 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 15 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 16 */ 17 #include <sys/param.h> 18 #include <sys/fcntl.h> 19 #include <sys/systm.h> 20 #include <sys/ioctl.h> 21 #include <sys/conf.h> 22 #include <sys/poll.h> 23 #include <sys/kernel.h> 24 #include <sys/task.h> 25 #include <sys/vnode.h> 26 #include <sys/malloc.h> 27 #include <sys/device.h> 28 #include <sys/audioio.h> 29 #include <dev/audio_if.h> 30 #include <dev/mulaw.h> 31 #include "audio.h" 32 #include "wskbd.h" 33 34 #ifdef AUDIO_DEBUG 35 #define DPRINTF(...) \ 36 do { \ 37 if (audio_debug) \ 38 printf(__VA_ARGS__); \ 39 } while(0) 40 #define DPRINTFN(n, ...) \ 41 do { \ 42 if (audio_debug > (n)) \ 43 printf(__VA_ARGS__); \ 44 } while(0) 45 #else 46 #define DPRINTF(...) do {} while(0) 47 #define DPRINTFN(n, ...) do {} while(0) 48 #endif 49 50 #define IPL_SOFTAUDIO IPL_SOFTNET 51 52 #define DEVNAME(sc) ((sc)->dev.dv_xname) 53 #define AUDIO_UNIT(n) (minor(n) & 0x0f) 54 #define AUDIO_DEV(n) (minor(n) & 0xf0) 55 #define AUDIO_DEV_AUDIO 0 /* minor of /dev/audio0 */ 56 #define AUDIO_DEV_MIXER 0x10 /* minor of /dev/mixer0 */ 57 #define AUDIO_DEV_AUDIOCTL 0xc0 /* minor of /dev/audioctl */ 58 #define AUDIO_BUFSZ 65536 /* buffer size in bytes */ 59 60 /* 61 * mixer entries added by the audio(4) layer 62 */ 63 #define MIXER_RECORD 0 /* record class */ 64 #define MIXER_RECORD_ENABLE 1 /* record.enable control */ 65 #define MIXER_RECORD_ENABLE_OFF 0 /* record.enable=off value */ 66 #define MIXER_RECORD_ENABLE_ON 1 /* record.enable=on value */ 67 #define MIXER_RECORD_ENABLE_SYSCTL 2 /* record.enable=sysctl val */ 68 69 /* 70 * dma buffer 71 */ 72 struct audio_buf { 73 unsigned char *data; /* DMA memory block */ 74 size_t datalen; /* size of DMA memory block */ 75 size_t len; /* size of DMA FIFO */ 76 size_t start; /* first byte used in the FIFO */ 77 size_t used; /* bytes used in the FIFO */ 78 size_t blksz; /* DMA block size */ 79 unsigned int nblks; /* number of blocks */ 80 struct selinfo sel; /* to record & wakeup poll(2) */ 81 void *softintr; /* context to call selwakeup() */ 82 unsigned int pos; /* bytes transferred */ 83 unsigned int xrun; /* bytes lost by xruns */ 84 int blocking; /* read/write blocking */ 85 }; 86 87 #if NWSKBD > 0 88 struct wskbd_vol 89 { 90 int val; /* index of the value control */ 91 int mute; /* index of the mute control */ 92 int step; /* increment/decrement step */ 93 int nch; /* channels in the value control */ 94 int val_pending; /* pending change of val */ 95 int mute_pending; /* pending change of mute */ 96 #define WSKBD_MUTE_TOGGLE 1 97 #define WSKBD_MUTE_DISABLE 2 98 #define WSKBD_MUTE_ENABLE 3 99 }; 100 #endif 101 102 /* 103 * event indicating that a control was changed 104 */ 105 struct mixer_ev { 106 struct mixer_ev *next; 107 int pending; 108 }; 109 110 /* 111 * device structure 112 */ 113 struct audio_softc { 114 struct device dev; 115 struct audio_hw_if *ops; /* driver funcs */ 116 void *arg; /* first arg to driver funcs */ 117 int mode; /* bitmask of AUMODE_* */ 118 int quiesce; /* device suspended */ 119 struct audio_buf play, rec; 120 unsigned int sw_enc; /* user exposed AUDIO_ENCODING_* */ 121 unsigned int hw_enc; /* hardware AUDIO_ENCODING_* */ 122 unsigned int bits; /* bits per sample */ 123 unsigned int bps; /* bytes-per-sample */ 124 unsigned int msb; /* sample are MSB aligned */ 125 unsigned int rate; /* rate in Hz */ 126 unsigned int round; /* block size in frames */ 127 unsigned int pchan, rchan; /* number of channels */ 128 unsigned char silence[4]; /* a sample of silence */ 129 int pause; /* not trying to start DMA */ 130 int active; /* DMA in process */ 131 int offs; /* offset between play & rec dir */ 132 void (*conv_enc)(unsigned char *, int); /* encode to native */ 133 void (*conv_dec)(unsigned char *, int); /* decode to user */ 134 struct mixer_ctrl *mix_ents; /* mixer state for suspend/resume */ 135 int mix_nent; /* size of mixer state */ 136 int mix_isopen; /* mixer open for reading */ 137 int mix_blocking; /* read() blocking */ 138 struct selinfo mix_sel; /* wakeup poll(2) */ 139 struct mixer_ev *mix_evbuf; /* per mixer-control event */ 140 struct mixer_ev *mix_pending; /* list of changed controls */ 141 #if NWSKBD > 0 142 struct wskbd_vol spkr, mic; 143 struct task wskbd_task; 144 #endif 145 int record_enable; /* mixer record.enable value */ 146 }; 147 148 int audio_match(struct device *, void *, void *); 149 void audio_attach(struct device *, struct device *, void *); 150 int audio_activate(struct device *, int); 151 int audio_detach(struct device *, int); 152 void audio_pintr(void *); 153 void audio_rintr(void *); 154 #if NWSKBD > 0 155 void wskbd_mixer_init(struct audio_softc *); 156 void wskbd_mixer_cb(void *); 157 #endif 158 159 const struct cfattach audio_ca = { 160 sizeof(struct audio_softc), audio_match, audio_attach, 161 audio_detach, audio_activate 162 }; 163 164 struct cfdriver audio_cd = { 165 NULL, "audio", DV_DULL 166 }; 167 168 /* 169 * This mutex protects data structures (including registers on the 170 * sound-card) that are manipulated by both the interrupt handler and 171 * syscall code-paths. 172 * 173 * Note that driver methods may sleep (e.g. in malloc); consequently the 174 * audio layer calls them with the mutex unlocked. Driver methods are 175 * responsible for locking the mutex when they manipulate data used by 176 * the interrupt handler and interrupts may occur. 177 * 178 * Similarly, the driver is responsible for locking the mutex in its 179 * interrupt handler and to call the audio layer call-backs (i.e. 180 * audio_{p,r}int()) with the mutex locked. 181 */ 182 struct mutex audio_lock = MUTEX_INITIALIZER(IPL_AUDIO); 183 184 /* 185 * Global flag to control if audio recording is enabled when the 186 * mixerctl setting is record.enable=sysctl 187 */ 188 int audio_record_enable = 0; 189 190 #ifdef AUDIO_DEBUG 191 /* 192 * 0 - nothing, as if AUDIO_DEBUG isn't defined 193 * 1 - initialisations & setup 194 * 2 - blocks & interrupts 195 */ 196 int audio_debug = 1; 197 #endif 198 199 unsigned int 200 audio_gcd(unsigned int a, unsigned int b) 201 { 202 unsigned int r; 203 204 while (b > 0) { 205 r = a % b; 206 a = b; 207 b = r; 208 } 209 return a; 210 } 211 212 /* 213 * Calculate the least block size (in frames) such that both the 214 * corresponding play and/or record block sizes (in bytes) are multiple 215 * of the given number of bytes. 216 */ 217 int 218 audio_blksz_bytes(int mode, 219 struct audio_params *p, struct audio_params *r, int bytes) 220 { 221 unsigned int np, nr; 222 223 if (mode & AUMODE_PLAY) { 224 np = bytes / audio_gcd(p->bps * p->channels, bytes); 225 if (!(mode & AUMODE_RECORD)) 226 nr = np; 227 } 228 if (mode & AUMODE_RECORD) { 229 nr = bytes / audio_gcd(r->bps * r->channels, bytes); 230 if (!(mode & AUMODE_PLAY)) 231 np = nr; 232 } 233 234 return nr * np / audio_gcd(nr, np); 235 } 236 237 void 238 audio_buf_wakeup(void *addr) 239 { 240 struct audio_buf *buf = addr; 241 242 if (buf->blocking) { 243 wakeup(&buf->blocking); 244 buf->blocking = 0; 245 } 246 selwakeup(&buf->sel); 247 } 248 249 int 250 audio_buf_init(struct audio_softc *sc, struct audio_buf *buf, int dir) 251 { 252 buf->softintr = softintr_establish(IPL_SOFTAUDIO, 253 audio_buf_wakeup, buf); 254 if (buf->softintr == NULL) { 255 printf("%s: can't establish softintr\n", DEVNAME(sc)); 256 return ENOMEM; 257 } 258 if (sc->ops->round_buffersize) { 259 buf->datalen = sc->ops->round_buffersize(sc->arg, 260 dir, AUDIO_BUFSZ); 261 } else 262 buf->datalen = AUDIO_BUFSZ; 263 if (sc->ops->allocm) { 264 buf->data = sc->ops->allocm(sc->arg, dir, buf->datalen, 265 M_DEVBUF, M_WAITOK); 266 } else 267 buf->data = malloc(buf->datalen, M_DEVBUF, M_WAITOK); 268 if (buf->data == NULL) { 269 softintr_disestablish(buf->softintr); 270 return ENOMEM; 271 } 272 return 0; 273 } 274 275 void 276 audio_buf_done(struct audio_softc *sc, struct audio_buf *buf) 277 { 278 if (sc->ops->freem) 279 sc->ops->freem(sc->arg, buf->data, M_DEVBUF); 280 else 281 free(buf->data, M_DEVBUF, buf->datalen); 282 softintr_disestablish(buf->softintr); 283 } 284 285 /* 286 * return the reader pointer and the number of bytes available 287 */ 288 unsigned char * 289 audio_buf_rgetblk(struct audio_buf *buf, size_t *rsize) 290 { 291 size_t count; 292 293 count = buf->len - buf->start; 294 if (count > buf->used) 295 count = buf->used; 296 *rsize = count; 297 return buf->data + buf->start; 298 } 299 300 /* 301 * discard "count" bytes at the start position. 302 */ 303 void 304 audio_buf_rdiscard(struct audio_buf *buf, size_t count) 305 { 306 #ifdef AUDIO_DEBUG 307 if (count > buf->used) { 308 panic("audio_buf_rdiscard: bad count = %zu, " 309 "start = %zu, used = %zu\n", count, buf->start, buf->used); 310 } 311 #endif 312 buf->used -= count; 313 buf->start += count; 314 if (buf->start >= buf->len) 315 buf->start -= buf->len; 316 } 317 318 /* 319 * advance the writer pointer by "count" bytes 320 */ 321 void 322 audio_buf_wcommit(struct audio_buf *buf, size_t count) 323 { 324 #ifdef AUDIO_DEBUG 325 if (count > (buf->len - buf->used)) { 326 panic("audio_buf_wcommit: bad count = %zu, " 327 "start = %zu, used = %zu\n", count, buf->start, buf->used); 328 } 329 #endif 330 buf->used += count; 331 } 332 333 /* 334 * get writer pointer and the number of bytes writable 335 */ 336 unsigned char * 337 audio_buf_wgetblk(struct audio_buf *buf, size_t *rsize) 338 { 339 size_t end, avail, count; 340 341 end = buf->start + buf->used; 342 if (end >= buf->len) 343 end -= buf->len; 344 avail = buf->len - buf->used; 345 count = buf->len - end; 346 if (count > avail) 347 count = avail; 348 *rsize = count; 349 return buf->data + end; 350 } 351 352 void 353 audio_calc_sil(struct audio_softc *sc) 354 { 355 unsigned char *q; 356 unsigned int s, i; 357 int d, e; 358 359 e = sc->sw_enc; 360 #ifdef AUDIO_DEBUG 361 switch (e) { 362 case AUDIO_ENCODING_SLINEAR_LE: 363 case AUDIO_ENCODING_ULINEAR_LE: 364 case AUDIO_ENCODING_SLINEAR_BE: 365 case AUDIO_ENCODING_ULINEAR_BE: 366 break; 367 default: 368 printf("%s: unhandled play encoding %d\n", DEVNAME(sc), e); 369 memset(sc->silence, 0, sc->bps); 370 return; 371 } 372 #endif 373 if (e == AUDIO_ENCODING_SLINEAR_BE || e == AUDIO_ENCODING_ULINEAR_BE) { 374 d = -1; 375 q = sc->silence + sc->bps - 1; 376 } else { 377 d = 1; 378 q = sc->silence; 379 } 380 if (e == AUDIO_ENCODING_SLINEAR_LE || e == AUDIO_ENCODING_SLINEAR_BE) { 381 s = 0; 382 } else { 383 s = 0x80000000; 384 if (sc->msb) 385 s >>= 32 - 8 * sc->bps; 386 else 387 s >>= 32 - sc->bits; 388 } 389 for (i = 0; i < sc->bps; i++) { 390 *q = s; 391 q += d; 392 s >>= 8; 393 } 394 if (sc->conv_enc) 395 sc->conv_enc(sc->silence, sc->bps); 396 } 397 398 void 399 audio_fill_sil(struct audio_softc *sc, unsigned char *ptr, size_t count) 400 { 401 unsigned char *q, *p; 402 size_t i, j; 403 404 q = ptr; 405 for (j = count / sc->bps; j > 0; j--) { 406 p = sc->silence; 407 for (i = sc->bps; i > 0; i--) 408 *q++ = *p++; 409 } 410 } 411 412 void 413 audio_clear(struct audio_softc *sc) 414 { 415 if (sc->mode & AUMODE_PLAY) { 416 sc->play.used = sc->play.start = 0; 417 sc->play.pos = sc->play.xrun = 0; 418 audio_fill_sil(sc, sc->play.data, sc->play.len); 419 } 420 if (sc->mode & AUMODE_RECORD) { 421 sc->rec.used = sc->rec.start = 0; 422 sc->rec.pos = sc->rec.xrun = 0; 423 audio_fill_sil(sc, sc->rec.data, sc->rec.len); 424 } 425 } 426 427 /* 428 * called whenever a block is consumed by the driver 429 */ 430 void 431 audio_pintr(void *addr) 432 { 433 struct audio_softc *sc = addr; 434 unsigned char *ptr; 435 size_t count; 436 int error, nblk, todo; 437 438 MUTEX_ASSERT_LOCKED(&audio_lock); 439 if (!(sc->mode & AUMODE_PLAY) || !sc->active) { 440 printf("%s: play interrupt but not playing\n", DEVNAME(sc)); 441 return; 442 } 443 if (sc->quiesce) { 444 DPRINTF("%s: quiesced, skipping play intr\n", DEVNAME(sc)); 445 return; 446 } 447 448 /* 449 * check if record pointer wrapped, see explanation 450 * in audio_rintr() 451 */ 452 if ((sc->mode & AUMODE_RECORD) && sc->ops->underrun == NULL) { 453 sc->offs--; 454 nblk = sc->rec.len / sc->rec.blksz; 455 todo = -sc->offs; 456 if (todo >= nblk) { 457 todo -= todo % nblk; 458 DPRINTFN(1, "%s: rec ptr wrapped, moving %d blocks\n", 459 DEVNAME(sc), todo); 460 while (todo-- > 0) 461 audio_rintr(sc); 462 } 463 } 464 465 sc->play.pos += sc->play.blksz; 466 if (!sc->ops->underrun) { 467 audio_fill_sil(sc, sc->play.data + sc->play.start, 468 sc->play.blksz); 469 } 470 audio_buf_rdiscard(&sc->play, sc->play.blksz); 471 if (sc->play.used < sc->play.blksz) { 472 DPRINTFN(1, "%s: play underrun\n", DEVNAME(sc)); 473 sc->play.xrun += sc->play.blksz; 474 audio_buf_wcommit(&sc->play, sc->play.blksz); 475 if (sc->ops->underrun) 476 sc->ops->underrun(sc->arg); 477 } 478 479 DPRINTFN(1, "%s: play intr, used -> %zu, start -> %zu\n", 480 DEVNAME(sc), sc->play.used, sc->play.start); 481 482 if (!sc->ops->trigger_output) { 483 ptr = audio_buf_rgetblk(&sc->play, &count); 484 error = sc->ops->start_output(sc->arg, 485 ptr, sc->play.blksz, audio_pintr, sc); 486 if (error) { 487 printf("%s: play restart failed: %d\n", 488 DEVNAME(sc), error); 489 } 490 } 491 492 if (sc->play.used < sc->play.len) { 493 DPRINTFN(1, "%s: play wakeup, chan = %d\n", 494 DEVNAME(sc), sc->play.blocking); 495 /* 496 * As long as selwakeup() needs to be protected by the 497 * KERNEL_LOCK() we have to delay the wakeup to another 498 * context to keep the interrupt context KERNEL_LOCK() 499 * free. 500 */ 501 softintr_schedule(sc->play.softintr); 502 } 503 } 504 505 /* 506 * called whenever a block is produced by the driver 507 */ 508 void 509 audio_rintr(void *addr) 510 { 511 struct audio_softc *sc = addr; 512 unsigned char *ptr; 513 size_t count; 514 int error, nblk, todo; 515 516 MUTEX_ASSERT_LOCKED(&audio_lock); 517 if (!(sc->mode & AUMODE_RECORD) || !sc->active) { 518 printf("%s: rec interrupt but not recording\n", DEVNAME(sc)); 519 return; 520 } 521 if (sc->quiesce) { 522 DPRINTF("%s: quiesced, skipping rec intr\n", DEVNAME(sc)); 523 return; 524 } 525 526 /* 527 * Interrupts may be masked by other sub-systems during 320ms 528 * and more. During such a delay the hardware doesn't stop 529 * playing and the play buffer pointers may wrap, this can't be 530 * detected and corrected by low level drivers. This makes the 531 * record stream ahead of the play stream; this is detected as a 532 * hardware anomaly by userland and cause programs to misbehave. 533 * 534 * We fix this by advancing play position by an integer count of 535 * full buffers, so it reaches the record position. 536 */ 537 if ((sc->mode & AUMODE_PLAY) && sc->ops->underrun == NULL) { 538 sc->offs++; 539 nblk = sc->play.len / sc->play.blksz; 540 todo = sc->offs; 541 if (todo >= nblk) { 542 todo -= todo % nblk; 543 DPRINTFN(1, "%s: play ptr wrapped, moving %d blocks\n", 544 DEVNAME(sc), todo); 545 while (todo-- > 0) 546 audio_pintr(sc); 547 } 548 } 549 550 sc->rec.pos += sc->rec.blksz; 551 if ((sc->record_enable == MIXER_RECORD_ENABLE_SYSCTL && 552 !audio_record_enable) || 553 sc->record_enable == MIXER_RECORD_ENABLE_OFF) { 554 ptr = audio_buf_wgetblk(&sc->rec, &count); 555 audio_fill_sil(sc, ptr, sc->rec.blksz); 556 } 557 audio_buf_wcommit(&sc->rec, sc->rec.blksz); 558 if (sc->rec.used > sc->rec.len - sc->rec.blksz) { 559 DPRINTFN(1, "%s: rec overrun\n", DEVNAME(sc)); 560 sc->rec.xrun += sc->rec.blksz; 561 audio_buf_rdiscard(&sc->rec, sc->rec.blksz); 562 } 563 DPRINTFN(1, "%s: rec intr, used -> %zu\n", DEVNAME(sc), sc->rec.used); 564 565 if (!sc->ops->trigger_input) { 566 ptr = audio_buf_wgetblk(&sc->rec, &count); 567 error = sc->ops->start_input(sc->arg, 568 ptr, sc->rec.blksz, audio_rintr, sc); 569 if (error) { 570 printf("%s: rec restart failed: %d\n", 571 DEVNAME(sc), error); 572 } 573 } 574 575 if (sc->rec.used > 0) { 576 DPRINTFN(1, "%s: rec wakeup, chan = %d\n", 577 DEVNAME(sc), sc->rec.blocking); 578 /* 579 * As long as selwakeup() needs to be protected by the 580 * KERNEL_LOCK() we have to delay the wakeup to another 581 * context to keep the interrupt context KERNEL_LOCK() 582 * free. 583 */ 584 softintr_schedule(sc->rec.softintr); 585 } 586 } 587 588 int 589 audio_start_do(struct audio_softc *sc) 590 { 591 int error; 592 struct audio_params p; 593 unsigned char *ptr; 594 size_t count; 595 596 DPRINTF("%s: starting\n", DEVNAME(sc)); 597 598 error = 0; 599 sc->offs = 0; 600 if (sc->mode & AUMODE_PLAY) { 601 if (sc->ops->trigger_output) { 602 p.encoding = sc->hw_enc; 603 p.precision = sc->bits; 604 p.bps = sc->bps; 605 p.msb = sc->msb; 606 p.sample_rate = sc->rate; 607 p.channels = sc->pchan; 608 error = sc->ops->trigger_output(sc->arg, 609 sc->play.data, 610 sc->play.data + sc->play.len, 611 sc->play.blksz, 612 audio_pintr, sc, &p); 613 } else { 614 mtx_enter(&audio_lock); 615 ptr = audio_buf_rgetblk(&sc->play, &count); 616 error = sc->ops->start_output(sc->arg, 617 ptr, sc->play.blksz, audio_pintr, sc); 618 mtx_leave(&audio_lock); 619 } 620 if (error) 621 printf("%s: failed to start playback\n", DEVNAME(sc)); 622 } 623 if (sc->mode & AUMODE_RECORD) { 624 if (sc->ops->trigger_input) { 625 p.encoding = sc->hw_enc; 626 p.precision = sc->bits; 627 p.bps = sc->bps; 628 p.msb = sc->msb; 629 p.sample_rate = sc->rate; 630 p.channels = sc->rchan; 631 error = sc->ops->trigger_input(sc->arg, 632 sc->rec.data, 633 sc->rec.data + sc->rec.len, 634 sc->rec.blksz, 635 audio_rintr, sc, &p); 636 } else { 637 mtx_enter(&audio_lock); 638 ptr = audio_buf_wgetblk(&sc->rec, &count); 639 error = sc->ops->start_input(sc->arg, 640 ptr, sc->rec.blksz, audio_rintr, sc); 641 mtx_leave(&audio_lock); 642 } 643 if (error) 644 printf("%s: failed to start recording\n", DEVNAME(sc)); 645 } 646 return error; 647 } 648 649 int 650 audio_stop_do(struct audio_softc *sc) 651 { 652 if (sc->mode & AUMODE_PLAY) 653 sc->ops->halt_output(sc->arg); 654 if (sc->mode & AUMODE_RECORD) 655 sc->ops->halt_input(sc->arg); 656 DPRINTF("%s: stopped\n", DEVNAME(sc)); 657 return 0; 658 } 659 660 int 661 audio_start(struct audio_softc *sc) 662 { 663 sc->active = 1; 664 sc->play.xrun = sc->play.pos = sc->rec.xrun = sc->rec.pos = 0; 665 return audio_start_do(sc); 666 } 667 668 int 669 audio_stop(struct audio_softc *sc) 670 { 671 int error; 672 673 error = audio_stop_do(sc); 674 if (error) 675 return error; 676 audio_clear(sc); 677 sc->active = 0; 678 return 0; 679 } 680 681 int 682 audio_canstart(struct audio_softc *sc) 683 { 684 if (sc->active || sc->pause) 685 return 0; 686 if ((sc->mode & AUMODE_RECORD) && sc->rec.used != 0) 687 return 0; 688 if ((sc->mode & AUMODE_PLAY) && sc->play.used != sc->play.len) 689 return 0; 690 return 1; 691 } 692 693 int 694 audio_setpar_blksz(struct audio_softc *sc, 695 struct audio_params *p, struct audio_params *r) 696 { 697 unsigned int nr, np, max, min, mult; 698 unsigned int blk_mult, blk_max; 699 700 if (sc->ops->set_blksz) { 701 /* 702 * Don't allow block size of exceed half the buffer size 703 */ 704 if (sc->mode & AUMODE_PLAY) { 705 max = sc->play.datalen / 2 / (sc->pchan * sc->bps); 706 if (sc->round > max) 707 sc->round = max; 708 } 709 if (sc->mode & AUMODE_RECORD) { 710 max = sc->rec.datalen / 2 / (sc->rchan * sc->bps); 711 if (sc->round > max) 712 sc->round = max; 713 } 714 715 sc->round = sc->ops->set_blksz(sc->arg, sc->mode, 716 p, r, sc->round); 717 718 DPRINTF("%s: block size set to: %u\n", DEVNAME(sc), sc->round); 719 return 0; 720 } 721 722 /* 723 * get least multiplier of the number of frames per block 724 */ 725 if (sc->ops->round_blocksize) { 726 blk_mult = sc->ops->round_blocksize(sc->arg, 1); 727 if (blk_mult == 0) { 728 printf("%s: 0x%x: bad block size multiplier\n", 729 DEVNAME(sc), blk_mult); 730 return ENODEV; 731 } 732 } else 733 blk_mult = 1; 734 DPRINTF("%s: hw block size multiplier: %u\n", DEVNAME(sc), blk_mult); 735 if (sc->mode & AUMODE_PLAY) { 736 np = blk_mult / audio_gcd(sc->pchan * sc->bps, blk_mult); 737 if (!(sc->mode & AUMODE_RECORD)) 738 nr = np; 739 DPRINTF("%s: play number of frames multiplier: %u\n", 740 DEVNAME(sc), np); 741 } 742 if (sc->mode & AUMODE_RECORD) { 743 nr = blk_mult / audio_gcd(sc->rchan * sc->bps, blk_mult); 744 if (!(sc->mode & AUMODE_PLAY)) 745 np = nr; 746 DPRINTF("%s: record number of frames multiplier: %u\n", 747 DEVNAME(sc), nr); 748 } 749 mult = nr * np / audio_gcd(nr, np); 750 DPRINTF("%s: least common number of frames multiplier: %u\n", 751 DEVNAME(sc), mult); 752 753 /* 754 * get minimum and maximum frames per block 755 */ 756 if (sc->ops->round_blocksize) 757 blk_max = sc->ops->round_blocksize(sc->arg, AUDIO_BUFSZ); 758 else 759 blk_max = AUDIO_BUFSZ; 760 if ((sc->mode & AUMODE_PLAY) && blk_max > sc->play.datalen / 2) 761 blk_max = sc->play.datalen / 2; 762 if ((sc->mode & AUMODE_RECORD) && blk_max > sc->rec.datalen / 2) 763 blk_max = sc->rec.datalen / 2; 764 if (sc->mode & AUMODE_PLAY) { 765 np = blk_max / (sc->pchan * sc->bps); 766 if (!(sc->mode & AUMODE_RECORD)) 767 nr = np; 768 } 769 if (sc->mode & AUMODE_RECORD) { 770 nr = blk_max / (sc->rchan * sc->bps); 771 if (!(sc->mode & AUMODE_PLAY)) 772 np = nr; 773 } 774 max = np < nr ? np : nr; 775 max -= max % mult; 776 min = sc->rate / 1000 + mult - 1; 777 min -= min % mult; 778 DPRINTF("%s: frame number range: %u..%u\n", DEVNAME(sc), min, max); 779 if (max < min) { 780 printf("%s: %u: bad max frame number\n", DEVNAME(sc), max); 781 return EIO; 782 } 783 784 /* 785 * adjust the frame per block to match our constraints 786 */ 787 sc->round += mult / 2; 788 sc->round -= sc->round % mult; 789 if (sc->round > max) 790 sc->round = max; 791 else if (sc->round < min) 792 sc->round = min; 793 794 return 0; 795 } 796 797 int 798 audio_setpar_nblks(struct audio_softc *sc, 799 struct audio_params *p, struct audio_params *r) 800 { 801 unsigned int max; 802 803 /* 804 * set buffer size (number of blocks) 805 */ 806 if (sc->mode & AUMODE_PLAY) { 807 max = sc->play.datalen / (sc->round * sc->pchan * sc->bps); 808 if (sc->play.nblks > max) 809 sc->play.nblks = max; 810 else if (sc->play.nblks < 2) 811 sc->play.nblks = 2; 812 if (sc->ops->set_nblks) { 813 sc->play.nblks = sc->ops->set_nblks(sc->arg, sc->mode, 814 p, sc->round, sc->play.nblks); 815 DPRINTF("%s: play nblks -> %u\n", DEVNAME(sc), 816 sc->play.nblks); 817 } 818 } 819 if (sc->mode & AUMODE_RECORD) { 820 /* 821 * for recording, buffer size is not the latency (it's 822 * exactly one block), so let's get the maximum buffer 823 * size of maximum reliability during xruns 824 */ 825 max = sc->rec.datalen / (sc->round * sc->rchan * sc->bps); 826 if (sc->ops->set_nblks) { 827 max = sc->ops->set_nblks(sc->arg, sc->mode, 828 r, sc->round, max); 829 DPRINTF("%s: rec nblks -> %u\n", DEVNAME(sc), max); 830 } 831 sc->rec.nblks = max; 832 } 833 return 0; 834 } 835 836 int 837 audio_setpar(struct audio_softc *sc) 838 { 839 struct audio_params p, r; 840 int error; 841 842 DPRINTF("%s: setpar: req enc=%d bits=%d, bps=%d, msb=%d " 843 "rate=%d, pchan=%d, rchan=%d, round=%u, nblks=%d\n", 844 DEVNAME(sc), sc->sw_enc, sc->bits, sc->bps, sc->msb, 845 sc->rate, sc->pchan, sc->rchan, sc->round, sc->play.nblks); 846 847 /* 848 * check if requested parameters are in the allowed ranges 849 */ 850 if (sc->mode & AUMODE_PLAY) { 851 if (sc->pchan < 1) 852 sc->pchan = 1; 853 else if (sc->pchan > 64) 854 sc->pchan = 64; 855 } 856 if (sc->mode & AUMODE_RECORD) { 857 if (sc->rchan < 1) 858 sc->rchan = 1; 859 else if (sc->rchan > 64) 860 sc->rchan = 64; 861 } 862 switch (sc->sw_enc) { 863 case AUDIO_ENCODING_ULAW: 864 case AUDIO_ENCODING_ALAW: 865 case AUDIO_ENCODING_SLINEAR_LE: 866 case AUDIO_ENCODING_SLINEAR_BE: 867 case AUDIO_ENCODING_ULINEAR_LE: 868 case AUDIO_ENCODING_ULINEAR_BE: 869 break; 870 default: 871 sc->sw_enc = AUDIO_ENCODING_SLINEAR_LE; 872 } 873 if (sc->bits < 8) 874 sc->bits = 8; 875 else if (sc->bits > 32) 876 sc->bits = 32; 877 if (sc->bps < 1) 878 sc->bps = 1; 879 else if (sc->bps > 4) 880 sc->bps = 4; 881 if (sc->rate < 4000) 882 sc->rate = 4000; 883 else if (sc->rate > 192000) 884 sc->rate = 192000; 885 886 /* 887 * copy into struct audio_params, required by drivers 888 */ 889 p.encoding = r.encoding = sc->sw_enc; 890 p.precision = r.precision = sc->bits; 891 p.bps = r.bps = sc->bps; 892 p.msb = r.msb = sc->msb; 893 p.sample_rate = r.sample_rate = sc->rate; 894 p.channels = sc->pchan; 895 r.channels = sc->rchan; 896 897 /* 898 * set parameters 899 */ 900 error = sc->ops->set_params(sc->arg, sc->mode, sc->mode, &p, &r); 901 if (error) 902 return error; 903 if (sc->mode == (AUMODE_PLAY | AUMODE_RECORD)) { 904 if (p.encoding != r.encoding || 905 p.precision != r.precision || 906 p.bps != r.bps || 907 p.msb != r.msb || 908 p.sample_rate != r.sample_rate) { 909 printf("%s: different play and record parameters " 910 "returned by hardware\n", DEVNAME(sc)); 911 return ENODEV; 912 } 913 } 914 if (sc->mode & AUMODE_PLAY) { 915 sc->hw_enc = p.encoding; 916 sc->bits = p.precision; 917 sc->bps = p.bps; 918 sc->msb = p.msb; 919 sc->rate = p.sample_rate; 920 sc->pchan = p.channels; 921 } 922 if (sc->mode & AUMODE_RECORD) { 923 sc->hw_enc = r.encoding; 924 sc->bits = r.precision; 925 sc->bps = r.bps; 926 sc->msb = r.msb; 927 sc->rate = r.sample_rate; 928 sc->rchan = r.channels; 929 } 930 if (sc->rate == 0 || sc->bps == 0 || sc->bits == 0) { 931 printf("%s: invalid parameters returned by hardware\n", 932 DEVNAME(sc)); 933 return ENODEV; 934 } 935 if (sc->ops->commit_settings) { 936 error = sc->ops->commit_settings(sc->arg); 937 if (error) 938 return error; 939 } 940 941 /* 942 * conversion from/to exotic/dead encoding, for drivers not supporting 943 * linear 944 */ 945 switch (sc->hw_enc) { 946 case AUDIO_ENCODING_SLINEAR_LE: 947 case AUDIO_ENCODING_SLINEAR_BE: 948 case AUDIO_ENCODING_ULINEAR_LE: 949 case AUDIO_ENCODING_ULINEAR_BE: 950 sc->sw_enc = sc->hw_enc; 951 sc->conv_dec = sc->conv_enc = NULL; 952 break; 953 case AUDIO_ENCODING_ULAW: 954 #if BYTE_ORDER == LITTLE_ENDIAN 955 sc->sw_enc = AUDIO_ENCODING_SLINEAR_LE; 956 #else 957 sc->sw_enc = AUDIO_ENCODING_SLINEAR_BE; 958 #endif 959 if (sc->bits == 8) { 960 sc->conv_enc = slinear8_to_mulaw; 961 sc->conv_dec = mulaw_to_slinear8; 962 } else if (sc->bits == 24) { 963 sc->conv_enc = slinear24_to_mulaw24; 964 sc->conv_dec = mulaw24_to_slinear24; 965 } else { 966 sc->sw_enc = sc->hw_enc; 967 sc->conv_dec = sc->conv_enc = NULL; 968 } 969 break; 970 default: 971 printf("%s: setpar: enc = %d, bits = %d: emulation skipped\n", 972 DEVNAME(sc), sc->hw_enc, sc->bits); 973 sc->sw_enc = sc->hw_enc; 974 sc->conv_dec = sc->conv_enc = NULL; 975 } 976 audio_calc_sil(sc); 977 978 error = audio_setpar_blksz(sc, &p, &r); 979 if (error) 980 return error; 981 982 error = audio_setpar_nblks(sc, &p, &r); 983 if (error) 984 return error; 985 986 /* 987 * set buffer 988 */ 989 if (sc->mode & AUMODE_PLAY) { 990 sc->play.blksz = sc->round * sc->pchan * sc->bps; 991 sc->play.len = sc->play.nblks * sc->play.blksz; 992 } 993 if (sc->mode & AUMODE_RECORD) { 994 sc->rec.blksz = sc->round * sc->rchan * sc->bps; 995 sc->rec.len = sc->rec.nblks * sc->rec.blksz; 996 } 997 998 DPRINTF("%s: setpar: new enc=%d bits=%d, bps=%d, msb=%d " 999 "rate=%d, pchan=%d, rchan=%d, round=%u, nblks=%d\n", 1000 DEVNAME(sc), sc->sw_enc, sc->bits, sc->bps, sc->msb, 1001 sc->rate, sc->pchan, sc->rchan, sc->round, sc->play.nblks); 1002 return 0; 1003 } 1004 1005 int 1006 audio_ioc_start(struct audio_softc *sc) 1007 { 1008 if (!sc->pause) { 1009 DPRINTF("%s: can't start: already started\n", DEVNAME(sc)); 1010 return EBUSY; 1011 } 1012 if ((sc->mode & AUMODE_PLAY) && sc->play.used != sc->play.len) { 1013 DPRINTF("%s: play buffer not ready\n", DEVNAME(sc)); 1014 return EBUSY; 1015 } 1016 if ((sc->mode & AUMODE_RECORD) && sc->rec.used != 0) { 1017 DPRINTF("%s: record buffer not ready\n", DEVNAME(sc)); 1018 return EBUSY; 1019 } 1020 sc->pause = 0; 1021 return audio_start(sc); 1022 } 1023 1024 int 1025 audio_ioc_stop(struct audio_softc *sc) 1026 { 1027 if (sc->pause) { 1028 DPRINTF("%s: can't stop: not started\n", DEVNAME(sc)); 1029 return EBUSY; 1030 } 1031 sc->pause = 1; 1032 if (sc->active) 1033 return audio_stop(sc); 1034 return 0; 1035 } 1036 1037 int 1038 audio_ioc_getpar(struct audio_softc *sc, struct audio_swpar *p) 1039 { 1040 p->rate = sc->rate; 1041 p->sig = sc->sw_enc == AUDIO_ENCODING_SLINEAR_LE || 1042 sc->sw_enc == AUDIO_ENCODING_SLINEAR_BE; 1043 p->le = sc->sw_enc == AUDIO_ENCODING_SLINEAR_LE || 1044 sc->sw_enc == AUDIO_ENCODING_ULINEAR_LE; 1045 p->bits = sc->bits; 1046 p->bps = sc->bps; 1047 p->msb = sc->msb; 1048 p->pchan = sc->pchan; 1049 p->rchan = sc->rchan; 1050 p->nblks = sc->play.nblks; 1051 p->round = sc->round; 1052 return 0; 1053 } 1054 1055 int 1056 audio_ioc_setpar(struct audio_softc *sc, struct audio_swpar *p) 1057 { 1058 int error, le, sig; 1059 1060 if (sc->active) { 1061 DPRINTF("%s: can't change params during dma\n", 1062 DEVNAME(sc)); 1063 return EBUSY; 1064 } 1065 1066 /* 1067 * copy desired parameters into the softc structure 1068 */ 1069 if (p->sig != ~0U || p->le != ~0U || p->bits != ~0U) { 1070 sig = 1; 1071 le = (BYTE_ORDER == LITTLE_ENDIAN); 1072 sc->bits = 16; 1073 sc->bps = 2; 1074 sc->msb = 1; 1075 if (p->sig != ~0U) 1076 sig = p->sig; 1077 if (p->le != ~0U) 1078 le = p->le; 1079 if (p->bits != ~0U) { 1080 sc->bits = p->bits; 1081 sc->bps = sc->bits <= 8 ? 1082 1 : (sc->bits <= 16 ? 2 : 4); 1083 if (p->bps != ~0U) 1084 sc->bps = p->bps; 1085 if (p->msb != ~0U) 1086 sc->msb = p->msb ? 1 : 0; 1087 } 1088 sc->sw_enc = (sig) ? 1089 (le ? AUDIO_ENCODING_SLINEAR_LE : 1090 AUDIO_ENCODING_SLINEAR_BE) : 1091 (le ? AUDIO_ENCODING_ULINEAR_LE : 1092 AUDIO_ENCODING_ULINEAR_BE); 1093 } 1094 if (p->rate != ~0) 1095 sc->rate = p->rate; 1096 if (p->pchan != ~0) 1097 sc->pchan = p->pchan; 1098 if (p->rchan != ~0) 1099 sc->rchan = p->rchan; 1100 if (p->round != ~0) 1101 sc->round = p->round; 1102 if (p->nblks != ~0) 1103 sc->play.nblks = p->nblks; 1104 1105 /* 1106 * if the device is not opened for playback or recording don't 1107 * touch the hardware yet (ex. if this is /dev/audioctlN) 1108 */ 1109 if (sc->mode == 0) 1110 return 0; 1111 1112 /* 1113 * negociate parameters with the hardware 1114 */ 1115 error = audio_setpar(sc); 1116 if (error) 1117 return error; 1118 audio_clear(sc); 1119 if ((sc->mode & AUMODE_PLAY) && sc->ops->init_output) { 1120 error = sc->ops->init_output(sc->arg, 1121 sc->play.data, sc->play.len); 1122 if (error) 1123 return error; 1124 } 1125 if ((sc->mode & AUMODE_RECORD) && sc->ops->init_input) { 1126 error = sc->ops->init_input(sc->arg, 1127 sc->rec.data, sc->rec.len); 1128 if (error) 1129 return error; 1130 } 1131 return 0; 1132 } 1133 1134 int 1135 audio_ioc_getstatus(struct audio_softc *sc, struct audio_status *p) 1136 { 1137 p->mode = sc->mode; 1138 p->pause = sc->pause; 1139 p->active = sc->active; 1140 return 0; 1141 } 1142 1143 int 1144 audio_match(struct device *parent, void *match, void *aux) 1145 { 1146 struct audio_attach_args *sa = aux; 1147 1148 return (sa->type == AUDIODEV_TYPE_AUDIO) ? 1 : 0; 1149 } 1150 1151 void 1152 audio_attach(struct device *parent, struct device *self, void *aux) 1153 { 1154 struct audio_softc *sc = (void *)self; 1155 struct audio_attach_args *sa = aux; 1156 struct audio_hw_if *ops = sa->hwif; 1157 struct mixer_devinfo *mi; 1158 struct mixer_ctrl *ent; 1159 void *arg = sa->hdl; 1160 int error; 1161 1162 printf("\n"); 1163 1164 #ifdef DIAGNOSTIC 1165 if (ops == 0 || 1166 ops->open == 0 || 1167 ops->close == 0 || 1168 ops->set_params == 0 || 1169 (ops->start_output == 0 && ops->trigger_output == 0) || 1170 (ops->start_input == 0 && ops->trigger_input == 0) || 1171 ops->halt_output == 0 || 1172 ops->halt_input == 0 || 1173 ops->set_port == 0 || 1174 ops->get_port == 0 || 1175 ops->query_devinfo == 0 || 1176 ops->get_props == 0) { 1177 printf("%s: missing method\n", DEVNAME(sc)); 1178 sc->ops = 0; 1179 return; 1180 } 1181 #endif 1182 sc->ops = ops; 1183 sc->arg = arg; 1184 1185 #if NWSKBD > 0 1186 wskbd_mixer_init(sc); 1187 #endif /* NWSKBD > 0 */ 1188 1189 error = audio_buf_init(sc, &sc->play, AUMODE_PLAY); 1190 if (error) { 1191 sc->ops = 0; 1192 printf("%s: could not allocate play buffer\n", DEVNAME(sc)); 1193 return; 1194 } 1195 error = audio_buf_init(sc, &sc->rec, AUMODE_RECORD); 1196 if (error) { 1197 audio_buf_done(sc, &sc->play); 1198 sc->ops = 0; 1199 printf("%s: could not allocate record buffer\n", DEVNAME(sc)); 1200 return; 1201 } 1202 1203 /* set defaults */ 1204 #if BYTE_ORDER == LITTLE_ENDIAN 1205 sc->sw_enc = AUDIO_ENCODING_SLINEAR_LE; 1206 #else 1207 sc->sw_enc = AUDIO_ENCODING_SLINEAR_BE; 1208 #endif 1209 sc->bits = 16; 1210 sc->bps = 2; 1211 sc->msb = 1; 1212 sc->rate = 48000; 1213 sc->pchan = 2; 1214 sc->rchan = 2; 1215 sc->round = 960; 1216 sc->play.nblks = 2; 1217 sc->play.pos = sc->play.xrun = sc->rec.pos = sc->rec.xrun = 0; 1218 sc->record_enable = MIXER_RECORD_ENABLE_SYSCTL; 1219 1220 /* 1221 * allocate an array of mixer_ctrl structures to save the 1222 * mixer state and prefill them. 1223 */ 1224 1225 mi = malloc(sizeof(struct mixer_devinfo), M_TEMP, M_WAITOK); 1226 1227 mi->index = 0; 1228 while (1) { 1229 if (sc->ops->query_devinfo(sc->arg, mi) != 0) 1230 break; 1231 mi->index++; 1232 } 1233 sc->mix_nent = mi->index; 1234 sc->mix_ents = mallocarray(sc->mix_nent, 1235 sizeof(struct mixer_ctrl), M_DEVBUF, M_WAITOK); 1236 sc->mix_evbuf = mallocarray(sc->mix_nent, 1237 sizeof(struct mixer_ev), M_DEVBUF, M_WAITOK | M_ZERO); 1238 1239 ent = sc->mix_ents; 1240 mi->index = 0; 1241 while (1) { 1242 if (sc->ops->query_devinfo(sc->arg, mi) != 0) 1243 break; 1244 switch (mi->type) { 1245 case AUDIO_MIXER_VALUE: 1246 ent->un.value.num_channels = mi->un.v.num_channels; 1247 /* FALLTHROUGH */ 1248 case AUDIO_MIXER_SET: 1249 case AUDIO_MIXER_ENUM: 1250 ent->dev = mi->index; 1251 ent->type = mi->type; 1252 } 1253 mi->index++; 1254 ent++; 1255 } 1256 1257 free(mi, M_TEMP, sizeof(struct mixer_devinfo)); 1258 } 1259 1260 int 1261 audio_activate(struct device *self, int act) 1262 { 1263 struct audio_softc *sc = (struct audio_softc *)self; 1264 int i; 1265 1266 switch (act) { 1267 case DVACT_QUIESCE: 1268 /* 1269 * good drivers run play and rec handlers in a single 1270 * interrupt. Grab the lock to ensure we expose the same 1271 * sc->quiesce value to both play and rec handlers 1272 */ 1273 mtx_enter(&audio_lock); 1274 sc->quiesce = 1; 1275 mtx_leave(&audio_lock); 1276 1277 /* 1278 * once sc->quiesce is set, interrupts may occur, but 1279 * counters are not advanced and consequently processes 1280 * keep sleeping. 1281 * 1282 * XXX: ensure read/write/ioctl don't start/stop 1283 * DMA at the same time, this needs a "ready" condvar 1284 */ 1285 if (sc->mode != 0 && sc->active) 1286 audio_stop_do(sc); 1287 1288 /* 1289 * save mixer state 1290 */ 1291 for (i = 0; i != sc->mix_nent; i++) 1292 sc->ops->get_port(sc->arg, sc->mix_ents + i); 1293 1294 DPRINTF("%s: quiesce: active = %d\n", DEVNAME(sc), sc->active); 1295 break; 1296 case DVACT_WAKEUP: 1297 DPRINTF("%s: wakeup: active = %d\n", DEVNAME(sc), sc->active); 1298 1299 /* 1300 * restore mixer state 1301 */ 1302 for (i = 0; i != sc->mix_nent; i++) 1303 sc->ops->set_port(sc->arg, sc->mix_ents + i); 1304 1305 /* 1306 * keep buffer usage the same, but set start pointer to 1307 * the beginning of the buffer. 1308 * 1309 * No need to grab the audio_lock as DMA is stopped and 1310 * this is the only thread running (caller ensures this) 1311 */ 1312 sc->quiesce = 0; 1313 wakeup(&sc->quiesce); 1314 1315 if (sc->mode != 0) { 1316 if (audio_setpar(sc) != 0) 1317 break; 1318 if (sc->mode & AUMODE_PLAY) { 1319 sc->play.start = 0; 1320 audio_fill_sil(sc, sc->play.data, sc->play.len); 1321 } 1322 if (sc->mode & AUMODE_RECORD) { 1323 sc->rec.start = sc->rec.len - sc->rec.used; 1324 audio_fill_sil(sc, sc->rec.data, sc->rec.len); 1325 } 1326 if (sc->active) 1327 audio_start_do(sc); 1328 } 1329 break; 1330 } 1331 return 0; 1332 } 1333 1334 int 1335 audio_detach(struct device *self, int flags) 1336 { 1337 struct audio_softc *sc = (struct audio_softc *)self; 1338 int maj, mn; 1339 1340 DPRINTF("%s: audio_detach: flags = %d\n", DEVNAME(sc), flags); 1341 1342 wakeup(&sc->quiesce); 1343 1344 /* locate the major number */ 1345 for (maj = 0; maj < nchrdev; maj++) 1346 if (cdevsw[maj].d_open == audioopen) 1347 break; 1348 /* 1349 * Nuke the vnodes for any open instances, calls close but as 1350 * close uses device_lookup, it returns EXIO and does nothing 1351 */ 1352 mn = self->dv_unit; 1353 vdevgone(maj, mn | AUDIO_DEV_AUDIO, mn | AUDIO_DEV_AUDIO, VCHR); 1354 vdevgone(maj, mn | AUDIO_DEV_AUDIOCTL, mn | AUDIO_DEV_AUDIOCTL, VCHR); 1355 vdevgone(maj, mn | AUDIO_DEV_MIXER, mn | AUDIO_DEV_MIXER, VCHR); 1356 1357 /* 1358 * The close() method did nothing, quickly halt DMA (normally 1359 * parent is already gone, and code below is no-op), and wake-up 1360 * user-land blocked in read/write/ioctl, which return EIO. 1361 */ 1362 if (sc->mode != 0) { 1363 if (sc->active) { 1364 wakeup(&sc->play.blocking); 1365 selwakeup(&sc->play.sel); 1366 wakeup(&sc->rec.blocking); 1367 selwakeup(&sc->rec.sel); 1368 audio_stop(sc); 1369 } 1370 sc->ops->close(sc->arg); 1371 sc->mode = 0; 1372 } 1373 1374 /* free resources */ 1375 free(sc->mix_evbuf, M_DEVBUF, sc->mix_nent * sizeof(struct mixer_ev)); 1376 free(sc->mix_ents, M_DEVBUF, sc->mix_nent * sizeof(struct mixer_ctrl)); 1377 audio_buf_done(sc, &sc->play); 1378 audio_buf_done(sc, &sc->rec); 1379 return 0; 1380 } 1381 1382 int 1383 audio_submatch(struct device *parent, void *match, void *aux) 1384 { 1385 struct cfdata *cf = match; 1386 1387 return (cf->cf_driver == &audio_cd); 1388 } 1389 1390 struct device * 1391 audio_attach_mi(struct audio_hw_if *ops, void *arg, struct device *dev) 1392 { 1393 struct audio_attach_args aa; 1394 1395 aa.type = AUDIODEV_TYPE_AUDIO; 1396 aa.hwif = ops; 1397 aa.hdl = arg; 1398 1399 /* 1400 * attach this driver to the caller (hardware driver), this 1401 * checks the kernel config and possibly calls audio_attach() 1402 */ 1403 return config_found_sm(dev, &aa, audioprint, audio_submatch); 1404 } 1405 1406 int 1407 audioprint(void *aux, const char *pnp) 1408 { 1409 struct audio_attach_args *arg = aux; 1410 const char *type; 1411 1412 if (pnp != NULL) { 1413 switch (arg->type) { 1414 case AUDIODEV_TYPE_AUDIO: 1415 type = "audio"; 1416 break; 1417 case AUDIODEV_TYPE_OPL: 1418 type = "opl"; 1419 break; 1420 case AUDIODEV_TYPE_MPU: 1421 type = "mpu"; 1422 break; 1423 default: 1424 panic("audioprint: unknown type %d", arg->type); 1425 } 1426 printf("%s at %s", type, pnp); 1427 } 1428 return UNCONF; 1429 } 1430 1431 int 1432 audio_open(struct audio_softc *sc, int flags) 1433 { 1434 int error; 1435 int props; 1436 1437 if (sc->mode) 1438 return EBUSY; 1439 error = sc->ops->open(sc->arg, flags); 1440 if (error) 1441 return error; 1442 sc->active = 0; 1443 sc->pause = 1; 1444 sc->rec.blocking = 0; 1445 sc->play.blocking = 0; 1446 sc->mode = 0; 1447 if (flags & FWRITE) 1448 sc->mode |= AUMODE_PLAY; 1449 if (flags & FREAD) 1450 sc->mode |= AUMODE_RECORD; 1451 props = sc->ops->get_props(sc->arg); 1452 if (sc->mode == (AUMODE_PLAY | AUMODE_RECORD)) { 1453 if (!(props & AUDIO_PROP_FULLDUPLEX)) { 1454 error = ENOTTY; 1455 goto bad; 1456 } 1457 if (sc->ops->setfd) { 1458 error = sc->ops->setfd(sc->arg, 1); 1459 if (error) 1460 goto bad; 1461 } 1462 } 1463 1464 if (sc->ops->speaker_ctl) { 1465 /* 1466 * XXX: what is this used for? 1467 */ 1468 sc->ops->speaker_ctl(sc->arg, 1469 (sc->mode & AUMODE_PLAY) ? SPKR_ON : SPKR_OFF); 1470 } 1471 1472 error = audio_setpar(sc); 1473 if (error) 1474 goto bad; 1475 audio_clear(sc); 1476 1477 /* 1478 * allow read(2)/write(2) to automatically start DMA, without 1479 * the need for ioctl(), to make /dev/audio usable in scripts 1480 */ 1481 sc->pause = 0; 1482 return 0; 1483 bad: 1484 sc->ops->close(sc->arg); 1485 sc->mode = 0; 1486 return error; 1487 } 1488 1489 int 1490 audio_drain(struct audio_softc *sc) 1491 { 1492 int error, xrun; 1493 unsigned char *ptr; 1494 size_t count, bpf; 1495 1496 DPRINTF("%s: drain: mode = %d, pause = %d, active = %d, used = %zu\n", 1497 DEVNAME(sc), sc->mode, sc->pause, sc->active, sc->play.used); 1498 if (!(sc->mode & AUMODE_PLAY) || sc->pause) 1499 return 0; 1500 1501 /* discard partial samples, required by audio_fill_sil() */ 1502 mtx_enter(&audio_lock); 1503 bpf = sc->pchan * sc->bps; 1504 sc->play.used -= sc->play.used % bpf; 1505 if (sc->play.used == 0) { 1506 mtx_leave(&audio_lock); 1507 return 0; 1508 } 1509 1510 if (!sc->active) { 1511 /* 1512 * dma not started yet because buffer was not full 1513 * enough to start automatically. Pad it and start now. 1514 */ 1515 for (;;) { 1516 ptr = audio_buf_wgetblk(&sc->play, &count); 1517 if (count == 0) 1518 break; 1519 audio_fill_sil(sc, ptr, count); 1520 audio_buf_wcommit(&sc->play, count); 1521 } 1522 mtx_leave(&audio_lock); 1523 error = audio_start(sc); 1524 if (error) 1525 return error; 1526 mtx_enter(&audio_lock); 1527 } 1528 1529 xrun = sc->play.xrun; 1530 while (sc->play.xrun == xrun) { 1531 DPRINTF("%s: drain: used = %zu, xrun = %d\n", 1532 DEVNAME(sc), sc->play.used, sc->play.xrun); 1533 1534 /* 1535 * set a 5 second timeout, in case interrupts don't 1536 * work, useful only for debugging drivers 1537 */ 1538 sc->play.blocking = 1; 1539 error = msleep_nsec(&sc->play.blocking, &audio_lock, 1540 PWAIT | PCATCH, "au_dr", SEC_TO_NSEC(5)); 1541 if (!(sc->dev.dv_flags & DVF_ACTIVE)) 1542 error = EIO; 1543 if (error) { 1544 DPRINTF("%s: drain, err = %d\n", DEVNAME(sc), error); 1545 break; 1546 } 1547 } 1548 mtx_leave(&audio_lock); 1549 return error; 1550 } 1551 1552 int 1553 audio_close(struct audio_softc *sc) 1554 { 1555 audio_drain(sc); 1556 if (sc->active) 1557 audio_stop(sc); 1558 sc->ops->close(sc->arg); 1559 sc->mode = 0; 1560 DPRINTF("%s: close: done\n", DEVNAME(sc)); 1561 return 0; 1562 } 1563 1564 int 1565 audio_read(struct audio_softc *sc, struct uio *uio, int ioflag) 1566 { 1567 unsigned char *ptr; 1568 size_t count; 1569 int error; 1570 1571 DPRINTFN(1, "%s: read: resid = %zd\n", DEVNAME(sc), uio->uio_resid); 1572 1573 /* block if quiesced */ 1574 while (sc->quiesce) 1575 tsleep_nsec(&sc->quiesce, 0, "au_qrd", INFSLP); 1576 1577 /* start automatically if audio_ioc_start() was never called */ 1578 if (audio_canstart(sc)) { 1579 error = audio_start(sc); 1580 if (error) 1581 return error; 1582 } 1583 1584 mtx_enter(&audio_lock); 1585 1586 /* if there is no data then sleep */ 1587 while (sc->rec.used == 0) { 1588 if (ioflag & IO_NDELAY) { 1589 mtx_leave(&audio_lock); 1590 return EWOULDBLOCK; 1591 } 1592 DPRINTFN(1, "%s: read sleep\n", DEVNAME(sc)); 1593 sc->rec.blocking = 1; 1594 error = msleep_nsec(&sc->rec.blocking, 1595 &audio_lock, PWAIT | PCATCH, "au_rd", INFSLP); 1596 if (!(sc->dev.dv_flags & DVF_ACTIVE)) 1597 error = EIO; 1598 if (error) { 1599 DPRINTF("%s: read woke up error = %d\n", 1600 DEVNAME(sc), error); 1601 mtx_leave(&audio_lock); 1602 return error; 1603 } 1604 } 1605 1606 /* at this stage, there is data to transfer */ 1607 while (uio->uio_resid > 0 && sc->rec.used > 0) { 1608 ptr = audio_buf_rgetblk(&sc->rec, &count); 1609 if (count > uio->uio_resid) 1610 count = uio->uio_resid; 1611 mtx_leave(&audio_lock); 1612 DPRINTFN(1, "%s: read: start = %zu, count = %zu\n", 1613 DEVNAME(sc), ptr - sc->rec.data, count); 1614 if (sc->conv_dec) 1615 sc->conv_dec(ptr, count); 1616 error = uiomove(ptr, count, uio); 1617 if (error) 1618 return error; 1619 mtx_enter(&audio_lock); 1620 audio_buf_rdiscard(&sc->rec, count); 1621 } 1622 mtx_leave(&audio_lock); 1623 return 0; 1624 } 1625 1626 int 1627 audio_write(struct audio_softc *sc, struct uio *uio, int ioflag) 1628 { 1629 unsigned char *ptr; 1630 size_t count; 1631 int error; 1632 1633 DPRINTFN(1, "%s: write: resid = %zd\n", DEVNAME(sc), uio->uio_resid); 1634 1635 /* block if quiesced */ 1636 while (sc->quiesce) 1637 tsleep_nsec(&sc->quiesce, 0, "au_qwr", INFSLP); 1638 1639 /* 1640 * if IO_NDELAY flag is set then check if there is enough room 1641 * in the buffer to store at least one byte. If not then don't 1642 * start the write process. 1643 */ 1644 mtx_enter(&audio_lock); 1645 if (uio->uio_resid > 0 && (ioflag & IO_NDELAY)) { 1646 if (sc->play.used == sc->play.len) { 1647 mtx_leave(&audio_lock); 1648 return EWOULDBLOCK; 1649 } 1650 } 1651 1652 while (uio->uio_resid > 0) { 1653 while (1) { 1654 ptr = audio_buf_wgetblk(&sc->play, &count); 1655 if (count > 0) 1656 break; 1657 if (ioflag & IO_NDELAY) { 1658 /* 1659 * At this stage at least one byte is already 1660 * moved so we do not return EWOULDBLOCK 1661 */ 1662 mtx_leave(&audio_lock); 1663 return 0; 1664 } 1665 DPRINTFN(1, "%s: write sleep\n", DEVNAME(sc)); 1666 sc->play.blocking = 1; 1667 error = msleep_nsec(&sc->play.blocking, 1668 &audio_lock, PWAIT | PCATCH, "au_wr", INFSLP); 1669 if (!(sc->dev.dv_flags & DVF_ACTIVE)) 1670 error = EIO; 1671 if (error) { 1672 DPRINTF("%s: write woke up error = %d\n", 1673 DEVNAME(sc), error); 1674 mtx_leave(&audio_lock); 1675 return error; 1676 } 1677 } 1678 if (count > uio->uio_resid) 1679 count = uio->uio_resid; 1680 mtx_leave(&audio_lock); 1681 error = uiomove(ptr, count, uio); 1682 if (error) 1683 return 0; 1684 if (sc->conv_enc) { 1685 sc->conv_enc(ptr, count); 1686 DPRINTFN(1, "audio_write: converted count = %zu\n", 1687 count); 1688 } 1689 if (sc->ops->copy_output) 1690 sc->ops->copy_output(sc->arg, count); 1691 1692 mtx_enter(&audio_lock); 1693 audio_buf_wcommit(&sc->play, count); 1694 1695 /* start automatically if audio_ioc_start() was never called */ 1696 if (audio_canstart(sc)) { 1697 mtx_leave(&audio_lock); 1698 error = audio_start(sc); 1699 if (error) 1700 return error; 1701 mtx_enter(&audio_lock); 1702 } 1703 } 1704 mtx_leave(&audio_lock); 1705 return 0; 1706 } 1707 1708 int 1709 audio_getdev(struct audio_softc *sc, struct audio_device *adev) 1710 { 1711 memset(adev, 0, sizeof(struct audio_device)); 1712 if (sc->dev.dv_parent == NULL) 1713 return EIO; 1714 strlcpy(adev->name, sc->dev.dv_parent->dv_xname, MAX_AUDIO_DEV_LEN); 1715 return 0; 1716 } 1717 1718 int 1719 audio_ioctl(struct audio_softc *sc, unsigned long cmd, void *addr) 1720 { 1721 struct audio_pos *ap; 1722 int error = 0; 1723 1724 /* block if quiesced */ 1725 while (sc->quiesce) 1726 tsleep_nsec(&sc->quiesce, 0, "au_qio", INFSLP); 1727 1728 switch (cmd) { 1729 case FIONBIO: 1730 /* All handled in the upper FS layer. */ 1731 break; 1732 case AUDIO_GETPOS: 1733 mtx_enter(&audio_lock); 1734 ap = (struct audio_pos *)addr; 1735 ap->play_pos = sc->play.pos; 1736 ap->play_xrun = sc->play.xrun; 1737 ap->rec_pos = sc->rec.pos; 1738 ap->rec_xrun = sc->rec.xrun; 1739 mtx_leave(&audio_lock); 1740 break; 1741 case AUDIO_START: 1742 return audio_ioc_start(sc); 1743 case AUDIO_STOP: 1744 return audio_ioc_stop(sc); 1745 case AUDIO_SETPAR: 1746 error = audio_ioc_setpar(sc, (struct audio_swpar *)addr); 1747 break; 1748 case AUDIO_GETPAR: 1749 error = audio_ioc_getpar(sc, (struct audio_swpar *)addr); 1750 break; 1751 case AUDIO_GETSTATUS: 1752 error = audio_ioc_getstatus(sc, (struct audio_status *)addr); 1753 break; 1754 case AUDIO_GETDEV: 1755 error = audio_getdev(sc, (struct audio_device *)addr); 1756 break; 1757 default: 1758 DPRINTF("%s: unknown ioctl 0x%lx\n", DEVNAME(sc), cmd); 1759 error = ENOTTY; 1760 break; 1761 } 1762 return error; 1763 } 1764 1765 void 1766 audio_event(struct audio_softc *sc, int addr) 1767 { 1768 struct mixer_ev *e; 1769 1770 mtx_enter(&audio_lock); 1771 if (sc->mix_isopen) { 1772 e = sc->mix_evbuf + addr; 1773 if (!e->pending) { 1774 e->pending = 1; 1775 e->next = sc->mix_pending; 1776 sc->mix_pending = e; 1777 } 1778 if (sc->mix_blocking) { 1779 wakeup(&sc->mix_blocking); 1780 sc->mix_blocking = 0; 1781 } 1782 selwakeup(&sc->mix_sel); 1783 } 1784 mtx_leave(&audio_lock); 1785 } 1786 1787 int 1788 audio_mixer_devinfo(struct audio_softc *sc, struct mixer_devinfo *devinfo) 1789 { 1790 if (devinfo->index < sc->mix_nent) 1791 return sc->ops->query_devinfo(sc->arg, devinfo); 1792 1793 devinfo->next = -1; 1794 devinfo->prev = -1; 1795 switch (devinfo->index - sc->mix_nent) { 1796 case MIXER_RECORD: 1797 strlcpy(devinfo->label.name, AudioCrecord, MAX_AUDIO_DEV_LEN); 1798 devinfo->type = AUDIO_MIXER_CLASS; 1799 devinfo->mixer_class = -1; 1800 break; 1801 case MIXER_RECORD_ENABLE: 1802 strlcpy(devinfo->label.name, "enable", MAX_AUDIO_DEV_LEN); 1803 devinfo->type = AUDIO_MIXER_ENUM; 1804 devinfo->mixer_class = MIXER_RECORD + sc->mix_nent; 1805 devinfo->un.e.num_mem = 3; 1806 devinfo->un.e.member[0].ord = MIXER_RECORD_ENABLE_OFF; 1807 strlcpy(devinfo->un.e.member[0].label.name, "off", 1808 MAX_AUDIO_DEV_LEN); 1809 devinfo->un.e.member[1].ord = MIXER_RECORD_ENABLE_ON; 1810 strlcpy(devinfo->un.e.member[1].label.name, "on", 1811 MAX_AUDIO_DEV_LEN); 1812 devinfo->un.e.member[2].ord = MIXER_RECORD_ENABLE_SYSCTL; 1813 strlcpy(devinfo->un.e.member[2].label.name, "sysctl", 1814 MAX_AUDIO_DEV_LEN); 1815 break; 1816 default: 1817 return EINVAL; 1818 } 1819 1820 return 0; 1821 } 1822 1823 int 1824 audio_mixer_get(struct audio_softc *sc, struct mixer_ctrl *c) 1825 { 1826 if (c->dev < sc->mix_nent) 1827 return sc->ops->get_port(sc->arg, c); 1828 1829 switch (c->dev - sc->mix_nent) { 1830 case MIXER_RECORD: 1831 return EBADF; 1832 case MIXER_RECORD_ENABLE: 1833 c->un.ord = sc->record_enable; 1834 break; 1835 default: 1836 return EINVAL; 1837 } 1838 1839 return 0; 1840 } 1841 1842 int 1843 audio_mixer_set(struct audio_softc *sc, struct mixer_ctrl *c, struct proc *p) 1844 { 1845 int error; 1846 1847 if (c->dev < sc->mix_nent) { 1848 error = sc->ops->set_port(sc->arg, c); 1849 if (error) 1850 return error; 1851 if (sc->ops->commit_settings) 1852 return sc->ops->commit_settings(sc->arg); 1853 audio_event(sc, c->dev); 1854 return 0; 1855 } 1856 1857 switch (c->dev - sc->mix_nent) { 1858 case MIXER_RECORD: 1859 return EBADF; 1860 case MIXER_RECORD_ENABLE: 1861 switch (c->un.ord) { 1862 case MIXER_RECORD_ENABLE_OFF: 1863 case MIXER_RECORD_ENABLE_ON: 1864 case MIXER_RECORD_ENABLE_SYSCTL: 1865 break; 1866 default: 1867 return EINVAL; 1868 } 1869 if (suser(p) == 0) 1870 sc->record_enable = c->un.ord; 1871 break; 1872 default: 1873 return EINVAL; 1874 } 1875 1876 return 0; 1877 } 1878 1879 int 1880 audio_ioctl_mixer(struct audio_softc *sc, unsigned long cmd, void *addr, 1881 struct proc *p) 1882 { 1883 /* block if quiesced */ 1884 while (sc->quiesce) 1885 tsleep_nsec(&sc->quiesce, 0, "mix_qio", INFSLP); 1886 1887 switch (cmd) { 1888 case FIONBIO: 1889 /* All handled in the upper FS layer. */ 1890 break; 1891 case AUDIO_MIXER_DEVINFO: 1892 return audio_mixer_devinfo(sc, addr); 1893 case AUDIO_MIXER_READ: 1894 return audio_mixer_get(sc, addr); 1895 case AUDIO_MIXER_WRITE: 1896 return audio_mixer_set(sc, addr, p); 1897 default: 1898 return ENOTTY; 1899 } 1900 return 0; 1901 } 1902 1903 int 1904 audio_mixer_read(struct audio_softc *sc, struct uio *uio, int ioflag) 1905 { 1906 struct mixer_ev *e; 1907 int data; 1908 int error; 1909 1910 DPRINTF("%s: mixer read: resid = %zd\n", DEVNAME(sc), uio->uio_resid); 1911 1912 /* block if quiesced */ 1913 while (sc->quiesce) 1914 tsleep_nsec(&sc->quiesce, 0, "mix_qrd", INFSLP); 1915 1916 mtx_enter(&audio_lock); 1917 1918 /* if there are no events then sleep */ 1919 while (!sc->mix_pending) { 1920 if (ioflag & IO_NDELAY) { 1921 mtx_leave(&audio_lock); 1922 return EWOULDBLOCK; 1923 } 1924 DPRINTF("%s: mixer read sleep\n", DEVNAME(sc)); 1925 sc->mix_blocking = 1; 1926 error = msleep_nsec(&sc->mix_blocking, 1927 &audio_lock, PWAIT | PCATCH, "mix_rd", INFSLP); 1928 if (!(sc->dev.dv_flags & DVF_ACTIVE)) 1929 error = EIO; 1930 if (error) { 1931 DPRINTF("%s: mixer read woke up error = %d\n", 1932 DEVNAME(sc), error); 1933 mtx_leave(&audio_lock); 1934 return error; 1935 } 1936 } 1937 1938 /* at this stage, there is an event to transfer */ 1939 while (uio->uio_resid >= sizeof(int) && sc->mix_pending) { 1940 e = sc->mix_pending; 1941 sc->mix_pending = e->next; 1942 e->pending = 0; 1943 data = e - sc->mix_evbuf; 1944 mtx_leave(&audio_lock); 1945 DPRINTF("%s: mixer read: %u\n", DEVNAME(sc), data); 1946 error = uiomove(&data, sizeof(int), uio); 1947 if (error) 1948 return error; 1949 mtx_enter(&audio_lock); 1950 } 1951 1952 mtx_leave(&audio_lock); 1953 return 0; 1954 } 1955 1956 int 1957 audio_mixer_poll(struct audio_softc *sc, int events, struct proc *p) 1958 { 1959 int revents = 0; 1960 1961 mtx_enter(&audio_lock); 1962 if (sc->mix_isopen && sc->mix_pending) 1963 revents |= events & (POLLIN | POLLRDNORM); 1964 if (revents == 0) { 1965 if (events & (POLLIN | POLLRDNORM)) 1966 selrecord(p, &sc->mix_sel); 1967 } 1968 mtx_leave(&audio_lock); 1969 return revents; 1970 } 1971 1972 int 1973 audio_mixer_open(struct audio_softc *sc, int flags) 1974 { 1975 DPRINTF("%s: flags = 0x%x\n", __func__, flags); 1976 1977 if (flags & FREAD) { 1978 if (sc->mix_isopen) 1979 return EBUSY; 1980 sc->mix_isopen = 1; 1981 } 1982 return 0; 1983 } 1984 1985 int 1986 audio_mixer_close(struct audio_softc *sc, int flags) 1987 { 1988 int i; 1989 1990 DPRINTF("%s: flags = 0x%x\n", __func__, flags); 1991 1992 if (flags & FREAD) { 1993 sc->mix_isopen = 0; 1994 1995 mtx_enter(&audio_lock); 1996 sc->mix_pending = NULL; 1997 for (i = 0; i < sc->mix_nent; i++) 1998 sc->mix_evbuf[i].pending = 0; 1999 mtx_leave(&audio_lock); 2000 } 2001 return 0; 2002 } 2003 2004 int 2005 audio_poll(struct audio_softc *sc, int events, struct proc *p) 2006 { 2007 int revents = 0; 2008 2009 mtx_enter(&audio_lock); 2010 if ((sc->mode & AUMODE_RECORD) && sc->rec.used > 0) 2011 revents |= events & (POLLIN | POLLRDNORM); 2012 if ((sc->mode & AUMODE_PLAY) && sc->play.used < sc->play.len) 2013 revents |= events & (POLLOUT | POLLWRNORM); 2014 if (revents == 0) { 2015 if (events & (POLLIN | POLLRDNORM)) 2016 selrecord(p, &sc->rec.sel); 2017 if (events & (POLLOUT | POLLWRNORM)) 2018 selrecord(p, &sc->play.sel); 2019 } 2020 mtx_leave(&audio_lock); 2021 return revents; 2022 } 2023 2024 int 2025 audioopen(dev_t dev, int flags, int mode, struct proc *p) 2026 { 2027 struct audio_softc *sc; 2028 int error; 2029 2030 sc = (struct audio_softc *)device_lookup(&audio_cd, AUDIO_UNIT(dev)); 2031 if (sc == NULL) 2032 return ENXIO; 2033 if (sc->ops == NULL) 2034 error = ENXIO; 2035 else { 2036 switch (AUDIO_DEV(dev)) { 2037 case AUDIO_DEV_AUDIO: 2038 error = audio_open(sc, flags); 2039 break; 2040 case AUDIO_DEV_AUDIOCTL: 2041 error = audio_mixer_open(sc, flags); 2042 break; 2043 case AUDIO_DEV_MIXER: 2044 error = 0; 2045 break; 2046 default: 2047 error = ENXIO; 2048 } 2049 } 2050 device_unref(&sc->dev); 2051 return error; 2052 } 2053 2054 int 2055 audioclose(dev_t dev, int flags, int ifmt, struct proc *p) 2056 { 2057 struct audio_softc *sc; 2058 int error; 2059 2060 sc = (struct audio_softc *)device_lookup(&audio_cd, AUDIO_UNIT(dev)); 2061 if (sc == NULL) 2062 return ENXIO; 2063 switch (AUDIO_DEV(dev)) { 2064 case AUDIO_DEV_AUDIO: 2065 error = audio_close(sc); 2066 break; 2067 case AUDIO_DEV_AUDIOCTL: 2068 error = audio_mixer_close(sc, flags); 2069 break; 2070 case AUDIO_DEV_MIXER: 2071 error = 0; 2072 break; 2073 default: 2074 error = ENXIO; 2075 } 2076 device_unref(&sc->dev); 2077 return error; 2078 } 2079 2080 int 2081 audioread(dev_t dev, struct uio *uio, int ioflag) 2082 { 2083 struct audio_softc *sc; 2084 int error; 2085 2086 sc = (struct audio_softc *)device_lookup(&audio_cd, AUDIO_UNIT(dev)); 2087 if (sc == NULL) 2088 return ENXIO; 2089 switch (AUDIO_DEV(dev)) { 2090 case AUDIO_DEV_AUDIO: 2091 error = audio_read(sc, uio, ioflag); 2092 break; 2093 case AUDIO_DEV_AUDIOCTL: 2094 error = audio_mixer_read(sc, uio, ioflag); 2095 break; 2096 case AUDIO_DEV_MIXER: 2097 error = ENODEV; 2098 break; 2099 default: 2100 error = ENXIO; 2101 } 2102 device_unref(&sc->dev); 2103 return error; 2104 } 2105 2106 int 2107 audiowrite(dev_t dev, struct uio *uio, int ioflag) 2108 { 2109 struct audio_softc *sc; 2110 int error; 2111 2112 sc = (struct audio_softc *)device_lookup(&audio_cd, AUDIO_UNIT(dev)); 2113 if (sc == NULL) 2114 return ENXIO; 2115 switch (AUDIO_DEV(dev)) { 2116 case AUDIO_DEV_AUDIO: 2117 error = audio_write(sc, uio, ioflag); 2118 break; 2119 case AUDIO_DEV_AUDIOCTL: 2120 case AUDIO_DEV_MIXER: 2121 error = ENODEV; 2122 break; 2123 default: 2124 error = ENXIO; 2125 } 2126 device_unref(&sc->dev); 2127 return error; 2128 } 2129 2130 int 2131 audioioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct proc *p) 2132 { 2133 struct audio_softc *sc; 2134 int error; 2135 2136 sc = (struct audio_softc *)device_lookup(&audio_cd, AUDIO_UNIT(dev)); 2137 if (sc == NULL) 2138 return ENXIO; 2139 switch (AUDIO_DEV(dev)) { 2140 case AUDIO_DEV_AUDIO: 2141 error = audio_ioctl(sc, cmd, addr); 2142 break; 2143 case AUDIO_DEV_AUDIOCTL: 2144 if (cmd == AUDIO_SETPAR && sc->mode != 0) { 2145 error = EBUSY; 2146 break; 2147 } 2148 if (cmd == AUDIO_START || cmd == AUDIO_STOP) { 2149 error = ENXIO; 2150 break; 2151 } 2152 if (cmd == AUDIO_MIXER_DEVINFO || 2153 cmd == AUDIO_MIXER_READ || 2154 cmd == AUDIO_MIXER_WRITE) 2155 error = audio_ioctl_mixer(sc, cmd, addr, p); 2156 else 2157 error = audio_ioctl(sc, cmd, addr); 2158 break; 2159 case AUDIO_DEV_MIXER: 2160 error = audio_ioctl_mixer(sc, cmd, addr, p); 2161 break; 2162 default: 2163 error = ENXIO; 2164 } 2165 device_unref(&sc->dev); 2166 return error; 2167 } 2168 2169 int 2170 audiopoll(dev_t dev, int events, struct proc *p) 2171 { 2172 struct audio_softc *sc; 2173 int revents; 2174 2175 sc = (struct audio_softc *)device_lookup(&audio_cd, AUDIO_UNIT(dev)); 2176 if (sc == NULL) 2177 return POLLERR; 2178 switch (AUDIO_DEV(dev)) { 2179 case AUDIO_DEV_AUDIO: 2180 revents = audio_poll(sc, events, p); 2181 break; 2182 case AUDIO_DEV_AUDIOCTL: 2183 revents = audio_mixer_poll(sc, events, p); 2184 break; 2185 case AUDIO_DEV_MIXER: 2186 default: 2187 revents = 0; 2188 break; 2189 } 2190 device_unref(&sc->dev); 2191 return revents; 2192 } 2193 2194 #if NWSKBD > 0 2195 int 2196 wskbd_initmute(struct audio_softc *sc, struct mixer_devinfo *vol) 2197 { 2198 struct mixer_devinfo *mi; 2199 int index = -1; 2200 2201 mi = malloc(sizeof(struct mixer_devinfo), M_TEMP, M_WAITOK); 2202 2203 for (mi->index = vol->next; mi->index != -1; mi->index = mi->next) { 2204 if (sc->ops->query_devinfo(sc->arg, mi) != 0) 2205 break; 2206 if (strcmp(mi->label.name, AudioNmute) == 0) { 2207 index = mi->index; 2208 break; 2209 } 2210 } 2211 2212 free(mi, M_TEMP, sizeof(struct mixer_devinfo)); 2213 return index; 2214 } 2215 2216 int 2217 wskbd_initvol(struct audio_softc *sc, struct wskbd_vol *vol, char *cn, char *dn) 2218 { 2219 struct mixer_devinfo *dev, *cls; 2220 2221 vol->val = vol->mute = -1; 2222 dev = malloc(sizeof(struct mixer_devinfo), M_TEMP, M_WAITOK); 2223 cls = malloc(sizeof(struct mixer_devinfo), M_TEMP, M_WAITOK); 2224 2225 for (dev->index = 0; ; dev->index++) { 2226 if (sc->ops->query_devinfo(sc->arg, dev) != 0) 2227 break; 2228 if (dev->type != AUDIO_MIXER_VALUE) 2229 continue; 2230 cls->index = dev->mixer_class; 2231 if (sc->ops->query_devinfo(sc->arg, cls) != 0) 2232 continue; 2233 if (strcmp(cls->label.name, cn) == 0 && 2234 strcmp(dev->label.name, dn) == 0) { 2235 vol->val = dev->index; 2236 vol->nch = dev->un.v.num_channels; 2237 vol->step = dev->un.v.delta > 8 ? dev->un.v.delta : 8; 2238 vol->mute = wskbd_initmute(sc, dev); 2239 vol->val_pending = vol->mute_pending = 0; 2240 DPRINTF("%s: wskbd using %s.%s%s\n", DEVNAME(sc), 2241 cn, dn, vol->mute >= 0 ? ", mute control" : ""); 2242 break; 2243 } 2244 } 2245 2246 free(cls, M_TEMP, sizeof(struct mixer_devinfo)); 2247 free(dev, M_TEMP, sizeof(struct mixer_devinfo)); 2248 return (vol->val != -1); 2249 } 2250 2251 void 2252 wskbd_mixer_init(struct audio_softc *sc) 2253 { 2254 static struct { 2255 char *cn, *dn; 2256 } spkr_names[] = { 2257 {AudioCoutputs, AudioNmaster}, 2258 {AudioCinputs, AudioNdac}, 2259 {AudioCoutputs, AudioNdac}, 2260 {AudioCoutputs, AudioNoutput} 2261 }, mic_names[] = { 2262 {AudioCrecord, AudioNrecord}, 2263 {AudioCrecord, AudioNvolume}, 2264 {AudioCinputs, AudioNrecord}, 2265 {AudioCinputs, AudioNvolume}, 2266 {AudioCinputs, AudioNinput} 2267 }; 2268 int i; 2269 2270 if (sc->dev.dv_unit != 0) { 2271 DPRINTF("%s: not configuring wskbd keys\n", DEVNAME(sc)); 2272 return; 2273 } 2274 for (i = 0; i < sizeof(spkr_names) / sizeof(spkr_names[0]); i++) { 2275 if (wskbd_initvol(sc, &sc->spkr, 2276 spkr_names[i].cn, spkr_names[i].dn)) 2277 break; 2278 } 2279 for (i = 0; i < sizeof(mic_names) / sizeof(mic_names[0]); i++) { 2280 if (wskbd_initvol(sc, &sc->mic, 2281 mic_names[i].cn, mic_names[i].dn)) 2282 break; 2283 } 2284 task_set(&sc->wskbd_task, wskbd_mixer_cb, sc); 2285 } 2286 2287 void 2288 wskbd_mixer_update(struct audio_softc *sc, struct wskbd_vol *vol) 2289 { 2290 struct mixer_ctrl ctrl; 2291 int val_pending, mute_pending, i, gain, error, s; 2292 2293 s = spltty(); 2294 val_pending = vol->val_pending; 2295 vol->val_pending = 0; 2296 mute_pending = vol->mute_pending; 2297 vol->mute_pending = 0; 2298 splx(s); 2299 2300 if (sc->ops == NULL) 2301 return; 2302 if (vol->mute >= 0 && mute_pending) { 2303 ctrl.dev = vol->mute; 2304 ctrl.type = AUDIO_MIXER_ENUM; 2305 error = sc->ops->get_port(sc->arg, &ctrl); 2306 if (error) { 2307 DPRINTF("%s: get mute err = %d\n", DEVNAME(sc), error); 2308 return; 2309 } 2310 switch (mute_pending) { 2311 case WSKBD_MUTE_TOGGLE: 2312 ctrl.un.ord = !ctrl.un.ord; 2313 break; 2314 case WSKBD_MUTE_DISABLE: 2315 ctrl.un.ord = 0; 2316 break; 2317 case WSKBD_MUTE_ENABLE: 2318 ctrl.un.ord = 1; 2319 break; 2320 } 2321 DPRINTFN(1, "%s: wskbd mute setting to %d\n", 2322 DEVNAME(sc), ctrl.un.ord); 2323 error = sc->ops->set_port(sc->arg, &ctrl); 2324 if (error) { 2325 DPRINTF("%s: set mute err = %d\n", DEVNAME(sc), error); 2326 return; 2327 } 2328 audio_event(sc, vol->mute); 2329 } 2330 if (vol->val >= 0 && val_pending) { 2331 ctrl.dev = vol->val; 2332 ctrl.type = AUDIO_MIXER_VALUE; 2333 ctrl.un.value.num_channels = vol->nch; 2334 error = sc->ops->get_port(sc->arg, &ctrl); 2335 if (error) { 2336 DPRINTF("%s: get mute err = %d\n", DEVNAME(sc), error); 2337 return; 2338 } 2339 for (i = 0; i < vol->nch; i++) { 2340 gain = ctrl.un.value.level[i] + vol->step * val_pending; 2341 if (gain > AUDIO_MAX_GAIN) 2342 gain = AUDIO_MAX_GAIN; 2343 else if (gain < AUDIO_MIN_GAIN) 2344 gain = AUDIO_MIN_GAIN; 2345 ctrl.un.value.level[i] = gain; 2346 DPRINTFN(1, "%s: wskbd level %d set to %d\n", 2347 DEVNAME(sc), i, gain); 2348 } 2349 error = sc->ops->set_port(sc->arg, &ctrl); 2350 if (error) { 2351 DPRINTF("%s: set vol err = %d\n", DEVNAME(sc), error); 2352 return; 2353 } 2354 audio_event(sc, vol->val); 2355 } 2356 } 2357 2358 void 2359 wskbd_mixer_cb(void *arg) 2360 { 2361 struct audio_softc *sc = arg; 2362 2363 wskbd_mixer_update(sc, &sc->spkr); 2364 wskbd_mixer_update(sc, &sc->mic); 2365 device_unref(&sc->dev); 2366 } 2367 2368 int 2369 wskbd_set_mixermute(long mute, long out) 2370 { 2371 struct audio_softc *sc; 2372 struct wskbd_vol *vol; 2373 2374 sc = (struct audio_softc *)device_lookup(&audio_cd, 0); 2375 if (sc == NULL) 2376 return ENODEV; 2377 vol = out ? &sc->spkr : &sc->mic; 2378 vol->mute_pending = mute ? WSKBD_MUTE_ENABLE : WSKBD_MUTE_DISABLE; 2379 if (!task_add(systq, &sc->wskbd_task)) 2380 device_unref(&sc->dev); 2381 return 0; 2382 } 2383 2384 int 2385 wskbd_set_mixervolume(long dir, long out) 2386 { 2387 struct audio_softc *sc; 2388 struct wskbd_vol *vol; 2389 2390 sc = (struct audio_softc *)device_lookup(&audio_cd, 0); 2391 if (sc == NULL) 2392 return ENODEV; 2393 vol = out ? &sc->spkr : &sc->mic; 2394 if (dir == 0) 2395 vol->mute_pending ^= WSKBD_MUTE_TOGGLE; 2396 else 2397 vol->val_pending += dir; 2398 if (!task_add(systq, &sc->wskbd_task)) 2399 device_unref(&sc->dev); 2400 return 0; 2401 } 2402 #endif /* NWSKBD > 0 */ 2403