qemu/audio/ossaudio.c
<<
>>
Prefs
   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
  41typedef struct OSSVoiceOut {
  42    HWVoiceOut hw;
  43    int fd;
  44    int nfrags;
  45    int fragsize;
  46    int mmapped;
  47    Audiodev *dev;
  48} OSSVoiceOut;
  49
  50typedef struct OSSVoiceIn {
  51    HWVoiceIn hw;
  52    int fd;
  53    int nfrags;
  54    int fragsize;
  55    Audiodev *dev;
  56} OSSVoiceIn;
  57
  58struct oss_params {
  59    int freq;
  60    int fmt;
  61    int nchannels;
  62    int nfrags;
  63    int fragsize;
  64};
  65
  66static 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
  77static 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
  95static 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
 107static void oss_helper_poll_out (void *opaque)
 108{
 109    AudioState *s = opaque;
 110    audio_run(s, "oss_poll_out");
 111}
 112
 113static void oss_helper_poll_in (void *opaque)
 114{
 115    AudioState *s = opaque;
 116    audio_run(s, "oss_poll_in");
 117}
 118
 119static 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
 126static 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
 133static 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
 167static 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
 209static 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
 223static 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
 247static 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
 370static 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
 385static void *oss_get_buffer_out(HWVoiceOut *hw, size_t *size)
 386{
 387    OSSVoiceOut *oss = (OSSVoiceOut *) hw;
 388    if (oss->mmapped) {
 389        *size = MIN(oss_get_available_bytes(oss), hw->size_emul - hw->pos_emul);
 390        return hw->buf_emul + hw->pos_emul;
 391    } else {
 392        return audio_generic_get_buffer_out(hw, size);
 393    }
 394}
 395
 396static size_t oss_put_buffer_out(HWVoiceOut *hw, void *buf, size_t size)
 397{
 398    OSSVoiceOut *oss = (OSSVoiceOut *) hw;
 399    if (oss->mmapped) {
 400        assert(buf == hw->buf_emul + hw->pos_emul && size < hw->size_emul);
 401
 402        hw->pos_emul = (hw->pos_emul + size) % hw->size_emul;
 403        return size;
 404    } else {
 405        return audio_generic_put_buffer_out(hw, buf, size);
 406    }
 407}
 408
 409static size_t oss_write(HWVoiceOut *hw, void *buf, size_t len)
 410{
 411    OSSVoiceOut *oss = (OSSVoiceOut *) hw;
 412    size_t pos;
 413
 414    if (oss->mmapped) {
 415        size_t total_len;
 416        len = MIN(len, oss_get_available_bytes(oss));
 417
 418        total_len = len;
 419        while (len) {
 420            size_t to_copy = MIN(len, hw->size_emul - hw->pos_emul);
 421            memcpy(hw->buf_emul + hw->pos_emul, buf, to_copy);
 422
 423            hw->pos_emul = (hw->pos_emul + to_copy) % hw->pos_emul;
 424            buf += to_copy;
 425            len -= to_copy;
 426        }
 427        return total_len;
 428    }
 429
 430    pos = 0;
 431    while (len) {
 432        ssize_t bytes_written;
 433        void *pcm = advance(buf, pos);
 434
 435        bytes_written = write(oss->fd, pcm, len);
 436        if (bytes_written < 0) {
 437            if (errno != EAGAIN) {
 438                oss_logerr(errno, "failed to write %zu bytes\n",
 439                           len);
 440            }
 441            return pos;
 442        }
 443
 444        pos += bytes_written;
 445        if (bytes_written < len) {
 446            break;
 447        }
 448        len -= bytes_written;
 449    }
 450    return pos;
 451}
 452
 453static void oss_fini_out (HWVoiceOut *hw)
 454{
 455    int err;
 456    OSSVoiceOut *oss = (OSSVoiceOut *) hw;
 457
 458    ldebug ("oss_fini\n");
 459    oss_anal_close (&oss->fd);
 460
 461    if (oss->mmapped && hw->buf_emul) {
 462        err = munmap(hw->buf_emul, hw->size_emul);
 463        if (err) {
 464            oss_logerr(errno, "Failed to unmap buffer %p, size %zu\n",
 465                       hw->buf_emul, hw->size_emul);
 466        }
 467        hw->buf_emul = NULL;
 468    }
 469}
 470
 471static int oss_init_out(HWVoiceOut *hw, struct audsettings *as,
 472                        void *drv_opaque)
 473{
 474    OSSVoiceOut *oss = (OSSVoiceOut *) hw;
 475    struct oss_params req, obt;
 476    int endianness;
 477    int err;
 478    int fd;
 479    AudioFormat effective_fmt;
 480    struct audsettings obt_as;
 481    Audiodev *dev = drv_opaque;
 482    AudiodevOssOptions *oopts = &dev->u.oss;
 483
 484    oss->fd = -1;
 485
 486    req.fmt = aud_to_ossfmt (as->fmt, as->endianness);
 487    req.freq = as->freq;
 488    req.nchannels = as->nchannels;
 489
 490    if (oss_open(0, &req, as, &obt, &fd, dev)) {
 491        return -1;
 492    }
 493
 494    err = oss_to_audfmt (obt.fmt, &effective_fmt, &endianness);
 495    if (err) {
 496        oss_anal_close (&fd);
 497        return -1;
 498    }
 499
 500    obt_as.freq = obt.freq;
 501    obt_as.nchannels = obt.nchannels;
 502    obt_as.fmt = effective_fmt;
 503    obt_as.endianness = endianness;
 504
 505    audio_pcm_init_info (&hw->info, &obt_as);
 506    oss->nfrags = obt.nfrags;
 507    oss->fragsize = obt.fragsize;
 508
 509    if (obt.nfrags * obt.fragsize % hw->info.bytes_per_frame) {
 510        dolog ("warning: Misaligned DAC buffer, size %d, alignment %d\n",
 511               obt.nfrags * obt.fragsize, hw->info.bytes_per_frame);
 512    }
 513
 514    hw->samples = (obt.nfrags * obt.fragsize) / hw->info.bytes_per_frame;
 515
 516    oss->mmapped = 0;
 517    if (oopts->has_try_mmap && oopts->try_mmap) {
 518        hw->size_emul = hw->samples * hw->info.bytes_per_frame;
 519        hw->buf_emul = mmap(
 520            NULL,
 521            hw->size_emul,
 522            PROT_READ | PROT_WRITE,
 523            MAP_SHARED,
 524            fd,
 525            0
 526            );
 527        if (hw->buf_emul == MAP_FAILED) {
 528            oss_logerr(errno, "Failed to map %zu bytes of DAC\n",
 529                       hw->size_emul);
 530            hw->buf_emul = NULL;
 531        } else {
 532            int err;
 533            int trig = 0;
 534            if (ioctl (fd, SNDCTL_DSP_SETTRIGGER, &trig) < 0) {
 535                oss_logerr (errno, "SNDCTL_DSP_SETTRIGGER 0 failed\n");
 536            }
 537            else {
 538                trig = PCM_ENABLE_OUTPUT;
 539                if (ioctl (fd, SNDCTL_DSP_SETTRIGGER, &trig) < 0) {
 540                    oss_logerr (
 541                        errno,
 542                        "SNDCTL_DSP_SETTRIGGER PCM_ENABLE_OUTPUT failed\n"
 543                        );
 544                }
 545                else {
 546                    oss->mmapped = 1;
 547                }
 548            }
 549
 550            if (!oss->mmapped) {
 551                err = munmap(hw->buf_emul, hw->size_emul);
 552                if (err) {
 553                    oss_logerr(errno, "Failed to unmap buffer %p size %zu\n",
 554                               hw->buf_emul, hw->size_emul);
 555                }
 556                hw->buf_emul = NULL;
 557            }
 558        }
 559    }
 560
 561    oss->fd = fd;
 562    oss->dev = dev;
 563    return 0;
 564}
 565
 566static void oss_enable_out(HWVoiceOut *hw, bool enable)
 567{
 568    int trig;
 569    OSSVoiceOut *oss = (OSSVoiceOut *) hw;
 570    AudiodevOssPerDirectionOptions *opdo = oss->dev->u.oss.out;
 571
 572    if (enable) {
 573        bool poll_mode = opdo->try_poll;
 574
 575        ldebug("enabling voice\n");
 576        if (poll_mode) {
 577            oss_poll_out(hw);
 578            poll_mode = 0;
 579        }
 580        hw->poll_mode = poll_mode;
 581
 582        if (!oss->mmapped) {
 583            return;
 584        }
 585
 586        audio_pcm_info_clear_buf(&hw->info, hw->buf_emul, hw->mix_buf->size);
 587        trig = PCM_ENABLE_OUTPUT;
 588        if (ioctl(oss->fd, SNDCTL_DSP_SETTRIGGER, &trig) < 0) {
 589            oss_logerr(errno,
 590                       "SNDCTL_DSP_SETTRIGGER PCM_ENABLE_OUTPUT failed\n");
 591            return;
 592        }
 593    } else {
 594        if (hw->poll_mode) {
 595            qemu_set_fd_handler (oss->fd, NULL, NULL, NULL);
 596            hw->poll_mode = 0;
 597        }
 598
 599        if (!oss->mmapped) {
 600            return;
 601        }
 602
 603        ldebug ("disabling voice\n");
 604        trig = 0;
 605        if (ioctl (oss->fd, SNDCTL_DSP_SETTRIGGER, &trig) < 0) {
 606            oss_logerr (errno, "SNDCTL_DSP_SETTRIGGER 0 failed\n");
 607            return;
 608        }
 609    }
 610}
 611
 612static int oss_init_in(HWVoiceIn *hw, struct audsettings *as, void *drv_opaque)
 613{
 614    OSSVoiceIn *oss = (OSSVoiceIn *) hw;
 615    struct oss_params req, obt;
 616    int endianness;
 617    int err;
 618    int fd;
 619    AudioFormat effective_fmt;
 620    struct audsettings obt_as;
 621    Audiodev *dev = drv_opaque;
 622
 623    oss->fd = -1;
 624
 625    req.fmt = aud_to_ossfmt (as->fmt, as->endianness);
 626    req.freq = as->freq;
 627    req.nchannels = as->nchannels;
 628    if (oss_open(1, &req, as, &obt, &fd, dev)) {
 629        return -1;
 630    }
 631
 632    err = oss_to_audfmt (obt.fmt, &effective_fmt, &endianness);
 633    if (err) {
 634        oss_anal_close (&fd);
 635        return -1;
 636    }
 637
 638    obt_as.freq = obt.freq;
 639    obt_as.nchannels = obt.nchannels;
 640    obt_as.fmt = effective_fmt;
 641    obt_as.endianness = endianness;
 642
 643    audio_pcm_init_info (&hw->info, &obt_as);
 644    oss->nfrags = obt.nfrags;
 645    oss->fragsize = obt.fragsize;
 646
 647    if (obt.nfrags * obt.fragsize % hw->info.bytes_per_frame) {
 648        dolog ("warning: Misaligned ADC buffer, size %d, alignment %d\n",
 649               obt.nfrags * obt.fragsize, hw->info.bytes_per_frame);
 650    }
 651
 652    hw->samples = (obt.nfrags * obt.fragsize) / hw->info.bytes_per_frame;
 653
 654    oss->fd = fd;
 655    oss->dev = dev;
 656    return 0;
 657}
 658
 659static void oss_fini_in (HWVoiceIn *hw)
 660{
 661    OSSVoiceIn *oss = (OSSVoiceIn *) hw;
 662
 663    oss_anal_close (&oss->fd);
 664}
 665
 666static size_t oss_read(HWVoiceIn *hw, void *buf, size_t len)
 667{
 668    OSSVoiceIn *oss = (OSSVoiceIn *) hw;
 669    size_t pos = 0;
 670
 671    while (len) {
 672        ssize_t nread;
 673
 674        void *dst = advance(buf, pos);
 675        nread = read(oss->fd, dst, len);
 676
 677        if (nread == -1) {
 678            switch (errno) {
 679            case EINTR:
 680            case EAGAIN:
 681                break;
 682            default:
 683                oss_logerr(errno, "Failed to read %zu bytes of audio (to %p)\n",
 684                           len, dst);
 685                break;
 686            }
 687        }
 688
 689        pos += nread;
 690        len -= nread;
 691    }
 692
 693    return pos;
 694}
 695
 696static void oss_enable_in(HWVoiceIn *hw, bool enable)
 697{
 698    OSSVoiceIn *oss = (OSSVoiceIn *) hw;
 699    AudiodevOssPerDirectionOptions *opdo = oss->dev->u.oss.out;
 700
 701    if (enable) {
 702        bool poll_mode = opdo->try_poll;
 703
 704        if (poll_mode) {
 705            oss_poll_in(hw);
 706            poll_mode = 0;
 707        }
 708        hw->poll_mode = poll_mode;
 709    } else {
 710        if (hw->poll_mode) {
 711            hw->poll_mode = 0;
 712            qemu_set_fd_handler (oss->fd, NULL, NULL, NULL);
 713        }
 714    }
 715}
 716
 717static void oss_init_per_direction(AudiodevOssPerDirectionOptions *opdo)
 718{
 719    if (!opdo->has_try_poll) {
 720        opdo->try_poll = true;
 721        opdo->has_try_poll = true;
 722    }
 723}
 724
 725static void *oss_audio_init(Audiodev *dev)
 726{
 727    AudiodevOssOptions *oopts;
 728    assert(dev->driver == AUDIODEV_DRIVER_OSS);
 729
 730    oopts = &dev->u.oss;
 731    oss_init_per_direction(oopts->in);
 732    oss_init_per_direction(oopts->out);
 733
 734    if (access(oopts->in->has_dev ? oopts->in->dev : "/dev/dsp",
 735               R_OK | W_OK) < 0 ||
 736        access(oopts->out->has_dev ? oopts->out->dev : "/dev/dsp",
 737               R_OK | W_OK) < 0) {
 738        return NULL;
 739    }
 740    return dev;
 741}
 742
 743static void oss_audio_fini (void *opaque)
 744{
 745}
 746
 747static struct audio_pcm_ops oss_pcm_ops = {
 748    .init_out = oss_init_out,
 749    .fini_out = oss_fini_out,
 750    .write    = oss_write,
 751    .get_buffer_out = oss_get_buffer_out,
 752    .put_buffer_out = oss_put_buffer_out,
 753    .enable_out = oss_enable_out,
 754
 755    .init_in  = oss_init_in,
 756    .fini_in  = oss_fini_in,
 757    .read     = oss_read,
 758    .enable_in = oss_enable_in
 759};
 760
 761static struct audio_driver oss_audio_driver = {
 762    .name           = "oss",
 763    .descr          = "OSS http://www.opensound.com",
 764    .init           = oss_audio_init,
 765    .fini           = oss_audio_fini,
 766    .pcm_ops        = &oss_pcm_ops,
 767    .can_be_default = 1,
 768    .max_voices_out = INT_MAX,
 769    .max_voices_in  = INT_MAX,
 770    .voice_size_out = sizeof (OSSVoiceOut),
 771    .voice_size_in  = sizeof (OSSVoiceIn)
 772};
 773
 774static void register_audio_oss(void)
 775{
 776    audio_driver_register(&oss_audio_driver);
 777}
 778type_init(register_audio_oss);
 779