Bug Summary

File:dev/usb/uaudio.c
Warning:line 992, column 16
The right operand of '<' is a garbage value

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name uaudio.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -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 -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 -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/lib/clang/13.0.0 -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/swsmu -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/powerplay -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/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 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 -D CONFIG_DRM_AMD_DC_DCN3_0 -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 -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 /usr/obj/sys/arch/amd64/compile/GENERIC.MP/scan-build/2022-01-12-131800-47421-1 -x c /usr/src/sys/dev/usb/uaudio.c
1/* $OpenBSD: uaudio.c,v 1.164 2022/01/09 05:43:00 jsg Exp $ */
2/*
3 * Copyright (c) 2018 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/*
18 * The USB Audio Class (UAC) defines what is an audio device and how
19 * to use it. There are two versions of the UAC: v1.0 and v2.0. They
20 * are not compatible with each other but they are close enough to
21 * attempt to have the same driver for both.
22 *
23 */
24#include <sys/param.h>
25#include <sys/types.h>
26#include <sys/device.h>
27#include <sys/errno.h>
28#include <sys/fcntl.h>
29#include <sys/malloc.h>
30#include <sys/systm.h>
31#include <sys/time.h>
32#include <sys/audioio.h>
33#include <machine/bus.h>
34#include <dev/audio_if.h>
35#include <dev/usb/usb.h>
36#include <dev/usb/usbdi.h>
37#include <dev/usb/usbdivar.h>
38#include <dev/usb/usb_mem.h>
39
40#ifdef UAUDIO_DEBUG
41#define DPRINTF(...)do {} while(0) \
42 do { \
43 if (uaudio_debug) \
44 printf(__VA_ARGS__); \
45 } while (0)
46#else
47#define DPRINTF(...)do {} while(0) do {} while(0)
48#endif
49
50#define DEVNAME(sc)((sc)->dev.dv_xname) ((sc)->dev.dv_xname)
51
52/*
53 * Isochronous endpoint usage (XXX: these belong to dev/usb/usb.h).
54 */
55#define UE_ISO_USAGE0x30 0x30
56#define UE_ISO_USAGE_DATA0x00 0x00
57#define UE_ISO_USAGE_FEEDBACK0x10 0x10
58#define UE_ISO_USAGE_IMPL0x20 0x20
59#define UE_GET_ISO_USAGE(a)((a) & 0x30) ((a) & UE_ISO_USAGE0x30)
60
61/*
62 * Max length of unit names
63 */
64#define UAUDIO_NAMEMAX16 MAX_AUDIO_DEV_LEN16
65
66/*
67 * USB audio class versions
68 */
69#define UAUDIO_V10x100 0x100
70#define UAUDIO_V20x200 0x200
71
72/*
73 * AC class-specific descriptor interface sub-type
74 */
75#define UAUDIO_AC_HEADER0x1 0x1
76#define UAUDIO_AC_INPUT0x2 0x2
77#define UAUDIO_AC_OUTPUT0x3 0x3
78#define UAUDIO_AC_MIXER0x4 0x4
79#define UAUDIO_AC_SELECTOR0x5 0x5
80#define UAUDIO_AC_FEATURE0x6 0x6
81#define UAUDIO_AC_EFFECT0x7 0x7
82#define UAUDIO_AC_PROCESSING0x8 0x8
83#define UAUDIO_AC_EXTENSION0x9 0x9
84#define UAUDIO_AC_CLKSRC0xa 0xa
85#define UAUDIO_AC_CLKSEL0xb 0xb
86#define UAUDIO_AC_CLKMULT0xc 0xc
87#define UAUDIO_AC_RATECONV0xd 0xd
88
89/*
90 * AS class-specific interface sub-types
91 */
92#define UAUDIO_AS_GENERAL0x1 0x1
93#define UAUDIO_AS_FORMAT0x2 0x2
94
95/*
96 * AS class-specific endpoint sub-type
97 */
98#define UAUDIO_EP_GENERAL0x1 0x1
99
100/*
101 * UAC v1 formats, wFormatTag is an enum
102 */
103#define UAUDIO_V1_FMT_PCM0x1 0x1
104#define UAUDIO_V1_FMT_PCM80x2 0x2
105#define UAUDIO_V1_FMT_FLOAT0x3 0x3
106#define UAUDIO_V1_FMT_ALAW0x4 0x4
107#define UAUDIO_V1_FMT_MULAW0x5 0x5
108
109/*
110 * UAC v2 formats, bmFormats is a bitmap
111 */
112#define UAUDIO_V2_FMT_PCM0x01 0x01
113#define UAUDIO_V2_FMT_PCM80x02 0x02
114#define UAUDIO_V2_FMT_FLOAT0x04 0x04
115#define UAUDIO_V2_FMT_ALAW0x08 0x08
116#define UAUDIO_V2_FMT_MULAW0x10 0x10
117
118/*
119 * AC requests
120 */
121#define UAUDIO_V1_REQ_SET_CUR0x01 0x01
122#define UAUDIO_V1_REQ_SET_MIN0x02 0x02
123#define UAUDIO_V1_REQ_SET_MAX0x03 0x03
124#define UAUDIO_V1_REQ_SET_RES0x04 0x04
125#define UAUDIO_V1_REQ_GET_CUR0x81 0x81
126#define UAUDIO_V1_REQ_GET_MIN0x82 0x82
127#define UAUDIO_V1_REQ_GET_MAX0x83 0x83
128#define UAUDIO_V1_REQ_GET_RES0x84 0x84
129#define UAUDIO_V2_REQ_CUR1 1
130#define UAUDIO_V2_REQ_RANGES2 2
131
132/*
133 * AC request "selector control"
134 */
135#define UAUDIO_V2_REQSEL_CLKFREQ1 1
136#define UAUDIO_V2_REQSEL_CLKSEL1 1
137
138/*
139 * AS class-specific endpoint attributes
140 */
141#define UAUDIO_EP_FREQCTL0x01 0x01
142
143/*
144 * AC feature control selectors (aka wValue in the request)
145 */
146#define UAUDIO_REQSEL_MUTE0x01 0x01
147#define UAUDIO_REQSEL_VOLUME0x02 0x02
148#define UAUDIO_REQSEL_BASS0x03 0x03
149#define UAUDIO_REQSEL_MID0x04 0x04
150#define UAUDIO_REQSEL_TREBLE0x05 0x05
151#define UAUDIO_REQSEL_EQ0x06 0x06
152#define UAUDIO_REQSEL_AGC0x07 0x07
153#define UAUDIO_REQSEL_DELAY0x08 0x08
154#define UAUDIO_REQSEL_BASSBOOST0x09 0x09
155#define UAUDIO_REQSEL_LOUDNESS0x0a 0x0a
156#define UAUDIO_REQSEL_GAIN0x0b 0x0b
157#define UAUDIO_REQSEL_GAINPAD0x0c 0x0c
158#define UAUDIO_REQSEL_PHASEINV0x0d 0x0d
159
160/*
161 * Endpoint (UAC v1) or clock-source unit (UAC v2) sample rate control
162 */
163#define UAUDIO_REQSEL_RATE0x01 0x01
164
165/*
166 * Samples-per-frame are fractions. UAC v2.0 requires the denominator to
167 * be multiple of 2^16, as used in the sync pipe. On the other hand, to
168 * represent sample-per-frame of all rates we support, we need the
169 * denominator to be such that (rate / 1000) can be represented exactly,
170 * 80 works. So we use the least common multiplier of both.
171 */
172#define UAUDIO_SPF_DIV327680 327680
173
174/*
175 * names of DAC and ADC unit names
176 */
177#define UAUDIO_NAME_PLAY"dac" "dac"
178#define UAUDIO_NAME_REC"record" "record"
179
180/*
181 * read/write pointers for secure sequential access of binary data,
182 * ex. usb descriptors, tables and alike. Bytes are read using the
183 * read pointer up to the write pointer.
184 */
185struct uaudio_blob {
186 unsigned char *rptr, *wptr;
187};
188
189/*
190 * Ranges of integer values used to represent controls values and
191 * sample frequencies.
192 */
193struct uaudio_ranges {
194 unsigned int nval;
195 struct uaudio_ranges_el {
196 struct uaudio_ranges_el *next;
197 int min, max, res;
198 } *el;
199};
200
201struct uaudio_softc {
202 struct device dev;
203 struct usbd_device *udev;
204 int version;
205
206 /*
207 * UAC exposes the device as a circuit of units. Input and
208 * output jacks are known as terminal units, others are
209 * processing units. The purpose of this driver is to give
210 * them reasonable names and expose them as mixer(1)
211 * controls. Control names are derived from the type of the
212 * unit and its role in the circuit.
213 *
214 * UAC v2.0 exposes also the clock circuitry using units, so
215 * selecting the sample rate also involves units usage.
216 */
217 struct uaudio_unit {
218 struct uaudio_unit *unit_next, *src_next, *dst_next;
219 struct uaudio_unit *src_list, *dst_list;
220 char name[UAUDIO_NAMEMAX16];
221 unsigned int nch;
222 int type, id;
223
224 /* terminal or clock type */
225 unsigned int term;
226
227 /* clock source, if a terminal or selector */
228 struct uaudio_unit *clock;
229
230 /* sample rates, if this is a clock source */
231 struct uaudio_ranges rates;
232
233 /* mixer(4) bits */
234#define UAUDIO_CLASS_OUT0 0
235#define UAUDIO_CLASS_IN1 1
236#define UAUDIO_CLASS_COUNT2 2
237 int mixer_class;
238 struct uaudio_mixent {
239 struct uaudio_mixent *next;
240 char *fname;
241#define UAUDIO_MIX_SW0 0
242#define UAUDIO_MIX_NUM1 1
243#define UAUDIO_MIX_ENUM2 2
244 int type;
245 int chan;
246 int req_sel;
247 struct uaudio_ranges ranges;
248 } *mixent_list;
249 } *unit_list;
250
251 /*
252 * Current clock, UAC v2.0 only
253 */
254 struct uaudio_unit *clock;
255
256 /*
257 * Number of input and output terminals
258 */
259 unsigned int nin, nout;
260
261 /*
262 * When unique names are needed, they are generated using a
263 * base string suffixed with a number. Ex. "spkr5". The
264 * following structure is used to keep track of strings we
265 * allocated.
266 */
267 struct uaudio_name {
268 struct uaudio_name *next;
269 char *templ;
270 unsigned int unit;
271 } *names;
272
273 /*
274 * Audio streaming (AS) alternate settings, i.e. stream format
275 * and USB-related parameters to use it.
276 */
277 struct uaudio_alt {
278 struct uaudio_alt *next;
279 int ifnum, altnum;
280 int mode; /* one of AUMODE_{RECORD,PLAY} */
281 int data_addr; /* data endpoint address */
282 int sync_addr; /* feedback endpoint address */
283 int maxpkt; /* max supported bytes per frame */
284 int fps; /* USB (micro-)frames per second */
285 int bps, bits, nch; /* audio encoding */
286 int v1_rates; /* if UAC 1.0, bitmap of rates */
287 } *alts;
288
289 /*
290 * Audio parameters: play and record stream formats usable
291 * together.
292 */
293 struct uaudio_params {
294 struct uaudio_params *next;
295 struct uaudio_alt *palt, *ralt;
296 int v1_rates;
297 } *params_list, *params;
298
299 /*
300 * One direction audio stream, aka "DMA" in progress
301 */
302 struct uaudio_stream {
303#define UAUDIO_NXFERS_MIN2 2
304#define UAUDIO_NXFERS_MAX8 8
305 struct uaudio_xfer {
306 struct usbd_xfer *usb_xfer;
307 unsigned char *buf;
308 uint16_t *sizes;
309 unsigned int size; /* bytes requested */
310 unsigned int nframes; /* frames requested */
311 } data_xfers[UAUDIO_NXFERS_MAX8], sync_xfers[UAUDIO_NXFERS_MAX8];
312
313 /*
314 * We don't use all the data_xfers[] entries because
315 * we can't schedule too many frames in the usb
316 * controller.
317 */
318 unsigned int nxfers;
319
320 unsigned int spf_remain; /* frac sample left */
321 unsigned int spf; /* avg samples per frame */
322 unsigned int spf_min, spf_max; /* allowed boundaries */
323
324 /*
325 * The max frame size we'll need (which may be lower
326 * than the maxpkt the usb pipe supports).
327 */
328 unsigned int maxpkt;
329
330 /*
331 * max number of frames per xfer we'll need
332 */
333 unsigned int nframes_max;
334
335 /*
336 * At usb2.0 speed, the number of (micro-)frames per
337 * transfer must correspond to 1ms, which is the usb1.1
338 * frame duration. This is required by lower level usb
339 * drivers.
340 *
341 * The nframes_mask variable is used to test if the
342 * number of frames per transfer is usable (by checking
343 * that least significant bits are zero). For instance,
344 * nframes_mask will be set to 0x0 on usb1.1 device and
345 * 0x7 on usb2.0 devices running at 8000 fps.
346 */
347 unsigned int nframes_mask;
348
349 unsigned int data_nextxfer, sync_nextxfer;
350 struct usbd_pipe *data_pipe;
351 struct usbd_pipe *sync_pipe;
352 void (*intr)(void *);
353 void *arg;
354
355 /* audio ring extents, passed to trigger() methods */
356 unsigned char *ring_start, *ring_end;
357
358 /* pointer to first byte available */
359 unsigned char *ring_pos;
360
361 /* audio(9) block size in bytes */
362 int ring_blksz;
363
364 /* xfer position relative to block boundary */
365 int ring_offs;
366
367 /*
368 * As USB sample-per-frame is not constant, we must
369 * schedule transfers slightly larger that one audio
370 * block. This is the "safe" block size, that ensures
371 * the transfer will cross the audio block boundary.
372 */
373 int safe_blksz;
374
375 /*
376 * Number of bytes completed, when it reaches a
377 * block size, we fire an audio(9) interrupt.
378 */
379 int ring_icnt;
380
381 /*
382 * USB transfers are used as a FIFO which is the
383 * concatenation of all transfers. This is the write
384 * (read) position of the play (rec) stream
385 */
386 unsigned int ubuf_xfer; /* xfer index */
387 unsigned int ubuf_pos; /* offset in bytes */
388 } pstream, rstream;
389
390 int ctl_ifnum; /* aka AC interface */
391
392 int mode; /* open() mode */
393 int trigger_mode; /* trigger() mode */
394
395 unsigned int rate; /* current sample rate */
396 unsigned int ufps; /* USB frames per second */
397 unsigned int sync_pktsz; /* size of sync packet */
398 unsigned int host_nframes; /* max frames we can schedule */
399
400 int diff_nsamp; /* samples play is ahead of rec */
401 int diff_nframes; /* frames play is ahead of rec */
402 unsigned int adjspf_age; /* frames since last uaudio_adjspf */
403
404 /*
405 * bytes pending to be copied to transfer buffer. This is play
406 * only, as recorded frames are copied as soon they are
407 * received.
408 */
409 size_t copy_todo;
410};
411
412int uaudio_match(struct device *, void *, void *);
413void uaudio_attach(struct device *, struct device *, void *);
414int uaudio_detach(struct device *, int);
415
416int uaudio_open(void *, int);
417void uaudio_close(void *);
418int uaudio_set_params(void *, int, int, struct audio_params *,
419 struct audio_params *);
420unsigned int uaudio_set_blksz(void *, int,
421 struct audio_params *, struct audio_params *, unsigned int);
422int uaudio_trigger_output(void *, void *, void *, int,
423 void (*)(void *), void *, struct audio_params *);
424int uaudio_trigger_input(void *, void *, void *, int,
425 void (*)(void *), void *, struct audio_params *);
426void uaudio_copy_output(void *, size_t);
427void uaudio_underrun(void *);
428int uaudio_halt_output(void *);
429int uaudio_halt_input(void *);
430int uaudio_query_devinfo(void *, struct mixer_devinfo *);
431int uaudio_get_port(void *, struct mixer_ctrl *);
432int uaudio_set_port(void *, struct mixer_ctrl *);
433int uaudio_get_props(void *);
434
435int uaudio_process_unit(struct uaudio_softc *,
436 struct uaudio_unit *, int,
437 struct uaudio_blob,
438 struct uaudio_unit **);
439
440void uaudio_pdata_intr(struct usbd_xfer *, void *, usbd_status);
441void uaudio_rdata_intr(struct usbd_xfer *, void *, usbd_status);
442void uaudio_psync_intr(struct usbd_xfer *, void *, usbd_status);
443
444#ifdef UAUDIO_DEBUG
445char *uaudio_isoname(int isotype);
446char *uaudio_modename(int mode);
447char *uaudio_usagename(int usage);
448void uaudio_rates_print(int rates);
449void uaudio_ranges_print(struct uaudio_ranges *r);
450void uaudio_print_unit(struct uaudio_softc *sc, struct uaudio_unit *u);
451void uaudio_mixer_print(struct uaudio_softc *sc);
452void uaudio_conf_print(struct uaudio_softc *sc);
453
454/*
455 * 0 - nothing, same as if UAUDIO_DEBUG isn't defined
456 * 1 - initialisations & setup
457 * 2 - audio(4) calls
458 * 3 - transfers
459 */
460int uaudio_debug = 1;
461#endif
462
463struct cfdriver uaudio_cd = {
464 NULL((void *)0), "uaudio", DV_DULL
465};
466
467const struct cfattach uaudio_ca = {
468 sizeof(struct uaudio_softc), uaudio_match, uaudio_attach, uaudio_detach
469};
470
471struct audio_hw_if uaudio_hw_if = {
472 uaudio_open, /* open */
473 uaudio_close, /* close */
474 uaudio_set_params, /* set_params */
475 NULL((void *)0), /* round_blocksize */
476 NULL((void *)0), /* commit_settings */
477 NULL((void *)0), /* init_output */
478 NULL((void *)0), /* init_input */
479 NULL((void *)0), /* start_output */
480 NULL((void *)0), /* start_input */
481 uaudio_halt_output, /* halt_output */
482 uaudio_halt_input, /* halt_input */
483 NULL((void *)0), /* speaker_ctl */
484 NULL((void *)0), /* setfd */
485 uaudio_set_port, /* set_port */
486 uaudio_get_port, /* get_port */
487 uaudio_query_devinfo, /* query_devinfo */
488 NULL((void *)0), /* malloc, we use bounce buffers :'( */
489 NULL((void *)0), /* free */
490 NULL((void *)0), /* round_buffersize */
491 uaudio_get_props, /* get_props */
492 uaudio_trigger_output, /* trigger_output */
493 uaudio_trigger_input, /* trigger_input */
494 uaudio_copy_output, /* copy_output */
495 uaudio_underrun, /* underrun */
496 uaudio_set_blksz /* set_blksz */
497};
498
499/*
500 * To keep things simple, we support only the following rates, we
501 * don't care about continuous sample rates or other "advanced"
502 * features which complicate implementation.
503 */
504int uaudio_rates[] = {
505 8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000,
506 64000, 88200, 96000, 128000, 176400, 192000
507};
508
509/*
510 * Convert 8, 16, or 24-bit signed value to an int by expanding the
511 * sign bit.
512 */
513int
514uaudio_sign_expand(unsigned int val, int opsize)
515{
516 unsigned int s;
517
518 s = 1 << (8 * opsize - 1);
519 return (val ^ s) - s;
520}
521
522int
523uaudio_req(struct uaudio_softc *sc,
524 unsigned int type,
525 unsigned int req,
526 unsigned int sel,
527 unsigned int chan,
528 unsigned int ifnum,
529 unsigned int id,
530 unsigned char *buf,
531 size_t size)
532{
533 struct usb_device_request r;
534 int err;
535
536 r.bmRequestType = type;
537 r.bRequest = req;
538 USETW(r.wValue, sel << 8 | chan)(*(u_int16_t *)(r.wValue) = (sel << 8 | chan));
539 USETW(r.wIndex, id << 8 | ifnum)(*(u_int16_t *)(r.wIndex) = (id << 8 | ifnum));
540 USETW(r.wLength, size)(*(u_int16_t *)(r.wLength) = (size));
541
542 DPRINTF("%s: type = 0x%x, req = 0x%x, val = 0x%x, "do {} while(0)
543 "index = 0x%x, size = %d\n", __func__,do {} while(0)
544 type, req, UGETW(r.wValue), UGETW(r.wIndex), UGETW(r.wLength))do {} while(0);
545
546 err = usbd_do_request(sc->udev, &r, buf);
547 if (err) {
548 DPRINTF("%s: failed: %s\n", __func__, usbd_errstr(err))do {} while(0);
549 return 0;
550 }
551 return 1;
552}
553
554/*
555 * Read a number of the given size (in bytes) from the given
556 * blob. Return 0 on error.
557 */
558int
559uaudio_getnum(struct uaudio_blob *p, unsigned int size, unsigned int *ret)
560{
561 unsigned int i, num = 0;
562
563 if (p->wptr - p->rptr < size) {
564 DPRINTF("%s: %d: too small\n", __func__, size)do {} while(0);
565 return 0;
566 }
567
568 for (i = 0; i < size; i++)
569 num |= *p->rptr++ << (8 * i);
570
571 if (ret)
572 *ret = num;
573 return 1;
574}
575
576/*
577 * Read a USB descriptor from the given blob. Return 0 on error.
578 */
579int
580uaudio_getdesc(struct uaudio_blob *p, struct uaudio_blob *ret)
581{
582 unsigned int size;
583
584 if (!uaudio_getnum(p, 1, &size))
585 return 0;
586 if (size-- == 0) {
587 DPRINTF("%s: zero sized desc\n", __func__)do {} while(0);
588 return 0;
589 }
590 if (p->wptr - p->rptr < size) {
591 DPRINTF("%s: too small\n", __func__)do {} while(0);
592 return 0;
593 }
594 ret->rptr = p->rptr;
595 ret->wptr = p->rptr + size;
596 p->rptr += size;
597 return 1;
598}
599
600/*
601 * Find the unit with the given id, return NULL if not found.
602 */
603struct uaudio_unit *
604uaudio_unit_byid(struct uaudio_softc *sc, unsigned int id)
605{
606 struct uaudio_unit *u;
607
608 for (u = sc->unit_list; u != NULL((void *)0); u = u->unit_next) {
609 if (u->id == id)
610 break;
611 }
612 return u;
613}
614
615/*
616 * Return a terminal name for the given terminal type.
617 */
618char *
619uaudio_tname(struct uaudio_softc *sc, unsigned int type, int isout)
620{
621 unsigned int hi, lo;
622 char *name;
623
624 hi = type >> 8;
625 lo = type & 0xff;
626
627 /* usb data stream */
628 if (hi == 1)
629 return isout ? UAUDIO_NAME_REC"record" : UAUDIO_NAME_PLAY"dac";
630
631 /* if there is only one input (output) use "input" ("output") */
632 if (isout) {
633 if (sc->nout == 1)
634 return "output";
635 } else {
636 if (sc->nin == 1)
637 return "input";
638 }
639
640 /* determine name from USB terminal type */
641 switch (hi) {
642 case 2:
643 /* embedded inputs */
644 name = isout ? "mic-out" : "mic";
645 break;
646 case 3:
647 /* embedded outputs, mostly speakers, except 0x302 */
648 switch (lo) {
649 case 0x02:
650 name = isout ? "hp" : "hp-in";
651 break;
652 default:
653 name = isout ? "spkr" : "spkr-in";
654 break;
655 }
656 break;
657 case 4:
658 /* handsets and headset */
659 name = isout ? "spkr" : "mic";
660 break;
661 case 5:
662 /* phone line */
663 name = isout ? "phone-in" : "phone-out";
664 break;
665 case 6:
666 /* external sources/sinks */
667 switch (lo) {
668 case 0x02:
669 case 0x05:
670 case 0x06:
671 case 0x07:
672 case 0x09:
673 case 0x0a:
674 name = isout ? "dig-out" : "dig-in";
675 break;
676 default:
677 name = isout ? "line-out" : "line-in";
678 break;
679 }
680 break;
681 case 7:
682 /* internal devices */
683 name = isout ? "int-out" : "int-in";
684 break;
685 default:
686 name = isout ? "unk-out" : "unk-in";
687 }
688 return name;
689}
690
691/*
692 * Return a clock name for the given clock type.
693 */
694char *
695uaudio_clkname(unsigned int attr)
696{
697 static char *names[] = {"ext", "fixed", "var", "prog"};
698
699 return names[attr & 3];
700}
701
702/*
703 * Return an unique name for the given template.
704 */
705void
706uaudio_mkname(struct uaudio_softc *sc, char *templ, char *res)
707{
708 struct uaudio_name *n;
709 char *sep;
710
711 /*
712 * if this is not a terminal name (i.e. there's a underscore
713 * in the name, like in "spkr2_mic3"), then use underscore as
714 * separator to avoid concatenating two numbers
715 */
716 sep = strchr(templ, '_') != NULL((void *)0) ? "_" : "";
717
718 n = sc->names;
719 while (1) {
720 if (n == NULL((void *)0)) {
721 n = malloc(sizeof(struct uaudio_name),
722 M_USBDEV102, M_WAITOK0x0001);
723 n->templ = templ;
724 n->unit = 0;
725 n->next = sc->names;
726 sc->names = n;
727 }
728 if (strcmp(n->templ, templ) == 0)
729 break;
730 n = n->next;
731 }
732 if (n->unit == 0)
733 snprintf(res, UAUDIO_NAMEMAX16, "%s", templ);
734 else
735 snprintf(res, UAUDIO_NAMEMAX16, "%s%s%u", templ, sep, n->unit);
736 n->unit++;
737}
738
739/*
740 * Convert UAC v1.0 feature bitmap to UAC v2.0 feature bitmap.
741 */
742unsigned int
743uaudio_feature_fixup(struct uaudio_softc *sc, unsigned int ctl)
744{
745 int i;
746 unsigned int bits, n;
747
748 switch (sc->version) {
749 case UAUDIO_V10x100:
750 n = 0;
751 for (i = 0; i < 16; i++) {
752 bits = (ctl >> i) & 1;
753 if (bits)
754 bits |= 2;
755 n |= bits << (2 * i);
756 }
757 return n;
758 case UAUDIO_V20x200:
759 break;
760 }
761 return ctl;
762}
763
764/*
765 * Initialize a uaudio_ranges to the empty set
766 */
767void
768uaudio_ranges_init(struct uaudio_ranges *r)
769{
770 r->el = NULL((void *)0);
771 r->nval = 0;
772}
773
774/*
775 * Add the given range to the uaudio_ranges structures. Ranges are
776 * not supposed to overlap (required by USB spec). If they do we just
777 * return.
778 */
779void
780uaudio_ranges_add(struct uaudio_ranges *r, int min, int max, int res)
781{
782 struct uaudio_ranges_el *e, **pe;
783
784 if (min > max) {
785 DPRINTF("%s: [%d:%d]/%d: bad range\n", __func__,do {} while(0)
786 min, max, res)do {} while(0);
787 return;
788 }
789
790 for (pe = &r->el; (e = *pe) != NULL((void *)0); pe = &e->next) {
791 if (min <= e->max && max >= e->min) {
792 DPRINTF("%s: overlapping ranges\n", __func__)do {} while(0);
793 return;
794 }
795 if (min < e->max)
796 break;
797 }
798
799 /* XXX: use 'res' here */
800 r->nval += max - min + 1;
801
802 e = malloc(sizeof(struct uaudio_ranges_el), M_USBDEV102, M_WAITOK0x0001);
803 e->min = min;
804 e->max = max;
805 e->res = res;
806 e->next = *pe;
807 *pe = e;
808}
809
810/*
811 * Free all ranges making the uaudio_ranges the empty set
812 */
813void
814uaudio_ranges_clear(struct uaudio_ranges *r)
815{
816 struct uaudio_ranges_el *e;
817
818 while ((e = r->el) != NULL((void *)0)) {
819 r->el = e->next;
820 free(e, M_USBDEV102, sizeof(struct uaudio_ranges_el));
821 }
822 r->nval = 0;
823}
824
825/*
826 * Convert a value in the given uaudio_ranges, into a 0..255 integer
827 * suitable for mixer usage
828 */
829int
830uaudio_ranges_decode(struct uaudio_ranges *r, int val)
831{
832 struct uaudio_ranges_el *e;
833 int diff, pos;
834
835 pos = 0;
836
837 for (e = r->el; e != NULL((void *)0); e = e->next) {
838 if (val >= e->min && val <= e->max) {
839 pos += val - e->min;
840 return (r->nval == 1) ? 0 :
841 (pos * 255 + (r->nval - 1) / 2) / (r->nval - 1);
842 }
843 diff = e->max - e->min + 1;
844 pos += diff;
845 }
846 return 0;
847}
848
849/*
850 * Convert a 0..255 to a value in the uaudio_ranges suitable for a USB
851 * request.
852 */
853unsigned int
854uaudio_ranges_encode(struct uaudio_ranges *r, int val)
855{
856 struct uaudio_ranges_el *e;
857 int diff, pos;
858
859 pos = (val * (r->nval - 1) + 127) / 255;
860
861 for (e = r->el; e != NULL((void *)0); e = e->next) {
862 diff = e->max - e->min + 1;
863 if (pos < diff)
864 return e->min + pos;
865 pos -= diff;
866 }
867 return 0;
868}
869
870/*
871 * Return the bitmap of supported rates included in the given ranges.
872 * This is not a mixer thing, UAC v2.0 uses ranges to report sample
873 * rates.
874 */
875int
876uaudio_ranges_getrates(struct uaudio_ranges *r,
877 unsigned int mult, unsigned int div)
878{
879 struct uaudio_ranges_el *e;
880 int rates, i, v;
881
882 rates = 0;
883
884 for (e = r->el; e != NULL((void *)0); e = e->next) {
885 for (i = 0; i < nitems(uaudio_rates)(sizeof((uaudio_rates)) / sizeof((uaudio_rates)[0])); i++) {
886 v = (unsigned long long)uaudio_rates[i] * mult / div;
887 if (v < e->min || v > e->max)
888 continue;
889 if (e->res == 0 || v - e->min % e->res == 0)
890 rates |= 1 << i;
891 }
892 }
893
894 return rates;
895}
896
897/*
898 * Return the index in the uaudio_rates[] array of rate closest to the
899 * given rate in Hz.
900 */
901int
902uaudio_rates_indexof(int mask, int rate)
903{
904 int i, diff, best_index, best_diff;
905
906 best_index = -1;
907 best_diff = INT_MAX0x7fffffff;
908 for (i = 0; i < nitems(uaudio_rates)(sizeof((uaudio_rates)) / sizeof((uaudio_rates)[0])); i++) {
909 if ((mask & (1 << i)) == 0)
910 continue;
911 diff = uaudio_rates[i] - rate;
912 if (diff < 0)
913 diff = -diff;
914 if (diff < best_diff) {
915 best_index = i;
916 best_diff = diff;
917 }
918 }
919 return best_index;
920}
921
922/*
923 * Do a request that results in a uaudio_ranges. On UAC v1.0, this is
924 * simply a min/max/res triplet. On UAC v2.0, this is an array of
925 * min/max/res triplets.
926 */
927int
928uaudio_req_ranges(struct uaudio_softc *sc,
929 unsigned int opsize,
930 unsigned int sel,
931 unsigned int chan,
932 unsigned int ifnum,
933 unsigned int id,
934 struct uaudio_ranges *r)
935{
936 unsigned char req_buf[16], *req = NULL((void *)0);
937 size_t req_size;
938 struct uaudio_blob p;
939 unsigned int count, min, max, res;
96
'count' declared without an initial value
940 int i;
941
942 switch (sc->version) {
97
'Default' branch taken. Execution continues on line 992
943 case UAUDIO_V10x100:
944 count = 1;
945 req = req_buf;
946 p.rptr = p.wptr = req;
947 if (!uaudio_req(sc, UT_READ_CLASS_INTERFACE(0x80 | 0x20 | 0x01),
948 UAUDIO_V1_REQ_GET_MIN0x82, sel, chan,
949 ifnum, id, p.wptr, opsize))
950 return 0;
951 p.wptr += opsize;
952 if (!uaudio_req(sc, UT_READ_CLASS_INTERFACE(0x80 | 0x20 | 0x01),
953 UAUDIO_V1_REQ_GET_MAX0x83, sel, chan,
954 ifnum, id, p.wptr, opsize))
955 return 0;
956 p.wptr += opsize;
957 if (!uaudio_req(sc, UT_READ_CLASS_INTERFACE(0x80 | 0x20 | 0x01),
958 UAUDIO_V1_REQ_GET_RES0x84, sel, chan,
959 ifnum, id, p.wptr, opsize))
960 return 0;
961 p.wptr += opsize;
962 break;
963 case UAUDIO_V20x200:
964 /* fetch the ranges count only (first 2 bytes) */
965 if (!uaudio_req(sc, UT_READ_CLASS_INTERFACE(0x80 | 0x20 | 0x01),
966 UAUDIO_V2_REQ_RANGES2, sel, chan,
967 ifnum, id, req_buf, 2))
968 return 0;
969
970 /* count is at most 65535 */
971 count = req_buf[0] | req_buf[1] << 8;
972
973 /* restart the request on a large enough buffer */
974 req_size = 2 + 3 * opsize * count;
975 if (sizeof(req_buf) >= req_size)
976 req = req_buf;
977 else
978 req = malloc(req_size, M_USBDEV102, M_WAITOK0x0001);
979
980 p.rptr = p.wptr = req;
981 if (!uaudio_req(sc, UT_READ_CLASS_INTERFACE(0x80 | 0x20 | 0x01),
982 UAUDIO_V2_REQ_RANGES2, sel, chan,
983 ifnum, id, p.wptr, req_size))
984 return 0;
985 p.wptr += req_size;
986
987 /* skip initial 2 bytes of count */
988 p.rptr += 2;
989 break;
990 }
991
992 for (i = 0; i < count; i++) {
98
The right operand of '<' is a garbage value
993 if (!uaudio_getnum(&p, opsize, &min))
994 return 0;
995 if (!uaudio_getnum(&p, opsize, &max))
996 return 0;
997 if (!uaudio_getnum(&p, opsize, &res))
998 return 0;
999 uaudio_ranges_add(r,
1000 uaudio_sign_expand(min, opsize),
1001 uaudio_sign_expand(max, opsize),
1002 uaudio_sign_expand(res, opsize));
1003 }
1004
1005 if (req != req_buf)
1006 free(req, M_USBDEV102, req_size);
1007
1008 return 1;
1009}
1010
1011/*
1012 * Return the rates bitmap of the given interface alt setting
1013 */
1014int
1015uaudio_alt_getrates(struct uaudio_softc *sc, struct uaudio_alt *p)
1016{
1017 struct uaudio_unit *u;
1018 unsigned int mult = 1, div = 1;
1019
1020 switch (sc->version) {
1021 case UAUDIO_V10x100:
1022 return p->v1_rates;
1023 case UAUDIO_V20x200:
1024 u = sc->clock;
1025 while (1) {
1026 switch (u->type) {
1027 case UAUDIO_AC_CLKSRC0xa:
1028 return uaudio_ranges_getrates(&u->rates,
1029 mult, div);
1030 case UAUDIO_AC_CLKSEL0xb:
1031 u = u->clock;
1032 break;
1033 case UAUDIO_AC_CLKMULT0xc:
1034 case UAUDIO_AC_RATECONV0xd:
1035 /* XXX: adjust rate with multiplier */
1036 u = u->src_list;
1037 break;
1038 default:
1039 DPRINTF("%s: no clock\n", __func__)do {} while(0);
1040 return 0;
1041 }
1042 }
1043 }
1044 return 0;
1045}
1046
1047/*
1048 * return the clock unit of the given terminal unit (v2 only)
1049 */
1050int
1051uaudio_clock_id(struct uaudio_softc *sc)
1052{
1053 struct uaudio_unit *u;
1054
1055 u = sc->clock;
1056 while (1) {
1057 if (u == NULL((void *)0)) {
1058 DPRINTF("%s: NULL clock pointer\n", __func__)do {} while(0);
1059 return -1;
1060 }
1061 switch (u->type) {
1062 case UAUDIO_AC_CLKSRC0xa:
1063 return u->id;
1064 case UAUDIO_AC_CLKSEL0xb:
1065 u = u->clock;
1066 break;
1067 case UAUDIO_AC_CLKMULT0xc:
1068 case UAUDIO_AC_RATECONV0xd:
1069 u = u->src_list;
1070 break;
1071 default:
1072 DPRINTF("%s: no clock\n", __func__)do {} while(0);
1073 return -1;
1074 }
1075 }
1076}
1077
1078/*
1079 * Return the rates bitmap of the given parameters setting
1080 */
1081int
1082uaudio_getrates(struct uaudio_softc *sc, struct uaudio_params *p)
1083{
1084 switch (sc->version) {
1085 case UAUDIO_V10x100:
1086 return p->v1_rates;
1087 case UAUDIO_V20x200:
1088 return uaudio_alt_getrates(sc, p->palt ? p->palt : p->ralt);
1089 }
1090 return 0;
1091}
1092
1093/*
1094 * Add the given feature (aka mixer control) to the given unit.
1095 */
1096void
1097uaudio_feature_addent(struct uaudio_softc *sc,
1098 struct uaudio_unit *u, int uac_type, int chan)
1099{
1100 static struct {
1101 char *name;
1102 int mix_type;
1103 int req_sel;
1104 } features[] = {
1105 {"mute", UAUDIO_MIX_SW0, UAUDIO_REQSEL_MUTE0x01},
1106 {"level", UAUDIO_MIX_NUM1, UAUDIO_REQSEL_VOLUME0x02},
1107 {"bass", UAUDIO_MIX_NUM1, UAUDIO_REQSEL_BASS0x03},
1108 {"mid", UAUDIO_MIX_NUM1, UAUDIO_REQSEL_MID0x04},
1109 {"treble", UAUDIO_MIX_NUM1, UAUDIO_REQSEL_TREBLE0x05},
1110 {"eq", UAUDIO_MIX_NUM1, UAUDIO_REQSEL_EQ0x06},
1111 {"agc", UAUDIO_MIX_SW0, UAUDIO_REQSEL_AGC0x07},
1112 {NULL((void *)0), -1, -1}, /* delay */
1113 {"bassboost", UAUDIO_MIX_SW0, UAUDIO_REQSEL_BASSBOOST0x09},
1114 {"loud", UAUDIO_MIX_SW0, UAUDIO_REQSEL_LOUDNESS0x0a},
1115 {"gain", UAUDIO_MIX_NUM1, UAUDIO_REQSEL_GAIN0x0b},
1116 {"gainpad", UAUDIO_MIX_SW0, UAUDIO_REQSEL_GAINPAD0x0c},
1117 {"phase", UAUDIO_MIX_SW0, UAUDIO_REQSEL_PHASEINV0x0d},
1118 {NULL((void *)0), -1, -1}, /* underflow */
1119 {NULL((void *)0), -1, -1} /* overflow */
1120 };
1121 struct uaudio_mixent *m, *i, **pi;
1122 int cmp;
1123
1124 if (uac_type >= sizeof(features) / sizeof(features[0])) {
1125 printf("%s: skipped unknown feature\n", DEVNAME(sc)((sc)->dev.dv_xname));
1126 return;
1127 }
1128
1129 m = malloc(sizeof(struct uaudio_mixent), M_USBDEV102, M_WAITOK0x0001);
1130 m->chan = chan;
1131 m->fname = features[uac_type].name;
1132 m->type = features[uac_type].mix_type;
1133 m->req_sel = features[uac_type].req_sel;
1134 uaudio_ranges_init(&m->ranges);
1135
1136 if (m->type == UAUDIO_MIX_NUM1) {
1137 if (!uaudio_req_ranges(sc, 2,
1138 m->req_sel, chan < 0 ? 0 : chan + 1,
1139 sc->ctl_ifnum, u->id,
1140 &m->ranges)) {
1141 printf("%s: failed to get ranges for %s control\n",
1142 DEVNAME(sc)((sc)->dev.dv_xname), m->fname);
1143 free(m, M_USBDEV102, sizeof(struct uaudio_mixent));
1144 return;
1145 }
1146 if (m->ranges.el == NULL((void *)0)) {
1147 printf("%s: skipped %s control with empty range\n",
1148 DEVNAME(sc)((sc)->dev.dv_xname), m->fname);
1149 free(m, M_USBDEV102, sizeof(struct uaudio_mixent));
1150 return;
1151 }
1152#ifdef UAUDIO_DEBUG
1153 if (uaudio_debug)
1154 uaudio_ranges_print(&m->ranges);
1155#endif
1156 }
1157
1158 /*
1159 * Add to unit's mixer controls list, sorting entries by name
1160 * and increasing channel number.
1161 */
1162 for (pi = &u->mixent_list; (i = *pi) != NULL((void *)0); pi = &i->next) {
1163 cmp = strcmp(i->fname, m->fname);
1164 if (cmp == 0)
1165 cmp = i->chan - m->chan;
1166 if (cmp == 0) {
1167 DPRINTF("%02u: %s.%s: duplicate feature for chan %d\n",do {} while(0)
1168 u->id, u->name, m->fname, m->chan)do {} while(0);
1169 free(m, M_USBDEV102, sizeof(struct uaudio_mixent));
1170 return;
1171 }
1172 if (cmp > 0)
1173 break;
1174 }
1175 m->next = *pi;
1176 *pi = m;
1177
1178 DPRINTF("\t%s[%d]\n", m->fname, m->chan)do {} while(0);
1179}
1180
1181/*
1182 * For the given unit, parse the list of its sources and recursively
1183 * call uaudio_process_unit() for each.
1184 */
1185int
1186uaudio_process_srcs(struct uaudio_softc *sc,
1187 struct uaudio_unit *u, struct uaudio_blob units,
1188 struct uaudio_blob *p)
1189{
1190 struct uaudio_unit *s, **ps;
1191 unsigned int i, npin, sid;
1192
1193 if (!uaudio_getnum(p, 1, &npin))
1194 return 0;
1195 ps = &u->src_list;
1196 for (i = 0; i < npin; i++) {
1197 if (!uaudio_getnum(p, 1, &sid))
1198 return 0;
1199 if (!uaudio_process_unit(sc, u, sid, units, &s))
1200 return 0;
1201 s->src_next = NULL((void *)0);
1202 *ps = s;
1203 ps = &s->src_next;
1204 }
1205 return 1;
1206}
1207
1208/*
1209 * Parse the number of channels.
1210 */
1211int
1212uaudio_process_nch(struct uaudio_softc *sc,
1213 struct uaudio_unit *u, struct uaudio_blob *p)
1214{
1215 if (!uaudio_getnum(p, 1, &u->nch))
1216 return 0;
1217 /* skip junk */
1218 switch (sc->version) {
1219 case UAUDIO_V10x100:
1220 if (!uaudio_getnum(p, 2, NULL((void *)0))) /* bmChannelConfig */
1221 return 0;
1222 break;
1223 case UAUDIO_V20x200:
1224 if (!uaudio_getnum(p, 4, NULL((void *)0))) /* wChannelConfig */
1225 return 0;
1226 break;
1227 }
1228 if (!uaudio_getnum(p, 1, NULL((void *)0))) /* iChannelNames */
1229 return 0;
1230 return 1;
1231}
1232
1233/*
1234 * Find the AC class-specific descriptor for this unit id.
1235 */
1236int
1237uaudio_unit_getdesc(struct uaudio_softc *sc, int id,
1238 struct uaudio_blob units,
1239 struct uaudio_blob *p,
1240 unsigned int *rtype)
1241{
1242 unsigned int i, type, subtype;
1243
1244 /*
1245 * Find the usb descriptor for this id.
1246 */
1247 while (1) {
1248 if (units.rptr == units.wptr) {
1249 DPRINTF("%s: %02u: not found\n", __func__, id)do {} while(0);
1250 return 0;
1251 }
1252 if (!uaudio_getdesc(&units, p))
1253 return 0;
1254 if (!uaudio_getnum(p, 1, &type))
1255 return 0;
1256 if (!uaudio_getnum(p, 1, &subtype))
1257 return 0;
1258 if (!uaudio_getnum(p, 1, &i))
1259 return 0;
1260 if (i == id)
1261 break;
1262 }
1263 *rtype = subtype;
1264 return 1;
1265}
1266
1267/*
1268 * Parse a unit, possibly calling uaudio_process_unit() for each of
1269 * its sources.
1270 */
1271int
1272uaudio_process_unit(struct uaudio_softc *sc,
1273 struct uaudio_unit *dest, int id,
1274 struct uaudio_blob units,
1275 struct uaudio_unit **rchild)
1276{
1277 struct uaudio_blob p;
1278 struct uaudio_unit *u, *s;
1279 unsigned int i, j, size, ctl, type, subtype, assoc, clk;
1280#ifdef UAUDIO_DEBUG
1281 unsigned int bit;
1282#endif
1283
1284 if (!uaudio_unit_getdesc(sc, id, units, &p, &subtype))
1285 return 0;
1286
1287 /*
1288 * find this unit on the list as it may be already processed as
1289 * the source of another destination
1290 */
1291 u = uaudio_unit_byid(sc, id);
1292 if (u == NULL((void *)0)) {
1293 u = malloc(sizeof(struct uaudio_unit), M_USBDEV102, M_WAITOK0x0001);
1294 u->id = id;
1295 u->type = subtype;
1296 u->term = 0;
1297 u->src_list = NULL((void *)0);
1298 u->dst_list = NULL((void *)0);
1299 u->clock = NULL((void *)0);
1300 u->mixent_list = NULL((void *)0);
1301 u->nch = 0;
1302 u->name[0] = 0;
1303 uaudio_ranges_init(&u->rates);
1304 u->unit_next = sc->unit_list;
1305 sc->unit_list = u;
1306 } else {
1307 switch (u->type) {
1308 case UAUDIO_AC_CLKSRC0xa:
1309 case UAUDIO_AC_CLKSEL0xb:
1310 case UAUDIO_AC_CLKMULT0xc:
1311 case UAUDIO_AC_RATECONV0xd:
1312 /* not using 'dest' list */
1313 *rchild = u;
1314 return 1;
1315 }
1316 }
1317
1318 if (dest) {
1319 dest->dst_next = u->dst_list;
1320 u->dst_list = dest;
1321 if (dest->dst_next != NULL((void *)0)) {
1322 /* already seen */
1323 *rchild = u;
1324 return 1;
1325 }
1326 }
1327
1328 switch (u->type) {
1329 case UAUDIO_AC_INPUT0x2:
1330 if (!uaudio_getnum(&p, 2, &u->term))
1331 return 0;
1332 if (!uaudio_getnum(&p, 1, &assoc))
1333 return 0;
1334 if (u->term >> 8 != 1)
1335 sc->nin++;
1336 switch (sc->version) {
1337 case UAUDIO_V10x100:
1338 break;
1339 case UAUDIO_V20x200:
1340 if (!uaudio_getnum(&p, 1, &clk))
1341 return 0;
1342 if (!uaudio_process_unit(sc, NULL((void *)0),
1343 clk, units, &u->clock))
1344 return 0;
1345 break;
1346 }
1347 if (!uaudio_getnum(&p, 1, &u->nch))
1348 return 0;
1349 DPRINTF("%02u: "do {} while(0)
1350 "in, nch = %d, term = 0x%x, assoc = %d\n",do {} while(0)
1351 u->id, u->nch, u->term, assoc)do {} while(0);
1352 break;
1353 case UAUDIO_AC_OUTPUT0x3:
1354 if (!uaudio_getnum(&p, 2, &u->term))
1355 return 0;
1356 if (!uaudio_getnum(&p, 1, &assoc))
1357 return 0;
1358 if (!uaudio_getnum(&p, 1, &id))
1359 return 0;
1360 if (!uaudio_process_unit(sc, u, id, units, &s))
1361 return 0;
1362 if (u->term >> 8 != 1)
1363 sc->nout++;
1364 switch (sc->version) {
1365 case UAUDIO_V10x100:
1366 break;
1367 case UAUDIO_V20x200:
1368 if (!uaudio_getnum(&p, 1, &clk))
1369 return 0;
1370 if (!uaudio_process_unit(sc, NULL((void *)0),
1371 clk, units, &u->clock))
1372 return 0;
1373 break;
1374 }
1375 u->src_list = s;
1376 s->src_next = NULL((void *)0);
1377 u->nch = s->nch;
1378 DPRINTF("%02u: "do {} while(0)
1379 "out, id = %d, nch = %d, term = 0x%x, assoc = %d\n",do {} while(0)
1380 u->id, id, u->nch, u->term, assoc)do {} while(0);
1381 break;
1382 case UAUDIO_AC_MIXER0x4:
1383 if (!uaudio_process_srcs(sc, u, units, &p))
1384 return 0;
1385 if (!uaudio_process_nch(sc, u, &p))
1386 return 0;
1387 DPRINTF("%02u: mixer, nch = %u:\n", u->id, u->nch)do {} while(0);
1388
1389#ifdef UAUDIO_DEBUG
1390 /*
1391 * Print the list of available mixer's unit knobs (a bit
1392 * matrix). Matrix mixers are rare because levels are
1393 * already controlled by feature units, making the mixer
1394 * knobs redundant with the feature's knobs. So, for
1395 * now, we don't add clutter to the mixer(4) interface
1396 * and ignore all knobs. Other popular OSes doesn't
1397 * seem to expose them either.
1398 */
1399 bit = 0;
1400 for (s = u->src_list; s != NULL((void *)0); s = s->src_next) {
1401 for (i = 0; i < s->nch; i++) {
1402 for (j = 0; j < u->nch; j++) {
1403 if ((bit++ & 7) == 0) {
1404 if (!uaudio_getnum(&p, 1, &ctl))
1405 return 0;
1406 }
1407 if (ctl & 0x80)
1408 DPRINTF("\t%02u[%d] -> [%d]\n",do {} while(0)
1409 s->id, i, j)do {} while(0);
1410 ctl <<= 1;
1411 }
1412 }
1413 }
1414#endif
1415 break;
1416 case UAUDIO_AC_SELECTOR0x5:
1417 /*
1418 * Selectors are extremely rare, so not supported yet.
1419 */
1420 if (!uaudio_process_srcs(sc, u, units, &p))
1421 return 0;
1422 if (u->src_list == NULL((void *)0)) {
1423 printf("%s: selector %02u has no sources\n",
1424 DEVNAME(sc)((sc)->dev.dv_xname), u->id);
1425 return 0;
1426 }
1427 u->nch = u->src_list->nch;
1428 DPRINTF("%02u: selector, nch = %u\n", u->id, u->nch)do {} while(0);
1429 break;
1430 case UAUDIO_AC_FEATURE0x6:
1431 if (!uaudio_getnum(&p, 1, &id))
1432 return 0;
1433 if (!uaudio_process_unit(sc, u, id, units, &s))
1434 return 0;
1435 s->src_next = u->src_list;
1436 u->src_list = s;
1437 u->nch = s->nch;
1438 switch (sc->version) {
1439 case UAUDIO_V10x100:
1440 if (!uaudio_getnum(&p, 1, &size))
1441 return 0;
1442 break;
1443 case UAUDIO_V20x200:
1444 size = 4;
1445 break;
1446 }
1447 DPRINTF("%02d: feature id = %d, nch = %d, size = %d\n",do {} while(0)
1448 u->id, id, u->nch, size)do {} while(0);
1449
1450 if (!uaudio_getnum(&p, size, &ctl))
1451 return 0;
1452 ctl = uaudio_feature_fixup(sc, ctl);
1453 for (i = 0; i < 16; i++) {
1454 if ((ctl & 3) == 3)
1455 uaudio_feature_addent(sc, u, i, -1);
1456 ctl >>= 2;
1457 }
1458
1459 /*
1460 * certain devices provide no per-channel control descriptors
1461 */
1462 if (p.wptr - p.rptr == 1)
1463 break;
1464
1465 for (j = 0; j < u->nch; j++) {
1466 if (!uaudio_getnum(&p, size, &ctl))
1467 return 0;
1468 ctl = uaudio_feature_fixup(sc, ctl);
1469 for (i = 0; i < 16; i++) {
1470 if ((ctl & 3) == 3)
1471 uaudio_feature_addent(sc, u, i, j);
1472 ctl >>= 2;
1473 }
1474 }
1475 break;
1476 case UAUDIO_AC_EFFECT0x7:
1477 if (!uaudio_getnum(&p, 2, &type))
1478 return 0;
1479 if (!uaudio_getnum(&p, 1, &id))
1480 return 0;
1481 if (!uaudio_process_unit(sc, u, id, units, &s))
1482 return 0;
1483 s->src_next = u->src_list;
1484 u->src_list = s;
1485 u->nch = s->nch;
1486 DPRINTF("%02d: effect, type = %u, id = %d, nch = %d\n",do {} while(0)
1487 u->id, type, id, u->nch)do {} while(0);
1488 break;
1489 case UAUDIO_AC_PROCESSING0x8:
1490 case UAUDIO_AC_EXTENSION0x9:
1491 if (!uaudio_getnum(&p, 2, &type))
1492 return 0;
1493 if (!uaudio_process_srcs(sc, u, units, &p))
1494 return 0;
1495 if (!uaudio_process_nch(sc, u, &p))
1496 return 0;
1497 DPRINTF("%02u: proc/ext, type = 0x%x, nch = %u\n",do {} while(0)
1498 u->id, type, u->nch)do {} while(0);
1499 for (s = u->src_list; s != NULL((void *)0); s = s->src_next) {
1500 DPRINTF("%u:\tpin %u:\n", u->id, s->id)do {} while(0);
1501 }
1502 break;
1503 case UAUDIO_AC_CLKSRC0xa:
1504 if (!uaudio_getnum(&p, 1, &u->term))
1505 return 0;
1506 if (!uaudio_getnum(&p, 1, &ctl))
1507 return 0;
1508 DPRINTF("%02u: clock source, attr = 0x%x, ctl = 0x%x\n",do {} while(0)
1509 u->id, u->term, ctl)do {} while(0);
1510 break;
1511 case UAUDIO_AC_CLKSEL0xb:
1512 DPRINTF("%02u: clock sel\n", u->id)do {} while(0);
1513 if (!uaudio_process_srcs(sc, u, units, &p))
1514 return 0;
1515 if (u->src_list == NULL((void *)0)) {
1516 printf("%s: clock selector %02u with no srcs\n",
1517 DEVNAME(sc)((sc)->dev.dv_xname), u->id);
1518 return 0;
1519 }
1520 break;
1521 case UAUDIO_AC_CLKMULT0xc:
1522 DPRINTF("%02u: clock mult\n", u->id)do {} while(0);
1523
1524 /* XXX: fetch multiplier */
1525 printf("%s: clock multiplier not supported\n", DEVNAME(sc)((sc)->dev.dv_xname));
1526 break;
1527 case UAUDIO_AC_RATECONV0xd:
1528 DPRINTF("%02u: rate conv\n", u->id)do {} while(0);
1529
1530 /* XXX: fetch multiplier */
1531 printf("%s: rate converter not supported\n", DEVNAME(sc)((sc)->dev.dv_xname));
1532 break;
1533 }
1534 if (rchild)
1535 *rchild = u;
1536 return 1;
1537}
1538
1539/*
1540 * Try to set the unit name to the name of its destination terminal. If
1541 * the name is ambigus (already given to another source unit or having
1542 * multiple destinations) then return 0.
1543 */
1544int
1545uaudio_setname_dsts(struct uaudio_softc *sc, struct uaudio_unit *u, char *name)
1546{
1547 struct uaudio_unit *d = u;
1548
1549 while (d
49.1
'd' is not equal to NULL
!= NULL((void *)0)) {
50
Loop condition is true. Entering loop body
1550 if (d->dst_list == NULL((void *)0) || d->dst_list->dst_next != NULL((void *)0))
51
Assuming field 'dst_list' is not equal to NULL
52
Assuming field 'dst_next' is equal to NULL
53
Taking false branch
1551 break;
1552 d = d->dst_list;
1553 if (d->src_list == NULL((void *)0) || d->src_list->src_next != NULL((void *)0))
54
Assuming field 'src_list' is not equal to NULL
55
Assuming field 'src_next' is equal to NULL
56
Taking false branch
1554 break;
1555 if (d->name[0] != '\0') {
57
Assuming the condition is true
58
Taking true branch
1556 if (name
58.1
'name' is equal to NULL
!= NULL((void *)0) && strcmp(name, d->name) != 0)
1557 break;
1558 strlcpy(u->name, d->name, UAUDIO_NAMEMAX16);
1559 return 1;
59
Returning without writing to 'sc->version', which participates in a condition later
1560 }
1561 }
1562 return 0;
1563}
1564
1565/*
1566 * Try to set the unit name to the name of its source terminal. If the
1567 * name is ambigus (already given to another destination unit or
1568 * having multiple sources) then return 0.
1569 */
1570int
1571uaudio_setname_srcs(struct uaudio_softc *sc, struct uaudio_unit *u, char *name)
1572{
1573 struct uaudio_unit *s = u;
1574
1575 while (s
69.1
's' is not equal to NULL
!= NULL((void *)0)) {
70
Loop condition is true. Entering loop body
1576 if (s->src_list == NULL((void *)0) || s->src_list->src_next != NULL((void *)0))
71
Assuming field 'src_list' is not equal to NULL
72
Assuming field 'src_next' is equal to NULL
73
Taking false branch
1577 break;
1578 s = s->src_list;
1579 if (s->dst_list == NULL((void *)0) || s->dst_list->dst_next != NULL((void *)0))
74
Assuming field 'dst_list' is not equal to NULL
75
Assuming field 'dst_next' is equal to NULL
76
Taking false branch
1580 break;
1581 if (s->name[0] != '\0') {
77
Assuming the condition is true
78
Taking true branch
1582 if (name
78.1
'name' is not equal to NULL
!= NULL((void *)0) && strcmp(name, s->name) != 0)
79
Taking false branch
1583 break;
1584 strlcpy(u->name, s->name, UAUDIO_NAMEMAX16);
1585 return 1;
80
Returning without writing to 'sc->version', which participates in a condition later
1586 }
1587 }
1588 return 0;
1589}
1590
1591/*
1592 * Set the name of the given unit by using both its source and
1593 * destination units. This is naming scheme is only useful to units
1594 * that would have ambiguous names if only sources or only destination
1595 * were used.
1596 */
1597void
1598uaudio_setname_middle(struct uaudio_softc *sc, struct uaudio_unit *u)
1599{
1600 struct uaudio_unit *s, *d;
1601 char name[UAUDIO_NAMEMAX16];
1602
1603 s = u->src_list;
1604 while (1) {
1605 if (s == NULL((void *)0)) {
1606 DPRINTF("%s: %02u: has no srcs\n",do {} while(0)
1607 __func__, u->id)do {} while(0);
1608 return;
1609 }
1610 if (s->name[0] != '\0')
1611 break;
1612 s = s->src_list;
1613 }
1614
1615 d = u->dst_list;
1616 while (1) {
1617 if (d == NULL((void *)0)) {
1618 DPRINTF("%s: %02u: has no dests\n",do {} while(0)
1619 __func__, u->id)do {} while(0);
1620 return;
1621 }
1622 if (d->name[0] != '\0')
1623 break;
1624 d = d->dst_list;
1625 }
1626
1627 snprintf(name, UAUDIO_NAMEMAX16, "%s_%s", d->name, s->name);
1628 uaudio_mkname(sc, name, u->name);
1629}
1630
1631#ifdef UAUDIO_DEBUG
1632/*
1633 * Return the synchronization type name, for debug purposes only.
1634 */
1635char *
1636uaudio_isoname(int isotype)
1637{
1638 switch (isotype) {
1639 case UE_ISO_ASYNC0x04:
1640 return "async";
1641 case UE_ISO_ADAPT0x08:
1642 return "adapt";
1643 case UE_ISO_SYNC0x0c:
1644 return "sync";
1645 default:
1646 return "unk";
1647 }
1648}
1649
1650/*
1651 * Return the name of the given mode, debug only
1652 */
1653char *
1654uaudio_modename(int mode)
1655{
1656 switch (mode) {
1657 case 0:
1658 return "none";
1659 case AUMODE_PLAY0x01:
1660 return "play";
1661 case AUMODE_RECORD0x02:
1662 return "rec";
1663 case AUMODE_PLAY0x01 | AUMODE_RECORD0x02:
1664 return "duplex";
1665 default:
1666 return "unk";
1667 }
1668}
1669
1670/*
1671 * Return UAC v2.0 endpoint usage, debug only
1672 */
1673char *
1674uaudio_usagename(int usage)
1675{
1676 switch (usage) {
1677 case UE_ISO_USAGE_DATA0x00:
1678 return "data";
1679 case UE_ISO_USAGE_FEEDBACK0x10:
1680 return "feed";
1681 case UE_ISO_USAGE_IMPL0x20:
1682 return "impl";
1683 default:
1684 return "unk";
1685 }
1686}
1687
1688/*
1689 * Print a bitmap of rates on the console.
1690 */
1691void
1692uaudio_rates_print(int rates)
1693{
1694 unsigned int i;
1695
1696 for (i = 0; i < nitems(uaudio_rates)(sizeof((uaudio_rates)) / sizeof((uaudio_rates)[0])); i++) {
1697 if (rates & (1 << i))
1698 printf(" %d", uaudio_rates[i]);
1699 }
1700 printf("\n");
1701}
1702
1703
1704/*
1705 * Print uaudio_ranges to console.
1706 */
1707void
1708uaudio_ranges_print(struct uaudio_ranges *r)
1709{
1710 struct uaudio_ranges_el *e;
1711 int more = 0;
1712
1713 for (e = r->el; e != NULL((void *)0); e = e->next) {
1714 if (more)
1715 printf(", ");
1716 if (e->min == e->max)
1717 printf("%d", e->min);
1718 else
1719 printf("[%d:%d]/%d", e->min, e->max, e->res);
1720 more = 1;
1721 }
1722 printf(" (%d vals)\n", r->nval);
1723}
1724
1725/*
1726 * Print unit to the console.
1727 */
1728void
1729uaudio_print_unit(struct uaudio_softc *sc, struct uaudio_unit *u)
1730{
1731 struct uaudio_unit *s;
1732
1733 switch (u->type) {
1734 case UAUDIO_AC_INPUT0x2:
1735 printf("%02u: input <%s>, dest = %02u <%s>\n",
1736 u->id, u->name, u->dst_list->id, u->dst_list->name);
1737 break;
1738 case UAUDIO_AC_OUTPUT0x3:
1739 printf("%02u: output <%s>, source = %02u <%s>\n",
1740 u->id, u->name, u->src_list->id, u->src_list->name);
1741 break;
1742 case UAUDIO_AC_MIXER0x4:
1743 printf("%02u: mixer <%s>:\n", u->id, u->name);
1744 for (s = u->src_list; s != NULL((void *)0); s = s->src_next)
1745 printf("%02u:\tsource %u <%s>:\n",
1746 u->id, s->id, s->name);
1747 break;
1748 case UAUDIO_AC_SELECTOR0x5:
1749 printf("%02u: selector <%s>:\n", u->id, u->name);
1750 for (s = u->src_list; s != NULL((void *)0); s = s->src_next)
1751 printf("%02u:\tsource %u <%s>:\n",
1752 u->id, s->id, s->name);
1753 break;
1754 case UAUDIO_AC_FEATURE0x6:
1755 printf("%02u: feature <%s>, "
1756 "src = %02u <%s>, dst = %02u <%s>, cls = %d\n",
1757 u->id, u->name,
1758 u->src_list->id, u->src_list->name,
1759 u->dst_list->id, u->dst_list->name, u->mixer_class);
1760 break;
1761 case UAUDIO_AC_EFFECT0x7:
1762 printf("%02u: effect <%s>, "
1763 "src = %02u <%s>, dst = %02u <%s>\n",
1764 u->id, u->name,
1765 u->src_list->id, u->src_list->name,
1766 u->dst_list->id, u->dst_list->name);
1767 break;
1768 case UAUDIO_AC_PROCESSING0x8:
1769 case UAUDIO_AC_EXTENSION0x9:
1770 printf("%02u: proc/ext <%s>:\n", u->id, u->name);
1771 for (s = u->src_list; s != NULL((void *)0); s = s->src_next)
1772 printf("%02u:\tsource %u <%s>:\n",
1773 u->id, s->id, s->name);
1774 break;
1775 case UAUDIO_AC_CLKSRC0xa:
1776 printf("%02u: clock source <%s>\n", u->id, u->name);
1777 break;
1778 case UAUDIO_AC_CLKSEL0xb:
1779 printf("%02u: clock sel <%s>\n", u->id, u->name);
1780 break;
1781 case UAUDIO_AC_CLKMULT0xc:
1782 printf("%02u: clock mult\n", u->id);
1783 break;
1784 case UAUDIO_AC_RATECONV0xd:
1785 printf("%02u: rate conv\n", u->id);
1786 break;
1787 }
1788}
1789
1790/*
1791 * Print the full mixer on the console.
1792 */
1793void
1794uaudio_mixer_print(struct uaudio_softc *sc)
1795{
1796 struct uaudio_mixent *m;
1797 struct uaudio_unit *u;
1798
1799 for (u = sc->unit_list; u != NULL((void *)0); u = u->unit_next) {
1800 for (m = u->mixent_list; m != NULL((void *)0); m = m->next) {
1801 printf("%02u:\t%s.%s",
1802 u->id, u->name, m->fname);
1803 if (m->chan >= 0)
1804 printf("[%u]", m->chan);
1805 printf("\n");
1806 }
1807 }
1808}
1809
1810/*
1811 * Print the full device configuration on the console.
1812 */
1813void
1814uaudio_conf_print(struct uaudio_softc *sc)
1815{
1816 struct uaudio_alt *a;
1817 struct uaudio_params *p;
1818 struct mixer_devinfo mi;
1819 struct mixer_ctrl ctl;
1820 int i, rates;
1821
1822 mi.index = 0;
1823 while (1) {
1824 if (uaudio_query_devinfo(sc, &mi) != 0)
1825 break;
1826
1827 if (mi.type != AUDIO_MIXER_CLASS0) {
1828 ctl.dev = mi.index;
1829 if (uaudio_get_port(sc, &ctl) != 0) {
1830 printf("%02u: failed to get port\n", mi.index);
1831 memset(&ctl.un, 0, sizeof(ctl.un))__builtin_memset((&ctl.un), (0), (sizeof(ctl.un)));
1832 }
1833 }
1834
1835 printf("%02u: <%s>, next = %d, prev = %d, class = %d",
1836 mi.index, mi.label.name, mi.next, mi.prev, mi.mixer_class);
1837
1838 switch (mi.type) {
1839 case AUDIO_MIXER_CLASS0:
1840 break;
1841 case AUDIO_MIXER_VALUE3:
1842 printf(", nch = %d, delta = %d",
1843 mi.un.v.num_channels, mi.un.v.delta);
1844 printf(", val =");
1845 for (i = 0; i < mi.un.v.num_channels; i++)
1846 printf(" %d", ctl.un.value.level[i]);
1847 break;
1848 case AUDIO_MIXER_ENUM1:
1849 printf(", members:");
1850 for (i = 0; i != mi.un.e.num_mem; i++) {
1851 printf(" %s(=%d)",
1852 mi.un.e.member[i].label.name,
1853 mi.un.e.member[i].ord);
1854 }
1855 printf(", val = %d", ctl.un.ord);
1856 break;
1857 }
1858
1859 printf("\n");
1860 mi.index++;
1861 }
1862
1863 printf("%d controls\n", mi.index);
1864
1865 printf("alts:\n");
1866 for (a = sc->alts; a != NULL((void *)0); a = a->next) {
1867 rates = uaudio_alt_getrates(sc, a);
1868 printf("mode = %s, ifnum = %d, altnum = %d, "
1869 "addr = 0x%x, maxpkt = %d, sync = 0x%x, "
1870 "nch = %d, fmt = s%dle%d, rates:",
1871 uaudio_modename(a->mode),
1872 a->ifnum, a->altnum,
1873 a->data_addr, a->maxpkt,
1874 a->sync_addr,
1875 a->nch, a->bits, a->bps);
1876 uaudio_rates_print(rates);
1877 }
1878
1879 printf("parameters:\n");
1880 for (p = sc->params_list; p != NULL((void *)0); p = p->next) {
1881 switch (sc->version) {
1882 case UAUDIO_V10x100:
1883 rates = p->v1_rates;
1884 break;
1885 case UAUDIO_V20x200:
1886 rates = uaudio_getrates(sc, p);
1887 break;
1888 }
1889 printf("pchan = %d, s%dle%d, rchan = %d, s%dle%d, rates:",
1890 p->palt ? p->palt->nch : 0,
1891 p->palt ? p->palt->bits : 0,
1892 p->palt ? p->palt->bps : 0,
1893 p->ralt ? p->ralt->nch : 0,
1894 p->ralt ? p->ralt->bits : 0,
1895 p->ralt ? p->ralt->bps : 0);
1896 uaudio_rates_print(rates);
1897 }
1898}
1899#endif
1900
1901/*
1902 * Return the number of mixer controls that have the same name but
1903 * control different channels of the same stream.
1904 */
1905int
1906uaudio_mixer_nchan(struct uaudio_mixent *m, struct uaudio_mixent **rnext)
1907{
1908 char *name;
1909 int i;
1910
1911 i = 0;
1912 name = m->fname;
1913 while (m != NULL((void *)0) && strcmp(name, m->fname) == 0) {
1914 m = m->next;
1915 i++;
1916 }
1917 if (rnext)
1918 *rnext = m;
1919 return i;
1920}
1921
1922/*
1923 * Skip redundant mixer entries that we don't want to expose to userland.
1924 * For instance if there is a mute-all-channels control and per-channel
1925 * mute controls, we don't want both (we expose the per-channel mute)
1926 */
1927void
1928uaudio_mixer_skip(struct uaudio_mixent **pm)
1929{
1930 struct uaudio_mixent *m = *pm;
1931
1932 if (m != NULL((void *)0) &&
1933 m->chan == -1 &&
1934 m->next != NULL((void *)0) &&
1935 strcmp(m->fname, m->next->fname) == 0)
1936 m = m->next;
1937
1938 *pm = m;
1939}
1940
1941/*
1942 * Return pointer to the unit and mixer entry which have the given
1943 * index exposed by the mixer(4) API.
1944 */
1945int
1946uaudio_mixer_byindex(struct uaudio_softc *sc, int index,
1947 struct uaudio_unit **ru, struct uaudio_mixent **rm)
1948{
1949 struct uaudio_unit *u;
1950 struct uaudio_mixent *m;
1951 char *name;
1952 int i;
1953
1954 i = UAUDIO_CLASS_COUNT2;
1955 for (u = sc->unit_list; u != NULL((void *)0); u = u->unit_next) {
1956 m = u->mixent_list;
1957 while (1) {
1958 uaudio_mixer_skip(&m);
1959 if (m == NULL((void *)0))
1960 break;
1961 if (index == i) {
1962 *ru = u;
1963 *rm = m;
1964 return 1;
1965 }
1966 if (m->type == UAUDIO_MIX_NUM1) {
1967 name = m->fname;
1968 while (m != NULL((void *)0) &&
1969 strcmp(name, m->fname) == 0)
1970 m = m->next;
1971 } else
1972 m = m->next;
1973 i++;
1974 }
1975 }
1976 return 0;
1977}
1978
1979/*
1980 * Parse AC header descriptor, we use it only to determine UAC
1981 * version. Other properties (like wTotalLength) can be determined
1982 * using other descriptors, so we try to no rely on them to avoid
1983 * inconsistencies and the need for certain quirks.
1984 */
1985int
1986uaudio_process_header(struct uaudio_softc *sc, struct uaudio_blob *p)
1987{
1988 struct uaudio_blob ph;
1989 unsigned int type, subtype;
1990
1991 if (!uaudio_getdesc(p, &ph))
1992 return 0;
1993 if (!uaudio_getnum(&ph, 1, &type))
1994 return 0;
1995 if (type != UDESC_CS_INTERFACE0x24) {
1996 DPRINTF("%s: expected cs iface desc\n", __func__)do {} while(0);
1997 return 0;
1998 }
1999 if (!uaudio_getnum(&ph, 1, &subtype))
2000 return 0;
2001 if (subtype != UAUDIO_AC_HEADER0x1) {
2002 DPRINTF("%s: expected header desc\n", __func__)do {} while(0);
2003 return 0;
2004 }
2005 if (!uaudio_getnum(&ph, 2, &sc->version))
2006 return 0;
2007
2008 DPRINTF("%s: version 0x%x\n", __func__, sc->version)do {} while(0);
2009 return 1;
2010}
2011
2012/*
2013 * Process AC interrupt endpoint descriptor, this is mainly to skip
2014 * the descriptor as we use neither of it's properties. Our mixer
2015 * interface doesn't support unsolicitated state changes, so we've no
2016 * use of it yet.
2017 */
2018int
2019uaudio_process_ac_ep(struct uaudio_softc *sc, struct uaudio_blob *p)
2020{
2021#ifdef UAUDIO_DEBUG
2022 static const char *xfer[] = {
2023 "ctl", "iso", "bulk", "intr"
2024 };
2025#endif
2026 struct uaudio_blob dp;
2027 unsigned int type, addr, attr, maxpkt, ival;
2028 unsigned char *savepos;
2029
2030 /*
2031 * parse optional interrupt endpoint descriptor
2032 */
2033 if (p->rptr == p->wptr)
87
Assuming field 'rptr' is equal to field 'wptr'
88
Taking true branch
2034 return 1;
89
Returning without writing to 'sc->version', which participates in a condition later
2035 savepos = p->rptr;
2036 if (!uaudio_getdesc(p, &dp))
2037 return 0;
2038 if (!uaudio_getnum(&dp, 1, &type))
2039 return 0;
2040 if (type != UDESC_ENDPOINT0x05) {
2041 p->rptr = savepos;
2042 return 1;
2043 }
2044
2045 if (!uaudio_getnum(&dp, 1, &addr))
2046 return 0;
2047 if (!uaudio_getnum(&dp, 1, &attr))
2048 return 0;
2049 if (!uaudio_getnum(&dp, 2, &maxpkt))
2050 return 0;
2051 if (!uaudio_getnum(&dp, 1, &ival))
2052 return 0;
2053
2054 DPRINTF("%s: addr = 0x%x, type = %s, maxpkt = %d, ival = %d\n",do {} while(0)
2055 __func__, addr, xfer[UE_GET_XFERTYPE(attr)],do {} while(0)
2056 UE_GET_SIZE(maxpkt), ival)do {} while(0);
2057
2058 return 1;
2059}
2060
2061/*
2062 * Process the AC interface descriptors: mainly build the mixer and,
2063 * for UAC v2.0, find the clock source.
2064 *
2065 * The audio device exposes an audio control (AC) interface with a big
2066 * set of USB descriptors which expose the complete circuit the
2067 * device. The circuit describes how the signal flows between the USB
2068 * streaming interfaces to the terminal connectors (jacks, speakers,
2069 * mics, ...). The circuit is build of mixers, source selectors, gain
2070 * controls, mutters, processors, and alike; each comes with its own
2071 * set of controls. Most of the boring driver work is to parse the
2072 * circuit and build a human-usable set of controls that could be
2073 * exposed through the mixer(4) interface.
2074 */
2075int
2076uaudio_process_ac(struct uaudio_softc *sc, struct uaudio_blob *p, int ifnum)
2077{
2078 struct uaudio_blob units, pu;
2079 struct uaudio_unit *u, *v;
2080 unsigned char *savepos;
2081 unsigned int type, subtype, id;
2082 char *name, val;
2083
2084 DPRINTF("%s: ifnum = %d, %zd bytes to process\n", __func__,do {} while(0)
22
Loop condition is false. Exiting loop
2085 ifnum, p->wptr - p->rptr)do {} while(0);
2086
2087 sc->ctl_ifnum = ifnum;
2088
2089 /* The first AC class-specific descriptor is the AC header */
2090 if (!uaudio_process_header(sc, p))
23
Taking false branch
2091 return 0;
2092
2093 /*
2094 * Determine the size of the AC descriptors array: scan
2095 * descriptors until we get the first non-class-specific
2096 * descriptor. This avoids relying on the wTotalLength field.
2097 */
2098 savepos = p->rptr;
2099 units.rptr = units.wptr = p->rptr;
2100 while (p->rptr != p->wptr) {
24
Loop condition is true. Entering loop body
29
Loop condition is false. Execution continues on line 2109
2101 if (!uaudio_getdesc(p, &pu))
25
Taking false branch
2102 return 0;
2103 if (!uaudio_getnum(&pu, 1, &type))
26
Taking false branch
2104 return 0;
2105 if (type != UDESC_CS_INTERFACE0x24)
27
Assuming 'type' is equal to UDESC_CS_INTERFACE
28
Taking false branch
2106 break;
2107 units.wptr = p->rptr;
2108 }
2109 p->rptr = savepos;
2110
2111 /*
2112 * Load units, walking from outputs to inputs, as
2113 * the usb audio class spec requires.
2114 */
2115 while (p->rptr != units.wptr) {
30
Assuming field 'rptr' is not equal to field 'wptr'
31
Loop condition is true. Entering loop body
40
Assuming field 'rptr' is equal to field 'wptr'
41
Loop condition is false. Execution continues on line 2133
2116 if (!uaudio_getdesc(p, &pu))
32
Taking false branch
2117 return 0;
2118 if (!uaudio_getnum(&pu, 1, &type))
33
Taking false branch
2119 return 0;
2120 if (!uaudio_getnum(&pu, 1, &subtype))
34
Taking false branch
2121 return 0;
2122 if (subtype == UAUDIO_AC_OUTPUT0x3) {
35
Assuming 'subtype' is equal to UAUDIO_AC_OUTPUT
36
Taking true branch
2123 if (!uaudio_getnum(&pu, 1, &id))
37
Taking false branch
2124 return 0;
2125 if (!uaudio_process_unit(sc, NULL((void *)0), id, units, NULL((void *)0)))
38
Assuming the condition is false
39
Taking false branch
2126 return 0;
2127 }
2128 }
2129
2130 /*
2131 * set terminal, effect, and processor unit names
2132 */
2133 for (u = sc->unit_list; u != NULL((void *)0); u = u->unit_next) {
42
Assuming 'u' is not equal to NULL
43
Loop condition is true. Entering loop body
45
Assuming 'u' is equal to NULL
46
Loop condition is false. Execution continues on line 2162
2134 switch (u->type) {
44
'Default' branch taken. Execution continues on line 2133
2135 case UAUDIO_AC_INPUT0x2:
2136 uaudio_mkname(sc, uaudio_tname(sc, u->term, 0), u->name);
2137 break;
2138 case UAUDIO_AC_OUTPUT0x3:
2139 uaudio_mkname(sc, uaudio_tname(sc, u->term, 1), u->name);
2140 break;
2141 case UAUDIO_AC_CLKSRC0xa:
2142 uaudio_mkname(sc, uaudio_clkname(u->term), u->name);
2143 break;
2144 case UAUDIO_AC_CLKSEL0xb:
2145 uaudio_mkname(sc, "clksel", u->name);
2146 break;
2147 case UAUDIO_AC_EFFECT0x7:
2148 uaudio_mkname(sc, "fx", u->name);
2149 break;
2150 case UAUDIO_AC_PROCESSING0x8:
2151 uaudio_mkname(sc, "proc", u->name);
2152 break;
2153 case UAUDIO_AC_EXTENSION0x9:
2154 uaudio_mkname(sc, "ext", u->name);
2155 break;
2156 }
2157 }
2158
2159 /*
2160 * set mixer/selector unit names
2161 */
2162 for (u = sc->unit_list; u
46.1
'u' is not equal to NULL
!= NULL((void *)0)
; u = u->unit_next) {
47
Loop condition is true. Entering loop body
62
Assuming 'u' is equal to NULL
63
Loop condition is false. Execution continues on line 2182
2163 if (u->type != UAUDIO_AC_MIXER0x4 &&
48
Assuming field 'type' is equal to UAUDIO_AC_MIXER
2164 u->type != UAUDIO_AC_SELECTOR0x5)
2165 continue;
2166 if (!uaudio_setname_dsts(sc, u, NULL((void *)0))) {
49
Calling 'uaudio_setname_dsts'
60
Returning from 'uaudio_setname_dsts'
61
Taking false branch
2167 switch (u->type) {
2168 case UAUDIO_AC_MIXER0x4:
2169 name = "mix";
2170 break;
2171 case UAUDIO_AC_SELECTOR0x5:
2172 name = "sel";
2173 break;
2174 }
2175 uaudio_mkname(sc, name, u->name);
2176 }
2177 }
2178
2179 /*
2180 * set feature unit names and classes
2181 */
2182 for (u = sc->unit_list; u
63.1
'u' is not equal to NULL
!= NULL((void *)0)
; u = u->unit_next) {
64
Loop condition is true. Entering loop body
84
Assuming 'u' is equal to NULL
85
Loop condition is false. Execution continues on line 2217
2183 if (u->type != UAUDIO_AC_FEATURE0x6)
65
Assuming field 'type' is equal to UAUDIO_AC_FEATURE
66
Taking false branch
2184 continue;
2185 if (uaudio_setname_dsts(sc, u, UAUDIO_NAME_REC"record")) {
67
Assuming the condition is false
68
Taking false branch
2186 u->mixer_class = UAUDIO_CLASS_IN1;
2187 continue;
2188 }
2189 if (uaudio_setname_srcs(sc, u, UAUDIO_NAME_PLAY"dac")) {
69
Calling 'uaudio_setname_srcs'
81
Returning from 'uaudio_setname_srcs'
82
Taking true branch
2190 u->mixer_class = UAUDIO_CLASS_OUT0;
2191 continue;
83
Execution continues on line 2182
2192 }
2193 if (uaudio_setname_dsts(sc, u, NULL((void *)0))) {
2194 u->mixer_class = UAUDIO_CLASS_OUT0;
2195 continue;
2196 }
2197 if (uaudio_setname_srcs(sc, u, NULL((void *)0))) {
2198 u->mixer_class = UAUDIO_CLASS_IN1;
2199 continue;
2200 }
2201 uaudio_setname_middle(sc, u);
2202 u->mixer_class = UAUDIO_CLASS_IN1;
2203 }
2204
2205#ifdef UAUDIO_DEBUG
2206 if (uaudio_debug) {
2207 printf("%s: units list:\n", DEVNAME(sc)((sc)->dev.dv_xname));
2208 for (u = sc->unit_list; u != NULL((void *)0); u = u->unit_next)
2209 uaudio_print_unit(sc, u);
2210
2211 printf("%s: mixer controls:\n", DEVNAME(sc)((sc)->dev.dv_xname));
2212 uaudio_mixer_print(sc);
2213 }
2214#endif
2215
2216 /* follows optional interrupt endpoint descriptor */
2217 if (!uaudio_process_ac_ep(sc, p))
86
Calling 'uaudio_process_ac_ep'
90
Returning from 'uaudio_process_ac_ep'
91
Taking false branch
2218 return 0;
2219
2220 /* fetch clock source rates */
2221 for (u = sc->unit_list; u != NULL((void *)0); u = u->unit_next) {
92
Assuming 'u' is not equal to NULL
93
Loop condition is true. Entering loop body
2222 switch (u->type) {
94
Control jumps to 'case 10:' at line 2223
2223 case UAUDIO_AC_CLKSRC0xa:
2224 if (!uaudio_req_ranges(sc, 4,
95
Calling 'uaudio_req_ranges'
2225 UAUDIO_V2_REQSEL_CLKFREQ1,
2226 0, /* channel (not used) */
2227 sc->ctl_ifnum,
2228 u->id,
2229 &u->rates)) {
2230 printf("%s: failed to read clock rates\n",
2231 DEVNAME(sc)((sc)->dev.dv_xname));
2232 return 1;
2233 }
2234#ifdef UAUDIO_DEBUG
2235 if (uaudio_debug) {
2236 printf("%02u: clock rates: ", u->id);
2237 uaudio_ranges_print(&u->rates);
2238 }
2239#endif
2240 break;
2241 case UAUDIO_AC_CLKSEL0xb:
2242 if (!uaudio_req(sc, UT_READ_CLASS_INTERFACE(0x80 | 0x20 | 0x01),
2243 UAUDIO_V2_REQ_CUR1,
2244 UAUDIO_V2_REQSEL_CLKSEL1, 0,
2245 sc->ctl_ifnum, u->id,
2246 &val, 1)) {
2247 printf("%s: failed to read clock selector\n",
2248 DEVNAME(sc)((sc)->dev.dv_xname));
2249 return 0;
2250 }
2251 for (v = u->src_list; v != NULL((void *)0); v = v->src_next) {
2252 if (--val == 0)
2253 break;
2254 }
2255 u->clock = v;
2256 break;
2257 }
2258 }
2259
2260 if (sc->version == UAUDIO_V20x200) {
2261 /*
2262 * Find common clock unit. We assume all terminals
2263 * belong to the same clock domain (ie are connected
2264 * to the same source)
2265 */
2266 sc->clock = NULL((void *)0);
2267 for (u = sc->unit_list; u != NULL((void *)0); u = u->unit_next) {
2268 if (u->type != UAUDIO_AC_INPUT0x2 &&
2269 u->type != UAUDIO_AC_OUTPUT0x3)
2270 continue;
2271 if (sc->clock == NULL((void *)0)) {
2272 if (u->clock == NULL((void *)0)) {
2273 printf("%s: terminal with no clock\n",
2274 DEVNAME(sc)((sc)->dev.dv_xname));
2275 return 0;
2276 }
2277 sc->clock = u->clock;
2278 } else if (u->clock != sc->clock) {
2279 printf("%s: only one clock domain supported\n",
2280 DEVNAME(sc)((sc)->dev.dv_xname));
2281 return 0;
2282 }
2283 }
2284
2285 if (sc->clock == NULL((void *)0)) {
2286 printf("%s: no clock found\n", DEVNAME(sc)((sc)->dev.dv_xname));
2287 return 0;
2288 }
2289 }
2290 return 1;
2291}
2292
2293/*
2294 * Parse endpoint descriptor with the following format:
2295 *
2296 * For playback there's a output data endpoint, of the
2297 * following types:
2298 *
2299 * type sync descr
2300 * -------------------------------------------------------
2301 * async: Yes the device uses it's own clock but
2302 * sends feedback on a (input) sync endpoint
2303 * for the host to adjust next packet size
2304 *
2305 * sync: - data rate is constant, and device
2306 * is clocked to the usb bus.
2307 *
2308 * adapt: - the device adapts to data rate of the
2309 * host. If fixed packet size is used,
2310 * data rate is equivalent to the usb clock
2311 * so this mode is the same as the
2312 * sync mode.
2313 *
2314 * For recording there's and input data endpoint, of
2315 * the following types:
2316 *
2317 * type sync descr
2318 * -------------------------------------------------------
2319 * async: - the device uses its own clock and
2320 * adjusts packet sizes.
2321 *
2322 * sync: - the device uses usb clock rate
2323 *
2324 * adapt: Yes the device uses host's feedback (on
2325 * on a dedicated (output) sync endpoint
2326 * to adapt to software's desired rate
2327 *
2328 *
2329 * For usb1.1 ival is cardcoded to 1 for isochronous
2330 * transfers, which means one transfer every ms. I.e one
2331 * transfer every frame period.
2332 *
2333 * For usb2, ival the poll interval is:
2334 *
2335 * frame_period * 2^(ival - 1)
2336 *
2337 * so, if we use this formula, we get something working in all
2338 * cases.
2339 *
2340 * The MaxPacketsOnly attribute is used only by "Type II" encodings,
2341 * so we don't care about it.
2342 */
2343int
2344uaudio_process_as_ep(struct uaudio_softc *sc,
2345 struct uaudio_blob *p, struct uaudio_alt *a, int nep)
2346{
2347 unsigned int addr, attr, maxpkt, isotype, ival;
2348
2349 if (!uaudio_getnum(p, 1, &addr))
2350 return 0;
2351 if (!uaudio_getnum(p, 1, &attr))
2352 return 0;
2353 if (!uaudio_getnum(p, 2, &maxpkt))
2354 return 0;
2355 if (!uaudio_getnum(p, 1, &ival)) /* bInterval */
2356 return 0;
2357
2358 DPRINTF("%s: addr = 0x%x, %s/%s, "do {} while(0)
2359 "maxpktsz = %d, ival = %d\n",do {} while(0)
2360 __func__, addr,do {} while(0)
2361 uaudio_isoname(UE_GET_ISO_TYPE(attr)),do {} while(0)
2362 uaudio_usagename(UE_GET_ISO_USAGE(attr)),do {} while(0)
2363 maxpkt, ival)do {} while(0);
2364
2365 if (UE_GET_XFERTYPE(attr)((attr) & 0x03) != UE_ISOCHRONOUS0x01) {
2366 printf("%s: skipped non-isoc endpt.\n", DEVNAME(sc)((sc)->dev.dv_xname));
2367 return 1;
2368 }
2369
2370 /*
2371 * For each AS interface setting, there's a single data
2372 * endpoint and an optional feedback endpoint. The
2373 * synchronization type is non-zero and must be set in the data
2374 * endpoints.
2375 *
2376 * However, the isoc sync type field of the attribute can't be
2377 * trusted: a lot of devices have it wrong. If the isoc sync
2378 * type is set it's necessarily a data endpoint, if it's not,
2379 * then if it is the only endpoint, it necessarily the data
2380 * endpoint.
2381 */
2382 isotype = UE_GET_ISO_TYPE(attr)((attr) & 0x0c);
2383 if (isotype || nep == 1) {
2384 /* this is the data endpoint */
2385
2386 if (a->data_addr && addr != a->data_addr) {
2387 printf("%s: skipped extra data endpt.\n", DEVNAME(sc)((sc)->dev.dv_xname));
2388 return 1;
2389 }
2390
2391 a->mode = (UE_GET_DIR(addr)((addr) & 0x80) == UE_DIR_IN0x80) ?
2392 AUMODE_RECORD0x02 : AUMODE_PLAY0x01;
2393 a->data_addr = addr;
2394 a->fps = sc->ufps / (1 << (ival - 1));
2395 a->maxpkt = UE_GET_SIZE(maxpkt)((maxpkt) & 0x7ff);
2396 } else {
2397 /* this is the sync endpoint */
2398
2399 if (a->sync_addr && addr != a->sync_addr) {
2400 printf("%s: skipped extra sync endpt.\n", DEVNAME(sc)((sc)->dev.dv_xname));
2401 return 1;
2402 }
2403 a->sync_addr = addr;
2404 }
2405
2406 return 1;
2407}
2408
2409/*
2410 * Parse AS general descriptor. Non-PCM interfaces are skipped. UAC
2411 * v2.0 report the number of channels. For UAC v1.0 we set the number
2412 * of channels to zero, it will be determined later from the format
2413 * descriptor.
2414 */
2415int
2416uaudio_process_as_general(struct uaudio_softc *sc,
2417 struct uaudio_blob *p, int *rispcm, struct uaudio_alt *a)
2418{
2419 unsigned int term, fmt, ctl, fmt_type, fmt_map, nch;
2420
2421 if (!uaudio_getnum(p, 1, &term))
2422 return 0;
2423 switch (sc->version) {
2424 case UAUDIO_V10x100:
2425 if (!uaudio_getnum(p, 1, NULL((void *)0))) /* bDelay */
2426 return 0;
2427 if (!uaudio_getnum(p, 1, &fmt))
2428 return 0;
2429 *rispcm = (fmt == UAUDIO_V1_FMT_PCM0x1);
2430 break;
2431 case UAUDIO_V20x200:
2432 /* XXX: should we check if alt setting control is valid ? */
2433 if (!uaudio_getnum(p, 1, &ctl))
2434 return 0;
2435 if (!uaudio_getnum(p, 1, &fmt_type))
2436 return 0;
2437 if (!uaudio_getnum(p, 4, &fmt_map))
2438 return 0;
2439 if (!uaudio_getnum(p, 1, &nch))
2440 return 0;
2441 a->nch = nch;
2442 *rispcm = (fmt_type == 1) && (fmt_map & UAUDIO_V2_FMT_PCM0x01);
2443 }
2444 return 1;
2445}
2446
2447/*
2448 * Parse AS format descriptor: we support only "Type 1" formats, aka
2449 * PCM. Other formats are not really audio, they are data-only
2450 * interfaces that we don't want to support: ethernet is much better
2451 * for raw data transfers.
2452 *
2453 * XXX: handle ieee 754 32-bit floating point formats.
2454 */
2455int
2456uaudio_process_as_format(struct uaudio_softc *sc,
2457 struct uaudio_blob *p, struct uaudio_alt *a, int *ispcm)
2458{
2459 unsigned int type, bps, bits, nch, nrates, rate_min, rate_max, rates;
2460 int i, j;
2461
2462 switch (sc->version) {
2463 case UAUDIO_V10x100:
2464 if (!uaudio_getnum(p, 1, &type))
2465 return 0;
2466 if (type != 1) {
2467 DPRINTF("%s: class v1: "do {} while(0)
2468 "skipped unsupported type = %d\n", __func__, type)do {} while(0);
2469 *ispcm = 0;
2470 return 1;
2471 }
2472 if (!uaudio_getnum(p, 1, &nch))
2473 return 0;
2474 if (!uaudio_getnum(p, 1, &bps))
2475 return 0;
2476 if (!uaudio_getnum(p, 1, &bits))
2477 return 0;
2478 if (!uaudio_getnum(p, 1, &nrates))
2479 return 0;
2480 rates = 0;
2481 if (nrates == 0) {
2482 if (!uaudio_getnum(p, 3, &rate_min))
2483 return 0;
2484 if (!uaudio_getnum(p, 3, &rate_max))
2485 return 0;
2486 for (i = 0; i < nitems(uaudio_rates)(sizeof((uaudio_rates)) / sizeof((uaudio_rates)[0])); i++) {
2487 if (uaudio_rates[i] >= rate_min &&
2488 uaudio_rates[i] <= rate_max)
2489 rates |= 1 << i;
2490 }
2491 } else {
2492 for (j = 0; j < nrates; j++) {
2493 if (!uaudio_getnum(p, 3, &rate_min))
2494 return 0;
2495 for (i = 0; i < nitems(uaudio_rates)(sizeof((uaudio_rates)) / sizeof((uaudio_rates)[0])); i++) {
2496 if (uaudio_rates[i] == rate_min)
2497 rates |= 1 << i;
2498 }
2499 }
2500 }
2501 a->v1_rates = rates;
2502 a->nch = nch;
2503 break;
2504 case UAUDIO_V20x200:
2505 /*
2506 * sample rate ranges are obtained with requests to
2507 * the clock source, as defined by the clock source
2508 * descriptor
2509 *
2510 * the number of channels is in the GENERAL descriptor
2511 */
2512 if (!uaudio_getnum(p, 1, &type))
2513 return 0;
2514 if (type != 1) {
2515 DPRINTF("%s: class v2: "do {} while(0)
2516 "skipped unsupported type = %d\n", __func__, type)do {} while(0);
2517 *ispcm = 0;
2518 return 1;
2519 }
2520 if (!uaudio_getnum(p, 1, &bps))
2521 return 0;
2522 if (!uaudio_getnum(p, 1, &bits))
2523 return 0;
2524
2525 /*
2526 * nch is in the v2 general desc, rates come from the
2527 * clock source, so we're done.
2528 */
2529 break;
2530 }
2531 a->bps = bps;
2532 a->bits = bits;
2533 *ispcm = 1;
2534 return 1;
2535}
2536
2537/*
2538 * Parse AS descriptors.
2539 *
2540 * The audio streaming (AS) interfaces are used to move data between
2541 * the host and the device. On the one hand, the device has
2542 * analog-to-digital (ADC) and digital-to-analog (DAC) converters
2543 * which have their own low-jitter clock source. On other hand, the
2544 * USB host runs a bus clock using another clock source. So both
2545 * drift. That's why, the device sends feedback to the driver for the
2546 * host to adjust continuously its data rate, hence the need for sync
2547 * endpoints.
2548 */
2549int
2550uaudio_process_as(struct uaudio_softc *sc,
2551 struct uaudio_blob *p, int ifnum, int altnum, int nep)
2552{
2553 struct uaudio_alt *a, *anext, **pa;
2554 struct uaudio_blob dp;
2555 unsigned char *savep;
2556 unsigned int type, subtype;
2557 int ispcm = 0;
2558
2559 a = malloc(sizeof(struct uaudio_alt), M_USBDEV102, M_WAITOK0x0001);
2560 a->mode = 0;
2561 a->nch = 0;
2562 a->v1_rates = 0;
2563 a->data_addr = 0;
2564 a->sync_addr = 0;
2565 a->ifnum = ifnum;
2566 a->altnum = altnum;
2567
2568 while (p->rptr != p->wptr) {
2569 savep = p->rptr;
2570 if (!uaudio_getdesc(p, &dp))
2571 goto failed;
2572 if (!uaudio_getnum(&dp, 1, &type))
2573 goto failed;
2574 if (type != UDESC_CS_INTERFACE0x24) {
2575 p->rptr = savep;
2576 break;
2577 }
2578 if (!uaudio_getnum(&dp, 1, &subtype))
2579 goto failed;
2580 switch (subtype) {
2581 case UAUDIO_AS_GENERAL0x1:
2582 if (!uaudio_process_as_general(sc, &dp, &ispcm, a))
2583 goto failed;
2584 break;
2585 case UAUDIO_AS_FORMAT0x2:
2586 if (!uaudio_process_as_format(sc, &dp, a, &ispcm))
2587 goto failed;
2588 break;
2589 default:
2590 DPRINTF("%s: unknown desc\n", __func__)do {} while(0);
2591 continue;
2592 }
2593 if (!ispcm) {
2594 DPRINTF("%s: non-pcm iface\n", __func__)do {} while(0);
2595 free(a, M_USBDEV102, sizeof(struct uaudio_alt));
2596 return 1;
2597 }
2598 }
2599
2600
2601 while (p->rptr != p->wptr) {
2602 savep = p->rptr;
2603 if (!uaudio_getdesc(p, &dp))
2604 goto failed;
2605 if (!uaudio_getnum(&dp, 1, &type))
2606 goto failed;
2607 if (type == UDESC_CS_ENDPOINT0x25)
2608 continue;
2609 if (type != UDESC_ENDPOINT0x05) {
2610 p->rptr = savep;
2611 break;
2612 }
2613 if (!uaudio_process_as_ep(sc, &dp, a, nep))
2614 goto failed;
2615 }
2616
2617 if (a->mode == 0) {
2618 printf("%s: no data endpoints found\n", DEVNAME(sc)((sc)->dev.dv_xname));
2619 free(a, M_USBDEV102, sizeof(struct uaudio_alt));
2620 return 1;
2621 }
2622
2623 /*
2624 * Append to list of alts, but keep the list sorted by number
2625 * of channels, bits and rate. From the most capable to the
2626 * less capable.
2627 */
2628 pa = &sc->alts;
2629 while (1) {
2630 if ((anext = *pa) == NULL((void *)0))
2631 break;
2632 if (a->nch > anext->nch)
2633 break;
2634 else if (a->nch == anext->nch) {
2635 if (a->bits > anext->bits)
2636 break;
2637 else if (sc->version == UAUDIO_V10x100 &&
2638 a->v1_rates > anext->v1_rates)
2639 break;
2640 }
2641 pa = &anext->next;
2642 }
2643 a->next = *pa;
2644 *pa = a;
2645 return 1;
2646failed:
2647 free(a, M_USBDEV102, sizeof(struct uaudio_alt));
2648 return 0;
2649}
2650
2651/*
2652 * Populate the sc->params_list with combinations of play and rec alt
2653 * settings that work together in full-duplex.
2654 */
2655void
2656uaudio_fixup_params(struct uaudio_softc *sc)
2657{
2658 struct uaudio_alt *ap, *ar, *a;
2659 struct uaudio_params *p, **pp;
2660 int rates;
2661
2662 /*
2663 * Add full-duplex parameter combinations.
2664 */
2665 pp = &sc->params_list;
2666 for (ap = sc->alts; ap != NULL((void *)0); ap = ap->next) {
2667 if (ap->mode != AUMODE_PLAY0x01)
2668 continue;
2669 for (ar = sc->alts; ar != NULL((void *)0); ar = ar->next) {
2670 if (ar->mode != AUMODE_RECORD0x02)
2671 continue;
2672 if (ar->bps != ap->bps || ar->bits != ap->bits)
2673 continue;
2674 switch (sc->version) {
2675 case UAUDIO_V10x100:
2676 rates = ap->v1_rates & ar->v1_rates;
2677 if (rates == 0)
2678 continue;
2679 break;
2680 case UAUDIO_V20x200:
2681 /* UAC v2.0 common rates */
2682 rates = 0;
2683 break;
2684 }
2685 p = malloc(sizeof(struct uaudio_params),
2686 M_USBDEV102, M_WAITOK0x0001);
2687 p->palt = ap;
2688 p->ralt = ar;
2689 p->v1_rates = rates;
2690 p->next = NULL((void *)0);
2691 *pp = p;
2692 pp = &p->next;
2693 }
2694 }
2695
2696 /*
2697 * For unidirectional devices, add play-only and or rec-only
2698 * parameters.
2699 */
2700 if (sc->params_list == NULL((void *)0)) {
2701 for (a = sc->alts; a != NULL((void *)0); a = a->next) {
2702 p = malloc(sizeof(struct uaudio_params),
2703 M_USBDEV102, M_WAITOK0x0001);
2704 if (a->mode == AUMODE_PLAY0x01) {
2705 p->palt = a;
2706 p->ralt = NULL((void *)0);
2707 } else {
2708 p->palt = NULL((void *)0);
2709 p->ralt = a;
2710 }
2711 p->v1_rates = a->v1_rates;
2712 p->next = NULL((void *)0);
2713 *pp = p;
2714 pp = &p->next;
2715 }
2716 }
2717}
2718
2719/*
2720 * Parse all descriptors and build configuration of the device.
2721 */
2722int
2723uaudio_process_conf(struct uaudio_softc *sc, struct uaudio_blob *p)
2724{
2725 struct uaudio_blob dp;
2726 unsigned int type, ifnum, altnum, nep, class, subclass;
2727
2728 while (p->rptr != p->wptr) {
6
Assuming field 'rptr' is not equal to field 'wptr'
7
Loop condition is true. Entering loop body
2729 if (!uaudio_getdesc(p, &dp))
8
Taking false branch
2730 return 0;
2731 if (!uaudio_getnum(&dp, 1, &type))
9
Taking false branch
2732 return 0;
2733 if (type != UDESC_INTERFACE0x04)
10
Assuming 'type' is equal to UDESC_INTERFACE
11
Taking false branch
2734 continue;
2735 if (!uaudio_getnum(&dp, 1, &ifnum))
12
Taking false branch
2736 return 0;
2737 if (!uaudio_getnum(&dp, 1, &altnum))
13
Taking false branch
2738 return 0;
2739 if (!uaudio_getnum(&dp, 1, &nep))
14
Taking false branch
2740 return 0;
2741 if (!uaudio_getnum(&dp, 1, &class))
15
Taking false branch
2742 return 0;
2743 if (!uaudio_getnum(&dp, 1, &subclass))
16
Taking false branch
2744 return 0;
2745 if (class != UICLASS_AUDIO0x01) {
17
Assuming 'class' is equal to UICLASS_AUDIO
18
Taking false branch
2746 DPRINTF("%s: skipped iface\n", __func__)do {} while(0);
2747 continue;
2748 }
2749
2750 switch (subclass) {
19
Control jumps to 'case 1:' at line 2751
2751 case UISUBCLASS_AUDIOCONTROL1:
2752 usbd_claim_iface(sc->udev, ifnum);
2753 if (sc->unit_list
19.1
Field 'unit_list' is equal to NULL
!= NULL((void *)0)) {
20
Taking false branch
2754 DPRINTF("%s: >1 AC ifaces\n", __func__)do {} while(0);
2755 goto done;
2756 }
2757 if (!uaudio_process_ac(sc, p, ifnum))
21
Calling 'uaudio_process_ac'
2758 return 0;
2759 break;
2760 case UISUBCLASS_AUDIOSTREAM2:
2761 usbd_claim_iface(sc->udev, ifnum);
2762 if (nep == 0) {
2763 DPRINTF("%s: "do {} while(0)
2764 "stop altnum %d\n", __func__, altnum)do {} while(0);
2765 break; /* 0 is "stop sound", skip it */
2766 }
2767 if (!uaudio_process_as(sc, p, ifnum, altnum, nep))
2768 return 0;
2769 }
2770 }
2771done:
2772 uaudio_fixup_params(sc);
2773
2774 return 1;
2775}
2776
2777/*
2778 * Allocate a isochronous transfer and its bounce-buffers with the
2779 * given maximum framesize and maximum frames per transfer.
2780 */
2781int
2782uaudio_xfer_alloc(struct uaudio_softc *sc, struct uaudio_xfer *xfer,
2783 unsigned int framesize, unsigned int count)
2784{
2785 xfer->usb_xfer = usbd_alloc_xfer(sc->udev);
2786 if (xfer->usb_xfer == NULL((void *)0))
2787 return ENOMEM12;
2788
2789 xfer->buf = usbd_alloc_buffer(xfer->usb_xfer, framesize * count);
2790 if (xfer->buf == NULL((void *)0))
2791 return ENOMEM12;
2792
2793 xfer->sizes = mallocarray(count,
2794 sizeof(xfer->sizes[0]), M_USBDEV102, M_WAITOK0x0001);
2795 if (xfer->sizes == NULL((void *)0))
2796 return ENOMEM12;
2797
2798 return 0;
2799}
2800
2801/*
2802 * Free a isochronous transfer and its bounce-buffers.
2803 */
2804void
2805uaudio_xfer_free(struct uaudio_softc *sc, struct uaudio_xfer *xfer,
2806 unsigned int count)
2807{
2808 if (xfer->usb_xfer != NULL((void *)0)) {
2809 /* frees request buffer as well */
2810 usbd_free_xfer(xfer->usb_xfer);
2811 xfer->usb_xfer = NULL((void *)0);
2812 }
2813 if (xfer->sizes != NULL((void *)0)) {
2814 free(xfer->sizes, M_USBDEV102,
2815 sizeof(xfer->sizes[0]) * count);
2816 xfer->sizes = NULL((void *)0);
2817 }
2818}
2819
2820/*
2821 * Close a stream and free all associated resources
2822 */
2823void
2824uaudio_stream_close(struct uaudio_softc *sc, int dir)
2825{
2826 struct uaudio_stream *s = &sc->pstream;
2827 struct uaudio_alt *a = sc->params->palt;
2828 struct usbd_interface *iface;
2829 int err, i;
2830
2831 if (dir == AUMODE_PLAY0x01) {
2832 s = &sc->pstream;
2833 a = sc->params->palt;
2834 } else {
2835 s = &sc->rstream;
2836 a = sc->params->ralt;
2837 }
2838
2839 if (s->data_pipe) {
2840 usbd_close_pipe(s->data_pipe);
2841 s->data_pipe = NULL((void *)0);
2842 }
2843
2844 if (s->sync_pipe) {
2845 usbd_close_pipe(s->sync_pipe);
2846 s->sync_pipe = NULL((void *)0);
2847 }
2848
2849 err = usbd_device2interface_handle(sc->udev, a->ifnum, &iface);
2850 if (err)
2851 printf("%s: can't get iface handle\n", DEVNAME(sc)((sc)->dev.dv_xname));
2852 else {
2853 err = usbd_set_interface(iface, 0);
2854 if (err)
2855 printf("%s: can't reset interface\n", DEVNAME(sc)((sc)->dev.dv_xname));
2856 }
2857
2858 for (i = 0; i < UAUDIO_NXFERS_MAX8; i++) {
2859 uaudio_xfer_free(sc, s->data_xfers + i, s->nframes_max);
2860 uaudio_xfer_free(sc, s->sync_xfers + i, 1);
2861 }
2862}
2863
2864/*
2865 * Open a stream with the given buffer settings and set the current
2866 * interface alt setting.
2867 */
2868int
2869uaudio_stream_open(struct uaudio_softc *sc, int dir,
2870 void *start, void *end, size_t blksz, void (*intr)(void *), void *arg)
2871{
2872 struct uaudio_stream *s;
2873 struct uaudio_alt *a;
2874 struct usbd_interface *iface;
2875 unsigned char req_buf[4];
2876 unsigned int bpa, spf_max, min_blksz;
2877 int err, clock_id, i;
2878
2879 if (dir == AUMODE_PLAY0x01) {
2880 s = &sc->pstream;
2881 a = sc->params->palt;
2882 } else {
2883 s = &sc->rstream;
2884 a = sc->params->ralt;
2885 }
2886
2887 for (i = 0; i < UAUDIO_NXFERS_MAX8; i++) {
2888 s->data_xfers[i].usb_xfer = NULL((void *)0);
2889 s->data_xfers[i].sizes = NULL((void *)0);
2890 s->sync_xfers[i].usb_xfer = NULL((void *)0);
2891 s->sync_xfers[i].sizes = NULL((void *)0);
2892 }
2893 s->data_pipe = NULL((void *)0);
2894 s->sync_pipe = NULL((void *)0);
2895
2896 s->nframes_mask = 0;
2897 i = a->fps;
2898 while (i > 1000) {
2899 s->nframes_mask = (s->nframes_mask << 1) | 1;
2900 i >>= 1;
2901 }
2902
2903 /* bytes per audio frame */
2904 bpa = a->bps * a->nch;
2905
2906 /* ideal samples per usb frame, fixed-point */
2907 s->spf = (uint64_t)sc->rate * UAUDIO_SPF_DIV327680 / a->fps;
2908
2909 /*
2910 * UAC2.0 spec allows 1000PPM tolerance in sample frequency,
2911 * while USB1.1 requires 1Hz, which is 125PPM at 8kHz. We
2912 * accept as much as 1/256, which is 2500PPM.
2913 */
2914 s->spf_min = (uint64_t)s->spf * 255 / 256;
2915 s->spf_max = (uint64_t)s->spf * 257 / 256;
2916
2917 /* max spf can't exceed the device usb packet size */
2918 spf_max = (a->maxpkt / bpa) * UAUDIO_SPF_DIV327680;
2919 if (s->spf > spf_max) {
2920 printf("%s: samples per frame too large\n", DEVNAME(sc)((sc)->dev.dv_xname));
2921 return EIO5;
2922 }
2923 if (s->spf_max > spf_max)
2924 s->spf_max = spf_max;
2925
2926 /*
2927 * Upon transfer completion the device must reach the audio
2928 * block boundary, which is propagated to upper layers. In the
2929 * worst case, we schedule only frames of spf_max samples, but
2930 * the device returns only frames of spf_min samples; in this
2931 * case the amount actually transferred is at least:
2932 *
2933 * min_blksz = blksz / spf_max * spf_min
2934 *
2935 * As we've UAUDIO_NXFERS outstanding blocks, worst-case
2936 * remaining bytes is at most:
2937 *
2938 * UAUDIO_NXFERS * (blksz - min_blksz)
2939 */
2940 min_blksz = (((uint64_t)blksz << 32) / s->spf_max * s->spf_min) >> 32;
2941
2942 /* round to sample size */
2943 min_blksz -= min_blksz % bpa;
2944
2945 /* finally this is what ensures we cross block boundary */
2946 s->safe_blksz = blksz + UAUDIO_NXFERS_MAX8 * (blksz - min_blksz);
2947
2948 /* max number of (micro-)frames we'll ever use */
2949 s->nframes_max = (uint64_t)(s->safe_blksz / bpa) *
2950 UAUDIO_SPF_DIV327680 / s->spf_min + 1;
2951
2952 /* round to next usb1.1 frame */
2953 s->nframes_max = (s->nframes_max + s->nframes_mask) &
2954 ~s->nframes_mask;
2955
2956 /* this is the max packet size we'll ever need */
2957 s->maxpkt = bpa *
2958 ((s->spf_max + UAUDIO_SPF_DIV327680 - 1) / UAUDIO_SPF_DIV327680);
2959
2960 /* how many xfers we need to fill sc->host_nframes */
2961 s->nxfers = sc->host_nframes / s->nframes_max;
2962 if (s->nxfers > UAUDIO_NXFERS_MAX8)
2963 s->nxfers = UAUDIO_NXFERS_MAX8;
2964
2965 DPRINTF("%s: %s: blksz = %zu, rate = %u, fps = %u\n", __func__,do {} while(0)
2966 dir == AUMODE_PLAY ? "play" : "rec", blksz, sc->rate, a->fps)do {} while(0);
2967 DPRINTF("%s: spf = 0x%x in [0x%x:0x%x]\n", __func__,do {} while(0)
2968 s->spf, s->spf_min, s->spf_max)do {} while(0);
2969 DPRINTF("%s: nframes_max = %u, nframes_mask = %u, maxpkt = %u\n",do {} while(0)
2970 __func__, s->nframes_max, s->nframes_mask, s->maxpkt)do {} while(0);
2971 DPRINTF("%s: safe_blksz = %d, nxfers = %d\n", __func__,do {} while(0)
2972 s->safe_blksz, s->nxfers)do {} while(0);
2973
2974 if (s->nxfers < UAUDIO_NXFERS_MIN2) {
2975 printf("%s: block size too large\n", DEVNAME(sc)((sc)->dev.dv_xname));
2976 return EIO5;
2977 }
2978
2979 /*
2980 * Require at least 2ms block size to ensure no
2981 * transfer exceeds two blocks.
2982 *
2983 * XXX: use s->nframes_mask instead of 1000
2984 */
2985 if (1000 * blksz < 2 * sc->rate * bpa) {
2986 printf("%s: audio block too small\n", DEVNAME(sc)((sc)->dev.dv_xname));
2987 return EIO5;
2988 }
2989
2990 for (i = 0; i < s->nxfers; i++) {
2991 err = uaudio_xfer_alloc(sc, s->data_xfers + i,
2992 s->maxpkt, s->nframes_max);
2993 if (err)
2994 goto failed;
2995 if (a->sync_addr) {
2996 err = uaudio_xfer_alloc(sc, s->sync_xfers + i,
2997 sc->sync_pktsz, 1);
2998 if (err)
2999 goto failed;
3000 }
3001 }
3002
3003 err = usbd_device2interface_handle(sc->udev, a->ifnum, &iface);
3004 if (err) {
3005 printf("%s: can't get iface handle\n", DEVNAME(sc)((sc)->dev.dv_xname));
3006 goto failed;
3007 }
3008
3009 err = usbd_set_interface(iface, a->altnum);
3010 if (err) {
3011 printf("%s: can't set interface\n", DEVNAME(sc)((sc)->dev.dv_xname));
3012 goto failed;
3013 }
3014
3015 /*
3016 * Set the sample rate.
3017 *
3018 * Certain devices are able to lock their clock to the data
3019 * rate and expose no frequency control. In this case, the
3020 * request to set the frequency will fail, but this error is
3021 * safe to ignore.
3022 *
3023 * Such devices expose this capability in the class-specific
3024 * endpoint descriptor (UAC v1.0) or in the clock unit
3025 * descriptor (UAC v2.0) but we don't want to use them for now
3026 * as certain devices have them wrong, missing or misplaced.
3027 */
3028 switch (sc->version) {
3029 case UAUDIO_V10x100:
3030 req_buf[0] = sc->rate;
3031 req_buf[1] = sc->rate >> 8;
3032 req_buf[2] = sc->rate >> 16;
3033 if (!uaudio_req(sc, UT_WRITE_CLASS_ENDPOINT(0x00 | 0x20 | 0x02),
3034 UAUDIO_V1_REQ_SET_CUR0x01, UAUDIO_REQSEL_RATE0x01, 0,
3035 a->data_addr, 0, req_buf, 3)) {
3036 DPRINTF("%s: not setting endpoint rate\n", __func__)do {} while(0);
3037 }
3038 break;
3039 case UAUDIO_V20x200:
3040 req_buf[0] = sc->rate;
3041 req_buf[1] = sc->rate >> 8;
3042 req_buf[2] = sc->rate >> 16;
3043 req_buf[3] = sc->rate >> 24;
3044 clock_id = uaudio_clock_id(sc);
3045 if (clock_id < 0) {
3046 printf("%s: can't get clock id\n", DEVNAME(sc)((sc)->dev.dv_xname));
3047 goto failed;
3048 }
3049 if (!uaudio_req(sc, UT_WRITE_CLASS_INTERFACE(0x00 | 0x20 | 0x01),
3050 UAUDIO_V2_REQ_CUR1, UAUDIO_REQSEL_RATE0x01, 0,
3051 sc->ctl_ifnum, clock_id, req_buf, 4)) {
3052 DPRINTF("%s: not setting clock rate\n", __func__)do {} while(0);
3053 }
3054 break;
3055 }
3056
3057 err = usbd_open_pipe(iface, a->data_addr, 0, &s->data_pipe);
3058 if (err) {
3059 printf("%s: can't open data pipe\n", DEVNAME(sc)((sc)->dev.dv_xname));
3060 goto failed;
3061 }
3062
3063 if (a->sync_addr) {
3064 err = usbd_open_pipe(iface, a->sync_addr, 0, &s->sync_pipe);
3065 if (err) {
3066 printf("%s: can't open sync pipe\n", DEVNAME(sc)((sc)->dev.dv_xname));
3067 goto failed;
3068 }
3069 }
3070
3071 s->data_nextxfer = 0;
3072 s->sync_nextxfer = 0;
3073 s->spf_remain = 0;
3074
3075 s->intr = intr;
3076 s->arg = arg;
3077 s->ring_start = start;
3078 s->ring_end = end;
3079 s->ring_blksz = blksz;
3080
3081 s->ring_pos = s->ring_start;
3082 s->ring_offs = 0;
3083 s->ring_icnt = 0;
3084
3085 s->ubuf_xfer = 0;
3086 s->ubuf_pos = 0;
3087 return 0;
3088
3089failed:
3090 uaudio_stream_close(sc, dir);
3091 return ENOMEM12;
3092}
3093
3094/*
3095 * Adjust play samples-per-frame to keep play and rec streams in sync.
3096 */
3097void
3098uaudio_adjspf(struct uaudio_softc *sc)
3099{
3100 struct uaudio_stream *s = &sc->pstream;
3101 int diff;
3102
3103 if (sc->mode != (AUMODE_RECORD0x02 | AUMODE_PLAY0x01))
3104 return;
3105 if (s->sync_pipe != NULL((void *)0))
3106 return;
3107
3108 /*
3109 * number of samples play stream is ahead of record stream.
3110 */
3111 diff = sc->diff_nsamp;
3112 if (sc->diff_nframes > 0) {
3113 diff -= (uint64_t)sc->pstream.spf *
3114 sc->diff_nframes / UAUDIO_SPF_DIV327680;
3115 } else {
3116 diff += (uint64_t)sc->rstream.spf *
3117 -sc->diff_nframes / UAUDIO_SPF_DIV327680;
3118 }
3119
3120 /*
3121 * adjust samples-per-frames to resync within the next second
3122 */
3123 s->spf = (uint64_t)(sc->rate - diff) * UAUDIO_SPF_DIV327680 / sc->ufps;
3124 if (s->spf > s->spf_max)
3125 s->spf = s->spf_max;
3126 else if (s->spf < s->spf_min)
3127 s->spf = s->spf_min;
3128#ifdef UAUDIO_DEBUG
3129 if (uaudio_debug >= 2)
3130 printf("%s: diff = %d, spf = 0x%x\n", __func__, diff, s->spf);
3131#endif
3132}
3133
3134/*
3135 * Copy one audio block to the xfer buffer.
3136 */
3137void
3138uaudio_pdata_copy(struct uaudio_softc *sc)
3139{
3140 struct uaudio_stream *s = &sc->pstream;
3141 struct uaudio_xfer *xfer;
3142 size_t count, avail;
3143 int index;
3144#ifdef UAUDIO_DEBUG
3145 struct timeval tv;
3146
3147 getmicrotime(&tv);
3148#endif
3149 while (sc->copy_todo > 0 && s->ubuf_xfer < s->nxfers) {
3150 index = s->data_nextxfer + s->ubuf_xfer;
3151 if (index >= s->nxfers)
3152 index -= s->nxfers;
3153 xfer = s->data_xfers + index;
3154 avail = s->ring_end - s->ring_pos;
3155 count = xfer->size - s->ubuf_pos;
3156 if (count > avail)
3157 count = avail;
3158 if (count > sc->copy_todo)
3159 count = sc->copy_todo;
3160#ifdef UAUDIO_DEBUG
3161 if (uaudio_debug >= 2) {
3162 printf("%s: %llu.%06lu: %zd..%zd -> %u:%u..%zu\n",
3163 __func__, tv.tv_sec, tv.tv_usec,
3164 s->ring_pos - s->ring_start,
3165 s->ring_pos - s->ring_start + count,
3166 s->ubuf_xfer, s->ubuf_pos, s->ubuf_pos + count);
3167 }
3168#endif
3169 memcpy(xfer->buf + s->ubuf_pos, s->ring_pos, count)__builtin_memcpy((xfer->buf + s->ubuf_pos), (s->ring_pos
), (count))
;
3170 sc->copy_todo -= count;
3171 s->ring_pos += count;
3172 if (s->ring_pos == s->ring_end) {
3173 s->ring_pos = s->ring_start;
3174 }
3175 s->ubuf_pos += count;
3176 if (s->ubuf_pos == xfer->size) {
3177 usb_syncmem(&xfer->usb_xfer->dmabuf, 0, xfer->size,
3178 BUS_DMASYNC_PREWRITE0x04);
3179 s->ubuf_pos = 0;
3180#ifdef DIAGNOSTIC1
3181 if (s->ubuf_xfer == s->nxfers) {
3182 printf("%s: overflow\n", __func__);
3183 return;
3184 }
3185#endif
3186 s->ubuf_xfer++;
3187 }
3188 }
3189}
3190
3191/*
3192 * Calculate and fill xfer frames sizes.
3193 */
3194void
3195uaudio_pdata_calcsizes(struct uaudio_softc *sc, struct uaudio_xfer *xfer)
3196{
3197#ifdef UAUDIO_DEBUG
3198 struct timeval tv;
3199#endif
3200 struct uaudio_stream *s = &sc->pstream;
3201 struct uaudio_alt *a = sc->params->palt;
3202 unsigned int fsize, bpf;
3203 int done;
3204
3205 bpf = a->bps * a->nch;
3206 done = s->ring_offs;
3207 xfer->nframes = 0;
3208
3209 while (1) {
3210 /*
3211 * if we crossed the next block boundary, we're done
3212 */
3213 if ((xfer->nframes & s->nframes_mask) == 0 &&
3214 done > s->safe_blksz)
3215 break;
3216
3217 /*
3218 * this can't happen, debug only
3219 */
3220 if (xfer->nframes == s->nframes_max) {
3221 printf("%s: too many frames for play xfer: "
3222 "done = %u, blksz = %d\n",
3223 DEVNAME(sc)((sc)->dev.dv_xname), done, s->ring_blksz);
3224 break;
3225 }
3226
3227 /*
3228 * calculate frame size and adjust state
3229 */
3230 s->spf_remain += s->spf;
3231 fsize = s->spf_remain / UAUDIO_SPF_DIV327680 * bpf;
3232 s->spf_remain %= UAUDIO_SPF_DIV327680;
3233 done += fsize;
3234 xfer->sizes[xfer->nframes] = fsize;
3235 xfer->nframes++;
3236 }
3237
3238 xfer->size = done - s->ring_offs;
3239 s->ring_offs = done - s->ring_blksz;
3240
3241#ifdef UAUDIO_DEBUG
3242 if (uaudio_debug >= 3) {
3243 getmicrotime(&tv);
3244 printf("%s: size = %d, offs -> %d\n", __func__,
3245 xfer->size, s->ring_offs);
3246 }
3247#endif
3248 memset(xfer->buf, 0, xfer->size)__builtin_memset((xfer->buf), (0), (xfer->size));
3249}
3250
3251/*
3252 * Submit a play data transfer to the USB driver.
3253 */
3254void
3255uaudio_pdata_xfer(struct uaudio_softc *sc)
3256{
3257#ifdef UAUDIO_DEBUG
3258 struct timeval tv;
3259#endif
3260 struct uaudio_stream *s = &sc->pstream;
3261 struct uaudio_xfer *xfer;
3262 int err;
3263
3264 xfer = s->data_xfers + s->data_nextxfer;
3265
3266#ifdef UAUDIO_DEBUG
3267 if (uaudio_debug >= 3) {
3268 getmicrotime(&tv);
3269 printf("%s: %llu.%06lu: "
3270 "%d bytes, %u frames, remain = 0x%x, offs = %d\n",
3271 __func__, tv.tv_sec, tv.tv_usec,
3272 xfer->size, xfer->nframes,
3273 s->spf_remain, s->ring_offs);
3274 }
3275#endif
3276
3277 /* this can't happen, debug only */
3278 if (xfer->nframes == 0) {
3279 printf("%s: zero frame play xfer\n", DEVNAME(sc)((sc)->dev.dv_xname));
3280 return;
3281 }
3282
3283 /*
3284 * We accept short transfers because in case of babble/stale frames
3285 * the transfer will be short
3286 */
3287 usbd_setup_isoc_xfer(xfer->usb_xfer, s->data_pipe, sc,
3288 xfer->sizes, xfer->nframes,
3289 USBD_NO_COPY0x01 | USBD_SHORT_XFER_OK0x04,
3290 uaudio_pdata_intr);
3291
3292 err = usbd_transfer(xfer->usb_xfer);
3293 if (err != 0 && err != USBD_IN_PROGRESS)
3294 printf("%s: play xfer, err = %d\n", DEVNAME(sc)((sc)->dev.dv_xname), err);
3295
3296 if (++s->data_nextxfer == s->nxfers)
3297 s->data_nextxfer = 0;
3298}
3299
3300/*
3301 * Callback called by the USB driver upon completion of play data transfer.
3302 */
3303void
3304uaudio_pdata_intr(struct usbd_xfer *usb_xfer, void *arg, usbd_status status)
3305{
3306#ifdef UAUDIO_DEBUG
3307 struct timeval tv;
3308#endif
3309 struct uaudio_softc *sc = arg;
3310 struct uaudio_stream *s = &sc->pstream;
3311 struct uaudio_xfer *xfer;
3312 uint32_t size;
3313 int nintr;
3314
3315 if (status != 0 && status != USBD_IOERROR) {
3316 DPRINTF("%s: xfer status = %d\n", __func__, status)do {} while(0);
3317 return;
3318 }
3319
3320 xfer = s->data_xfers + s->data_nextxfer;
3321 if (xfer->usb_xfer != usb_xfer) {
3322 DPRINTF("%s: wrong xfer\n", __func__)do {} while(0);
3323 return;
3324 }
3325
3326 sc->diff_nsamp += xfer->size /
3327 (sc->params->palt->nch * sc->params->palt->bps);
3328 sc->diff_nframes += xfer->nframes;
3329
3330#ifdef UAUDIO_DEBUG
3331 if (uaudio_debug >= 2) {
3332 getmicrotime(&tv);
3333 printf("%s: %llu.%06lu: %u: %u bytes\n",
3334 __func__, tv.tv_sec, tv.tv_usec,
3335 s->data_nextxfer, xfer->size);
3336 }
3337#endif
3338 usbd_get_xfer_status(usb_xfer, NULL((void *)0), NULL((void *)0), &size, NULL((void *)0));
3339 if (size != xfer->size) {
3340 DPRINTF("%s: %u bytes out of %u: incomplete play xfer\n",do {} while(0)
3341 DEVNAME(sc), size, xfer->size)do {} while(0);
3342 }
3343
3344 /*
3345 * Upper layer call-back may call uaudio_underrun(), which
3346 * needs the current size of this transfer. So, don't
3347 * recalculate the sizes and don't schedule the transfer yet.
3348 */
3349 s->ring_icnt += xfer->size;
3350 nintr = 0;
3351 mtx_enter(&audio_lock);
3352 while (s->ring_icnt >= s->ring_blksz) {
3353 s->intr(s->arg);
3354 s->ring_icnt -= s->ring_blksz;
3355 nintr++;
3356 }
3357 mtx_leave(&audio_lock);
3358 if (nintr != 1)
3359 printf("%s: %d: bad play intr count\n", __func__, nintr);
3360
3361 uaudio_pdata_calcsizes(sc, xfer);
3362 uaudio_pdata_xfer(sc);
3363#ifdef DIAGNOSTIC1
3364 if (s->ubuf_xfer == 0) {
3365 printf("%s: underflow\n", __func__);
3366 return;
3367 }
3368#endif
3369 s->ubuf_xfer--;
3370 uaudio_pdata_copy(sc);
3371}
3372
3373/*
3374 * Submit a play sync transfer to the USB driver.
3375 */
3376void
3377uaudio_psync_xfer(struct uaudio_softc *sc)
3378{
3379#ifdef UAUDIO_DEBUG
3380 struct timeval tv;
3381#endif
3382 struct uaudio_stream *s = &sc->pstream;
3383 struct uaudio_xfer *xfer;
3384 unsigned int i;
3385 int err;
3386
3387 xfer = s->sync_xfers + s->sync_nextxfer;
3388 xfer->nframes = 1;
3389
3390 for (i = 0; i < xfer->nframes; i++)
3391 xfer->sizes[i] = sc->sync_pktsz;
3392
3393 xfer->size = xfer->nframes * sc->sync_pktsz;
3394
3395#ifdef UAUDIO_DEBUG
3396 memset(xfer->buf, 0xd0, sc->sync_pktsz * xfer->nframes)__builtin_memset((xfer->buf), (0xd0), (sc->sync_pktsz *
xfer->nframes))
;
3397#endif
3398
3399 usbd_setup_isoc_xfer(xfer->usb_xfer, s->sync_pipe, sc,
3400 xfer->sizes, xfer->nframes,
3401 USBD_NO_COPY0x01 | USBD_SHORT_XFER_OK0x04,
3402 uaudio_psync_intr);
3403
3404 err = usbd_transfer(xfer->usb_xfer);
3405 if (err != 0 && err != USBD_IN_PROGRESS)
3406 printf("%s: sync play xfer, err = %d\n", DEVNAME(sc)((sc)->dev.dv_xname), err);
3407
3408 if (++s->sync_nextxfer == s->nxfers)
3409 s->sync_nextxfer = 0;
3410
3411#ifdef UAUDIO_DEBUG
3412 if (uaudio_debug >= 3) {
3413 getmicrotime(&tv);
3414 printf("%s: %llu.%06lu: %dB, %d fr\n", __func__,
3415 tv.tv_sec, tv.tv_usec, sc->sync_pktsz, xfer->nframes);
3416 }
3417#endif
3418}
3419
3420/*
3421 * Callback called by the USB driver upon completion of play sync transfer.
3422 */
3423void
3424uaudio_psync_intr(struct usbd_xfer *usb_xfer, void *arg, usbd_status status)
3425{
3426#ifdef UAUDIO_DEBUG
3427 struct timeval tv;
3428#endif
3429 struct uaudio_softc *sc = arg;
3430 struct uaudio_stream *s = &sc->pstream;
3431 struct uaudio_xfer *xfer;
3432 unsigned char *buf;
3433 unsigned int i;
3434 int32_t val;
3435
3436 if (status != 0) {
3437 DPRINTF("%s: xfer status = %d\n", __func__, status)do {} while(0);
3438 return;
3439 }
3440
3441 xfer = s->sync_xfers + s->sync_nextxfer;
3442 if (xfer->usb_xfer != usb_xfer) {
3443 DPRINTF("%s: wrong xfer\n", __func__)do {} while(0);
3444 return;
3445 }
3446
3447 /* XXX: there's only one frame, the loop is not necessary */
3448
3449 buf = xfer->buf;
3450 for (i = 0; i < xfer->nframes; i++) {
3451 if (xfer->sizes[i] == sc->sync_pktsz) {
3452 val = buf[0] | buf[1] << 8 | buf[2] << 16;
3453 if (sc->sync_pktsz == 4)
3454 val |= xfer->buf[3] << 24;
3455 else
3456 val <<= 2;
3457 val *= UAUDIO_SPF_DIV327680 / (1 << 16);
3458#ifdef UAUDIO_DEBUG
3459 if (uaudio_debug >= 2) {
3460 getmicrotime(&tv);
3461 printf("%s: %llu.%06lu: spf: %08x\n",
3462 __func__, tv.tv_sec, tv.tv_usec, val);
3463 }
3464#endif
3465 if (val > s->spf_max)
3466 s->spf = s->spf_max;
3467 else if (val < s->spf_min)
3468 s->spf = s->spf_min;
3469 else
3470 s->spf = val;
3471 }
3472 buf += sc->sync_pktsz;
3473 }
3474
3475 uaudio_psync_xfer(sc);
3476}
3477
3478/*
3479 * Submit a rec data transfer to the USB driver.
3480 */
3481void
3482uaudio_rdata_xfer(struct uaudio_softc *sc)
3483{
3484#ifdef UAUDIO_DEBUG
3485 struct timeval tv;
3486#endif
3487 struct uaudio_stream *s = &sc->rstream;
3488 struct uaudio_alt *a = sc->params->ralt;
3489 struct uaudio_xfer *xfer;
3490 unsigned int fsize, bpf;
3491 int done;
3492 int err;
3493
3494 xfer = s->data_xfers + s->data_nextxfer;
3495 bpf = a->bps * a->nch;
3496 xfer->nframes = 0;
3497 done = s->ring_offs;
3498
3499 while (1) {
3500 /*
3501 * if we crossed the next block boundary, we're done
3502 */
3503 if ((xfer->nframes & s->nframes_mask) == 0 &&
3504 done > s->safe_blksz) {
3505 done:
3506 xfer->size = done - s->ring_offs;
3507 s->ring_offs = done - s->ring_blksz;
3508 break;
3509 }
3510
3511 /*
3512 * this can't happen, debug only
3513 */
3514 if (xfer->nframes == s->nframes_max) {
3515 printf("%s: too many frames for rec xfer: "
3516 "done = %d, blksz = %d\n",
3517 DEVNAME(sc)((sc)->dev.dv_xname), done, s->ring_blksz);
3518 goto done;
3519 }
3520
3521 /*
3522 * estimate next block using s->spf, but allow
3523 * transfers up to maxpkt
3524 */
3525 s->spf_remain += s->spf;
3526 fsize = s->spf_remain / UAUDIO_SPF_DIV327680 * bpf;
3527 s->spf_remain %= UAUDIO_SPF_DIV327680;
3528 done += fsize;
3529 xfer->sizes[xfer->nframes] = s->maxpkt;
3530 xfer->nframes++;
3531 }
3532
3533#ifdef UAUDIO_DEBUG
3534 if (uaudio_debug >= 3) {
3535 getmicrotime(&tv);
3536 printf("%s: %llu.%06lu: "
3537 "%u fr, %d bytes (max %d), offs = %d\n",
3538 __func__, tv.tv_sec, tv.tv_usec,
3539 xfer->nframes, xfer->size,
3540 s->maxpkt * xfer->nframes, s->ring_offs);
3541 }
3542#endif
3543
3544 /* this can't happen, debug only */
3545 if (xfer->nframes == 0) {
3546 printf("%s: zero frame rec xfer\n", DEVNAME(sc)((sc)->dev.dv_xname));
3547 return;
3548 }
3549
3550#ifdef UAUDIO_DEBUG
3551 memset(xfer->buf, 0xd0, s->maxpkt * xfer->nframes)__builtin_memset((xfer->buf), (0xd0), (s->maxpkt * xfer
->nframes))
;
3552#endif
3553 usbd_setup_isoc_xfer(xfer->usb_xfer, s->data_pipe, sc,
3554 xfer->sizes, xfer->nframes, USBD_NO_COPY0x01 | USBD_SHORT_XFER_OK0x04,
3555 uaudio_rdata_intr);
3556
3557 err = usbd_transfer(xfer->usb_xfer);
3558 if (err != 0 && err != USBD_IN_PROGRESS)
3559 printf("%s: rec xfer, err = %d\n", DEVNAME(sc)((sc)->dev.dv_xname), err);
3560
3561 if (++s->data_nextxfer == s->nxfers)
3562 s->data_nextxfer = 0;
3563}
3564
3565/*
3566 * Callback called by the USB driver upon completion of rec data transfer.
3567 */
3568void
3569uaudio_rdata_intr(struct usbd_xfer *usb_xfer, void *arg, usbd_status status)
3570{
3571#ifdef UAUDIO_DEBUG
3572 struct timeval tv;
3573#endif
3574 struct uaudio_softc *sc = arg;
3575 struct uaudio_stream *s = &sc->rstream;
3576 struct uaudio_alt *a = sc->params->ralt;
3577 struct uaudio_xfer *xfer;
3578 unsigned char *buf, *framebuf;
3579 unsigned int count, fsize, fsize_min, nframes, bpf;
3580 unsigned int data_size, null_count;
3581 unsigned int nintr;
3582
3583 if (status != 0) {
3584 DPRINTF("%s: xfer status = %d\n", __func__, status)do {} while(0);
3585 return;
3586 }
3587
3588 xfer = s->data_xfers + s->data_nextxfer;
3589 if (xfer->usb_xfer != usb_xfer) {
3590 DPRINTF("%s: wrong xfer\n", __func__)do {} while(0);
3591 return;
3592 }
3593
3594 bpf = a->bps * a->nch;
3595 framebuf = xfer->buf;
3596 nframes = 0;
3597 null_count = 0;
3598 data_size = 0;
3599 fsize_min = s->spf_min / UAUDIO_SPF_DIV327680;
3600 for (nframes = 0; nframes < xfer->nframes; nframes++) {
3601
3602 /*
3603 * Device clock may take some time to lock during which
3604 * we'd receive empty or incomplete packets for which we
3605 * need to generate silence.
3606 */
3607 fsize = xfer->sizes[nframes];
3608 if (fsize < fsize_min) {
3609 s->spf_remain += s->spf;
3610 fsize = s->spf_remain / UAUDIO_SPF_DIV327680 * bpf;
3611 s->spf_remain %= UAUDIO_SPF_DIV327680;
3612 memset(framebuf, 0, fsize)__builtin_memset((framebuf), (0), (fsize));
3613 null_count++;
3614 }
3615 data_size += fsize;
3616
3617 /*
3618 * fill ring from frame buffer, handling
3619 * boundary conditions
3620 */
3621 buf = framebuf;
3622 while (fsize > 0) {
3623 count = s->ring_end - s->ring_pos;
3624 if (count > fsize)
3625 count = fsize;
3626 memcpy(s->ring_pos, buf, count)__builtin_memcpy((s->ring_pos), (buf), (count));
3627 s->ring_pos += count;
3628 if (s->ring_pos == s->ring_end)
3629 s->ring_pos = s->ring_start;
3630 buf += count;
3631 fsize -= count;
3632 }
3633
3634 framebuf += s->maxpkt;
3635 }
3636
3637 s->ring_offs += data_size - xfer->size;
3638 s->ring_icnt += data_size;
3639
3640 sc->diff_nsamp -= data_size /
3641 (sc->params->ralt->nch * sc->params->ralt->bps);
3642 sc->diff_nframes -= xfer->nframes;
3643
3644 sc->adjspf_age += xfer->nframes;
3645 if (sc->adjspf_age >= sc->ufps / 8) {
3646 sc->adjspf_age -= sc->ufps / 8;
3647 uaudio_adjspf(sc);
3648 }
3649
3650#ifdef UAUDIO_DEBUG
3651 if (uaudio_debug >= 2) {
3652 getmicrotime(&tv);
3653 printf("%s: %llu.%06lu: %u: "
3654 "%u bytes of %u, offs -> %d\n",
3655 __func__, tv.tv_sec, tv.tv_usec,
3656 s->data_nextxfer, data_size, xfer->size, s->ring_offs);
3657 }
3658 if (null_count > 0) {
3659 DPRINTF("%s: %u null frames out of %u: incomplete record xfer\n",do {} while(0)
3660 DEVNAME(sc), null_count, xfer->nframes)do {} while(0);
3661 }
3662#endif
3663 uaudio_rdata_xfer(sc);
3664
3665 nintr = 0;
3666 mtx_enter(&audio_lock);
3667 while (s->ring_icnt >= s->ring_blksz) {
3668 s->intr(s->arg);
3669 s->ring_icnt -= s->ring_blksz;
3670 nintr++;
3671 }
3672 mtx_leave(&audio_lock);
3673 if (nintr != 1)
3674 printf("%s: %u: bad rec intr count\n", DEVNAME(sc)((sc)->dev.dv_xname), nintr);
3675}
3676
3677/*
3678 * Start simultaneously playback and recording, unless trigger_input()
3679 * and trigger_output() were not both called yet.
3680 */
3681void
3682uaudio_trigger(struct uaudio_softc *sc)
3683{
3684 int i, s;
3685
3686 if (sc->mode != sc->trigger_mode)
3687 return;
3688
3689 DPRINTF("%s: preparing\n", __func__)do {} while(0);
3690 if (sc->mode & AUMODE_PLAY0x01) {
3691 for (i = 0; i < sc->pstream.nxfers; i++)
3692 uaudio_pdata_calcsizes(sc, sc->pstream.data_xfers + i);
3693
3694 uaudio_pdata_copy(sc);
3695 }
3696
3697 sc->diff_nsamp = 0;
3698 sc->diff_nframes = 0;
3699 sc->adjspf_age = 0;
3700
3701 DPRINTF("%s: starting\n", __func__)do {} while(0);
3702 s = splusb()splraise(0x5);
3703 for (i = 0; i < UAUDIO_NXFERS_MAX8; i++) {
3704 if ((sc->mode & AUMODE_PLAY0x01) && i < sc->pstream.nxfers) {
3705 if (sc->pstream.sync_pipe)
3706 uaudio_psync_xfer(sc);
3707 uaudio_pdata_xfer(sc);
3708 }
3709 if ((sc->mode & AUMODE_RECORD0x02) && i < sc->rstream.nxfers)
3710 uaudio_rdata_xfer(sc);
3711 }
3712 splx(s)spllower(s);
3713}
3714
3715void
3716uaudio_print(struct uaudio_softc *sc)
3717{
3718 struct uaudio_unit *u;
3719 struct uaudio_mixent *m;
3720 struct uaudio_params *p;
3721 int pchan = 0, rchan = 0, async = 0;
3722 int nctl = 0;
3723
3724 for (u = sc->unit_list; u != NULL((void *)0); u = u->unit_next) {
3725 m = u->mixent_list;
3726 while (1) {
3727 uaudio_mixer_skip(&m);
3728 if (m == NULL((void *)0))
3729 break;
3730 m = m->next;
3731 nctl++;
3732 }
3733 }
3734
3735 for (p = sc->params_list; p != NULL((void *)0); p = p->next) {
3736 if (p->palt && p->palt->nch > pchan)
3737 pchan = p->palt->nch;
3738 if (p->ralt && p->ralt->nch > rchan)
3739 rchan = p->ralt->nch;
3740 if (p->palt && p->palt->sync_addr)
3741 async = 1;
3742 if (p->ralt && p->ralt->sync_addr)
3743 async = 1;
3744 }
3745
3746 printf("%s: class v%d, %s, %s, channels: %d play, %d rec, %d ctls\n",
3747 DEVNAME(sc)((sc)->dev.dv_xname),
3748 sc->version >> 8,
3749 sc->ufps == 1000 ? "full-speed" : "high-speed",
3750 async ? "async" : "sync",
3751 pchan, rchan, nctl);
3752}
3753
3754int
3755uaudio_match(struct device *parent, void *match, void *aux)
3756{
3757 struct usb_attach_arg *arg = aux;
3758 struct usb_interface_descriptor *idesc;
3759
3760 if (arg->iface == NULL((void *)0) || arg->device == NULL((void *)0))
3761 return UMATCH_NONE0;
3762
3763 idesc = usbd_get_interface_descriptor(arg->iface);
3764 if (idesc == NULL((void *)0)) {
3765 DPRINTF("%s: couldn't get idesc\n", __func__)do {} while(0);
3766 return UMATCH_NONE0;
3767 }
3768
3769 if (idesc->bInterfaceClass != UICLASS_AUDIO0x01 ||
3770 idesc->bInterfaceSubClass != UISUBCLASS_AUDIOSTREAM2)
3771 return UMATCH_NONE0;
3772
3773 return UMATCH_VENDOR_PRODUCT_CONF_IFACE8;
3774}
3775
3776void
3777uaudio_attach(struct device *parent, struct device *self, void *aux)
3778{
3779 struct uaudio_softc *sc = (struct uaudio_softc *)self;
3780 struct usb_attach_arg *arg = aux;
3781 struct usb_config_descriptor *cdesc;
3782 struct uaudio_blob desc;
3783
3784 /*
3785 * this device has audio AC or AS or MS interface, get the
3786 * full config descriptor and attach audio devices
3787 */
3788
3789 cdesc = usbd_get_config_descriptor(arg->device);
3790 if (cdesc == NULL((void *)0))
1
Assuming 'cdesc' is not equal to NULL
2
Taking false branch
3791 return;
3792
3793 desc.rptr = (unsigned char *)cdesc;
3794 desc.wptr = desc.rptr + UGETW(cdesc->wTotalLength)(*(u_int16_t *)(cdesc->wTotalLength));
3795
3796 sc->udev = arg->device;
3797 sc->unit_list = NULL((void *)0);
3798 sc->names = NULL((void *)0);
3799 sc->alts = NULL((void *)0);
3800 sc->params_list = NULL((void *)0);
3801 sc->clock = NULL((void *)0);
3802 sc->params = NULL((void *)0);
3803 sc->rate = 0;
3804 sc->mode = 0;
3805 sc->trigger_mode = 0;
3806 sc->copy_todo = 0;
3807
3808 /*
3809 * Ideally the USB host controller should expose the number of
3810 * frames we're allowed to schedule, but there's no such
3811 * interface. The uhci(4) driver can buffer up to 128 frames
3812 * (or it crashes), ehci(4) starts recording null frames if we
3813 * exceed 256 (micro-)frames, ohci(4) works with at most 50
3814 * frames.
3815 */
3816 switch (sc->udev->speed) {
3
Control jumps to 'case 3:' at line 3823
3817 case USB_SPEED_LOW1:
3818 case USB_SPEED_FULL2:
3819 sc->ufps = 1000;
3820 sc->sync_pktsz = 3;
3821 sc->host_nframes = 50;
3822 break;
3823 case USB_SPEED_HIGH3:
3824 case USB_SPEED_SUPER4:
3825 sc->ufps = 8000;
3826 sc->sync_pktsz = 4;
3827 sc->host_nframes = 240;
3828 break;
4
Execution continues on line 3834
3829 default:
3830 printf("%s: unsupported bus speed\n", DEVNAME(sc)((sc)->dev.dv_xname));
3831 return;
3832 }
3833
3834 if (!uaudio_process_conf(sc, &desc))
5
Calling 'uaudio_process_conf'
3835 return;
3836
3837#ifdef UAUDIO_DEBUG
3838 if (uaudio_debug)
3839 uaudio_conf_print(sc);
3840#endif
3841 /* print a nice uaudio attach line */
3842 uaudio_print(sc);
3843
3844 audio_attach_mi(&uaudio_hw_if, sc, &sc->dev);
3845}
3846
3847int
3848uaudio_detach(struct device *self, int flags)
3849{
3850 struct uaudio_softc *sc = (struct uaudio_softc *)self;
3851 struct uaudio_unit *unit;
3852 struct uaudio_params *params;
3853 struct uaudio_alt *alt;
3854 struct uaudio_name *name;
3855 struct uaudio_mixent *mixent;
3856 int rv;
3857
3858 rv = config_detach_children(self, flags);
3859
3860 usbd_ref_wait(sc->udev);
3861
3862 while ((alt = sc->alts) != NULL((void *)0)) {
3863 sc->alts = alt->next;
3864 free(alt, M_USBDEV102, sizeof(struct uaudio_alt));
3865 }
3866
3867 while ((params = sc->params_list) != NULL((void *)0)) {
3868 sc->params_list = params->next;
3869 free(params, M_USBDEV102, sizeof(struct uaudio_params));
3870 }
3871
3872 while ((unit = sc->unit_list) != NULL((void *)0)) {
3873 sc->unit_list = unit->unit_next;
3874 while ((mixent = unit->mixent_list) != NULL((void *)0)) {
3875 unit->mixent_list = mixent->next;
3876 uaudio_ranges_clear(&mixent->ranges);
3877 free(mixent, M_USBDEV102, sizeof(struct uaudio_mixent));
3878 }
3879 uaudio_ranges_clear(&unit->rates);
3880 free(unit, M_USBDEV102, sizeof(struct uaudio_unit));
3881 }
3882
3883 while ((name = sc->names)) {
3884 sc->names = name->next;
3885 free(name, M_USBDEV102, sizeof(struct uaudio_name));
3886 }
3887
3888 return rv;
3889}
3890
3891int
3892uaudio_open(void *self, int flags)
3893{
3894 struct uaudio_softc *sc = self;
3895 struct uaudio_params *p;
3896
3897 if (usbd_is_dying(sc->udev))
3898 return EIO5;
3899
3900 usbd_ref_incr(sc->udev);
3901
3902 flags &= (FREAD0x0001 | FWRITE0x0002);
3903
3904 for (p = sc->params_list; p != NULL((void *)0); p = p->next) {
3905 switch (flags) {
3906 case FWRITE0x0002:
3907 if (!p->palt)
3908 break;
3909 sc->mode = AUMODE_PLAY0x01;
3910 return 0;
3911 case FREAD0x0001:
3912 if (!p->ralt)
3913 break;
3914 sc->mode = AUMODE_RECORD0x02;
3915 return 0;
3916 case FREAD0x0001 | FWRITE0x0002:
3917 if (!(p->ralt && p->palt))
3918 break;
3919 sc->mode = AUMODE_RECORD0x02 | AUMODE_PLAY0x01;
3920 return 0;
3921 }
3922 }
3923
3924 usbd_ref_decr(sc->udev);
3925 return ENXIO6;
3926}
3927
3928void
3929uaudio_close(void *self)
3930{
3931 struct uaudio_softc *sc = self;
3932
3933 sc->mode = 0;
3934 usbd_ref_decr(sc->udev);
3935}
3936
3937int
3938uaudio_set_params(void *self, int setmode, int usemode,
3939 struct audio_params *ap, struct audio_params *ar)
3940{
3941 struct uaudio_softc *sc = (struct uaudio_softc *)self;
3942 struct uaudio_params *p, *best_mode, *best_rate, *best_nch;
3943 int rate, rateindex;
3944
3945#ifdef DIAGNOSTIC1
3946 if (setmode != usemode || setmode != sc->mode) {
3947 printf("%s: bad call to uaudio_set_params()\n", DEVNAME(sc)((sc)->dev.dv_xname));
3948 return EINVAL22;
3949 }
3950 if (sc->mode == 0) {
3951 printf("%s: uaudio_set_params(): not open\n", DEVNAME(sc)((sc)->dev.dv_xname));
3952 return EINVAL22;
3953 }
3954#endif
3955 /*
3956 * audio(4) layer requests equal play and record rates
3957 */
3958 rate = (sc->mode & AUMODE_PLAY0x01) ? ap->sample_rate : ar->sample_rate;
3959 rateindex = uaudio_rates_indexof(~0, rate);
3960
3961 DPRINTF("%s: rate %d -> %d (index %d)\n", __func__,do {} while(0)
3962 rate, uaudio_rates[rateindex], rateindex)do {} while(0);
3963
3964 best_mode = best_rate = best_nch = NULL((void *)0);
3965
3966 for (p = sc->params_list; p != NULL((void *)0); p = p->next) {
3967
3968 /* test if params match the requested mode */
3969 if (sc->mode & AUMODE_PLAY0x01) {
3970 if (p->palt == NULL((void *)0))
3971 continue;
3972 }
3973 if (sc->mode & AUMODE_RECORD0x02) {
3974 if (p->ralt == NULL((void *)0))
3975 continue;
3976 }
3977 if (best_mode == NULL((void *)0))
3978 best_mode = p;
3979
3980 /* test if params match the requested rate */
3981 if ((uaudio_getrates(sc, p) & (1 << rateindex)) == 0)
3982 continue;
3983 if (best_rate == NULL((void *)0))
3984 best_rate = p;
3985
3986 /* test if params match the requested channel counts */
3987 if (sc->mode & AUMODE_PLAY0x01) {
3988 if (p->palt->nch != ap->channels)
3989 continue;
3990 }
3991 if (sc->mode & AUMODE_RECORD0x02) {
3992 if (p->ralt->nch != ar->channels)
3993 continue;
3994 }
3995 if (best_nch == NULL((void *)0))
3996 best_nch = p;
3997
3998 /* test if params match the requested precision */
3999 if (sc->mode & AUMODE_PLAY0x01) {
4000 if (p->palt->bits != ap->precision)
4001 continue;
4002 }
4003 if (sc->mode & AUMODE_RECORD0x02) {
4004 if (p->ralt->bits != ar->precision)
4005 continue;
4006 }
4007
4008 /* everything matched, we're done */
4009 break;
4010 }
4011
4012 if (p == NULL((void *)0)) {
4013 if (best_nch)
4014 p = best_nch;
4015 else if (best_rate)
4016 p = best_rate;
4017 else if (best_mode)
4018 p = best_mode;
4019 else
4020 return ENOTTY25;
4021 }
4022
4023 /*
4024 * Recalculate rate index, because the chosen parameters
4025 * may not support the requested one
4026 */
4027 rateindex = uaudio_rates_indexof(uaudio_getrates(sc, p), rate);
4028 if (rateindex < 0)
4029 return ENOTTY25;
4030
4031 sc->params = p;
4032 sc->rate = uaudio_rates[rateindex];
4033
4034 DPRINTF("%s: rate = %u\n", __func__, sc->rate)do {} while(0);
4035
4036 if (sc->mode & AUMODE_PLAY0x01) {
4037 ap->sample_rate = sc->rate;
4038 ap->precision = p->palt->bits;
4039 ap->encoding = AUDIO_ENCODING_SLINEAR_LE6;
4040 ap->bps = p->palt->bps;
4041 ap->msb = 1;
4042 ap->channels = p->palt->nch;
4043 }
4044 if (sc->mode & AUMODE_RECORD0x02) {
4045 ar->sample_rate = sc->rate;
4046 ar->precision = p->ralt->bits;
4047 ar->encoding = AUDIO_ENCODING_SLINEAR_LE6;
4048 ar->bps = p->ralt->bps;
4049 ar->msb = 1;
4050 ar->channels = p->ralt->nch;
4051 }
4052
4053 return 0;
4054}
4055
4056unsigned int
4057uaudio_set_blksz(void *self, int mode,
4058 struct audio_params *p, struct audio_params *r, unsigned int blksz)
4059{
4060 struct uaudio_softc *sc = self;
4061 unsigned int fps, fps_min;
4062 unsigned int blksz_max, blksz_min;
4063
4064 /*
4065 * minimum block size is two transfers, see uaudio_stream_open()
4066 */
4067 fps_min = sc->ufps;
4068 if (mode & AUMODE_PLAY0x01) {
4069 fps = sc->params->palt->fps;
4070 if (fps_min > fps)
4071 fps_min = fps;
4072 }
4073 if (mode & AUMODE_RECORD0x02) {
4074 fps = sc->params->ralt->fps;
4075 if (fps_min > fps)
4076 fps_min = fps;
4077 }
4078 blksz_min = (sc->rate * 2 + fps_min - 1) / fps_min;
4079
4080 /*
4081 * max block size is only limited by the number of frames the
4082 * host can schedule
4083 */
4084 blksz_max = sc->rate * (sc->host_nframes / UAUDIO_NXFERS_MIN2) /
4085 sc->ufps * 85 / 100;
4086
4087 if (blksz > blksz_max)
4088 blksz = blksz_max;
4089 else if (blksz < blksz_min)
4090 blksz = blksz_min;
4091
4092 return blksz;
4093}
4094
4095int
4096uaudio_trigger_output(void *self, void *start, void *end, int blksz,
4097 void (*intr)(void *), void *arg, struct audio_params *param)
4098{
4099 struct uaudio_softc *sc = self;
4100 int err;
4101
4102 err = uaudio_stream_open(sc,
4103 AUMODE_PLAY0x01, start, end, blksz, intr, arg);
4104 if (err)
4105 return err;
4106
4107 sc->trigger_mode |= AUMODE_PLAY0x01;
4108 uaudio_trigger(sc);
4109 return 0;
4110}
4111
4112int
4113uaudio_trigger_input(void *self, void *start, void *end, int blksz,
4114 void (*intr)(void *), void *arg, struct audio_params *param)
4115{
4116 struct uaudio_softc *sc = self;
4117 int err;
4118
4119 err = uaudio_stream_open(sc,
4120 AUMODE_RECORD0x02, start, end, blksz, intr, arg);
4121 if (err)
4122 return err;
4123
4124 sc->trigger_mode |= AUMODE_RECORD0x02;
4125 uaudio_trigger(sc);
4126 return 0;
4127}
4128
4129void
4130uaudio_copy_output(void *self, size_t todo)
4131{
4132 struct uaudio_softc *sc = (struct uaudio_softc *)self;
4133 int s;
4134
4135 s = splusb()splraise(0x5);
4136 sc->copy_todo += todo;
4137
4138#ifdef UAUDIO_DEBUG
4139 if (uaudio_debug >= 3) {
4140 printf("%s: copy_todo -> %zd (+%zd)\n", __func__,
4141 sc->copy_todo, todo);
4142 }
4143#endif
4144
4145 if (sc->mode == sc->trigger_mode)
4146 uaudio_pdata_copy(sc);
4147 splx(s)spllower(s);
4148}
4149
4150void
4151uaudio_underrun(void *self)
4152{
4153 struct uaudio_softc *sc = (struct uaudio_softc *)self;
4154 struct uaudio_stream *s = &sc->pstream;
4155
4156 sc->copy_todo += s->ring_blksz;
4157
4158#ifdef UAUDIO_DEBUG
4159 if (uaudio_debug >= 3)
4160 printf("%s: copy_todo -> %zd\n", __func__, sc->copy_todo);
4161#endif
4162
4163 /* copy data (actually silence) produced by the audio(4) layer */
4164 uaudio_pdata_copy(sc);
4165}
4166
4167int
4168uaudio_halt_output(void *self)
4169{
4170 struct uaudio_softc *sc = (struct uaudio_softc *)self;
4171
4172 uaudio_stream_close(sc, AUMODE_PLAY0x01);
4173 sc->trigger_mode &= ~AUMODE_PLAY0x01;
4174 sc->copy_todo = 0;
4175 return 0;
4176}
4177
4178int
4179uaudio_halt_input(void *self)
4180{
4181 struct uaudio_softc *sc = (struct uaudio_softc *)self;
4182
4183 uaudio_stream_close(sc, AUMODE_RECORD0x02);
4184 sc->trigger_mode &= ~AUMODE_RECORD0x02;
4185 return 0;
4186}
4187
4188int
4189uaudio_get_props(void *self)
4190{
4191 return AUDIO_PROP_FULLDUPLEX0x01;
4192}
4193
4194int
4195uaudio_get_port_do(struct uaudio_softc *sc, struct mixer_ctrl *ctl)
4196{
4197 struct uaudio_unit *u;
4198 struct uaudio_mixent *m;
4199 unsigned char req_buf[4];
4200 struct uaudio_blob p;
4201 int i, nch, val, req_num;
4202
4203 if (!uaudio_mixer_byindex(sc, ctl->dev, &u, &m))
4204 return ENOENT2;
4205
4206 switch (sc->version) {
4207 case UAUDIO_V10x100:
4208 req_num = UAUDIO_V1_REQ_GET_CUR0x81;
4209 break;
4210 case UAUDIO_V20x200:
4211 req_num = UAUDIO_V2_REQ_CUR1;
4212 }
4213
4214 switch (m->type) {
4215 case UAUDIO_MIX_SW0:
4216 p.rptr = p.wptr = req_buf;
4217 if (!uaudio_req(sc,
4218 UT_READ_CLASS_INTERFACE(0x80 | 0x20 | 0x01),
4219 req_num,
4220 m->req_sel,
4221 m->chan < 0 ? 0 : m->chan,
4222 sc->ctl_ifnum,
4223 u->id,
4224 req_buf,
4225 1))
4226 return EIO5;
4227 p.wptr++;
4228 if (!uaudio_getnum(&p, 1, &val))
4229 return EIO5;
4230 ctl->un.ord = !!val;
4231 break;
4232 case UAUDIO_MIX_NUM1:
4233 nch = uaudio_mixer_nchan(m, NULL((void *)0));
4234 ctl->un.value.num_channels = nch;
4235 for (i = 0; i < nch; i++) {
4236 p.rptr = p.wptr = req_buf;
4237 if (!uaudio_req(sc,
4238 UT_READ_CLASS_INTERFACE(0x80 | 0x20 | 0x01),
4239 req_num,
4240 m->req_sel,
4241 m->chan < 0 ? 0 : i + 1,
4242 sc->ctl_ifnum,
4243 u->id,
4244 req_buf,
4245 2))
4246 return EIO5;
4247 p.wptr += 2;
4248 if (!uaudio_getnum(&p, 2, &val))
4249 return EIO5;
4250 ctl->un.value.level[i] =
4251 uaudio_ranges_decode(&m->ranges,
4252 uaudio_sign_expand(val, 2));
4253 m = m->next;
4254 }
4255 break;
4256 case UAUDIO_MIX_ENUM2:
4257 /* XXX: not used yet */
4258 break;
4259 }
4260 return 0;
4261}
4262
4263int
4264uaudio_set_port_do(struct uaudio_softc *sc, struct mixer_ctrl *ctl)
4265{
4266 struct uaudio_unit *u;
4267 struct uaudio_mixent *m;
4268 unsigned char req_buf[4];
4269 unsigned int val;
4270 int i, nch;
4271
4272 if (!uaudio_mixer_byindex(sc, ctl->dev, &u, &m))
4273 return ENOENT2;
4274
4275 switch (m->type) {
4276 case UAUDIO_MIX_SW0:
4277 if (ctl->un.ord < 0 || ctl->un.ord > 1)
4278 return EINVAL22;
4279 req_buf[0] = ctl->un.ord;
4280 if (!uaudio_req(sc,
4281 UT_WRITE_CLASS_INTERFACE(0x00 | 0x20 | 0x01),
4282 UAUDIO_V1_REQ_SET_CUR0x01,
4283 m->req_sel,
4284 m->chan < 0 ? 0 : m->chan,
4285 sc->ctl_ifnum,
4286 u->id,
4287 req_buf,
4288 1))
4289 return EIO5;
4290 break;
4291 case UAUDIO_MIX_NUM1:
4292 nch = uaudio_mixer_nchan(m, NULL((void *)0));
4293 ctl->un.value.num_channels = nch;
4294 for (i = 0; i < nch; i++) {
4295 val = uaudio_ranges_encode(&m->ranges,
4296 ctl->un.value.level[i]);
4297 DPRINTF("%s: ch %d, ctl %d, num val %d\n", __func__,do {} while(0)
4298 i, ctl->un.value.level[i], val)do {} while(0);
4299 req_buf[0] = val;
4300 req_buf[1] = val >> 8;
4301 if (!uaudio_req(sc,
4302 UT_WRITE_CLASS_INTERFACE(0x00 | 0x20 | 0x01),
4303 UAUDIO_V1_REQ_SET_CUR0x01,
4304 m->req_sel,
4305 m->chan < 0 ? 0 : i + 1,
4306 sc->ctl_ifnum,
4307 u->id,
4308 req_buf,
4309 2))
4310 return EIO5;
4311 m = m->next;
4312 }
4313 break;
4314 case UAUDIO_MIX_ENUM2:
4315 /* XXX: not used yet */
4316 break;
4317 }
4318 return 0;
4319}
4320
4321int
4322uaudio_query_devinfo_do(struct uaudio_softc *sc, struct mixer_devinfo *devinfo)
4323{
4324 struct uaudio_unit *u;
4325 struct uaudio_mixent *m;
4326
4327 devinfo->next = -1;
4328 devinfo->prev = -1;
4329 switch (devinfo->index) {
4330 case UAUDIO_CLASS_IN1:
4331 strlcpy(devinfo->label.name, AudioCinputs"inputs", MAX_AUDIO_DEV_LEN16);
4332 devinfo->type = AUDIO_MIXER_CLASS0;
4333 devinfo->mixer_class = -1;
4334 return 0;
4335 case UAUDIO_CLASS_OUT0:
4336 strlcpy(devinfo->label.name, AudioCoutputs"outputs", MAX_AUDIO_DEV_LEN16);
4337 devinfo->type = AUDIO_MIXER_CLASS0;
4338 devinfo->mixer_class = -1;
4339 return 0;
4340 }
4341
4342 /*
4343 * find the unit & mixent structure for the given index
4344 */
4345 if (!uaudio_mixer_byindex(sc, devinfo->index, &u, &m))
4346 return ENOENT2;
4347
4348 if (strcmp(m->fname, "level") == 0) {
4349 /*
4350 * mixer(4) interface doesn't give a names to level
4351 * controls
4352 */
4353 strlcpy(devinfo->label.name, u->name, MAX_AUDIO_DEV_LEN16);
4354 } else {
4355 if (m->chan == -1) {
4356 snprintf(devinfo->label.name, MAX_AUDIO_DEV_LEN16,
4357 "%s_%s", u->name, m->fname);
4358 } else {
4359 snprintf(devinfo->label.name, MAX_AUDIO_DEV_LEN16,
4360 "%s_%s%u", u->name, m->fname, m->chan);
4361 }
4362 }
4363
4364 devinfo->mixer_class = u->mixer_class;
4365 switch (m->type) {
4366 case UAUDIO_MIX_SW0:
4367 devinfo->type = AUDIO_MIXER_ENUM1;
4368 devinfo->un.e.num_mem = 2;
4369 devinfo->un.e.member[0].ord = 0;
4370 strlcpy(devinfo->un.e.member[0].label.name, "off",
4371 MAX_AUDIO_DEV_LEN16);
4372 devinfo->un.e.member[1].ord = 1;
4373 strlcpy(devinfo->un.e.member[1].label.name, "on",
4374 MAX_AUDIO_DEV_LEN16);
4375 break;
4376 case UAUDIO_MIX_NUM1:
4377 devinfo->type = AUDIO_MIXER_VALUE3;
4378 devinfo->un.v.num_channels = uaudio_mixer_nchan(m, NULL((void *)0));
4379 devinfo->un.v.delta = 1;
4380 break;
4381 case UAUDIO_MIX_ENUM2:
4382 /* XXX: not used yet */
4383 devinfo->type = AUDIO_MIXER_ENUM1;
4384 devinfo->un.e.num_mem = 0;
4385 break;
4386 }
4387 return 0;
4388}
4389
4390int
4391uaudio_get_port(void *arg, struct mixer_ctrl *ctl)
4392{
4393 struct uaudio_softc *sc = arg;
4394 int rc;
4395
4396 usbd_ref_incr(sc->udev);
4397 rc = uaudio_get_port_do(sc, ctl);
4398 usbd_ref_decr(sc->udev);
4399 return rc;
4400}
4401
4402int
4403uaudio_set_port(void *arg, struct mixer_ctrl *ctl)
4404{
4405 struct uaudio_softc *sc = arg;
4406 int rc;
4407
4408 usbd_ref_incr(sc->udev);
4409 rc = uaudio_set_port_do(sc, ctl);
4410 usbd_ref_decr(sc->udev);
4411 return rc;
4412}
4413
4414int
4415uaudio_query_devinfo(void *arg, struct mixer_devinfo *devinfo)
4416{
4417 struct uaudio_softc *sc = arg;
4418 int rc;
4419
4420 usbd_ref_incr(sc->udev);
4421 rc = uaudio_query_devinfo_do(sc, devinfo);
4422 usbd_ref_decr(sc->udev);
4423 return rc;
4424}