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