Bug Summary

File:dev/audio.c
Warning:line 276, column 12
The left operand of '*' is a garbage value

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.4 -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name audio.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model static -mframe-pointer=all -relaxed-aliasing -ffp-contract=on -fno-rounding-math -mconstructor-aliases -ffreestanding -mcmodel=kernel -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -target-feature -sse2 -target-feature -sse -target-feature -3dnow -target-feature -mmx -target-feature +save-args -target-feature +retpoline-external-thunk -disable-red-zone -no-implicit-float -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/sys/arch/amd64/compile/GENERIC.MP/obj -nostdsysteminc -nobuiltininc -resource-dir /usr/local/llvm16/lib/clang/16 -I /usr/src/sys -I /usr/src/sys/arch/amd64/compile/GENERIC.MP/obj -I /usr/src/sys/arch -I /usr/src/sys/dev/pci/drm/include -I /usr/src/sys/dev/pci/drm/include/uapi -I /usr/src/sys/dev/pci/drm/amd/include/asic_reg -I /usr/src/sys/dev/pci/drm/amd/include -I /usr/src/sys/dev/pci/drm/amd/amdgpu -I /usr/src/sys/dev/pci/drm/amd/display -I /usr/src/sys/dev/pci/drm/amd/display/include -I /usr/src/sys/dev/pci/drm/amd/display/dc -I /usr/src/sys/dev/pci/drm/amd/display/amdgpu_dm -I /usr/src/sys/dev/pci/drm/amd/pm/inc -I /usr/src/sys/dev/pci/drm/amd/pm/legacy-dpm -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/inc -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/smu11 -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/smu12 -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/smu13 -I /usr/src/sys/dev/pci/drm/amd/pm/powerplay/inc -I /usr/src/sys/dev/pci/drm/amd/pm/powerplay/hwmgr -I /usr/src/sys/dev/pci/drm/amd/pm/powerplay/smumgr -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/inc -I /usr/src/sys/dev/pci/drm/amd/pm/swsmu/inc/pmfw_if -I /usr/src/sys/dev/pci/drm/amd/display/dc/inc -I /usr/src/sys/dev/pci/drm/amd/display/dc/inc/hw -I /usr/src/sys/dev/pci/drm/amd/display/dc/clk_mgr -I /usr/src/sys/dev/pci/drm/amd/display/modules/inc -I /usr/src/sys/dev/pci/drm/amd/display/modules/hdcp -I /usr/src/sys/dev/pci/drm/amd/display/dmub/inc -I /usr/src/sys/dev/pci/drm/i915 -D DDB -D DIAGNOSTIC -D KTRACE -D ACCOUNTING -D KMEMSTATS -D PTRACE -D POOL_DEBUG -D CRYPTO -D SYSVMSG -D SYSVSEM -D SYSVSHM -D UVM_SWAP_ENCRYPT -D FFS -D FFS2 -D FFS_SOFTUPDATES -D UFS_DIRHASH -D QUOTA -D EXT2FS -D MFS -D NFSCLIENT -D NFSSERVER -D CD9660 -D UDF -D MSDOSFS -D FIFO -D FUSE -D SOCKET_SPLICE -D TCP_ECN -D TCP_SIGNATURE -D INET6 -D IPSEC -D PPP_BSDCOMP -D PPP_DEFLATE -D PIPEX -D MROUTING -D MPLS -D BOOT_CONFIG -D USER_PCICONF -D APERTURE -D MTRR -D NTFS -D SUSPEND -D HIBERNATE -D PCIVERBOSE -D USBVERBOSE -D WSDISPLAY_COMPAT_USL -D WSDISPLAY_COMPAT_RAWKBD -D WSDISPLAY_DEFAULTSCREENS=6 -D X86EMU -D ONEWIREVERBOSE -D MULTIPROCESSOR -D MAXUSERS=80 -D _KERNEL -O2 -Wno-pointer-sign -Wno-address-of-packed-member -Wno-constant-conversion -Wno-unused-but-set-variable -Wno-gnu-folding-constant -fdebug-compilation-dir=/usr/src/sys/arch/amd64/compile/GENERIC.MP/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fcf-protection=branch -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -o /home/ben/Projects/scan/2024-01-11-110808-61670-1 -x c /usr/src/sys/dev/audio.c
1/* $OpenBSD: audio.c,v 1.206 2023/02/10 14:34:16 visa Exp $ */
2/*
3 * Copyright (c) 2015 Alexandre Ratchov <alex@caoua.org>
4 *
5 * Permission to use, copy, modify, and distribute this software for any
6 * purpose with or without fee is hereby granted, provided that the above
7 * copyright notice and this permission notice appear in all copies.
8 *
9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16 */
17#include <sys/param.h>
18#include <sys/fcntl.h>
19#include <sys/systm.h>
20#include <sys/ioctl.h>
21#include <sys/conf.h>
22#include <sys/kernel.h>
23#include <sys/event.h>
24#include <sys/mutex.h>
25#include <sys/task.h>
26#include <sys/vnode.h>
27#include <sys/malloc.h>
28#include <sys/device.h>
29#include <sys/audioio.h>
30#include <dev/audio_if.h>
31#include <dev/mulaw.h>
32#include "audio.h"
33#include "wskbd.h"
34
35#ifdef AUDIO_DEBUG
36#define DPRINTF(...)do {} while(0) \
37 do { \
38 if (audio_debug) \
39 printf(__VA_ARGS__); \
40 } while(0)
41#define DPRINTFN(n, ...)do {} while(0) \
42 do { \
43 if (audio_debug > (n)) \
44 printf(__VA_ARGS__); \
45 } while(0)
46#else
47#define DPRINTF(...)do {} while(0) do {} while(0)
48#define DPRINTFN(n, ...)do {} while(0) do {} while(0)
49#endif
50
51#define IPL_SOFTAUDIO0x2 IPL_SOFTNET0x2
52
53#define DEVNAME(sc)((sc)->dev.dv_xname) ((sc)->dev.dv_xname)
54#define AUDIO_UNIT(n)(((unsigned)((n) & 0xff) | (((n) & 0xffff0000) >>
8)) & 0x0f) (minor(n)((unsigned)((n) & 0xff) | (((n) & 0xffff0000) >>
8)) & 0x0f)
55#define AUDIO_DEV(n)(((unsigned)((n) & 0xff) | (((n) & 0xffff0000) >>
8)) & 0xf0) (minor(n)((unsigned)((n) & 0xff) | (((n) & 0xffff0000) >>
8)) & 0xf0)
56#define AUDIO_DEV_AUDIO0 0 /* minor of /dev/audio0 */
57#define AUDIO_DEV_AUDIOCTL0xc0 0xc0 /* minor of /dev/audioctl */
58#define AUDIO_BUFSZ65536 65536 /* buffer size in bytes */
59
60/*
61 * mixer entries added by the audio(4) layer
62 */
63#define MIXER_RECORD0 0 /* record class */
64#define MIXER_RECORD_ENABLE1 1 /* record.enable control */
65#define MIXER_RECORD_ENABLE_OFF0 0 /* record.enable=off value */
66#define MIXER_RECORD_ENABLE_ON1 1 /* record.enable=on value */
67#define MIXER_RECORD_ENABLE_SYSCTL2 2 /* record.enable=sysctl val */
68
69/*
70 * dma buffer
71 */
72struct audio_buf {
73 unsigned char *data; /* DMA memory block */
74 size_t datalen; /* size of DMA memory block */
75 size_t len; /* size of DMA FIFO */
76 size_t start; /* first byte used in the FIFO */
77 size_t used; /* bytes used in the FIFO */
78 size_t blksz; /* DMA block size */
79 unsigned int nblks; /* number of blocks */
80 struct klist klist; /* list of knotes */
81 unsigned int pos; /* bytes transferred */
82 unsigned int xrun; /* bytes lost by xruns */
83 int blocking; /* read/write blocking */
84};
85
86#if NWSKBD1 > 0
87struct wskbd_vol
88{
89 int val; /* index of the value control */
90 int mute; /* index of the mute control */
91 int step; /* increment/decrement step */
92 int nch; /* channels in the value control */
93 int val_pending; /* pending change of val */
94 int mute_pending; /* pending change of mute */
95#define WSKBD_MUTE_TOGGLE1 1
96#define WSKBD_MUTE_DISABLE2 2
97#define WSKBD_MUTE_ENABLE3 3
98};
99
100int wskbd_set_mixervolume_unit(int, long, long);
101#endif
102
103/*
104 * event indicating that a control was changed
105 */
106struct mixer_ev {
107 struct mixer_ev *next;
108 int pending;
109};
110
111/*
112 * device structure
113 */
114struct audio_softc {
115 struct device dev;
116 const struct audio_hw_if *ops; /* driver funcs */
117 void *cookie; /* wskbd cookie */
118 void *arg; /* first arg to driver funcs */
119 int mode; /* bitmask of AUMODE_* */
120 int quiesce; /* device suspended */
121 struct audio_buf play, rec;
122 unsigned int sw_enc; /* user exposed AUDIO_ENCODING_* */
123 unsigned int hw_enc; /* hardware AUDIO_ENCODING_* */
124 unsigned int bits; /* bits per sample */
125 unsigned int bps; /* bytes-per-sample */
126 unsigned int msb; /* sample are MSB aligned */
127 unsigned int rate; /* rate in Hz */
128 unsigned int round; /* block size in frames */
129 unsigned int pchan, rchan; /* number of channels */
130 unsigned char silence[4]; /* a sample of silence */
131 int pause; /* not trying to start DMA */
132 int active; /* DMA in process */
133 int offs; /* offset between play & rec dir */
134 void (*conv_enc)(unsigned char *, int); /* encode to native */
135 void (*conv_dec)(unsigned char *, int); /* decode to user */
136 struct mixer_ctrl *mix_ents; /* mixer state for suspend/resume */
137 int mix_nent; /* size of mixer state */
138 int mix_isopen; /* mixer open for reading */
139 int mix_blocking; /* read() blocking */
140 struct klist mix_klist; /* list of knotes */
141 struct mixer_ev *mix_evbuf; /* per mixer-control event */
142 struct mixer_ev *mix_pending; /* list of changed controls */
143#if NWSKBD1 > 0
144 struct wskbd_vol spkr, mic;
145 struct task wskbd_task;
146#endif
147 int record_enable; /* mixer record.enable value */
148};
149
150int audio_match(struct device *, void *, void *);
151void audio_attach(struct device *, struct device *, void *);
152int audio_activate(struct device *, int);
153int audio_detach(struct device *, int);
154void audio_pintr(void *);
155void audio_rintr(void *);
156void audio_buf_wakeup(struct audio_buf *);
157void audio_mixer_wakeup(struct audio_softc *);
158#if NWSKBD1 > 0
159void wskbd_mixer_init(struct audio_softc *);
160void wskbd_mixer_cb(void *);
161#endif
162
163const struct cfattach audio_ca = {
164 sizeof(struct audio_softc), audio_match, audio_attach,
165 audio_detach, audio_activate
166};
167
168struct cfdriver audio_cd = {
169 NULL((void *)0), "audio", DV_DULL
170};
171
172void filt_audioctlrdetach(struct knote *);
173int filt_audioctlread(struct knote *, long);
174int filt_audiomodify(struct kevent *, struct knote *);
175int filt_audioprocess(struct knote *, struct kevent *);
176
177const struct filterops audioctlread_filtops = {
178 .f_flags = FILTEROP_ISFD0x00000001 | FILTEROP_MPSAFE0x00000002,
179 .f_attach = NULL((void *)0),
180 .f_detach = filt_audioctlrdetach,
181 .f_event = filt_audioctlread,
182 .f_modify = filt_audiomodify,
183 .f_process = filt_audioprocess,
184};
185
186void filt_audiowdetach(struct knote *);
187int filt_audiowrite(struct knote *, long);
188
189const struct filterops audiowrite_filtops = {
190 .f_flags = FILTEROP_ISFD0x00000001 | FILTEROP_MPSAFE0x00000002,
191 .f_attach = NULL((void *)0),
192 .f_detach = filt_audiowdetach,
193 .f_event = filt_audiowrite,
194 .f_modify = filt_audiomodify,
195 .f_process = filt_audioprocess,
196};
197
198void filt_audiordetach(struct knote *);
199int filt_audioread(struct knote *, long);
200
201const struct filterops audioread_filtops = {
202 .f_flags = FILTEROP_ISFD0x00000001 | FILTEROP_MPSAFE0x00000002,
203 .f_attach = NULL((void *)0),
204 .f_detach = filt_audiordetach,
205 .f_event = filt_audioread,
206 .f_modify = filt_audiomodify,
207 .f_process = filt_audioprocess,
208};
209
210/*
211 * This mutex protects data structures (including registers on the
212 * sound-card) that are manipulated by both the interrupt handler and
213 * syscall code-paths.
214 *
215 * Note that driver methods may sleep (e.g. in malloc); consequently the
216 * audio layer calls them with the mutex unlocked. Driver methods are
217 * responsible for locking the mutex when they manipulate data used by
218 * the interrupt handler and interrupts may occur.
219 *
220 * Similarly, the driver is responsible for locking the mutex in its
221 * interrupt handler and to call the audio layer call-backs (i.e.
222 * audio_{p,r}int()) with the mutex locked.
223 */
224struct mutex audio_lock = MUTEX_INITIALIZER(IPL_AUDIO){ ((void *)0), ((((0xb)) > 0x0 && ((0xb)) < 0x9
) ? 0x9 : ((0xb))), 0x0 };
225
226/*
227 * Global flag to control if audio recording is enabled when the
228 * mixerctl setting is record.enable=sysctl
229 */
230int audio_record_enable = 0;
231
232#ifdef AUDIO_DEBUG
233/*
234 * 0 - nothing, as if AUDIO_DEBUG isn't defined
235 * 1 - initialisations & setup
236 * 2 - blocks & interrupts
237 */
238int audio_debug = 1;
239#endif
240
241unsigned int
242audio_gcd(unsigned int a, unsigned int b)
243{
244 unsigned int r;
245
246 while (b > 0) {
247 r = a % b;
248 a = b;
249 b = r;
250 }
251 return a;
252}
253
254/*
255 * Calculate the least block size (in frames) such that both the
256 * corresponding play and/or record block sizes (in bytes) are multiple
257 * of the given number of bytes.
258 */
259int
260audio_blksz_bytes(int mode,
261 struct audio_params *p, struct audio_params *r, int bytes)
262{
263 unsigned int np, nr;
1
'nr' declared without an initial value
→
264
265 if (mode & AUMODE_PLAY0x01) {
2
←
Assuming the condition is false
→
3
←
Taking false branch
→
266 np = bytes / audio_gcd(p->bps * p->channels, bytes);
267 if (!(mode & AUMODE_RECORD0x02))
268 nr = np;
269 }
270 if (mode & AUMODE_RECORD0x02) {
4
←
Assuming the condition is false
→
5
←
Taking false branch
→
271 nr = bytes / audio_gcd(r->bps * r->channels, bytes);
272 if (!(mode & AUMODE_PLAY0x01))
273 np = nr;
274 }
275
276 return nr * np / audio_gcd(nr, np);
6
←
The left operand of '*' is a garbage value
277}
278
279void
280audio_mixer_wakeup(struct audio_softc *sc)
281{
282 MUTEX_ASSERT_LOCKED(&audio_lock)do { if (((&audio_lock)->mtx_owner != ({struct cpu_info
*__ci; asm volatile("movq %%gs:%P1,%0" : "=r" (__ci) :"n" (__builtin_offsetof
(struct cpu_info, ci_self))); __ci;})) && !(panicstr ||
db_active)) panic("mutex %p not held in %s", (&audio_lock
), __func__); } while (0);
283
284 if (sc->mix_blocking) {
285 wakeup(&sc->mix_blocking);
286 sc->mix_blocking = 0;
287 }
288 knote_locked(&sc->mix_klist, 0);
289}
290
291void
292audio_buf_wakeup(struct audio_buf *buf)
293{
294 MUTEX_ASSERT_LOCKED(&audio_lock)do { if (((&audio_lock)->mtx_owner != ({struct cpu_info
*__ci; asm volatile("movq %%gs:%P1,%0" : "=r" (__ci) :"n" (__builtin_offsetof
(struct cpu_info, ci_self))); __ci;})) && !(panicstr ||
db_active)) panic("mutex %p not held in %s", (&audio_lock
), __func__); } while (0);
295
296 if (buf->blocking) {
297 wakeup(&buf->blocking);
298 buf->blocking = 0;
299 }
300 knote_locked(&buf->klist, 0);
301}
302
303int
304audio_buf_init(struct audio_softc *sc, struct audio_buf *buf, int dir)
305{
306 klist_init_mutex(&buf->klist, &audio_lock);
307 if (sc->ops->round_buffersize) {
308 buf->datalen = sc->ops->round_buffersize(sc->arg,
309 dir, AUDIO_BUFSZ65536);
310 } else
311 buf->datalen = AUDIO_BUFSZ65536;
312 if (sc->ops->allocm) {
313 buf->data = sc->ops->allocm(sc->arg, dir, buf->datalen,
314 M_DEVBUF2, M_WAITOK0x0001);
315 } else
316 buf->data = malloc(buf->datalen, M_DEVBUF2, M_WAITOK0x0001);
317 if (buf->data == NULL((void *)0)) {
318 klist_free(&buf->klist);
319 return ENOMEM12;
320 }
321 return 0;
322}
323
324void
325audio_buf_done(struct audio_softc *sc, struct audio_buf *buf)
326{
327 if (sc->ops->freem)
328 sc->ops->freem(sc->arg, buf->data, M_DEVBUF2);
329 else
330 free(buf->data, M_DEVBUF2, buf->datalen);
331 klist_free(&buf->klist);
332}
333
334/*
335 * return the reader pointer and the number of bytes available
336 */
337unsigned char *
338audio_buf_rgetblk(struct audio_buf *buf, size_t *rsize)
339{
340 size_t count;
341
342 count = buf->len - buf->start;
343 if (count > buf->used)
344 count = buf->used;
345 *rsize = count;
346 return buf->data + buf->start;
347}
348
349/*
350 * discard "count" bytes at the start position.
351 */
352void
353audio_buf_rdiscard(struct audio_buf *buf, size_t count)
354{
355#ifdef AUDIO_DEBUG
356 if (count > buf->used) {
357 panic("audio_buf_rdiscard: bad count = %zu, "
358 "start = %zu, used = %zu", count, buf->start, buf->used);
359 }
360#endif
361 buf->used -= count;
362 buf->start += count;
363 if (buf->start >= buf->len)
364 buf->start -= buf->len;
365}
366
367/*
368 * advance the writer pointer by "count" bytes
369 */
370void
371audio_buf_wcommit(struct audio_buf *buf, size_t count)
372{
373#ifdef AUDIO_DEBUG
374 if (count > (buf->len - buf->used)) {
375 panic("audio_buf_wcommit: bad count = %zu, "
376 "start = %zu, used = %zu", count, buf->start, buf->used);
377 }
378#endif
379 buf->used += count;
380}
381
382/*
383 * get writer pointer and the number of bytes writable
384 */
385unsigned char *
386audio_buf_wgetblk(struct audio_buf *buf, size_t *rsize)
387{
388 size_t end, avail, count;
389
390 end = buf->start + buf->used;
391 if (end >= buf->len)
392 end -= buf->len;
393 avail = buf->len - buf->used;
394 count = buf->len - end;
395 if (count > avail)
396 count = avail;
397 *rsize = count;
398 return buf->data + end;
399}
400
401void
402audio_calc_sil(struct audio_softc *sc)
403{
404 unsigned char *q;
405 unsigned int s, i;
406 int d, e;
407
408 e = sc->sw_enc;
409#ifdef AUDIO_DEBUG
410 switch (e) {
411 case AUDIO_ENCODING_SLINEAR_LE6:
412 case AUDIO_ENCODING_ULINEAR_LE8:
413 case AUDIO_ENCODING_SLINEAR_BE7:
414 case AUDIO_ENCODING_ULINEAR_BE9:
415 break;
416 default:
417 printf("%s: unhandled play encoding %d\n", DEVNAME(sc)((sc)->dev.dv_xname), e);
418 memset(sc->silence, 0, sc->bps)__builtin_memset((sc->silence), (0), (sc->bps));
419 return;
420 }
421#endif
422 if (e == AUDIO_ENCODING_SLINEAR_BE7 || e == AUDIO_ENCODING_ULINEAR_BE9) {
423 d = -1;
424 q = sc->silence + sc->bps - 1;
425 } else {
426 d = 1;
427 q = sc->silence;
428 }
429 if (e == AUDIO_ENCODING_SLINEAR_LE6 || e == AUDIO_ENCODING_SLINEAR_BE7) {
430 s = 0;
431 } else {
432 s = 0x80000000;
433 if (sc->msb)
434 s >>= 32 - 8 * sc->bps;
435 else
436 s >>= 32 - sc->bits;
437 }
438 for (i = 0; i < sc->bps; i++) {
439 *q = s;
440 q += d;
441 s >>= 8;
442 }
443 if (sc->conv_enc)
444 sc->conv_enc(sc->silence, sc->bps);
445}
446
447void
448audio_fill_sil(struct audio_softc *sc, unsigned char *ptr, size_t count)
449{
450 unsigned char *q, *p;
451 size_t i, j;
452
453 q = ptr;
454 for (j = count / sc->bps; j > 0; j--) {
455 p = sc->silence;
456 for (i = sc->bps; i > 0; i--)
457 *q++ = *p++;
458 }
459}
460
461void
462audio_clear(struct audio_softc *sc)
463{
464 if (sc->mode & AUMODE_PLAY0x01) {
465 sc->play.used = sc->play.start = 0;
466 sc->play.pos = sc->play.xrun = 0;
467 audio_fill_sil(sc, sc->play.data, sc->play.len);
468 }
469 if (sc->mode & AUMODE_RECORD0x02) {
470 sc->rec.used = sc->rec.start = 0;
471 sc->rec.pos = sc->rec.xrun = 0;
472 audio_fill_sil(sc, sc->rec.data, sc->rec.len);
473 }
474}
475
476/*
477 * called whenever a block is consumed by the driver
478 */
479void
480audio_pintr(void *addr)
481{
482 struct audio_softc *sc = addr;
483 unsigned char *ptr;
484 size_t count;
485 int error, nblk, todo;
486
487 MUTEX_ASSERT_LOCKED(&audio_lock)do { if (((&audio_lock)->mtx_owner != ({struct cpu_info
*__ci; asm volatile("movq %%gs:%P1,%0" : "=r" (__ci) :"n" (__builtin_offsetof
(struct cpu_info, ci_self))); __ci;})) && !(panicstr ||
db_active)) panic("mutex %p not held in %s", (&audio_lock
), __func__); } while (0);
488 if (!(sc->mode & AUMODE_PLAY0x01) || !sc->active) {
489 printf("%s: play interrupt but not playing\n", DEVNAME(sc)((sc)->dev.dv_xname));
490 return;
491 }
492 if (sc->quiesce) {
493 DPRINTF("%s: quiesced, skipping play intr\n", DEVNAME(sc))do {} while(0);
494 return;
495 }
496
497 /*
498 * check if record pointer wrapped, see explanation
499 * in audio_rintr()
500 */
501 if ((sc->mode & AUMODE_RECORD0x02) && sc->ops->underrun == NULL((void *)0)) {
502 sc->offs--;
503 nblk = sc->rec.len / sc->rec.blksz;
504 todo = -sc->offs;
505 if (todo >= nblk) {
506 todo -= todo % nblk;
507 DPRINTFN(1, "%s: rec ptr wrapped, moving %d blocks\n",do {} while(0)
508 DEVNAME(sc), todo)do {} while(0);
509 while (todo-- > 0)
510 audio_rintr(sc);
511 }
512 }
513
514 sc->play.pos += sc->play.blksz;
515 if (!sc->ops->underrun) {
516 audio_fill_sil(sc, sc->play.data + sc->play.start,
517 sc->play.blksz);
518 }
519 audio_buf_rdiscard(&sc->play, sc->play.blksz);
520 if (sc->play.used < sc->play.blksz) {
521 DPRINTFN(1, "%s: play underrun\n", DEVNAME(sc))do {} while(0);
522 sc->play.xrun += sc->play.blksz;
523 audio_buf_wcommit(&sc->play, sc->play.blksz);
524 if (sc->ops->underrun)
525 sc->ops->underrun(sc->arg);
526 }
527
528 DPRINTFN(1, "%s: play intr, used -> %zu, start -> %zu\n",do {} while(0)
529 DEVNAME(sc), sc->play.used, sc->play.start)do {} while(0);
530
531 if (!sc->ops->trigger_output) {
532 ptr = audio_buf_rgetblk(&sc->play, &count);
533 error = sc->ops->start_output(sc->arg,
534 ptr, sc->play.blksz, audio_pintr, sc);
535 if (error) {
536 printf("%s: play restart failed: %d\n",
537 DEVNAME(sc)((sc)->dev.dv_xname), error);
538 }
539 }
540
541 if (sc->play.used < sc->play.len) {
542 DPRINTFN(1, "%s: play wakeup, chan = %d\n",do {} while(0)
543 DEVNAME(sc), sc->play.blocking)do {} while(0);
544 audio_buf_wakeup(&sc->play);
545 }
546}
547
548/*
549 * called whenever a block is produced by the driver
550 */
551void
552audio_rintr(void *addr)
553{
554 struct audio_softc *sc = addr;
555 unsigned char *ptr;
556 size_t count;
557 int error, nblk, todo;
558
559 MUTEX_ASSERT_LOCKED(&audio_lock)do { if (((&audio_lock)->mtx_owner != ({struct cpu_info
*__ci; asm volatile("movq %%gs:%P1,%0" : "=r" (__ci) :"n" (__builtin_offsetof
(struct cpu_info, ci_self))); __ci;})) && !(panicstr ||
db_active)) panic("mutex %p not held in %s", (&audio_lock
), __func__); } while (0);
560 if (!(sc->mode & AUMODE_RECORD0x02) || !sc->active) {
561 printf("%s: rec interrupt but not recording\n", DEVNAME(sc)((sc)->dev.dv_xname));
562 return;
563 }
564 if (sc->quiesce) {
565 DPRINTF("%s: quiesced, skipping rec intr\n", DEVNAME(sc))do {} while(0);
566 return;
567 }
568
569 /*
570 * Interrupts may be masked by other sub-systems during 320ms
571 * and more. During such a delay the hardware doesn't stop
572 * playing and the play buffer pointers may wrap, this can't be
573 * detected and corrected by low level drivers. This makes the
574 * record stream ahead of the play stream; this is detected as a
575 * hardware anomaly by userland and cause programs to misbehave.
576 *
577 * We fix this by advancing play position by an integer count of
578 * full buffers, so it reaches the record position.
579 */
580 if ((sc->mode & AUMODE_PLAY0x01) && sc->ops->underrun == NULL((void *)0)) {
581 sc->offs++;
582 nblk = sc->play.len / sc->play.blksz;
583 todo = sc->offs;
584 if (todo >= nblk) {
585 todo -= todo % nblk;
586 DPRINTFN(1, "%s: play ptr wrapped, moving %d blocks\n",do {} while(0)
587 DEVNAME(sc), todo)do {} while(0);
588 while (todo-- > 0)
589 audio_pintr(sc);
590 }
591 }
592
593 sc->rec.pos += sc->rec.blksz;
594 if ((sc->record_enable == MIXER_RECORD_ENABLE_SYSCTL2 &&
595 !audio_record_enable) ||
596 sc->record_enable == MIXER_RECORD_ENABLE_OFF0) {
597 ptr = audio_buf_wgetblk(&sc->rec, &count);
598 audio_fill_sil(sc, ptr, sc->rec.blksz);
599 }
600 audio_buf_wcommit(&sc->rec, sc->rec.blksz);
601 if (sc->rec.used > sc->rec.len - sc->rec.blksz) {
602 DPRINTFN(1, "%s: rec overrun\n", DEVNAME(sc))do {} while(0);
603 sc->rec.xrun += sc->rec.blksz;
604 audio_buf_rdiscard(&sc->rec, sc->rec.blksz);
605 }
606 DPRINTFN(1, "%s: rec intr, used -> %zu\n", DEVNAME(sc), sc->rec.used)do {} while(0);
607
608 if (!sc->ops->trigger_input) {
609 ptr = audio_buf_wgetblk(&sc->rec, &count);
610 error = sc->ops->start_input(sc->arg,
611 ptr, sc->rec.blksz, audio_rintr, sc);
612 if (error) {
613 printf("%s: rec restart failed: %d\n",
614 DEVNAME(sc)((sc)->dev.dv_xname), error);
615 }
616 }
617
618 if (sc->rec.used > 0) {
619 DPRINTFN(1, "%s: rec wakeup, chan = %d\n",do {} while(0)
620 DEVNAME(sc), sc->rec.blocking)do {} while(0);
621 audio_buf_wakeup(&sc->rec);
622 }
623}
624
625int
626audio_start_do(struct audio_softc *sc)
627{
628 int error;
629 struct audio_params p;
630 unsigned char *ptr;
631 size_t count;
632
633 DPRINTF("%s: starting\n", DEVNAME(sc))do {} while(0);
634
635 error = 0;
636 sc->offs = 0;
637 if (sc->mode & AUMODE_PLAY0x01) {
638 if (sc->ops->trigger_output) {
639 p.encoding = sc->hw_enc;
640 p.precision = sc->bits;
641 p.bps = sc->bps;
642 p.msb = sc->msb;
643 p.sample_rate = sc->rate;
644 p.channels = sc->pchan;
645 error = sc->ops->trigger_output(sc->arg,
646 sc->play.data,
647 sc->play.data + sc->play.len,
648 sc->play.blksz,
649 audio_pintr, sc, &p);
650 } else {
651 mtx_enter(&audio_lock);
652 ptr = audio_buf_rgetblk(&sc->play, &count);
653 error = sc->ops->start_output(sc->arg,
654 ptr, sc->play.blksz, audio_pintr, sc);
655 mtx_leave(&audio_lock);
656 }
657 if (error)
658 printf("%s: failed to start playback\n", DEVNAME(sc)((sc)->dev.dv_xname));
659 }
660 if (sc->mode & AUMODE_RECORD0x02) {
661 if (sc->ops->trigger_input) {
662 p.encoding = sc->hw_enc;
663 p.precision = sc->bits;
664 p.bps = sc->bps;
665 p.msb = sc->msb;
666 p.sample_rate = sc->rate;
667 p.channels = sc->rchan;
668 error = sc->ops->trigger_input(sc->arg,
669 sc->rec.data,
670 sc->rec.data + sc->rec.len,
671 sc->rec.blksz,
672 audio_rintr, sc, &p);
673 } else {
674 mtx_enter(&audio_lock);
675 ptr = audio_buf_wgetblk(&sc->rec, &count);
676 error = sc->ops->start_input(sc->arg,
677 ptr, sc->rec.blksz, audio_rintr, sc);
678 mtx_leave(&audio_lock);
679 }
680 if (error)
681 printf("%s: failed to start recording\n", DEVNAME(sc)((sc)->dev.dv_xname));
682 }
683 return error;
684}
685
686int
687audio_stop_do(struct audio_softc *sc)
688{
689 if (sc->mode & AUMODE_PLAY0x01)
690 sc->ops->halt_output(sc->arg);
691 if (sc->mode & AUMODE_RECORD0x02)
692 sc->ops->halt_input(sc->arg);
693 DPRINTF("%s: stopped\n", DEVNAME(sc))do {} while(0);
694 return 0;
695}
696
697int
698audio_start(struct audio_softc *sc)
699{
700 sc->active = 1;
701 sc->play.xrun = sc->play.pos = sc->rec.xrun = sc->rec.pos = 0;
702 return audio_start_do(sc);
703}
704
705int
706audio_stop(struct audio_softc *sc)
707{
708 int error;
709
710 error = audio_stop_do(sc);
711 if (error)
712 return error;
713 audio_clear(sc);
714 sc->active = 0;
715 return 0;
716}
717
718int
719audio_canstart(struct audio_softc *sc)
720{
721 if (sc->active || sc->pause)
722 return 0;
723 if ((sc->mode & AUMODE_RECORD0x02) && sc->rec.used != 0)
724 return 0;
725 if ((sc->mode & AUMODE_PLAY0x01) && sc->play.used != sc->play.len)
726 return 0;
727 return 1;
728}
729
730int
731audio_setpar_blksz(struct audio_softc *sc,
732 struct audio_params *p, struct audio_params *r)
733{
734 unsigned int nr, np, max, min, mult;
735 unsigned int blk_mult, blk_max;
736
737 if (sc->ops->set_blksz) {
738 /*
739 * Don't allow block size of exceed half the buffer size
740 */
741 if (sc->mode & AUMODE_PLAY0x01) {
742 max = sc->play.datalen / 2 / (sc->pchan * sc->bps);
743 if (sc->round > max)
744 sc->round = max;
745 }
746 if (sc->mode & AUMODE_RECORD0x02) {
747 max = sc->rec.datalen / 2 / (sc->rchan * sc->bps);
748 if (sc->round > max)
749 sc->round = max;
750 }
751
752 sc->round = sc->ops->set_blksz(sc->arg, sc->mode,
753 p, r, sc->round);
754
755 DPRINTF("%s: block size set to: %u\n", DEVNAME(sc), sc->round)do {} while(0);
756 return 0;
757 }
758
759 /*
760 * get least multiplier of the number of frames per block
761 */
762 if (sc->ops->round_blocksize) {
763 blk_mult = sc->ops->round_blocksize(sc->arg, 1);
764 if (blk_mult == 0) {
765 printf("%s: 0x%x: bad block size multiplier\n",
766 DEVNAME(sc)((sc)->dev.dv_xname), blk_mult);
767 return ENODEV19;
768 }
769 } else
770 blk_mult = 1;
771 DPRINTF("%s: hw block size multiplier: %u\n", DEVNAME(sc), blk_mult)do {} while(0);
772 if (sc->mode & AUMODE_PLAY0x01) {
773 np = blk_mult / audio_gcd(sc->pchan * sc->bps, blk_mult);
774 if (!(sc->mode & AUMODE_RECORD0x02))
775 nr = np;
776 DPRINTF("%s: play number of frames multiplier: %u\n",do {} while(0)
777 DEVNAME(sc), np)do {} while(0);
778 }
779 if (sc->mode & AUMODE_RECORD0x02) {
780 nr = blk_mult / audio_gcd(sc->rchan * sc->bps, blk_mult);
781 if (!(sc->mode & AUMODE_PLAY0x01))
782 np = nr;
783 DPRINTF("%s: record number of frames multiplier: %u\n",do {} while(0)
784 DEVNAME(sc), nr)do {} while(0);
785 }
786 mult = nr * np / audio_gcd(nr, np);
787 DPRINTF("%s: least common number of frames multiplier: %u\n",do {} while(0)
788 DEVNAME(sc), mult)do {} while(0);
789
790 /*
791 * get minimum and maximum frames per block
792 */
793 if (sc->ops->round_blocksize)
794 blk_max = sc->ops->round_blocksize(sc->arg, AUDIO_BUFSZ65536);
795 else
796 blk_max = AUDIO_BUFSZ65536;
797 if ((sc->mode & AUMODE_PLAY0x01) && blk_max > sc->play.datalen / 2)
798 blk_max = sc->play.datalen / 2;
799 if ((sc->mode & AUMODE_RECORD0x02) && blk_max > sc->rec.datalen / 2)
800 blk_max = sc->rec.datalen / 2;
801 if (sc->mode & AUMODE_PLAY0x01) {
802 np = blk_max / (sc->pchan * sc->bps);
803 if (!(sc->mode & AUMODE_RECORD0x02))
804 nr = np;
805 }
806 if (sc->mode & AUMODE_RECORD0x02) {
807 nr = blk_max / (sc->rchan * sc->bps);
808 if (!(sc->mode & AUMODE_PLAY0x01))
809 np = nr;
810 }
811 max = np < nr ? np : nr;
812 max -= max % mult;
813 min = sc->rate / 1000 + mult - 1;
814 min -= min % mult;
815 DPRINTF("%s: frame number range: %u..%u\n", DEVNAME(sc), min, max)do {} while(0);
816 if (max < min) {
817 printf("%s: %u: bad max frame number\n", DEVNAME(sc)((sc)->dev.dv_xname), max);
818 return EIO5;
819 }
820
821 /*
822 * adjust the frame per block to match our constraints
823 */
824 sc->round += mult / 2;
825 sc->round -= sc->round % mult;
826 if (sc->round > max)
827 sc->round = max;
828 else if (sc->round < min)
829 sc->round = min;
830
831 return 0;
832}
833
834int
835audio_setpar_nblks(struct audio_softc *sc,
836 struct audio_params *p, struct audio_params *r)
837{
838 unsigned int max;
839
840 /*
841 * set buffer size (number of blocks)
842 */
843 if (sc->mode & AUMODE_PLAY0x01) {
844 max = sc->play.datalen / (sc->round * sc->pchan * sc->bps);
845 if (sc->play.nblks > max)
846 sc->play.nblks = max;
847 else if (sc->play.nblks < 2)
848 sc->play.nblks = 2;
849 if (sc->ops->set_nblks) {
850 sc->play.nblks = sc->ops->set_nblks(sc->arg, sc->mode,
851 p, sc->round, sc->play.nblks);
852 DPRINTF("%s: play nblks -> %u\n", DEVNAME(sc),do {} while(0)
853 sc->play.nblks)do {} while(0);
854 }
855 }
856 if (sc->mode & AUMODE_RECORD0x02) {
857 /*
858 * for recording, buffer size is not the latency (it's
859 * exactly one block), so let's get the maximum buffer
860 * size of maximum reliability during xruns
861 */
862 max = sc->rec.datalen / (sc->round * sc->rchan * sc->bps);
863 if (sc->ops->set_nblks) {
864 max = sc->ops->set_nblks(sc->arg, sc->mode,
865 r, sc->round, max);
866 DPRINTF("%s: rec nblks -> %u\n", DEVNAME(sc), max)do {} while(0);
867 }
868 sc->rec.nblks = max;
869 }
870 return 0;
871}
872
873int
874audio_setpar(struct audio_softc *sc)
875{
876 struct audio_params p, r;
877 int error;
878
879 DPRINTF("%s: setpar: req enc=%d bits=%d, bps=%d, msb=%d "do {} while(0)
880 "rate=%d, pchan=%d, rchan=%d, round=%u, nblks=%d\n",do {} while(0)
881 DEVNAME(sc), sc->sw_enc, sc->bits, sc->bps, sc->msb,do {} while(0)
882 sc->rate, sc->pchan, sc->rchan, sc->round, sc->play.nblks)do {} while(0);
883
884 /*
885 * check if requested parameters are in the allowed ranges
886 */
887 if (sc->mode & AUMODE_PLAY0x01) {
888 if (sc->pchan < 1)
889 sc->pchan = 1;
890 else if (sc->pchan > 64)
891 sc->pchan = 64;
892 }
893 if (sc->mode & AUMODE_RECORD0x02) {
894 if (sc->rchan < 1)
895 sc->rchan = 1;
896 else if (sc->rchan > 64)
897 sc->rchan = 64;
898 }
899 switch (sc->sw_enc) {
900 case AUDIO_ENCODING_ULAW1:
901 case AUDIO_ENCODING_ALAW2:
902 case AUDIO_ENCODING_SLINEAR_LE6:
903 case AUDIO_ENCODING_SLINEAR_BE7:
904 case AUDIO_ENCODING_ULINEAR_LE8:
905 case AUDIO_ENCODING_ULINEAR_BE9:
906 break;
907 default:
908 sc->sw_enc = AUDIO_ENCODING_SLINEAR_LE6;
909 }
910 if (sc->bits < 8)
911 sc->bits = 8;
912 else if (sc->bits > 32)
913 sc->bits = 32;
914 if (sc->bps < 1)
915 sc->bps = 1;
916 else if (sc->bps > 4)
917 sc->bps = 4;
918 if (sc->rate < 4000)
919 sc->rate = 4000;
920 else if (sc->rate > 192000)
921 sc->rate = 192000;
922
923 /*
924 * copy into struct audio_params, required by drivers
925 */
926 p.encoding = r.encoding = sc->sw_enc;
927 p.precision = r.precision = sc->bits;
928 p.bps = r.bps = sc->bps;
929 p.msb = r.msb = sc->msb;
930 p.sample_rate = r.sample_rate = sc->rate;
931 p.channels = sc->pchan;
932 r.channels = sc->rchan;
933
934 /*
935 * set parameters
936 */
937 error = sc->ops->set_params(sc->arg, sc->mode, sc->mode, &p, &r);
938 if (error)
939 return error;
940 if (sc->mode == (AUMODE_PLAY0x01 | AUMODE_RECORD0x02)) {
941 if (p.encoding != r.encoding ||
942 p.precision != r.precision ||
943 p.bps != r.bps ||
944 p.msb != r.msb ||
945 p.sample_rate != r.sample_rate) {
946 printf("%s: different play and record parameters "
947 "returned by hardware\n", DEVNAME(sc)((sc)->dev.dv_xname));
948 return ENODEV19;
949 }
950 }
951 if (sc->mode & AUMODE_PLAY0x01) {
952 sc->hw_enc = p.encoding;
953 sc->bits = p.precision;
954 sc->bps = p.bps;
955 sc->msb = p.msb;
956 sc->rate = p.sample_rate;
957 sc->pchan = p.channels;
958 }
959 if (sc->mode & AUMODE_RECORD0x02) {
960 sc->hw_enc = r.encoding;
961 sc->bits = r.precision;
962 sc->bps = r.bps;
963 sc->msb = r.msb;
964 sc->rate = r.sample_rate;
965 sc->rchan = r.channels;
966 }
967 if (sc->rate == 0 || sc->bps == 0 || sc->bits == 0) {
968 printf("%s: invalid parameters returned by hardware\n",
969 DEVNAME(sc)((sc)->dev.dv_xname));
970 return ENODEV19;
971 }
972 if (sc->ops->commit_settings) {
973 error = sc->ops->commit_settings(sc->arg);
974 if (error)
975 return error;
976 }
977
978 /*
979 * conversion from/to exotic/dead encoding, for drivers not supporting
980 * linear
981 */
982 switch (sc->hw_enc) {
983 case AUDIO_ENCODING_SLINEAR_LE6:
984 case AUDIO_ENCODING_SLINEAR_BE7:
985 case AUDIO_ENCODING_ULINEAR_LE8:
986 case AUDIO_ENCODING_ULINEAR_BE9:
987 sc->sw_enc = sc->hw_enc;
988 sc->conv_dec = sc->conv_enc = NULL((void *)0);
989 break;
990 case AUDIO_ENCODING_ULAW1:
991#if BYTE_ORDER1234 == LITTLE_ENDIAN1234
992 sc->sw_enc = AUDIO_ENCODING_SLINEAR_LE6;
993#else
994 sc->sw_enc = AUDIO_ENCODING_SLINEAR_BE7;
995#endif
996 if (sc->bits == 8) {
997 sc->conv_enc = slinear8_to_mulaw;
998 sc->conv_dec = mulaw_to_slinear8;
999 } else if (sc->bits == 24) {
1000 sc->conv_enc = slinear24_to_mulaw24;
1001 sc->conv_dec = mulaw24_to_slinear24;
1002 } else {
1003 sc->sw_enc = sc->hw_enc;
1004 sc->conv_dec = sc->conv_enc = NULL((void *)0);
1005 }
1006 break;
1007 default:
1008 printf("%s: setpar: enc = %d, bits = %d: emulation skipped\n",
1009 DEVNAME(sc)((sc)->dev.dv_xname), sc->hw_enc, sc->bits);
1010 sc->sw_enc = sc->hw_enc;
1011 sc->conv_dec = sc->conv_enc = NULL((void *)0);
1012 }
1013 audio_calc_sil(sc);
1014
1015 error = audio_setpar_blksz(sc, &p, &r);
1016 if (error)
1017 return error;
1018
1019 error = audio_setpar_nblks(sc, &p, &r);
1020 if (error)
1021 return error;
1022
1023 /*
1024 * set buffer
1025 */
1026 if (sc->mode & AUMODE_PLAY0x01) {
1027 sc->play.blksz = sc->round * sc->pchan * sc->bps;
1028 sc->play.len = sc->play.nblks * sc->play.blksz;
1029 }
1030 if (sc->mode & AUMODE_RECORD0x02) {
1031 sc->rec.blksz = sc->round * sc->rchan * sc->bps;
1032 sc->rec.len = sc->rec.nblks * sc->rec.blksz;
1033 }
1034
1035 DPRINTF("%s: setpar: new enc=%d bits=%d, bps=%d, msb=%d "do {} while(0)
1036 "rate=%d, pchan=%d, rchan=%d, round=%u, nblks=%d\n",do {} while(0)
1037 DEVNAME(sc), sc->sw_enc, sc->bits, sc->bps, sc->msb,do {} while(0)
1038 sc->rate, sc->pchan, sc->rchan, sc->round, sc->play.nblks)do {} while(0);
1039 return 0;
1040}
1041
1042int
1043audio_ioc_start(struct audio_softc *sc)
1044{
1045 if (!sc->pause) {
1046 DPRINTF("%s: can't start: already started\n", DEVNAME(sc))do {} while(0);
1047 return EBUSY16;
1048 }
1049 if ((sc->mode & AUMODE_PLAY0x01) && sc->play.used != sc->play.len) {
1050 DPRINTF("%s: play buffer not ready\n", DEVNAME(sc))do {} while(0);
1051 return EBUSY16;
1052 }
1053 if ((sc->mode & AUMODE_RECORD0x02) && sc->rec.used != 0) {
1054 DPRINTF("%s: record buffer not ready\n", DEVNAME(sc))do {} while(0);
1055 return EBUSY16;
1056 }
1057 sc->pause = 0;
1058 return audio_start(sc);
1059}
1060
1061int
1062audio_ioc_stop(struct audio_softc *sc)
1063{
1064 if (sc->pause) {
1065 DPRINTF("%s: can't stop: not started\n", DEVNAME(sc))do {} while(0);
1066 return EBUSY16;
1067 }
1068 sc->pause = 1;
1069 if (sc->active)
1070 return audio_stop(sc);
1071 return 0;
1072}
1073
1074int
1075audio_ioc_getpar(struct audio_softc *sc, struct audio_swpar *p)
1076{
1077 p->rate = sc->rate;
1078 p->sig = sc->sw_enc == AUDIO_ENCODING_SLINEAR_LE6 ||
1079 sc->sw_enc == AUDIO_ENCODING_SLINEAR_BE7;
1080 p->le = sc->sw_enc == AUDIO_ENCODING_SLINEAR_LE6 ||
1081 sc->sw_enc == AUDIO_ENCODING_ULINEAR_LE8;
1082 p->bits = sc->bits;
1083 p->bps = sc->bps;
1084 p->msb = sc->msb;
1085 p->pchan = sc->pchan;
1086 p->rchan = sc->rchan;
1087 p->nblks = sc->play.nblks;
1088 p->round = sc->round;
1089 return 0;
1090}
1091
1092int
1093audio_ioc_setpar(struct audio_softc *sc, struct audio_swpar *p)
1094{
1095 int error, le, sig;
1096
1097 if (sc->active) {
1098 DPRINTF("%s: can't change params during dma\n",do {} while(0)
1099 DEVNAME(sc))do {} while(0);
1100 return EBUSY16;
1101 }
1102
1103 /*
1104 * copy desired parameters into the softc structure
1105 */
1106 if (p->sig != ~0U || p->le != ~0U || p->bits != ~0U) {
1107 sig = 1;
1108 le = (BYTE_ORDER1234 == LITTLE_ENDIAN1234);
1109 sc->bits = 16;
1110 sc->bps = 2;
1111 sc->msb = 1;
1112 if (p->sig != ~0U)
1113 sig = p->sig;
1114 if (p->le != ~0U)
1115 le = p->le;
1116 if (p->bits != ~0U) {
1117 sc->bits = p->bits;
1118 sc->bps = sc->bits <= 8 ?
1119 1 : (sc->bits <= 16 ? 2 : 4);
1120 if (p->bps != ~0U)
1121 sc->bps = p->bps;
1122 if (p->msb != ~0U)
1123 sc->msb = p->msb ? 1 : 0;
1124 }
1125 sc->sw_enc = (sig) ?
1126 (le ? AUDIO_ENCODING_SLINEAR_LE6 :
1127 AUDIO_ENCODING_SLINEAR_BE7) :
1128 (le ? AUDIO_ENCODING_ULINEAR_LE8 :
1129 AUDIO_ENCODING_ULINEAR_BE9);
1130 }
1131 if (p->rate != ~0)
1132 sc->rate = p->rate;
1133 if (p->pchan != ~0)
1134 sc->pchan = p->pchan;
1135 if (p->rchan != ~0)
1136 sc->rchan = p->rchan;
1137 if (p->round != ~0)
1138 sc->round = p->round;
1139 if (p->nblks != ~0)
1140 sc->play.nblks = p->nblks;
1141
1142 /*
1143 * if the device is not opened for playback or recording don't
1144 * touch the hardware yet (ex. if this is /dev/audioctlN)
1145 */
1146 if (sc->mode == 0)
1147 return 0;
1148
1149 /*
1150 * negotiate parameters with the hardware
1151 */
1152 error = audio_setpar(sc);
1153 if (error)
1154 return error;
1155 audio_clear(sc);
1156 if ((sc->mode & AUMODE_PLAY0x01) && sc->ops->init_output) {
1157 error = sc->ops->init_output(sc->arg,
1158 sc->play.data, sc->play.len);
1159 if (error)
1160 return error;
1161 }
1162 if ((sc->mode & AUMODE_RECORD0x02) && sc->ops->init_input) {
1163 error = sc->ops->init_input(sc->arg,
1164 sc->rec.data, sc->rec.len);
1165 if (error)
1166 return error;
1167 }
1168 return 0;
1169}
1170
1171int
1172audio_ioc_getstatus(struct audio_softc *sc, struct audio_status *p)
1173{
1174 p->mode = sc->mode;
1175 p->pause = sc->pause;
1176 p->active = sc->active;
1177 return 0;
1178}
1179
1180int
1181audio_match(struct device *parent, void *match, void *aux)
1182{
1183 struct audio_attach_args *sa = aux;
1184
1185 return (sa->type == AUDIODEV_TYPE_AUDIO0) ? 1 : 0;
1186}
1187
1188void
1189audio_attach(struct device *parent, struct device *self, void *aux)
1190{
1191 struct audio_softc *sc = (void *)self;
1192 struct audio_attach_args *sa = aux;
1193 const struct audio_hw_if *ops = sa->hwif;
1194 struct mixer_devinfo *mi;
1195 struct mixer_ctrl *ent;
1196 void *arg = sa->hdl;
1197 int error;
1198
1199 printf("\n");
1200
1201#ifdef DIAGNOSTIC1
1202 if (ops == 0 ||
1203 ops->open == 0 ||
1204 ops->close == 0 ||
1205 ops->set_params == 0 ||
1206 (ops->start_output == 0 && ops->trigger_output == 0) ||
1207 (ops->start_input == 0 && ops->trigger_input == 0) ||
1208 ops->halt_output == 0 ||
1209 ops->halt_input == 0 ||
1210 ops->set_port == 0 ||
1211 ops->get_port == 0 ||
1212 ops->query_devinfo == 0) {
1213 printf("%s: missing method\n", DEVNAME(sc)((sc)->dev.dv_xname));
1214 sc->ops = 0;
1215 return;
1216 }
1217#endif
1218 sc->ops = ops;
1219 sc->cookie = sa->cookie;
1220 sc->arg = arg;
1221
1222#if NWSKBD1 > 0
1223 wskbd_mixer_init(sc);
1224#endif /* NWSKBD > 0 */
1225
1226 error = audio_buf_init(sc, &sc->play, AUMODE_PLAY0x01);
1227 if (error) {
1228 sc->ops = 0;
1229 printf("%s: could not allocate play buffer\n", DEVNAME(sc)((sc)->dev.dv_xname));
1230 return;
1231 }
1232 error = audio_buf_init(sc, &sc->rec, AUMODE_RECORD0x02);
1233 if (error) {
1234 audio_buf_done(sc, &sc->play);
1235 sc->ops = 0;
1236 printf("%s: could not allocate record buffer\n", DEVNAME(sc)((sc)->dev.dv_xname));
1237 return;
1238 }
1239
1240 klist_init_mutex(&sc->mix_klist, &audio_lock);
1241
1242 /* set defaults */
1243#if BYTE_ORDER1234 == LITTLE_ENDIAN1234
1244 sc->sw_enc = AUDIO_ENCODING_SLINEAR_LE6;
1245#else
1246 sc->sw_enc = AUDIO_ENCODING_SLINEAR_BE7;
1247#endif
1248 sc->bits = 16;
1249 sc->bps = 2;
1250 sc->msb = 1;
1251 sc->rate = 48000;
1252 sc->pchan = 2;
1253 sc->rchan = 2;
1254 sc->round = 960;
1255 sc->play.nblks = 2;
1256 sc->play.pos = sc->play.xrun = sc->rec.pos = sc->rec.xrun = 0;
1257 sc->record_enable = MIXER_RECORD_ENABLE_SYSCTL2;
1258
1259 /*
1260 * allocate an array of mixer_ctrl structures to save the
1261 * mixer state and prefill them.
1262 */
1263
1264 mi = malloc(sizeof(struct mixer_devinfo), M_TEMP127, M_WAITOK0x0001);
1265
1266 mi->index = 0;
1267 while (1) {
1268 if (sc->ops->query_devinfo(sc->arg, mi) != 0)
1269 break;
1270 mi->index++;
1271 }
1272 sc->mix_nent = mi->index;
1273 sc->mix_ents = mallocarray(sc->mix_nent,
1274 sizeof(struct mixer_ctrl), M_DEVBUF2, M_WAITOK0x0001);
1275 sc->mix_evbuf = mallocarray(sc->mix_nent,
1276 sizeof(struct mixer_ev), M_DEVBUF2, M_WAITOK0x0001 | M_ZERO0x0008);
1277
1278 ent = sc->mix_ents;
1279 mi->index = 0;
1280 while (1) {
1281 if (sc->ops->query_devinfo(sc->arg, mi) != 0)
1282 break;
1283 switch (mi->type) {
1284 case AUDIO_MIXER_VALUE3:
1285 ent->un.value.num_channels = mi->un.v.num_channels;
1286 /* FALLTHROUGH */
1287 case AUDIO_MIXER_SET2:
1288 case AUDIO_MIXER_ENUM1:
1289 ent->dev = mi->index;
1290 ent->type = mi->type;
1291 }
1292 mi->index++;
1293 ent++;
1294 }
1295
1296 free(mi, M_TEMP127, sizeof(struct mixer_devinfo));
1297}
1298
1299int
1300audio_activate(struct device *self, int act)
1301{
1302 struct audio_softc *sc = (struct audio_softc *)self;
1303 int i;
1304
1305 switch (act) {
1306 case DVACT_QUIESCE2:
1307 /*
1308 * good drivers run play and rec handlers in a single
1309 * interrupt. Grab the lock to ensure we expose the same
1310 * sc->quiesce value to both play and rec handlers
1311 */
1312 mtx_enter(&audio_lock);
1313 sc->quiesce = 1;
1314 mtx_leave(&audio_lock);
1315
1316 /*
1317 * once sc->quiesce is set, interrupts may occur, but
1318 * counters are not advanced and consequently processes
1319 * keep sleeping.
1320 *
1321 * XXX: ensure read/write/ioctl don't start/stop
1322 * DMA at the same time, this needs a "ready" condvar
1323 */
1324 if (sc->mode != 0 && sc->active)
1325 audio_stop_do(sc);
1326
1327 /*
1328 * save mixer state
1329 */
1330 for (i = 0; i != sc->mix_nent; i++)
1331 sc->ops->get_port(sc->arg, sc->mix_ents + i);
1332
1333 DPRINTF("%s: quiesce: active = %d\n", DEVNAME(sc), sc->active)do {} while(0);
1334 break;
1335 case DVACT_WAKEUP5:
1336 DPRINTF("%s: wakeup: active = %d\n", DEVNAME(sc), sc->active)do {} while(0);
1337
1338 /*
1339 * restore mixer state
1340 */
1341 for (i = 0; i != sc->mix_nent; i++)
1342 sc->ops->set_port(sc->arg, sc->mix_ents + i);
1343
1344 /*
1345 * keep buffer usage the same, but set start pointer to
1346 * the beginning of the buffer.
1347 *
1348 * No need to grab the audio_lock as DMA is stopped and
1349 * this is the only thread running (caller ensures this)
1350 */
1351 sc->quiesce = 0;
1352 wakeup(&sc->quiesce);
1353
1354 if (sc->mode != 0) {
1355 if (audio_setpar(sc) != 0)
1356 break;
1357 if (sc->mode & AUMODE_PLAY0x01) {
1358 sc->play.start = 0;
1359 audio_fill_sil(sc, sc->play.data, sc->play.len);
1360 }
1361 if (sc->mode & AUMODE_RECORD0x02) {
1362 sc->rec.start = sc->rec.len - sc->rec.used;
1363 audio_fill_sil(sc, sc->rec.data, sc->rec.len);
1364 }
1365 if (sc->active)
1366 audio_start_do(sc);
1367 }
1368 break;
1369 }
1370 return 0;
1371}
1372
1373int
1374audio_detach(struct device *self, int flags)
1375{
1376 struct audio_softc *sc = (struct audio_softc *)self;
1377 int maj, mn;
1378
1379 DPRINTF("%s: audio_detach: flags = %d\n", DEVNAME(sc), flags)do {} while(0);
1380
1381 wakeup(&sc->quiesce);
1382
1383 /* locate the major number */
1384 for (maj = 0; maj < nchrdev; maj++)
1385 if (cdevsw[maj].d_open == audioopen)
1386 break;
1387 /*
1388 * Nuke the vnodes for any open instances, calls close but as
1389 * close uses device_lookup, it returns EXIO and does nothing
1390 */
1391 mn = self->dv_unit;
1392 vdevgone(maj, mn | AUDIO_DEV_AUDIO0, mn | AUDIO_DEV_AUDIO0, VCHR);
1393 vdevgone(maj, mn | AUDIO_DEV_AUDIOCTL0xc0, mn | AUDIO_DEV_AUDIOCTL0xc0, VCHR);
1394
1395 /*
1396 * The close() method did nothing, quickly halt DMA (normally
1397 * parent is already gone, and code below is no-op), and wake-up
1398 * user-land blocked in read/write/ioctl, which return EIO.
1399 */
1400 if (sc->mode != 0) {
1401 if (sc->active) {
1402 wakeup(&sc->play.blocking);
1403 wakeup(&sc->rec.blocking);
1404 audio_stop(sc);
1405 }
1406 sc->ops->close(sc->arg);
1407 sc->mode = 0;
1408 }
1409 if (sc->mix_isopen)
1410 wakeup(&sc->mix_blocking);
1411 klist_invalidate(&sc->play.klist);
1412 klist_invalidate(&sc->rec.klist);
1413 klist_invalidate(&sc->mix_klist);
1414
1415 /* free resources */
1416 klist_free(&sc->mix_klist);
1417 free(sc->mix_evbuf, M_DEVBUF2, sc->mix_nent * sizeof(struct mixer_ev));
1418 free(sc->mix_ents, M_DEVBUF2, sc->mix_nent * sizeof(struct mixer_ctrl));
1419 audio_buf_done(sc, &sc->play);
1420 audio_buf_done(sc, &sc->rec);
1421 return 0;
1422}
1423
1424int
1425audio_submatch(struct device *parent, void *match, void *aux)
1426{
1427 struct cfdata *cf = match;
1428
1429 return (cf->cf_driver == &audio_cd);
1430}
1431
1432struct device *
1433audio_attach_mi(const struct audio_hw_if *ops, void *arg, void *cookie,
1434 struct device *dev)
1435{
1436 struct audio_attach_args aa;
1437
1438 aa.type = AUDIODEV_TYPE_AUDIO0;
1439 aa.hwif = ops;
1440 aa.hdl = arg;
1441 aa.cookie = cookie;
1442
1443 /*
1444 * attach this driver to the caller (hardware driver), this
1445 * checks the kernel config and possibly calls audio_attach()
1446 */
1447 return config_found_sm(dev, &aa, audioprint, audio_submatch);
1448}
1449
1450int
1451audioprint(void *aux, const char *pnp)
1452{
1453 struct audio_attach_args *arg = aux;
1454 const char *type;
1455
1456 if (pnp != NULL((void *)0)) {
1457 switch (arg->type) {
1458 case AUDIODEV_TYPE_AUDIO0:
1459 type = "audio";
1460 break;
1461 case AUDIODEV_TYPE_OPL2:
1462 type = "opl";
1463 break;
1464 case AUDIODEV_TYPE_MPU3:
1465 type = "mpu";
1466 break;
1467 default:
1468 panic("audioprint: unknown type %d", arg->type);
1469 }
1470 printf("%s at %s", type, pnp);
1471 }
1472 return UNCONF1;
1473}
1474
1475int
1476audio_open(struct audio_softc *sc, int flags)
1477{
1478 int error;
1479
1480 if (sc->mode)
1481 return EBUSY16;
1482 error = sc->ops->open(sc->arg, flags);
1483 if (error)
1484 return error;
1485 sc->active = 0;
1486 sc->pause = 1;
1487 sc->rec.blocking = 0;
1488 sc->play.blocking = 0;
1489 sc->mode = 0;
1490 if (flags & FWRITE0x0002)
1491 sc->mode |= AUMODE_PLAY0x01;
1492 if (flags & FREAD0x0001)
1493 sc->mode |= AUMODE_RECORD0x02;
1494
1495 error = audio_setpar(sc);
1496 if (error)
1497 goto bad;
1498 audio_clear(sc);
1499
1500 /*
1501 * allow read(2)/write(2) to automatically start DMA, without
1502 * the need for ioctl(), to make /dev/audio usable in scripts
1503 */
1504 sc->pause = 0;
1505 return 0;
1506bad:
1507 sc->ops->close(sc->arg);
1508 sc->mode = 0;
1509 return error;
1510}
1511
1512int
1513audio_drain(struct audio_softc *sc)
1514{
1515 int error, xrun;
1516 unsigned char *ptr;
1517 size_t count, bpf;
1518
1519 DPRINTF("%s: drain: mode = %d, pause = %d, active = %d, used = %zu\n",do {} while(0)
1520 DEVNAME(sc), sc->mode, sc->pause, sc->active, sc->play.used)do {} while(0);
1521 if (!(sc->mode & AUMODE_PLAY0x01) || sc->pause)
1522 return 0;
1523
1524 /* discard partial samples, required by audio_fill_sil() */
1525 mtx_enter(&audio_lock);
1526 bpf = sc->pchan * sc->bps;
1527 sc->play.used -= sc->play.used % bpf;
1528 if (sc->play.used == 0) {
1529 mtx_leave(&audio_lock);
1530 return 0;
1531 }
1532
1533 if (!sc->active) {
1534 /*
1535 * dma not started yet because buffer was not full
1536 * enough to start automatically. Pad it and start now.
1537 */
1538 for (;;) {
1539 ptr = audio_buf_wgetblk(&sc->play, &count);
1540 if (count == 0)
1541 break;
1542 audio_fill_sil(sc, ptr, count);
1543 audio_buf_wcommit(&sc->play, count);
1544 }
1545 mtx_leave(&audio_lock);
1546 error = audio_start(sc);
1547 if (error)
1548 return error;
1549 mtx_enter(&audio_lock);
1550 }
1551
1552 xrun = sc->play.xrun;
1553 while (sc->play.xrun == xrun) {
1554 DPRINTF("%s: drain: used = %zu, xrun = %d\n",do {} while(0)
1555 DEVNAME(sc), sc->play.used, sc->play.xrun)do {} while(0);
1556
1557 /*
1558 * set a 5 second timeout, in case interrupts don't
1559 * work, useful only for debugging drivers
1560 */
1561 sc->play.blocking = 1;
1562 error = msleep_nsec(&sc->play.blocking, &audio_lock,
1563 PWAIT32 | PCATCH0x100, "au_dr", SEC_TO_NSEC(5));
1564 if (!(sc->dev.dv_flags & DVF_ACTIVE0x0001))
1565 error = EIO5;
1566 if (error) {
1567 DPRINTF("%s: drain, err = %d\n", DEVNAME(sc), error)do {} while(0);
1568 break;
1569 }
1570 }
1571 mtx_leave(&audio_lock);
1572 return error;
1573}
1574
1575int
1576audio_close(struct audio_softc *sc)
1577{
1578 audio_drain(sc);
1579 if (sc->active)
1580 audio_stop(sc);
1581 sc->ops->close(sc->arg);
1582 sc->mode = 0;
1583 DPRINTF("%s: close: done\n", DEVNAME(sc))do {} while(0);
1584 return 0;
1585}
1586
1587int
1588audio_read(struct audio_softc *sc, struct uio *uio, int ioflag)
1589{
1590 unsigned char *ptr;
1591 size_t count;
1592 int error;
1593
1594 DPRINTFN(1, "%s: read: resid = %zd\n", DEVNAME(sc), uio->uio_resid)do {} while(0);
1595
1596 /* block if quiesced */
1597 while (sc->quiesce)
1598 tsleep_nsec(&sc->quiesce, 0, "au_qrd", INFSLP0xffffffffffffffffULL);
1599
1600 /* start automatically if audio_ioc_start() was never called */
1601 if (audio_canstart(sc)) {
1602 error = audio_start(sc);
1603 if (error)
1604 return error;
1605 }
1606
1607 mtx_enter(&audio_lock);
1608
1609 /* if there is no data then sleep */
1610 while (sc->rec.used == 0) {
1611 if (ioflag & IO_NDELAY0x10) {
1612 mtx_leave(&audio_lock);
1613 return EWOULDBLOCK35;
1614 }
1615 DPRINTFN(1, "%s: read sleep\n", DEVNAME(sc))do {} while(0);
1616 sc->rec.blocking = 1;
1617 error = msleep_nsec(&sc->rec.blocking,
1618 &audio_lock, PWAIT32 | PCATCH0x100, "au_rd", INFSLP0xffffffffffffffffULL);
1619 if (!(sc->dev.dv_flags & DVF_ACTIVE0x0001))
1620 error = EIO5;
1621 if (error) {
1622 DPRINTF("%s: read woke up error = %d\n",do {} while(0)
1623 DEVNAME(sc), error)do {} while(0);
1624 mtx_leave(&audio_lock);
1625 return error;
1626 }
1627 }
1628
1629 /* at this stage, there is data to transfer */
1630 while (uio->uio_resid > 0 && sc->rec.used > 0) {
1631 ptr = audio_buf_rgetblk(&sc->rec, &count);
1632 if (count > uio->uio_resid)
1633 count = uio->uio_resid;
1634 mtx_leave(&audio_lock);
1635 DPRINTFN(1, "%s: read: start = %zu, count = %zu\n",do {} while(0)
1636 DEVNAME(sc), ptr - sc->rec.data, count)do {} while(0);
1637 if (sc->conv_dec)
1638 sc->conv_dec(ptr, count);
1639 error = uiomove(ptr, count, uio);
1640 if (error)
1641 return error;
1642 mtx_enter(&audio_lock);
1643 audio_buf_rdiscard(&sc->rec, count);
1644 }
1645 mtx_leave(&audio_lock);
1646 return 0;
1647}
1648
1649int
1650audio_write(struct audio_softc *sc, struct uio *uio, int ioflag)
1651{
1652 unsigned char *ptr;
1653 size_t count;
1654 int error;
1655
1656 DPRINTFN(1, "%s: write: resid = %zd\n", DEVNAME(sc), uio->uio_resid)do {} while(0);
1657
1658 /* block if quiesced */
1659 while (sc->quiesce)
1660 tsleep_nsec(&sc->quiesce, 0, "au_qwr", INFSLP0xffffffffffffffffULL);
1661
1662 /*
1663 * if IO_NDELAY flag is set then check if there is enough room
1664 * in the buffer to store at least one byte. If not then don't
1665 * start the write process.
1666 */
1667 mtx_enter(&audio_lock);
1668 if (uio->uio_resid > 0 && (ioflag & IO_NDELAY0x10)) {
1669 if (sc->play.used == sc->play.len) {
1670 mtx_leave(&audio_lock);
1671 return EWOULDBLOCK35;
1672 }
1673 }
1674
1675 while (uio->uio_resid > 0) {
1676 while (1) {
1677 ptr = audio_buf_wgetblk(&sc->play, &count);
1678 if (count > 0)
1679 break;
1680 if (ioflag & IO_NDELAY0x10) {
1681 /*
1682 * At this stage at least one byte is already
1683 * moved so we do not return EWOULDBLOCK
1684 */
1685 mtx_leave(&audio_lock);
1686 return 0;
1687 }
1688 DPRINTFN(1, "%s: write sleep\n", DEVNAME(sc))do {} while(0);
1689 sc->play.blocking = 1;
1690 error = msleep_nsec(&sc->play.blocking,
1691 &audio_lock, PWAIT32 | PCATCH0x100, "au_wr", INFSLP0xffffffffffffffffULL);
1692 if (!(sc->dev.dv_flags & DVF_ACTIVE0x0001))
1693 error = EIO5;
1694 if (error) {
1695 DPRINTF("%s: write woke up error = %d\n",do {} while(0)
1696 DEVNAME(sc), error)do {} while(0);
1697 mtx_leave(&audio_lock);
1698 return error;
1699 }
1700 }
1701 if (count > uio->uio_resid)
1702 count = uio->uio_resid;
1703 mtx_leave(&audio_lock);
1704 error = uiomove(ptr, count, uio);
1705 if (error)
1706 return 0;
1707 if (sc->conv_enc) {
1708 sc->conv_enc(ptr, count);
1709 DPRINTFN(1, "audio_write: converted count = %zu\n",do {} while(0)
1710 count)do {} while(0);
1711 }
1712 if (sc->ops->copy_output)
1713 sc->ops->copy_output(sc->arg, count);
1714
1715 mtx_enter(&audio_lock);
1716 audio_buf_wcommit(&sc->play, count);
1717
1718 /* start automatically if audio_ioc_start() was never called */
1719 if (audio_canstart(sc)) {
1720 mtx_leave(&audio_lock);
1721 error = audio_start(sc);
1722 if (error)
1723 return error;
1724 mtx_enter(&audio_lock);
1725 }
1726 }
1727 mtx_leave(&audio_lock);
1728 return 0;
1729}
1730
1731int
1732audio_getdev(struct audio_softc *sc, struct audio_device *adev)
1733{
1734 memset(adev, 0, sizeof(struct audio_device))__builtin_memset((adev), (0), (sizeof(struct audio_device)));
1735 if (sc->dev.dv_parent == NULL((void *)0))
1736 return EIO5;
1737 strlcpy(adev->name, sc->dev.dv_parent->dv_xname, MAX_AUDIO_DEV_LEN16);
1738 return 0;
1739}
1740
1741int
1742audio_ioctl(struct audio_softc *sc, unsigned long cmd, void *addr)
1743{
1744 struct audio_pos *ap;
1745 int error = 0;
1746
1747 /* block if quiesced */
1748 while (sc->quiesce)
1749 tsleep_nsec(&sc->quiesce, 0, "au_qio", INFSLP0xffffffffffffffffULL);
1750
1751 switch (cmd) {
1752 case FIONBIO((unsigned long)0x80000000 | ((sizeof(int) & 0x1fff) <<
16) | ((('f')) << 8) | ((126))):
1753 /* All handled in the upper FS layer. */
1754 break;
1755 case AUDIO_GETPOS((unsigned long)0x40000000 | ((sizeof(struct audio_pos) &
0x1fff) << 16) | ((('A')) << 8) | ((35))):
1756 mtx_enter(&audio_lock);
1757 ap = (struct audio_pos *)addr;
1758 ap->play_pos = sc->play.pos;
1759 ap->play_xrun = sc->play.xrun;
1760 ap->rec_pos = sc->rec.pos;
1761 ap->rec_xrun = sc->rec.xrun;
1762 mtx_leave(&audio_lock);
1763 break;
1764 case AUDIO_START((unsigned long)0x20000000 | ((0 & 0x1fff) << 16) |
((('A')) << 8) | ((38))):
1765 return audio_ioc_start(sc);
1766 case AUDIO_STOP((unsigned long)0x20000000 | ((0 & 0x1fff) << 16) |
((('A')) << 8) | ((39))):
1767 return audio_ioc_stop(sc);
1768 case AUDIO_SETPAR(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct audio_swpar) & 0x1fff) << 16) | ((('A')) <<
8) | ((37))):
1769 error = audio_ioc_setpar(sc, (struct audio_swpar *)addr);
1770 break;
1771 case AUDIO_GETPAR((unsigned long)0x40000000 | ((sizeof(struct audio_swpar) &
0x1fff) << 16) | ((('A')) << 8) | ((36))):
1772 error = audio_ioc_getpar(sc, (struct audio_swpar *)addr);
1773 break;
1774 case AUDIO_GETSTATUS((unsigned long)0x40000000 | ((sizeof(struct audio_status) &
0x1fff) << 16) | ((('A')) << 8) | ((40))):
1775 error = audio_ioc_getstatus(sc, (struct audio_status *)addr);
1776 break;
1777 case AUDIO_GETDEV((unsigned long)0x40000000 | ((sizeof(struct audio_device) &
0x1fff) << 16) | ((('A')) << 8) | ((27))):
1778 error = audio_getdev(sc, (struct audio_device *)addr);
1779 break;
1780 default:
1781 DPRINTF("%s: unknown ioctl 0x%lx\n", DEVNAME(sc), cmd)do {} while(0);
1782 error = ENOTTY25;
1783 break;
1784 }
1785 return error;
1786}
1787
1788void
1789audio_event(struct audio_softc *sc, int addr)
1790{
1791 struct mixer_ev *e;
1792
1793 mtx_enter(&audio_lock);
1794 if (sc->mix_isopen) {
1795 e = sc->mix_evbuf + addr;
1796 if (!e->pending) {
1797 e->pending = 1;
1798 e->next = sc->mix_pending;
1799 sc->mix_pending = e;
1800 }
1801 audio_mixer_wakeup(sc);
1802 }
1803 mtx_leave(&audio_lock);
1804}
1805
1806int
1807audio_mixer_devinfo(struct audio_softc *sc, struct mixer_devinfo *devinfo)
1808{
1809 if (devinfo->index < sc->mix_nent)
1810 return sc->ops->query_devinfo(sc->arg, devinfo);
1811
1812 devinfo->next = -1;
1813 devinfo->prev = -1;
1814 switch (devinfo->index - sc->mix_nent) {
1815 case MIXER_RECORD0:
1816 strlcpy(devinfo->label.name, AudioCrecord"record", MAX_AUDIO_DEV_LEN16);
1817 devinfo->type = AUDIO_MIXER_CLASS0;
1818 devinfo->mixer_class = -1;
1819 break;
1820 case MIXER_RECORD_ENABLE1:
1821 strlcpy(devinfo->label.name, "enable", MAX_AUDIO_DEV_LEN16);
1822 devinfo->type = AUDIO_MIXER_ENUM1;
1823 devinfo->mixer_class = MIXER_RECORD0 + sc->mix_nent;
1824 devinfo->un.e.num_mem = 3;
1825 devinfo->un.e.member[0].ord = MIXER_RECORD_ENABLE_OFF0;
1826 strlcpy(devinfo->un.e.member[0].label.name, "off",
1827 MAX_AUDIO_DEV_LEN16);
1828 devinfo->un.e.member[1].ord = MIXER_RECORD_ENABLE_ON1;
1829 strlcpy(devinfo->un.e.member[1].label.name, "on",
1830 MAX_AUDIO_DEV_LEN16);
1831 devinfo->un.e.member[2].ord = MIXER_RECORD_ENABLE_SYSCTL2;
1832 strlcpy(devinfo->un.e.member[2].label.name, "sysctl",
1833 MAX_AUDIO_DEV_LEN16);
1834 break;
1835 default:
1836 return EINVAL22;
1837 }
1838
1839 return 0;
1840}
1841
1842int
1843audio_mixer_get(struct audio_softc *sc, struct mixer_ctrl *c)
1844{
1845 if (c->dev < sc->mix_nent)
1846 return sc->ops->get_port(sc->arg, c);
1847
1848 switch (c->dev - sc->mix_nent) {
1849 case MIXER_RECORD0:
1850 return EBADF9;
1851 case MIXER_RECORD_ENABLE1:
1852 c->un.ord = sc->record_enable;
1853 break;
1854 default:
1855 return EINVAL22;
1856 }
1857
1858 return 0;
1859}
1860
1861int
1862audio_mixer_set(struct audio_softc *sc, struct mixer_ctrl *c, struct proc *p)
1863{
1864 int error;
1865
1866 if (c->dev < sc->mix_nent) {
1867 error = sc->ops->set_port(sc->arg, c);
1868 if (error)
1869 return error;
1870 if (sc->ops->commit_settings)
1871 return sc->ops->commit_settings(sc->arg);
1872 audio_event(sc, c->dev);
1873 return 0;
1874 }
1875
1876 switch (c->dev - sc->mix_nent) {
1877 case MIXER_RECORD0:
1878 return EBADF9;
1879 case MIXER_RECORD_ENABLE1:
1880 switch (c->un.ord) {
1881 case MIXER_RECORD_ENABLE_OFF0:
1882 case MIXER_RECORD_ENABLE_ON1:
1883 case MIXER_RECORD_ENABLE_SYSCTL2:
1884 break;
1885 default:
1886 return EINVAL22;
1887 }
1888 if (suser(p) == 0)
1889 sc->record_enable = c->un.ord;
1890 break;
1891 default:
1892 return EINVAL22;
1893 }
1894
1895 return 0;
1896}
1897
1898int
1899audio_ioctl_mixer(struct audio_softc *sc, unsigned long cmd, void *addr,
1900 struct proc *p)
1901{
1902 /* block if quiesced */
1903 while (sc->quiesce)
1904 tsleep_nsec(&sc->quiesce, 0, "mix_qio", INFSLP0xffffffffffffffffULL);
1905
1906 switch (cmd) {
1907 case FIONBIO((unsigned long)0x80000000 | ((sizeof(int) & 0x1fff) <<
16) | ((('f')) << 8) | ((126))):
1908 /* All handled in the upper FS layer. */
1909 break;
1910 case AUDIO_MIXER_DEVINFO(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(mixer_devinfo_t) & 0x1fff) << 16) | ((('M')) <<
8) | ((2))):
1911 return audio_mixer_devinfo(sc, addr);
1912 case AUDIO_MIXER_READ(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(mixer_ctrl_t) & 0x1fff) << 16) | ((('M')) <<
8) | ((0))):
1913 return audio_mixer_get(sc, addr);
1914 case AUDIO_MIXER_WRITE(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(mixer_ctrl_t) & 0x1fff) << 16) | ((('M')) <<
8) | ((1))):
1915 return audio_mixer_set(sc, addr, p);
1916 default:
1917 return ENOTTY25;
1918 }
1919 return 0;
1920}
1921
1922int
1923audio_mixer_read(struct audio_softc *sc, struct uio *uio, int ioflag)
1924{
1925 struct mixer_ev *e;
1926 int data;
1927 int error;
1928
1929 DPRINTF("%s: mixer read: resid = %zd\n", DEVNAME(sc), uio->uio_resid)do {} while(0);
1930
1931 /* block if quiesced */
1932 while (sc->quiesce)
1933 tsleep_nsec(&sc->quiesce, 0, "mix_qrd", INFSLP0xffffffffffffffffULL);
1934
1935 mtx_enter(&audio_lock);
1936
1937 /* if there are no events then sleep */
1938 while (!sc->mix_pending) {
1939 if (ioflag & IO_NDELAY0x10) {
1940 mtx_leave(&audio_lock);
1941 return EWOULDBLOCK35;
1942 }
1943 DPRINTF("%s: mixer read sleep\n", DEVNAME(sc))do {} while(0);
1944 sc->mix_blocking = 1;
1945 error = msleep_nsec(&sc->mix_blocking,
1946 &audio_lock, PWAIT32 | PCATCH0x100, "mix_rd", INFSLP0xffffffffffffffffULL);
1947 if (!(sc->dev.dv_flags & DVF_ACTIVE0x0001))
1948 error = EIO5;
1949 if (error) {
1950 DPRINTF("%s: mixer read woke up error = %d\n",do {} while(0)
1951 DEVNAME(sc), error)do {} while(0);
1952 mtx_leave(&audio_lock);
1953 return error;
1954 }
1955 }
1956
1957 /* at this stage, there is an event to transfer */
1958 while (uio->uio_resid >= sizeof(int) && sc->mix_pending) {
1959 e = sc->mix_pending;
1960 sc->mix_pending = e->next;
1961 e->pending = 0;
1962 data = e - sc->mix_evbuf;
1963 mtx_leave(&audio_lock);
1964 DPRINTF("%s: mixer read: %u\n", DEVNAME(sc), data)do {} while(0);
1965 error = uiomove(&data, sizeof(int), uio);
1966 if (error)
1967 return error;
1968 mtx_enter(&audio_lock);
1969 }
1970
1971 mtx_leave(&audio_lock);
1972 return 0;
1973}
1974
1975int
1976audio_mixer_open(struct audio_softc *sc, int flags)
1977{
1978 DPRINTF("%s: flags = 0x%x\n", __func__, flags)do {} while(0);
1979
1980 if (flags & FREAD0x0001) {
1981 if (sc->mix_isopen)
1982 return EBUSY16;
1983 sc->mix_isopen = 1;
1984 }
1985 return 0;
1986}
1987
1988int
1989audio_mixer_close(struct audio_softc *sc, int flags)
1990{
1991 int i;
1992
1993 DPRINTF("%s: flags = 0x%x\n", __func__, flags)do {} while(0);
1994
1995 if (flags & FREAD0x0001) {
1996 sc->mix_isopen = 0;
1997
1998 mtx_enter(&audio_lock);
1999 sc->mix_pending = NULL((void *)0);
2000 for (i = 0; i < sc->mix_nent; i++)
2001 sc->mix_evbuf[i].pending = 0;
2002 mtx_leave(&audio_lock);
2003 }
2004 return 0;
2005}
2006
2007int
2008audioopen(dev_t dev, int flags, int mode, struct proc *p)
2009{
2010 struct audio_softc *sc;
2011 int error;
2012
2013 sc = (struct audio_softc *)device_lookup(&audio_cd, AUDIO_UNIT(dev)(((unsigned)((dev) & 0xff) | (((dev) & 0xffff0000) >>
8)) & 0x0f));
2014 if (sc == NULL((void *)0))
2015 return ENXIO6;
2016 if (sc->ops == NULL((void *)0))
2017 error = ENXIO6;
2018 else {
2019 switch (AUDIO_DEV(dev)(((unsigned)((dev) & 0xff) | (((dev) & 0xffff0000) >>
8)) & 0xf0)) {
2020 case AUDIO_DEV_AUDIO0:
2021 error = audio_open(sc, flags);
2022 break;
2023 case AUDIO_DEV_AUDIOCTL0xc0:
2024 error = audio_mixer_open(sc, flags);
2025 break;
2026 default:
2027 error = ENXIO6;
2028 }
2029 }
2030 device_unref(&sc->dev);
2031 return error;
2032}
2033
2034int
2035audioclose(dev_t dev, int flags, int ifmt, struct proc *p)
2036{
2037 struct audio_softc *sc;
2038 int error;
2039
2040 sc = (struct audio_softc *)device_lookup(&audio_cd, AUDIO_UNIT(dev)(((unsigned)((dev) & 0xff) | (((dev) & 0xffff0000) >>
8)) & 0x0f));
2041 if (sc == NULL((void *)0))
2042 return ENXIO6;
2043 switch (AUDIO_DEV(dev)(((unsigned)((dev) & 0xff) | (((dev) & 0xffff0000) >>
8)) & 0xf0)) {
2044 case AUDIO_DEV_AUDIO0:
2045 error = audio_close(sc);
2046 break;
2047 case AUDIO_DEV_AUDIOCTL0xc0:
2048 error = audio_mixer_close(sc, flags);
2049 break;
2050 default:
2051 error = ENXIO6;
2052 }
2053 device_unref(&sc->dev);
2054 return error;
2055}
2056
2057int
2058audioread(dev_t dev, struct uio *uio, int ioflag)
2059{
2060 struct audio_softc *sc;
2061 int error;
2062
2063 sc = (struct audio_softc *)device_lookup(&audio_cd, AUDIO_UNIT(dev)(((unsigned)((dev) & 0xff) | (((dev) & 0xffff0000) >>
8)) & 0x0f));
2064 if (sc == NULL((void *)0))
2065 return ENXIO6;
2066 switch (AUDIO_DEV(dev)(((unsigned)((dev) & 0xff) | (((dev) & 0xffff0000) >>
8)) & 0xf0)) {
2067 case AUDIO_DEV_AUDIO0:
2068 error = audio_read(sc, uio, ioflag);
2069 break;
2070 case AUDIO_DEV_AUDIOCTL0xc0:
2071 error = audio_mixer_read(sc, uio, ioflag);
2072 break;
2073 default:
2074 error = ENXIO6;
2075 }
2076 device_unref(&sc->dev);
2077 return error;
2078}
2079
2080int
2081audiowrite(dev_t dev, struct uio *uio, int ioflag)
2082{
2083 struct audio_softc *sc;
2084 int error;
2085
2086 sc = (struct audio_softc *)device_lookup(&audio_cd, AUDIO_UNIT(dev)(((unsigned)((dev) & 0xff) | (((dev) & 0xffff0000) >>
8)) & 0x0f));
2087 if (sc == NULL((void *)0))
2088 return ENXIO6;
2089 switch (AUDIO_DEV(dev)(((unsigned)((dev) & 0xff) | (((dev) & 0xffff0000) >>
8)) & 0xf0)) {
2090 case AUDIO_DEV_AUDIO0:
2091 error = audio_write(sc, uio, ioflag);
2092 break;
2093 case AUDIO_DEV_AUDIOCTL0xc0:
2094 error = ENODEV19;
2095 break;
2096 default:
2097 error = ENXIO6;
2098 }
2099 device_unref(&sc->dev);
2100 return error;
2101}
2102
2103int
2104audioioctl(dev_t dev, u_long cmd, caddr_t addr, int flag, struct proc *p)
2105{
2106 struct audio_softc *sc;
2107 int error;
2108
2109 sc = (struct audio_softc *)device_lookup(&audio_cd, AUDIO_UNIT(dev)(((unsigned)((dev) & 0xff) | (((dev) & 0xffff0000) >>
8)) & 0x0f));
2110 if (sc == NULL((void *)0))
2111 return ENXIO6;
2112 switch (AUDIO_DEV(dev)(((unsigned)((dev) & 0xff) | (((dev) & 0xffff0000) >>
8)) & 0xf0)) {
2113 case AUDIO_DEV_AUDIO0:
2114 error = audio_ioctl(sc, cmd, addr);
2115 break;
2116 case AUDIO_DEV_AUDIOCTL0xc0:
2117 if (cmd == AUDIO_SETPAR(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(struct audio_swpar) & 0x1fff) << 16) | ((('A')) <<
8) | ((37))) && sc->mode != 0) {
2118 error = EBUSY16;
2119 break;
2120 }
2121 if (cmd == AUDIO_START((unsigned long)0x20000000 | ((0 & 0x1fff) << 16) |
((('A')) << 8) | ((38))) || cmd == AUDIO_STOP((unsigned long)0x20000000 | ((0 & 0x1fff) << 16) |
((('A')) << 8) | ((39)))) {
2122 error = ENXIO6;
2123 break;
2124 }
2125 if (cmd == AUDIO_MIXER_DEVINFO(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(mixer_devinfo_t) & 0x1fff) << 16) | ((('M')) <<
8) | ((2))) ||
2126 cmd == AUDIO_MIXER_READ(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(mixer_ctrl_t) & 0x1fff) << 16) | ((('M')) <<
8) | ((0))) ||
2127 cmd == AUDIO_MIXER_WRITE(((unsigned long)0x80000000|(unsigned long)0x40000000) | ((sizeof
(mixer_ctrl_t) & 0x1fff) << 16) | ((('M')) <<
8) | ((1))))
2128 error = audio_ioctl_mixer(sc, cmd, addr, p);
2129 else
2130 error = audio_ioctl(sc, cmd, addr);
2131 break;
2132 default:
2133 error = ENXIO6;
2134 }
2135 device_unref(&sc->dev);
2136 return error;
2137}
2138
2139int
2140audiokqfilter(dev_t dev, struct knote *kn)
2141{
2142 struct audio_softc *sc;
2143 struct klist *klist;
2144 int error;
2145
2146 sc = (struct audio_softc *)device_lookup(&audio_cd, AUDIO_UNIT(dev)(((unsigned)((dev) & 0xff) | (((dev) & 0xffff0000) >>
8)) & 0x0f));
2147 if (sc == NULL((void *)0))
2148 return ENXIO6;
2149 error = 0;
2150 switch (AUDIO_DEV(dev)(((unsigned)((dev) & 0xff) | (((dev) & 0xffff0000) >>
8)) & 0xf0)) {
2151 case AUDIO_DEV_AUDIO0:
2152 switch (kn->kn_filterkn_kevent.filter) {
2153 case EVFILT_READ(-1):
2154 klist = &sc->rec.klist;
2155 kn->kn_fop = &audioread_filtops;
2156 break;
2157 case EVFILT_WRITE(-2):
2158 klist = &sc->play.klist;
2159 kn->kn_fop = &audiowrite_filtops;
2160 break;
2161 default:
2162 error = EINVAL22;
2163 goto done;
2164 }
2165 break;
2166 case AUDIO_DEV_AUDIOCTL0xc0:
2167 switch (kn->kn_filterkn_kevent.filter) {
2168 case EVFILT_READ(-1):
2169 klist = &sc->mix_klist;
2170 kn->kn_fop = &audioctlread_filtops;
2171 break;
2172 default:
2173 error = EINVAL22;
2174 goto done;
2175 }
2176 break;
2177 }
2178 kn->kn_hook = sc;
2179
2180 klist_insert(klist, kn);
2181done:
2182 device_unref(&sc->dev);
2183 return error;
2184}
2185
2186void
2187filt_audiordetach(struct knote *kn)
2188{
2189 struct audio_softc *sc = kn->kn_hook;
2190
2191 klist_remove(&sc->rec.klist, kn);
2192}
2193
2194int
2195filt_audioread(struct knote *kn, long hint)
2196{
2197 struct audio_softc *sc = kn->kn_hook;
2198
2199 MUTEX_ASSERT_LOCKED(&audio_lock)do { if (((&audio_lock)->mtx_owner != ({struct cpu_info
*__ci; asm volatile("movq %%gs:%P1,%0" : "=r" (__ci) :"n" (__builtin_offsetof
(struct cpu_info, ci_self))); __ci;})) && !(panicstr ||
db_active)) panic("mutex %p not held in %s", (&audio_lock
), __func__); } while (0);
2200
2201 return (sc->mode & AUMODE_RECORD0x02) && (sc->rec.used > 0);
2202}
2203
2204void
2205filt_audiowdetach(struct knote *kn)
2206{
2207 struct audio_softc *sc = kn->kn_hook;
2208
2209 klist_remove(&sc->play.klist, kn);
2210}
2211
2212int
2213filt_audiowrite(struct knote *kn, long hint)
2214{
2215 struct audio_softc *sc = kn->kn_hook;
2216
2217 MUTEX_ASSERT_LOCKED(&audio_lock)do { if (((&audio_lock)->mtx_owner != ({struct cpu_info
*__ci; asm volatile("movq %%gs:%P1,%0" : "=r" (__ci) :"n" (__builtin_offsetof
(struct cpu_info, ci_self))); __ci;})) && !(panicstr ||
db_active)) panic("mutex %p not held in %s", (&audio_lock
), __func__); } while (0);
2218
2219 return (sc->mode & AUMODE_PLAY0x01) && (sc->play.used < sc->play.len);
2220}
2221
2222void
2223filt_audioctlrdetach(struct knote *kn)
2224{
2225 struct audio_softc *sc = kn->kn_hook;
2226
2227 klist_remove(&sc->mix_klist, kn);
2228}
2229
2230int
2231filt_audioctlread(struct knote *kn, long hint)
2232{
2233 struct audio_softc *sc = kn->kn_hook;
2234
2235 MUTEX_ASSERT_LOCKED(&audio_lock)do { if (((&audio_lock)->mtx_owner != ({struct cpu_info
*__ci; asm volatile("movq %%gs:%P1,%0" : "=r" (__ci) :"n" (__builtin_offsetof
(struct cpu_info, ci_self))); __ci;})) && !(panicstr ||
db_active)) panic("mutex %p not held in %s", (&audio_lock
), __func__); } while (0);
2236
2237 return (sc->mix_isopen && sc->mix_pending);
2238}
2239
2240int
2241filt_audiomodify(struct kevent *kev, struct knote *kn)
2242{
2243 int active;
2244
2245 mtx_enter(&audio_lock);
2246 active = knote_modify(kev, kn);
2247 mtx_leave(&audio_lock);
2248
2249 return active;
2250}
2251
2252int
2253filt_audioprocess(struct knote *kn, struct kevent *kev)
2254{
2255 int active;
2256
2257 mtx_enter(&audio_lock);
2258 active = knote_process(kn, kev);
2259 mtx_leave(&audio_lock);
2260
2261 return active;
2262}
2263
2264#if NWSKBD1 > 0
2265int
2266wskbd_initmute(struct audio_softc *sc, struct mixer_devinfo *vol)
2267{
2268 struct mixer_devinfo *mi;
2269 int index = -1;
2270
2271 mi = malloc(sizeof(struct mixer_devinfo), M_TEMP127, M_WAITOK0x0001);
2272
2273 for (mi->index = vol->next; mi->index != -1; mi->index = mi->next) {
2274 if (sc->ops->query_devinfo(sc->arg, mi) != 0)
2275 break;
2276 if (strcmp(mi->label.name, AudioNmute"mute") == 0) {
2277 index = mi->index;
2278 break;
2279 }
2280 }
2281
2282 free(mi, M_TEMP127, sizeof(struct mixer_devinfo));
2283 return index;
2284}
2285
2286int
2287wskbd_initvol(struct audio_softc *sc, struct wskbd_vol *vol, char *cn, char *dn)
2288{
2289 struct mixer_devinfo *dev, *cls;
2290
2291 vol->val = vol->mute = -1;
2292 dev = malloc(sizeof(struct mixer_devinfo), M_TEMP127, M_WAITOK0x0001);
2293 cls = malloc(sizeof(struct mixer_devinfo), M_TEMP127, M_WAITOK0x0001);
2294
2295 for (dev->index = 0; ; dev->index++) {
2296 if (sc->ops->query_devinfo(sc->arg, dev) != 0)
2297 break;
2298 if (dev->type != AUDIO_MIXER_VALUE3)
2299 continue;
2300 cls->index = dev->mixer_class;
2301 if (sc->ops->query_devinfo(sc->arg, cls) != 0)
2302 continue;
2303 if (strcmp(cls->label.name, cn) == 0 &&
2304 strcmp(dev->label.name, dn) == 0) {
2305 vol->val = dev->index;
2306 vol->nch = dev->un.v.num_channels;
2307 vol->step = dev->un.v.delta > 8 ? dev->un.v.delta : 8;
2308 vol->mute = wskbd_initmute(sc, dev);
2309 vol->val_pending = vol->mute_pending = 0;
2310 DPRINTF("%s: wskbd using %s.%s%s\n", DEVNAME(sc),do {} while(0)
2311 cn, dn, vol->mute >= 0 ? ", mute control" : "")do {} while(0);
2312 break;
2313 }
2314 }
2315
2316 free(cls, M_TEMP127, sizeof(struct mixer_devinfo));
2317 free(dev, M_TEMP127, sizeof(struct mixer_devinfo));
2318 return (vol->val != -1);
2319}
2320
2321void
2322wskbd_mixer_init(struct audio_softc *sc)
2323{
2324 static struct {
2325 char *cn, *dn;
2326 } spkr_names[] = {
2327 {AudioCoutputs"outputs", AudioNmaster"master"},
2328 {AudioCinputs"inputs", AudioNdac"dac"},
2329 {AudioCoutputs"outputs", AudioNdac"dac"},
2330 {AudioCoutputs"outputs", AudioNoutput"output"}
2331 }, mic_names[] = {
2332 {AudioCrecord"record", AudioNrecord"record"},
2333 {AudioCrecord"record", AudioNvolume"volume"},
2334 {AudioCinputs"inputs", AudioNrecord"record"},
2335 {AudioCinputs"inputs", AudioNvolume"volume"},
2336 {AudioCinputs"inputs", AudioNinput"input"}
2337 };
2338 int i;
2339
2340 for (i = 0; i < sizeof(spkr_names) / sizeof(spkr_names[0]); i++) {
2341 if (wskbd_initvol(sc, &sc->spkr,
2342 spkr_names[i].cn, spkr_names[i].dn))
2343 break;
2344 }
2345 for (i = 0; i < sizeof(mic_names) / sizeof(mic_names[0]); i++) {
2346 if (wskbd_initvol(sc, &sc->mic,
2347 mic_names[i].cn, mic_names[i].dn))
2348 break;
2349 }
2350 task_set(&sc->wskbd_task, wskbd_mixer_cb, sc);
2351}
2352
2353void
2354wskbd_mixer_update(struct audio_softc *sc, struct wskbd_vol *vol)
2355{
2356 struct mixer_ctrl ctrl;
2357 int val_pending, mute_pending, i, gain, error, s;
2358
2359 s = spltty()splraise(0x9);
2360 val_pending = vol->val_pending;
2361 vol->val_pending = 0;
2362 mute_pending = vol->mute_pending;
2363 vol->mute_pending = 0;
2364 splx(s)spllower(s);
2365
2366 if (sc->ops == NULL((void *)0))
2367 return;
2368 if (vol->mute >= 0 && mute_pending) {
2369 ctrl.dev = vol->mute;
2370 ctrl.type = AUDIO_MIXER_ENUM1;
2371 error = sc->ops->get_port(sc->arg, &ctrl);
2372 if (error) {
2373 DPRINTF("%s: get mute err = %d\n", DEVNAME(sc), error)do {} while(0);
2374 return;
2375 }
2376 switch (mute_pending) {
2377 case WSKBD_MUTE_TOGGLE1:
2378 ctrl.un.ord = !ctrl.un.ord;
2379 break;
2380 case WSKBD_MUTE_DISABLE2:
2381 ctrl.un.ord = 0;
2382 break;
2383 case WSKBD_MUTE_ENABLE3:
2384 ctrl.un.ord = 1;
2385 break;
2386 }
2387 DPRINTFN(1, "%s: wskbd mute setting to %d\n",do {} while(0)
2388 DEVNAME(sc), ctrl.un.ord)do {} while(0);
2389 error = sc->ops->set_port(sc->arg, &ctrl);
2390 if (error) {
2391 DPRINTF("%s: set mute err = %d\n", DEVNAME(sc), error)do {} while(0);
2392 return;
2393 }
2394 audio_event(sc, vol->mute);
2395 }
2396 if (vol->val >= 0 && val_pending) {
2397 ctrl.dev = vol->val;
2398 ctrl.type = AUDIO_MIXER_VALUE3;
2399 ctrl.un.value.num_channels = vol->nch;
2400 error = sc->ops->get_port(sc->arg, &ctrl);
2401 if (error) {
2402 DPRINTF("%s: get mute err = %d\n", DEVNAME(sc), error)do {} while(0);
2403 return;
2404 }
2405 for (i = 0; i < vol->nch; i++) {
2406 gain = ctrl.un.value.level[i] + vol->step * val_pending;
2407 if (gain > AUDIO_MAX_GAIN255)
2408 gain = AUDIO_MAX_GAIN255;
2409 else if (gain < AUDIO_MIN_GAIN0)
2410 gain = AUDIO_MIN_GAIN0;
2411 ctrl.un.value.level[i] = gain;
2412 DPRINTFN(1, "%s: wskbd level %d set to %d\n",do {} while(0)
2413 DEVNAME(sc), i, gain)do {} while(0);
2414 }
2415 error = sc->ops->set_port(sc->arg, &ctrl);
2416 if (error) {
2417 DPRINTF("%s: set vol err = %d\n", DEVNAME(sc), error)do {} while(0);
2418 return;
2419 }
2420 audio_event(sc, vol->val);
2421 }
2422}
2423
2424void
2425wskbd_mixer_cb(void *arg)
2426{
2427 struct audio_softc *sc = arg;
2428
2429 wskbd_mixer_update(sc, &sc->spkr);
2430 wskbd_mixer_update(sc, &sc->mic);
2431 device_unref(&sc->dev);
2432}
2433
2434int
2435wskbd_set_mixermute(long mute, long out)
2436{
2437 struct audio_softc *sc;
2438 struct wskbd_vol *vol;
2439
2440 sc = (struct audio_softc *)device_lookup(&audio_cd, 0);
2441 if (sc == NULL((void *)0))
2442 return ENODEV19;
2443 vol = out ? &sc->spkr : &sc->mic;
2444 vol->mute_pending = mute ? WSKBD_MUTE_ENABLE3 : WSKBD_MUTE_DISABLE2;
2445 if (!task_add(systq, &sc->wskbd_task))
2446 device_unref(&sc->dev);
2447 return 0;
2448}
2449
2450/*
2451 * Adjust the volume of the audio device associated with the given cookie.
2452 * Otherwise, fallback to audio0.
2453 */
2454int
2455wskbd_set_mixervolume_dev(void *cookie, long dir, long out)
2456{
2457 int unit = 0;
2458 int i;
2459
2460 for (i = 0; i < audio_cd.cd_ndevs; i++) {
2461 struct audio_softc *sc;
2462
2463 sc = (struct audio_softc *)device_lookup(&audio_cd, i);
2464 if (sc == NULL((void *)0))
2465 continue;
2466 if (sc->cookie != cookie) {
2467 device_unref(&sc->dev);
2468 continue;
2469 }
2470
2471 device_unref(&sc->dev);
2472 unit = i;
2473 break;
2474 }
2475
2476 return wskbd_set_mixervolume_unit(unit, dir, out);
2477}
2478
2479int
2480wskbd_set_mixervolume(long dir, long out)
2481{
2482 return wskbd_set_mixervolume_unit(0, dir, out);
2483}
2484
2485int
2486wskbd_set_mixervolume_unit(int unit, long dir, long out)
2487{
2488 struct audio_softc *sc;
2489 struct wskbd_vol *vol;
2490
2491 sc = (struct audio_softc *)device_lookup(&audio_cd, unit);
2492 if (sc == NULL((void *)0))
2493 return ENODEV19;
2494 vol = out ? &sc->spkr : &sc->mic;
2495 if (dir == 0)
2496 vol->mute_pending ^= WSKBD_MUTE_TOGGLE1;
2497 else
2498 vol->val_pending += dir;
2499 if (!task_add(systq, &sc->wskbd_task))
2500 device_unref(&sc->dev);
2501 return 0;
2502}
2503#endif /* NWSKBD > 0 */