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