1 /* 2 * QEMU OSS audio driver 3 * 4 * Copyright (c) 2003-2005 Vassili Karpov (malc) 5 * 6 * Permission is hereby granted, free of charge, to any person obtaining a copy 7 * of this software and associated documentation files (the "Software"), to deal 8 * in the Software without restriction, including without limitation the rights 9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 10 * copies of the Software, and to permit persons to whom the Software is 11 * furnished to do so, subject to the following conditions: 12 * 13 * The above copyright notice and this permission notice shall be included in 14 * all copies or substantial portions of the Software. 15 * 16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN 22 * THE SOFTWARE. 23 */ 24 25 #include "qemu/osdep.h" 26 #include <sys/ioctl.h> 27 #include <sys/soundcard.h> 28 #include "qemu/main-loop.h" 29 #include "qemu/module.h" 30 #include "qemu/host-utils.h" 31 #include "audio.h" 32 #include "trace.h" 33 34 #define AUDIO_CAP "oss" 35 #include "audio_int.h" 36 37 #if defined OSS_GETVERSION && defined SNDCTL_DSP_POLICY 38 #define USE_DSP_POLICY 39 #endif 40 41 typedef struct OSSVoiceOut { 42 HWVoiceOut hw; 43 int fd; 44 int nfrags; 45 int fragsize; 46 int mmapped; 47 Audiodev *dev; 48 } OSSVoiceOut; 49 50 typedef struct OSSVoiceIn { 51 HWVoiceIn hw; 52 int fd; 53 int nfrags; 54 int fragsize; 55 Audiodev *dev; 56 } OSSVoiceIn; 57 58 struct oss_params { 59 int freq; 60 int fmt; 61 int nchannels; 62 int nfrags; 63 int fragsize; 64 }; 65 66 static void GCC_FMT_ATTR (2, 3) oss_logerr (int err, const char *fmt, ...) 67 { 68 va_list ap; 69 70 va_start (ap, fmt); 71 AUD_vlog (AUDIO_CAP, fmt, ap); 72 va_end (ap); 73 74 AUD_log (AUDIO_CAP, "Reason: %s\n", strerror (err)); 75 } 76 77 static void GCC_FMT_ATTR (3, 4) oss_logerr2 ( 78 int err, 79 const char *typ, 80 const char *fmt, 81 ... 82 ) 83 { 84 va_list ap; 85 86 AUD_log (AUDIO_CAP, "Could not initialize %s\n", typ); 87 88 va_start (ap, fmt); 89 AUD_vlog (AUDIO_CAP, fmt, ap); 90 va_end (ap); 91 92 AUD_log (AUDIO_CAP, "Reason: %s\n", strerror (err)); 93 } 94 95 static void oss_anal_close (int *fdp) 96 { 97 int err; 98 99 qemu_set_fd_handler (*fdp, NULL, NULL, NULL); 100 err = close (*fdp); 101 if (err) { 102 oss_logerr (errno, "Failed to close file(fd=%d)\n", *fdp); 103 } 104 *fdp = -1; 105 } 106 107 static void oss_helper_poll_out (void *opaque) 108 { 109 AudioState *s = opaque; 110 audio_run(s, "oss_poll_out"); 111 } 112 113 static void oss_helper_poll_in (void *opaque) 114 { 115 AudioState *s = opaque; 116 audio_run(s, "oss_poll_in"); 117 } 118 119 static void oss_poll_out (HWVoiceOut *hw) 120 { 121 OSSVoiceOut *oss = (OSSVoiceOut *) hw; 122 123 qemu_set_fd_handler(oss->fd, NULL, oss_helper_poll_out, hw->s); 124 } 125 126 static void oss_poll_in (HWVoiceIn *hw) 127 { 128 OSSVoiceIn *oss = (OSSVoiceIn *) hw; 129 130 qemu_set_fd_handler(oss->fd, oss_helper_poll_in, NULL, hw->s); 131 } 132 133 static int aud_to_ossfmt (AudioFormat fmt, int endianness) 134 { 135 switch (fmt) { 136 case AUDIO_FORMAT_S8: 137 return AFMT_S8; 138 139 case AUDIO_FORMAT_U8: 140 return AFMT_U8; 141 142 case AUDIO_FORMAT_S16: 143 if (endianness) { 144 return AFMT_S16_BE; 145 } 146 else { 147 return AFMT_S16_LE; 148 } 149 150 case AUDIO_FORMAT_U16: 151 if (endianness) { 152 return AFMT_U16_BE; 153 } 154 else { 155 return AFMT_U16_LE; 156 } 157 158 default: 159 dolog ("Internal logic error: Bad audio format %d\n", fmt); 160 #ifdef DEBUG_AUDIO 161 abort (); 162 #endif 163 return AFMT_U8; 164 } 165 } 166 167 static int oss_to_audfmt (int ossfmt, AudioFormat *fmt, int *endianness) 168 { 169 switch (ossfmt) { 170 case AFMT_S8: 171 *endianness = 0; 172 *fmt = AUDIO_FORMAT_S8; 173 break; 174 175 case AFMT_U8: 176 *endianness = 0; 177 *fmt = AUDIO_FORMAT_U8; 178 break; 179 180 case AFMT_S16_LE: 181 *endianness = 0; 182 *fmt = AUDIO_FORMAT_S16; 183 break; 184 185 case AFMT_U16_LE: 186 *endianness = 0; 187 *fmt = AUDIO_FORMAT_U16; 188 break; 189 190 case AFMT_S16_BE: 191 *endianness = 1; 192 *fmt = AUDIO_FORMAT_S16; 193 break; 194 195 case AFMT_U16_BE: 196 *endianness = 1; 197 *fmt = AUDIO_FORMAT_U16; 198 break; 199 200 default: 201 dolog ("Unrecognized audio format %d\n", ossfmt); 202 return -1; 203 } 204 205 return 0; 206 } 207 208 #if defined DEBUG_MISMATCHES || defined DEBUG 209 static void oss_dump_info (struct oss_params *req, struct oss_params *obt) 210 { 211 dolog ("parameter | requested value | obtained value\n"); 212 dolog ("format | %10d | %10d\n", req->fmt, obt->fmt); 213 dolog ("channels | %10d | %10d\n", 214 req->nchannels, obt->nchannels); 215 dolog ("frequency | %10d | %10d\n", req->freq, obt->freq); 216 dolog ("nfrags | %10d | %10d\n", req->nfrags, obt->nfrags); 217 dolog ("fragsize | %10d | %10d\n", 218 req->fragsize, obt->fragsize); 219 } 220 #endif 221 222 #ifdef USE_DSP_POLICY 223 static int oss_get_version (int fd, int *version, const char *typ) 224 { 225 if (ioctl (fd, OSS_GETVERSION, &version)) { 226 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) 227 /* 228 * Looks like atm (20100109) FreeBSD knows OSS_GETVERSION 229 * since 7.x, but currently only on the mixer device (or in 230 * the Linuxolator), and in the native version that part of 231 * the code is in fact never reached so the ioctl fails anyway. 232 * Until this is fixed, just check the errno and if its what 233 * FreeBSD's sound drivers return atm assume they are new enough. 234 */ 235 if (errno == EINVAL) { 236 *version = 0x040000; 237 return 0; 238 } 239 #endif 240 oss_logerr2 (errno, typ, "Failed to get OSS version\n"); 241 return -1; 242 } 243 return 0; 244 } 245 #endif 246 247 static int oss_open(int in, struct oss_params *req, audsettings *as, 248 struct oss_params *obt, int *pfd, Audiodev *dev) 249 { 250 AudiodevOssOptions *oopts = &dev->u.oss; 251 AudiodevOssPerDirectionOptions *opdo = in ? oopts->in : oopts->out; 252 int fd; 253 int oflags = (oopts->has_exclusive && oopts->exclusive) ? O_EXCL : 0; 254 audio_buf_info abinfo; 255 int fmt, freq, nchannels; 256 int setfragment = 1; 257 const char *dspname = opdo->has_dev ? opdo->dev : "/dev/dsp"; 258 const char *typ = in ? "ADC" : "DAC"; 259 #ifdef USE_DSP_POLICY 260 int policy = oopts->has_dsp_policy ? oopts->dsp_policy : 5; 261 #endif 262 263 /* Kludge needed to have working mmap on Linux */ 264 oflags |= (oopts->has_try_mmap && oopts->try_mmap) ? 265 O_RDWR : (in ? O_RDONLY : O_WRONLY); 266 267 fd = open (dspname, oflags | O_NONBLOCK); 268 if (-1 == fd) { 269 oss_logerr2 (errno, typ, "Failed to open `%s'\n", dspname); 270 return -1; 271 } 272 273 freq = req->freq; 274 nchannels = req->nchannels; 275 fmt = req->fmt; 276 req->nfrags = opdo->has_buffer_count ? opdo->buffer_count : 4; 277 req->fragsize = audio_buffer_bytes( 278 qapi_AudiodevOssPerDirectionOptions_base(opdo), as, 23220); 279 280 if (ioctl (fd, SNDCTL_DSP_SAMPLESIZE, &fmt)) { 281 oss_logerr2 (errno, typ, "Failed to set sample size %d\n", req->fmt); 282 goto err; 283 } 284 285 if (ioctl (fd, SNDCTL_DSP_CHANNELS, &nchannels)) { 286 oss_logerr2 (errno, typ, "Failed to set number of channels %d\n", 287 req->nchannels); 288 goto err; 289 } 290 291 if (ioctl (fd, SNDCTL_DSP_SPEED, &freq)) { 292 oss_logerr2 (errno, typ, "Failed to set frequency %d\n", req->freq); 293 goto err; 294 } 295 296 if (ioctl (fd, SNDCTL_DSP_NONBLOCK, NULL)) { 297 oss_logerr2 (errno, typ, "Failed to set non-blocking mode\n"); 298 goto err; 299 } 300 301 #ifdef USE_DSP_POLICY 302 if (policy >= 0) { 303 int version; 304 305 if (!oss_get_version (fd, &version, typ)) { 306 trace_oss_version(version); 307 308 if (version >= 0x040000) { 309 int policy2 = policy; 310 if (ioctl(fd, SNDCTL_DSP_POLICY, &policy2)) { 311 oss_logerr2 (errno, typ, 312 "Failed to set timing policy to %d\n", 313 policy); 314 goto err; 315 } 316 setfragment = 0; 317 } 318 } 319 } 320 #endif 321 322 if (setfragment) { 323 int mmmmssss = (req->nfrags << 16) | ctz32 (req->fragsize); 324 if (ioctl (fd, SNDCTL_DSP_SETFRAGMENT, &mmmmssss)) { 325 oss_logerr2 (errno, typ, "Failed to set buffer length (%d, %d)\n", 326 req->nfrags, req->fragsize); 327 goto err; 328 } 329 } 330 331 if (ioctl (fd, in ? SNDCTL_DSP_GETISPACE : SNDCTL_DSP_GETOSPACE, &abinfo)) { 332 oss_logerr2 (errno, typ, "Failed to get buffer length\n"); 333 goto err; 334 } 335 336 if (!abinfo.fragstotal || !abinfo.fragsize) { 337 AUD_log (AUDIO_CAP, "Returned bogus buffer information(%d, %d) for %s\n", 338 abinfo.fragstotal, abinfo.fragsize, typ); 339 goto err; 340 } 341 342 obt->fmt = fmt; 343 obt->nchannels = nchannels; 344 obt->freq = freq; 345 obt->nfrags = abinfo.fragstotal; 346 obt->fragsize = abinfo.fragsize; 347 *pfd = fd; 348 349 #ifdef DEBUG_MISMATCHES 350 if ((req->fmt != obt->fmt) || 351 (req->nchannels != obt->nchannels) || 352 (req->freq != obt->freq) || 353 (req->fragsize != obt->fragsize) || 354 (req->nfrags != obt->nfrags)) { 355 dolog ("Audio parameters mismatch\n"); 356 oss_dump_info (req, obt); 357 } 358 #endif 359 360 #ifdef DEBUG 361 oss_dump_info (req, obt); 362 #endif 363 return 0; 364 365 err: 366 oss_anal_close (&fd); 367 return -1; 368 } 369 370 static size_t oss_get_available_bytes(OSSVoiceOut *oss) 371 { 372 int err; 373 struct count_info cntinfo; 374 assert(oss->mmapped); 375 376 err = ioctl(oss->fd, SNDCTL_DSP_GETOPTR, &cntinfo); 377 if (err < 0) { 378 oss_logerr(errno, "SNDCTL_DSP_GETOPTR failed\n"); 379 return 0; 380 } 381 382 return audio_ring_dist(cntinfo.ptr, oss->hw.pos_emul, oss->hw.size_emul); 383 } 384 385 static void oss_run_buffer_out(HWVoiceOut *hw) 386 { 387 OSSVoiceOut *oss = (OSSVoiceOut *)hw; 388 389 if (!oss->mmapped) { 390 audio_generic_run_buffer_out(hw); 391 } 392 } 393 394 static void *oss_get_buffer_out(HWVoiceOut *hw, size_t *size) 395 { 396 OSSVoiceOut *oss = (OSSVoiceOut *) hw; 397 if (oss->mmapped) { 398 *size = MIN(oss_get_available_bytes(oss), hw->size_emul - hw->pos_emul); 399 return hw->buf_emul + hw->pos_emul; 400 } else { 401 return audio_generic_get_buffer_out(hw, size); 402 } 403 } 404 405 static size_t oss_put_buffer_out(HWVoiceOut *hw, void *buf, size_t size) 406 { 407 OSSVoiceOut *oss = (OSSVoiceOut *) hw; 408 if (oss->mmapped) { 409 assert(buf == hw->buf_emul + hw->pos_emul && size < hw->size_emul); 410 411 hw->pos_emul = (hw->pos_emul + size) % hw->size_emul; 412 return size; 413 } else { 414 return audio_generic_put_buffer_out(hw, buf, size); 415 } 416 } 417 418 static size_t oss_write(HWVoiceOut *hw, void *buf, size_t len) 419 { 420 OSSVoiceOut *oss = (OSSVoiceOut *) hw; 421 size_t pos; 422 423 if (oss->mmapped) { 424 size_t total_len; 425 len = MIN(len, oss_get_available_bytes(oss)); 426 427 total_len = len; 428 while (len) { 429 size_t to_copy = MIN(len, hw->size_emul - hw->pos_emul); 430 memcpy(hw->buf_emul + hw->pos_emul, buf, to_copy); 431 432 hw->pos_emul = (hw->pos_emul + to_copy) % hw->size_emul; 433 buf += to_copy; 434 len -= to_copy; 435 } 436 return total_len; 437 } 438 439 pos = 0; 440 while (len) { 441 ssize_t bytes_written; 442 void *pcm = advance(buf, pos); 443 444 bytes_written = write(oss->fd, pcm, len); 445 if (bytes_written < 0) { 446 if (errno != EAGAIN) { 447 oss_logerr(errno, "failed to write %zu bytes\n", 448 len); 449 } 450 return pos; 451 } 452 453 pos += bytes_written; 454 if (bytes_written < len) { 455 break; 456 } 457 len -= bytes_written; 458 } 459 return pos; 460 } 461 462 static void oss_fini_out (HWVoiceOut *hw) 463 { 464 int err; 465 OSSVoiceOut *oss = (OSSVoiceOut *) hw; 466 467 ldebug ("oss_fini\n"); 468 oss_anal_close (&oss->fd); 469 470 if (oss->mmapped && hw->buf_emul) { 471 err = munmap(hw->buf_emul, hw->size_emul); 472 if (err) { 473 oss_logerr(errno, "Failed to unmap buffer %p, size %zu\n", 474 hw->buf_emul, hw->size_emul); 475 } 476 hw->buf_emul = NULL; 477 } 478 } 479 480 static int oss_init_out(HWVoiceOut *hw, struct audsettings *as, 481 void *drv_opaque) 482 { 483 OSSVoiceOut *oss = (OSSVoiceOut *) hw; 484 struct oss_params req, obt; 485 int endianness; 486 int err; 487 int fd; 488 AudioFormat effective_fmt; 489 struct audsettings obt_as; 490 Audiodev *dev = drv_opaque; 491 AudiodevOssOptions *oopts = &dev->u.oss; 492 493 oss->fd = -1; 494 495 req.fmt = aud_to_ossfmt (as->fmt, as->endianness); 496 req.freq = as->freq; 497 req.nchannels = as->nchannels; 498 499 if (oss_open(0, &req, as, &obt, &fd, dev)) { 500 return -1; 501 } 502 503 err = oss_to_audfmt (obt.fmt, &effective_fmt, &endianness); 504 if (err) { 505 oss_anal_close (&fd); 506 return -1; 507 } 508 509 obt_as.freq = obt.freq; 510 obt_as.nchannels = obt.nchannels; 511 obt_as.fmt = effective_fmt; 512 obt_as.endianness = endianness; 513 514 audio_pcm_init_info (&hw->info, &obt_as); 515 oss->nfrags = obt.nfrags; 516 oss->fragsize = obt.fragsize; 517 518 if (obt.nfrags * obt.fragsize % hw->info.bytes_per_frame) { 519 dolog ("warning: Misaligned DAC buffer, size %d, alignment %d\n", 520 obt.nfrags * obt.fragsize, hw->info.bytes_per_frame); 521 } 522 523 hw->samples = (obt.nfrags * obt.fragsize) / hw->info.bytes_per_frame; 524 525 oss->mmapped = 0; 526 if (oopts->has_try_mmap && oopts->try_mmap) { 527 hw->size_emul = hw->samples * hw->info.bytes_per_frame; 528 hw->buf_emul = mmap( 529 NULL, 530 hw->size_emul, 531 PROT_READ | PROT_WRITE, 532 MAP_SHARED, 533 fd, 534 0 535 ); 536 if (hw->buf_emul == MAP_FAILED) { 537 oss_logerr(errno, "Failed to map %zu bytes of DAC\n", 538 hw->size_emul); 539 hw->buf_emul = NULL; 540 } else { 541 int err; 542 int trig = 0; 543 if (ioctl (fd, SNDCTL_DSP_SETTRIGGER, &trig) < 0) { 544 oss_logerr (errno, "SNDCTL_DSP_SETTRIGGER 0 failed\n"); 545 } 546 else { 547 trig = PCM_ENABLE_OUTPUT; 548 if (ioctl (fd, SNDCTL_DSP_SETTRIGGER, &trig) < 0) { 549 oss_logerr ( 550 errno, 551 "SNDCTL_DSP_SETTRIGGER PCM_ENABLE_OUTPUT failed\n" 552 ); 553 } 554 else { 555 oss->mmapped = 1; 556 } 557 } 558 559 if (!oss->mmapped) { 560 err = munmap(hw->buf_emul, hw->size_emul); 561 if (err) { 562 oss_logerr(errno, "Failed to unmap buffer %p size %zu\n", 563 hw->buf_emul, hw->size_emul); 564 } 565 hw->buf_emul = NULL; 566 } 567 } 568 } 569 570 oss->fd = fd; 571 oss->dev = dev; 572 return 0; 573 } 574 575 static void oss_enable_out(HWVoiceOut *hw, bool enable) 576 { 577 int trig; 578 OSSVoiceOut *oss = (OSSVoiceOut *) hw; 579 AudiodevOssPerDirectionOptions *opdo = oss->dev->u.oss.out; 580 581 if (enable) { 582 hw->poll_mode = opdo->try_poll; 583 584 ldebug("enabling voice\n"); 585 if (hw->poll_mode) { 586 oss_poll_out(hw); 587 } 588 589 if (!oss->mmapped) { 590 return; 591 } 592 593 audio_pcm_info_clear_buf(&hw->info, hw->buf_emul, hw->samples); 594 trig = PCM_ENABLE_OUTPUT; 595 if (ioctl(oss->fd, SNDCTL_DSP_SETTRIGGER, &trig) < 0) { 596 oss_logerr(errno, 597 "SNDCTL_DSP_SETTRIGGER PCM_ENABLE_OUTPUT failed\n"); 598 return; 599 } 600 } else { 601 if (hw->poll_mode) { 602 qemu_set_fd_handler (oss->fd, NULL, NULL, NULL); 603 hw->poll_mode = 0; 604 } 605 606 if (!oss->mmapped) { 607 return; 608 } 609 610 ldebug ("disabling voice\n"); 611 trig = 0; 612 if (ioctl (oss->fd, SNDCTL_DSP_SETTRIGGER, &trig) < 0) { 613 oss_logerr (errno, "SNDCTL_DSP_SETTRIGGER 0 failed\n"); 614 return; 615 } 616 } 617 } 618 619 static int oss_init_in(HWVoiceIn *hw, struct audsettings *as, void *drv_opaque) 620 { 621 OSSVoiceIn *oss = (OSSVoiceIn *) hw; 622 struct oss_params req, obt; 623 int endianness; 624 int err; 625 int fd; 626 AudioFormat effective_fmt; 627 struct audsettings obt_as; 628 Audiodev *dev = drv_opaque; 629 630 oss->fd = -1; 631 632 req.fmt = aud_to_ossfmt (as->fmt, as->endianness); 633 req.freq = as->freq; 634 req.nchannels = as->nchannels; 635 if (oss_open(1, &req, as, &obt, &fd, dev)) { 636 return -1; 637 } 638 639 err = oss_to_audfmt (obt.fmt, &effective_fmt, &endianness); 640 if (err) { 641 oss_anal_close (&fd); 642 return -1; 643 } 644 645 obt_as.freq = obt.freq; 646 obt_as.nchannels = obt.nchannels; 647 obt_as.fmt = effective_fmt; 648 obt_as.endianness = endianness; 649 650 audio_pcm_init_info (&hw->info, &obt_as); 651 oss->nfrags = obt.nfrags; 652 oss->fragsize = obt.fragsize; 653 654 if (obt.nfrags * obt.fragsize % hw->info.bytes_per_frame) { 655 dolog ("warning: Misaligned ADC buffer, size %d, alignment %d\n", 656 obt.nfrags * obt.fragsize, hw->info.bytes_per_frame); 657 } 658 659 hw->samples = (obt.nfrags * obt.fragsize) / hw->info.bytes_per_frame; 660 661 oss->fd = fd; 662 oss->dev = dev; 663 return 0; 664 } 665 666 static void oss_fini_in (HWVoiceIn *hw) 667 { 668 OSSVoiceIn *oss = (OSSVoiceIn *) hw; 669 670 oss_anal_close (&oss->fd); 671 } 672 673 static size_t oss_read(HWVoiceIn *hw, void *buf, size_t len) 674 { 675 OSSVoiceIn *oss = (OSSVoiceIn *) hw; 676 size_t pos = 0; 677 678 while (len) { 679 ssize_t nread; 680 681 void *dst = advance(buf, pos); 682 nread = read(oss->fd, dst, len); 683 684 if (nread == -1) { 685 switch (errno) { 686 case EINTR: 687 case EAGAIN: 688 break; 689 default: 690 oss_logerr(errno, "Failed to read %zu bytes of audio (to %p)\n", 691 len, dst); 692 break; 693 } 694 break; 695 } 696 697 pos += nread; 698 len -= nread; 699 } 700 701 return pos; 702 } 703 704 static void oss_enable_in(HWVoiceIn *hw, bool enable) 705 { 706 OSSVoiceIn *oss = (OSSVoiceIn *) hw; 707 AudiodevOssPerDirectionOptions *opdo = oss->dev->u.oss.out; 708 709 if (enable) { 710 hw->poll_mode = opdo->try_poll; 711 712 if (hw->poll_mode) { 713 oss_poll_in(hw); 714 } 715 } else { 716 if (hw->poll_mode) { 717 qemu_set_fd_handler (oss->fd, NULL, NULL, NULL); 718 hw->poll_mode = 0; 719 } 720 } 721 } 722 723 static void oss_init_per_direction(AudiodevOssPerDirectionOptions *opdo) 724 { 725 if (!opdo->has_try_poll) { 726 opdo->try_poll = true; 727 opdo->has_try_poll = true; 728 } 729 } 730 731 static void *oss_audio_init(Audiodev *dev) 732 { 733 AudiodevOssOptions *oopts; 734 assert(dev->driver == AUDIODEV_DRIVER_OSS); 735 736 oopts = &dev->u.oss; 737 oss_init_per_direction(oopts->in); 738 oss_init_per_direction(oopts->out); 739 740 if (access(oopts->in->has_dev ? oopts->in->dev : "/dev/dsp", 741 R_OK | W_OK) < 0 || 742 access(oopts->out->has_dev ? oopts->out->dev : "/dev/dsp", 743 R_OK | W_OK) < 0) { 744 return NULL; 745 } 746 return dev; 747 } 748 749 static void oss_audio_fini (void *opaque) 750 { 751 } 752 753 static struct audio_pcm_ops oss_pcm_ops = { 754 .init_out = oss_init_out, 755 .fini_out = oss_fini_out, 756 .write = oss_write, 757 .run_buffer_out = oss_run_buffer_out, 758 .get_buffer_out = oss_get_buffer_out, 759 .put_buffer_out = oss_put_buffer_out, 760 .enable_out = oss_enable_out, 761 762 .init_in = oss_init_in, 763 .fini_in = oss_fini_in, 764 .read = oss_read, 765 .enable_in = oss_enable_in 766 }; 767 768 static struct audio_driver oss_audio_driver = { 769 .name = "oss", 770 .descr = "OSS http://www.opensound.com", 771 .init = oss_audio_init, 772 .fini = oss_audio_fini, 773 .pcm_ops = &oss_pcm_ops, 774 .can_be_default = 1, 775 .max_voices_out = INT_MAX, 776 .max_voices_in = INT_MAX, 777 .voice_size_out = sizeof (OSSVoiceOut), 778 .voice_size_in = sizeof (OSSVoiceIn) 779 }; 780 781 static void register_audio_oss(void) 782 { 783 audio_driver_register(&oss_audio_driver); 784 } 785 type_init(register_audio_oss); 786