audio/ossaudio.c

   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         }
 695
 696         pos += nread;
 697         len -= nread;
 698     }
 699
 700     return pos;
 701 }
 702
 703 static void oss_enable_in(HWVoiceIn *hw, bool enable)
 704 {
 705     OSSVoiceIn *oss = (OSSVoiceIn *) hw;
 706     AudiodevOssPerDirectionOptions *opdo = oss->dev->u.oss.out;
 707
 708     if (enable) {
 709         hw->poll_mode = opdo->try_poll;
 710
 711         if (hw->poll_mode) {
 712             oss_poll_in(hw);
 713         }
 714     } else {
 715         if (hw->poll_mode) {
 716             qemu_set_fd_handler (oss->fd, NULL, NULL, NULL);
 717             hw->poll_mode = 0;
 718         }
 719     }
 720 }
 721
 722 static void oss_init_per_direction(AudiodevOssPerDirectionOptions *opdo)
 723 {
 724     if (!opdo->has_try_poll) {
 725         opdo->try_poll = true;
 726         opdo->has_try_poll = true;
 727     }
 728 }
 729
 730 static void *oss_audio_init(Audiodev *dev)
 731 {
 732     AudiodevOssOptions *oopts;
 733     assert(dev->driver == AUDIODEV_DRIVER_OSS);
 734
 735     oopts = &dev->u.oss;
 736     oss_init_per_direction(oopts->in);
 737     oss_init_per_direction(oopts->out);
 738
 739     if (access(oopts->in->has_dev ? oopts->in->dev : "/dev/dsp",
 740                R_OK | W_OK) < 0 ||
 741         access(oopts->out->has_dev ? oopts->out->dev : "/dev/dsp",
 742                R_OK | W_OK) < 0) {
 743         return NULL;
 744     }
 745     return dev;
 746 }
 747
 748 static void oss_audio_fini (void *opaque)
 749 {
 750 }
 751
 752 static struct audio_pcm_ops oss_pcm_ops = {
 753     .init_out = oss_init_out,
 754     .fini_out = oss_fini_out,
 755     .write    = oss_write,
 756     .run_buffer_out = oss_run_buffer_out,
 757     .get_buffer_out = oss_get_buffer_out,
 758     .put_buffer_out = oss_put_buffer_out,
 759     .enable_out = oss_enable_out,
 760
 761     .init_in  = oss_init_in,
 762     .fini_in  = oss_fini_in,
 763     .read     = oss_read,
 764     .enable_in = oss_enable_in
 765 };
 766
 767 static struct audio_driver oss_audio_driver = {
 768     .name           = "oss",
 769     .descr          = "OSS http://www.opensound.com",
 770     .init           = oss_audio_init,
 771     .fini           = oss_audio_fini,
 772     .pcm_ops        = &oss_pcm_ops,
 773     .can_be_default = 1,
 774     .max_voices_out = INT_MAX,
 775     .max_voices_in  = INT_MAX,
 776     .voice_size_out = sizeof (OSSVoiceOut),
 777     .voice_size_in  = sizeof (OSSVoiceIn)
 778 };
 779
 780 static void register_audio_oss(void)
 781 {
 782     audio_driver_register(&oss_audio_driver);
 783 }
 784 type_init(register_audio_oss);