xref: /freebsd/sys/dev/sound/usb/uaudio.c (revision 18d87fe4fe3b310796e138855016678453140423)
1 /*	$NetBSD: uaudio.c,v 1.91 2004/11/05 17:46:14 kent Exp $	*/
2 
3 /*-
4  * SPDX-License-Identifier: BSD-2-Clause
5  *
6  * Copyright (c) 1999 The NetBSD Foundation, Inc.
7  * All rights reserved.
8  *
9  * This code is derived from software contributed to The NetBSD Foundation
10  * by Lennart Augustsson (lennart@augustsson.net) at
11  * Carlstedt Research & Technology.
12  *
13  * Redistribution and use in source and binary forms, with or without
14  * modification, are permitted provided that the following conditions
15  * are met:
16  * 1. Redistributions of source code must retain the above copyright
17  *    notice, this list of conditions and the following disclaimer.
18  * 2. Redistributions in binary form must reproduce the above copyright
19  *    notice, this list of conditions and the following disclaimer in the
20  *    documentation and/or other materials provided with the distribution.
21  *
22  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
23  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
24  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
25  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
26  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
27  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
28  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
29  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
30  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
31  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
32  * POSSIBILITY OF SUCH DAMAGE.
33  */
34 
35 #include <sys/cdefs.h>
36 /*
37  * USB audio specs: http://www.usb.org/developers/devclass_docs/audio10.pdf
38  *                  http://www.usb.org/developers/devclass_docs/frmts10.pdf
39  *                  http://www.usb.org/developers/devclass_docs/termt10.pdf
40  */
41 
42 /*
43  * Also merged:
44  *  $NetBSD: uaudio.c,v 1.94 2005/01/15 15:19:53 kent Exp $
45  *  $NetBSD: uaudio.c,v 1.95 2005/01/16 06:02:19 dsainty Exp $
46  *  $NetBSD: uaudio.c,v 1.96 2005/01/16 12:46:00 kent Exp $
47  *  $NetBSD: uaudio.c,v 1.97 2005/02/24 08:19:38 martin Exp $
48  */
49 
50 #include <sys/stdint.h>
51 #include <sys/stddef.h>
52 #include <sys/param.h>
53 #include <sys/queue.h>
54 #include <sys/types.h>
55 #include <sys/systm.h>
56 #include <sys/kernel.h>
57 #include <sys/bus.h>
58 #include <sys/module.h>
59 #include <sys/lock.h>
60 #include <sys/mutex.h>
61 #include <sys/condvar.h>
62 #include <sys/sysctl.h>
63 #include <sys/sx.h>
64 #include <sys/unistd.h>
65 #include <sys/callout.h>
66 #include <sys/malloc.h>
67 #include <sys/priv.h>
68 
69 #include <dev/hid/hid.h>
70 
71 #include "usbdevs.h"
72 #include <dev/usb/usb.h>
73 #include <dev/usb/usbdi.h>
74 #include <dev/usb/usbdi_util.h>
75 #include <dev/usb/usbhid.h>
76 #include <dev/usb/usb_request.h>
77 #include <dev/usb/usb_process.h>
78 
79 #define	USB_DEBUG_VAR uaudio_debug
80 #include <dev/usb/usb_debug.h>
81 
82 #include <dev/usb/quirk/usb_quirk.h>
83 
84 #include <sys/reboot.h>			/* for bootverbose */
85 
86 #ifdef HAVE_KERNEL_OPTION_HEADERS
87 #include "opt_snd.h"
88 #endif
89 
90 #include <dev/sound/pcm/sound.h>
91 #include <dev/sound/usb/uaudioreg.h>
92 #include <dev/sound/usb/uaudio.h>
93 #include <dev/sound/chip.h>
94 #include "feeder_if.h"
95 
96 static int uaudio_default_rate = 0;		/* use rate list */
97 static int uaudio_default_bits = 32;
98 static int uaudio_default_channels = 0;		/* use default */
99 static int uaudio_buffer_ms = 2;
100 static bool uaudio_handle_hid = true;
101 
102 static SYSCTL_NODE(_hw_usb, OID_AUTO, uaudio, CTLFLAG_RW | CTLFLAG_MPSAFE, 0,
103     "USB uaudio");
104 SYSCTL_BOOL(_hw_usb_uaudio, OID_AUTO, handle_hid, CTLFLAG_RWTUN,
105     &uaudio_handle_hid, 0, "uaudio handles any HID volume/mute keys, if set");
106 SYSCTL_INT(_hw_usb_uaudio, OID_AUTO, default_rate, CTLFLAG_RWTUN,
107     &uaudio_default_rate, 0, "uaudio default sample rate");
108 SYSCTL_INT(_hw_usb_uaudio, OID_AUTO, default_bits, CTLFLAG_RWTUN,
109     &uaudio_default_bits, 0, "uaudio default sample bits");
110 SYSCTL_INT(_hw_usb_uaudio, OID_AUTO, default_channels, CTLFLAG_RWTUN,
111     &uaudio_default_channels, 0, "uaudio default sample channels");
112 
113 static int
114 uaudio_buffer_ms_sysctl(SYSCTL_HANDLER_ARGS)
115 {
116 	int err, val;
117 
118 	val = uaudio_buffer_ms;
119 	err = sysctl_handle_int(oidp, &val, 0, req);
120 
121 	if (err != 0 || req->newptr == NULL || val == uaudio_buffer_ms)
122 		return (err);
123 
124 	if (val > 8)
125 		val = 8;
126 	else if (val < 2)
127 		val = 2;
128 
129 	uaudio_buffer_ms = val;
130 
131 	return (0);
132 }
133 SYSCTL_PROC(_hw_usb_uaudio, OID_AUTO, buffer_ms,
134     CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, 0, sizeof(int),
135     uaudio_buffer_ms_sysctl, "I",
136     "uaudio buffering delay from 2ms to 8ms");
137 
138 #ifdef USB_DEBUG
139 static int uaudio_debug;
140 
141 SYSCTL_INT(_hw_usb_uaudio, OID_AUTO, debug, CTLFLAG_RWTUN,
142     &uaudio_debug, 0, "uaudio debug level");
143 #else
144 #define	uaudio_debug 0
145 #endif
146 
147 #define	UAUDIO_NFRAMES		64	/* must be factor of 8 due HS-USB */
148 #define	UAUDIO_NCHANBUFS	2	/* number of outstanding request */
149 #define	UAUDIO_RECURSE_LIMIT	255	/* rounds */
150 #define	UAUDIO_CHANNELS_MAX	MIN(64, AFMT_CHANNEL_MAX)
151 #define	UAUDIO_MATRIX_MAX	8	/* channels */
152 
153 #define	MAKE_WORD(h,l) (((h) << 8) | (l))
154 #define	BIT_TEST(bm,bno) (((bm)[(bno) / 8] >> (7 - ((bno) % 8))) & 1)
155 #define	UAUDIO_MAX_CHAN(x) (x)
156 #define	MIX(sc) ((sc)->sc_mixer_node)
157 
158 union uaudio_asid {
159 	const struct usb_audio_streaming_interface_descriptor *v1;
160 	const struct usb_audio20_streaming_interface_descriptor *v2;
161 };
162 
163 union uaudio_asf1d {
164 	const struct usb_audio_streaming_type1_descriptor *v1;
165 	const struct usb_audio20_streaming_type1_descriptor *v2;
166 };
167 
168 union uaudio_sed {
169 	const struct usb_audio_streaming_endpoint_descriptor *v1;
170 	const struct usb_audio20_streaming_endpoint_descriptor *v2;
171 };
172 
173 struct uaudio_mixer_node {
174 	const char *name;
175 
176 	int32_t	minval;
177 	int32_t	maxval;
178 #define	MIX_MAX_CHAN 16
179 	int32_t	wValue[MIX_MAX_CHAN];	/* using nchan */
180 	uint32_t mul;
181 	uint32_t ctl;
182 
183 	int wData[MIX_MAX_CHAN];	/* using nchan */
184 	uint16_t wIndex;
185 
186 	uint8_t	update[(MIX_MAX_CHAN + 7) / 8];
187 	uint8_t	nchan;
188 	uint8_t	type;
189 #define	MIX_ON_OFF	1
190 #define	MIX_SIGNED_16	2
191 #define	MIX_UNSIGNED_16	3
192 #define	MIX_SIGNED_8	4
193 #define	MIX_SELECTOR	5
194 #define	MIX_UNKNOWN     6
195 #define	MIX_SIZE(n) ((((n) == MIX_SIGNED_16) || \
196 		      ((n) == MIX_UNSIGNED_16)) ? 2 : 1)
197 #define	MIX_UNSIGNED(n) ((n) == MIX_UNSIGNED_16)
198 
199 #define	MAX_SELECTOR_INPUT_PIN 256
200 	uint8_t	slctrtype[MAX_SELECTOR_INPUT_PIN];
201 	uint8_t val_default;
202 
203 	uint8_t desc[64];
204 
205 	struct uaudio_mixer_node *next;
206 };
207 
208 struct uaudio_configure_msg {
209 	struct usb_proc_msg hdr;
210 	struct uaudio_softc *sc;
211 };
212 
213 #define	CHAN_MAX_ALT 24
214 
215 struct uaudio_chan_alt {
216 	union uaudio_asf1d p_asf1d;
217 	union uaudio_sed p_sed;
218 	const usb_endpoint_descriptor_audio_t *p_ed1;
219 	const struct uaudio_format *p_fmt;
220 	const struct usb_config *usb_cfg;
221 	uint32_t sample_rate;	/* in Hz */
222 	uint16_t sample_size;
223 	uint8_t	iface_index;
224 	uint8_t	iface_alt_index;
225 	uint8_t channels;
226 };
227 
228 struct uaudio_chan {
229 	struct pcmchan_caps pcm_cap;	/* capabilities */
230 	struct uaudio_chan_alt usb_alt[CHAN_MAX_ALT];
231 	struct snd_dbuf *pcm_buf;
232 	struct mtx *pcm_mtx;		/* lock protecting this structure */
233 	struct uaudio_softc *priv_sc;
234 	struct pcm_channel *pcm_ch;
235 	struct usb_xfer *xfer[UAUDIO_NCHANBUFS + 1];
236 
237 	uint8_t *buf;			/* pointer to buffer */
238 	uint8_t *start;			/* upper layer buffer start */
239 	uint8_t *end;			/* upper layer buffer end */
240 	uint8_t *cur;			/* current position in upper layer
241 					 * buffer */
242 
243 	uint32_t intr_frames;		/* in units */
244 	uint32_t frames_per_second;
245 	uint32_t sample_rem;
246 	uint32_t sample_curr;
247 	uint32_t max_buf;
248 	int32_t jitter_rem;
249 	int32_t jitter_curr;
250 
251 	int feedback_rate;
252 
253 	uint32_t pcm_format[2];
254 
255 	uint16_t bytes_per_frame[2];
256 
257 	uint32_t intr_counter;
258 	uint32_t running;
259 	uint32_t num_alt;
260 	uint32_t cur_alt;
261 	uint32_t set_alt;
262 	uint32_t operation;
263 #define	CHAN_OP_NONE 0
264 #define	CHAN_OP_START 1
265 #define	CHAN_OP_STOP 2
266 #define	CHAN_OP_DRAIN 3
267 
268 	uint8_t iface_index;
269 };
270 
271 #define	UMIDI_EMB_JACK_MAX   16		/* units */
272 #define	UMIDI_TX_FRAMES	   256		/* units */
273 #define	UMIDI_TX_BUFFER    (UMIDI_TX_FRAMES * 4)	/* bytes */
274 
275 enum {
276 	UMIDI_TX_TRANSFER,
277 	UMIDI_RX_TRANSFER,
278 	UMIDI_N_TRANSFER,
279 };
280 
281 struct umidi_sub_chan {
282 	struct usb_fifo_sc fifo;
283 	uint8_t *temp_cmd;
284 	uint8_t	temp_0[4];
285 	uint8_t	temp_1[4];
286 	uint8_t	state;
287 #define	UMIDI_ST_UNKNOWN   0		/* scan for command */
288 #define	UMIDI_ST_1PARAM    1
289 #define	UMIDI_ST_2PARAM_1  2
290 #define	UMIDI_ST_2PARAM_2  3
291 #define	UMIDI_ST_SYSEX_0   4
292 #define	UMIDI_ST_SYSEX_1   5
293 #define	UMIDI_ST_SYSEX_2   6
294 
295 	uint8_t	read_open:1;
296 	uint8_t	write_open:1;
297 	uint8_t	unused:6;
298 };
299 
300 struct umidi_chan {
301 	struct umidi_sub_chan sub[UMIDI_EMB_JACK_MAX];
302 	struct mtx mtx;
303 
304 	struct usb_xfer *xfer[UMIDI_N_TRANSFER];
305 
306 	uint8_t	iface_index;
307 	uint8_t	iface_alt_index;
308 
309 	uint8_t	read_open_refcount;
310 	uint8_t	write_open_refcount;
311 
312 	uint8_t	curr_cable;
313 	uint8_t	max_emb_jack;
314 	uint8_t	valid;
315 	uint8_t single_command;
316 };
317 
318 struct uaudio_search_result {
319 	uint8_t	bit_input[(256 + 7) / 8];
320 	uint8_t	bit_output[(256 + 7) / 8];
321 	uint8_t	recurse_level;
322 	uint8_t	id_max;
323 	uint8_t is_input;
324 };
325 
326 enum {
327 	UAUDIO_HID_RX_TRANSFER,
328 	UAUDIO_HID_N_TRANSFER,
329 };
330 
331 struct uaudio_hid {
332 	struct usb_xfer *xfer[UAUDIO_HID_N_TRANSFER];
333 	struct hid_location volume_up_loc;
334 	struct hid_location volume_down_loc;
335 	struct hid_location mute_loc;
336 	uint32_t flags;
337 #define	UAUDIO_HID_VALID		0x0001
338 #define	UAUDIO_HID_HAS_ID		0x0002
339 #define	UAUDIO_HID_HAS_VOLUME_UP	0x0004
340 #define	UAUDIO_HID_HAS_VOLUME_DOWN	0x0008
341 #define	UAUDIO_HID_HAS_MUTE		0x0010
342 	uint8_t iface_index;
343 	uint8_t volume_up_id;
344 	uint8_t volume_down_id;
345 	uint8_t mute_id;
346 };
347 
348 #define	UAUDIO_SPDIF_OUT	0x01	/* Enable S/PDIF output */
349 #define	UAUDIO_SPDIF_OUT_48K	0x02	/* Out sample rate = 48K */
350 #define	UAUDIO_SPDIF_OUT_96K	0x04	/* Out sample rate = 96K */
351 #define	UAUDIO_SPDIF_IN_MIX	0x10	/* Input mix enable */
352 
353 #define	UAUDIO_MAX_CHILD 2
354 
355 struct uaudio_softc_child {
356 	device_t pcm_device;
357 	struct mtx *mixer_lock;
358 	struct snd_mixer *mixer_dev;
359 
360 	uint32_t mix_info;
361 	uint32_t recsrc_info;
362 
363 	uint8_t	pcm_registered:1;
364 	uint8_t	mixer_init:1;
365 };
366 
367 struct uaudio_softc {
368 	struct sbuf sc_sndstat;
369 	struct sndcard_func sc_sndcard_func;
370 	struct uaudio_chan sc_rec_chan[UAUDIO_MAX_CHILD];
371 	struct uaudio_chan sc_play_chan[UAUDIO_MAX_CHILD];
372 	struct umidi_chan sc_midi_chan;
373 	struct uaudio_hid sc_hid;
374 	struct uaudio_search_result sc_mixer_clocks;
375 	struct uaudio_mixer_node sc_mixer_node;
376 	struct uaudio_configure_msg sc_config_msg[2];
377 	struct uaudio_softc_child sc_child[UAUDIO_MAX_CHILD];
378 
379 	struct usb_device *sc_udev;
380 	struct usb_xfer *sc_mixer_xfer[1];
381 	struct uaudio_mixer_node *sc_mixer_root;
382 	struct uaudio_mixer_node *sc_mixer_curr;
383 	int     (*sc_set_spdif_fn) (struct uaudio_softc *, int);
384 
385 	uint16_t sc_audio_rev;
386 	uint16_t sc_mixer_count;
387 
388 	uint8_t	sc_mixer_iface_index;
389 	uint8_t	sc_mixer_iface_no;
390 	uint8_t	sc_mixer_chan;
391 	uint8_t	sc_sndstat_valid:1;
392 	uint8_t	sc_uq_audio_swap_lr:1;
393 	uint8_t	sc_uq_au_inp_async:1;
394 	uint8_t	sc_uq_au_no_xu:1;
395 	uint8_t	sc_uq_bad_adc:1;
396 	uint8_t	sc_uq_au_vendor_class:1;
397 	uint8_t	sc_pcm_bitperfect:1;
398 };
399 
400 struct uaudio_terminal_node {
401 	union {
402 		const struct usb_descriptor *desc;
403 		const struct usb_audio_input_terminal *it_v1;
404 		const struct usb_audio_output_terminal *ot_v1;
405 		const struct usb_audio_mixer_unit_0 *mu_v1;
406 		const struct usb_audio_selector_unit *su_v1;
407 		const struct usb_audio_feature_unit *fu_v1;
408 		const struct usb_audio_processing_unit_0 *pu_v1;
409 		const struct usb_audio_extension_unit_0 *eu_v1;
410 		const struct usb_audio20_clock_source_unit *csrc_v2;
411 		const struct usb_audio20_clock_selector_unit_0 *csel_v2;
412 		const struct usb_audio20_clock_multiplier_unit *cmul_v2;
413 		const struct usb_audio20_input_terminal *it_v2;
414 		const struct usb_audio20_output_terminal *ot_v2;
415 		const struct usb_audio20_mixer_unit_0 *mu_v2;
416 		const struct usb_audio20_selector_unit *su_v2;
417 		const struct usb_audio20_feature_unit *fu_v2;
418 		const struct usb_audio20_sample_rate_unit *ru_v2;
419 		const struct usb_audio20_processing_unit_0 *pu_v2;
420 		const struct usb_audio20_extension_unit_0 *eu_v2;
421 		const struct usb_audio20_effect_unit *ef_v2;
422 	}	u;
423 	struct uaudio_search_result usr;
424 	struct uaudio_terminal_node *root;
425 };
426 
427 struct uaudio_format {
428 	uint16_t wFormat;
429 	uint8_t	bPrecision;
430 	uint32_t freebsd_fmt;
431 	const char *description;
432 };
433 
434 static const struct uaudio_format uaudio10_formats[] = {
435 	{UA_FMT_PCM8, 8, AFMT_U8, "8-bit U-LE PCM"},
436 	{UA_FMT_PCM8, 16, AFMT_U16_LE, "16-bit U-LE PCM"},
437 	{UA_FMT_PCM8, 24, AFMT_U24_LE, "24-bit U-LE PCM"},
438 	{UA_FMT_PCM8, 32, AFMT_U32_LE, "32-bit U-LE PCM"},
439 
440 	{UA_FMT_PCM, 8, AFMT_S8, "8-bit S-LE PCM"},
441 	{UA_FMT_PCM, 16, AFMT_S16_LE, "16-bit S-LE PCM"},
442 	{UA_FMT_PCM, 24, AFMT_S24_LE, "24-bit S-LE PCM"},
443 	{UA_FMT_PCM, 32, AFMT_S32_LE, "32-bit S-LE PCM"},
444 
445 	{UA_FMT_ALAW, 8, AFMT_A_LAW, "8-bit A-Law"},
446 	{UA_FMT_MULAW, 8, AFMT_MU_LAW, "8-bit mu-Law"},
447 	{0, 0, 0, NULL}
448 };
449 
450 static const struct uaudio_format uaudio20_formats[] = {
451 	{UA20_FMT_PCM, 8, AFMT_S8, "8-bit S-LE PCM"},
452 	{UA20_FMT_PCM, 16, AFMT_S16_LE, "16-bit S-LE PCM"},
453 	{UA20_FMT_PCM, 24, AFMT_S24_LE, "24-bit S-LE PCM"},
454 	{UA20_FMT_PCM, 32, AFMT_S32_LE, "32-bit S-LE PCM"},
455 
456 	{UA20_FMT_PCM8, 8, AFMT_U8, "8-bit U-LE PCM"},
457 	{UA20_FMT_PCM8, 16, AFMT_U16_LE, "16-bit U-LE PCM"},
458 	{UA20_FMT_PCM8, 24, AFMT_U24_LE, "24-bit U-LE PCM"},
459 	{UA20_FMT_PCM8, 32, AFMT_U32_LE, "32-bit U-LE PCM"},
460 
461 	{UA20_FMT_ALAW, 8, AFMT_A_LAW, "8-bit A-Law"},
462 	{UA20_FMT_MULAW, 8, AFMT_MU_LAW, "8-bit mu-Law"},
463 	{0, 0, 0, NULL}
464 };
465 
466 /* prototypes */
467 
468 static device_probe_t uaudio_probe;
469 static device_attach_t uaudio_attach;
470 static device_detach_t uaudio_detach;
471 
472 static usb_callback_t uaudio_chan_play_callback;
473 static usb_callback_t uaudio_chan_play_sync_callback;
474 static usb_callback_t uaudio_chan_record_callback;
475 static usb_callback_t uaudio_chan_record_sync_callback;
476 static usb_callback_t uaudio_mixer_write_cfg_callback;
477 static usb_callback_t umidi_bulk_read_callback;
478 static usb_callback_t umidi_bulk_write_callback;
479 static usb_callback_t uaudio_hid_rx_callback;
480 
481 static usb_proc_callback_t uaudio_configure_msg;
482 
483 /* ==== USB mixer ==== */
484 
485 static int uaudio_mixer_sysctl_handler(SYSCTL_HANDLER_ARGS);
486 static void uaudio_mixer_ctl_free(struct uaudio_softc *);
487 static void uaudio_mixer_register_sysctl(struct uaudio_softc *, device_t, unsigned);
488 static void uaudio_mixer_reload_all(struct uaudio_softc *);
489 static void uaudio_mixer_controls_create_ftu(struct uaudio_softc *);
490 
491 /* ==== USB audio v1.0 ==== */
492 
493 static void	uaudio_mixer_add_mixer(struct uaudio_softc *,
494 		    const struct uaudio_terminal_node *, int);
495 static void	uaudio_mixer_add_selector(struct uaudio_softc *,
496 		    const struct uaudio_terminal_node *, int);
497 static uint32_t	uaudio_mixer_feature_get_bmaControls(
498 		    const struct usb_audio_feature_unit *, uint8_t);
499 static void	uaudio_mixer_add_feature(struct uaudio_softc *,
500 		    const struct uaudio_terminal_node *, int);
501 static void	uaudio_mixer_add_processing_updown(struct uaudio_softc *,
502 		    const struct uaudio_terminal_node *, int);
503 static void	uaudio_mixer_add_processing(struct uaudio_softc *,
504 		    const struct uaudio_terminal_node *, int);
505 static void	uaudio_mixer_add_extension(struct uaudio_softc *,
506 		    const struct uaudio_terminal_node *, int);
507 static struct	usb_audio_cluster uaudio_mixer_get_cluster(uint8_t,
508 		    const struct uaudio_terminal_node *);
509 static uint16_t	uaudio_mixer_determine_class(const struct uaudio_terminal_node *);
510 static void	uaudio_mixer_find_inputs_sub(struct uaudio_terminal_node *,
511 		    const uint8_t *, uint8_t, struct uaudio_search_result *);
512 static const void *uaudio_mixer_verify_desc(const void *, uint32_t);
513 static usb_error_t uaudio_set_speed(struct usb_device *, uint8_t, uint32_t);
514 static int	uaudio_mixer_get(struct usb_device *, uint16_t, uint8_t,
515 		    struct uaudio_mixer_node *);
516 
517 /* ==== USB audio v2.0 ==== */
518 
519 static void	uaudio20_mixer_add_mixer(struct uaudio_softc *,
520 		    const struct uaudio_terminal_node *, int);
521 static void	uaudio20_mixer_add_selector(struct uaudio_softc *,
522 		    const struct uaudio_terminal_node *, int);
523 static void	uaudio20_mixer_add_feature(struct uaudio_softc *,
524 		    const struct uaudio_terminal_node *, int);
525 static struct	usb_audio20_cluster uaudio20_mixer_get_cluster(uint8_t,
526 		    const struct uaudio_terminal_node *);
527 static uint16_t	uaudio20_mixer_determine_class(const struct uaudio_terminal_node *);
528 static void	uaudio20_mixer_find_inputs_sub(struct uaudio_terminal_node *,
529 		    const uint8_t *, uint8_t, struct uaudio_search_result *);
530 static const void *uaudio20_mixer_verify_desc(const void *, uint32_t);
531 static usb_error_t uaudio20_set_speed(struct usb_device *, uint8_t,
532 		    uint8_t, uint32_t);
533 
534 /* USB audio v1.0 and v2.0 */
535 
536 static void	uaudio_chan_fill_info_sub(struct uaudio_softc *,
537 		    struct usb_device *, uint32_t, uint8_t, uint8_t);
538 static void	uaudio_chan_fill_info(struct uaudio_softc *,
539 		    struct usb_device *);
540 static void	uaudio_mixer_add_ctl_sub(struct uaudio_softc *,
541 		    struct uaudio_mixer_node *);
542 static void	uaudio_mixer_add_ctl(struct uaudio_softc *,
543 		    struct uaudio_mixer_node *);
544 static void	uaudio_mixer_fill_info(struct uaudio_softc *,
545 		    struct usb_device *, void *);
546 static int	uaudio_mixer_signext(uint8_t, int);
547 static void	uaudio_mixer_init(struct uaudio_softc *, unsigned);
548 static uint8_t	umidi_convert_to_usb(struct umidi_sub_chan *, uint8_t, uint8_t);
549 static struct	umidi_sub_chan *umidi_sub_by_fifo(struct usb_fifo *);
550 static void	umidi_start_read(struct usb_fifo *);
551 static void	umidi_stop_read(struct usb_fifo *);
552 static void	umidi_start_write(struct usb_fifo *);
553 static void	umidi_stop_write(struct usb_fifo *);
554 static int	umidi_open(struct usb_fifo *, int);
555 static int	umidi_ioctl(struct usb_fifo *, u_long cmd, void *, int);
556 static void	umidi_close(struct usb_fifo *, int);
557 static void	umidi_init(device_t dev);
558 static int	umidi_probe(device_t dev);
559 static int	umidi_detach(device_t dev);
560 static int	uaudio_hid_probe(struct uaudio_softc *sc,
561 		    struct usb_attach_arg *uaa);
562 static void	uaudio_hid_detach(struct uaudio_softc *sc);
563 
564 #ifdef USB_DEBUG
565 static void	uaudio_chan_dump_ep_desc(
566 		    const usb_endpoint_descriptor_audio_t *);
567 #endif
568 
569 static const struct usb_config
570 	uaudio_cfg_record[UAUDIO_NCHANBUFS + 1] = {
571 	[0] = {
572 		.type = UE_ISOCHRONOUS,
573 		.endpoint = UE_ADDR_ANY,
574 		.direction = UE_DIR_IN,
575 		.bufsize = 0,	/* use "wMaxPacketSize * frames" */
576 		.frames = UAUDIO_NFRAMES,
577 		.flags = {.short_xfer_ok = 1,},
578 		.callback = &uaudio_chan_record_callback,
579 	},
580 
581 	[1] = {
582 		.type = UE_ISOCHRONOUS,
583 		.endpoint = UE_ADDR_ANY,
584 		.direction = UE_DIR_IN,
585 		.bufsize = 0,	/* use "wMaxPacketSize * frames" */
586 		.frames = UAUDIO_NFRAMES,
587 		.flags = {.short_xfer_ok = 1,},
588 		.callback = &uaudio_chan_record_callback,
589 	},
590 
591 	[2] = {
592 		.type = UE_ISOCHRONOUS,
593 		.endpoint = UE_ADDR_ANY,
594 		.direction = UE_DIR_OUT,
595 		.bufsize = 0,	/* use "wMaxPacketSize * frames" */
596 		.frames = 1,
597 		.flags = {.no_pipe_ok = 1,.short_xfer_ok = 1,},
598 		.callback = &uaudio_chan_record_sync_callback,
599 	},
600 };
601 
602 static const struct usb_config
603 	uaudio_cfg_play[UAUDIO_NCHANBUFS + 1] = {
604 	[0] = {
605 		.type = UE_ISOCHRONOUS,
606 		.endpoint = UE_ADDR_ANY,
607 		.direction = UE_DIR_OUT,
608 		.bufsize = 0,	/* use "wMaxPacketSize * frames" */
609 		.frames = UAUDIO_NFRAMES,
610 		.flags = {.short_xfer_ok = 1,},
611 		.callback = &uaudio_chan_play_callback,
612 	},
613 
614 	[1] = {
615 		.type = UE_ISOCHRONOUS,
616 		.endpoint = UE_ADDR_ANY,
617 		.direction = UE_DIR_OUT,
618 		.bufsize = 0,	/* use "wMaxPacketSize * frames" */
619 		.frames = UAUDIO_NFRAMES,
620 		.flags = {.short_xfer_ok = 1,},
621 		.callback = &uaudio_chan_play_callback,
622 	},
623 
624 	[2] = {
625 		.type = UE_ISOCHRONOUS,
626 		.endpoint = UE_ADDR_ANY,
627 		.direction = UE_DIR_IN,
628 		.bufsize = 0,	/* use "wMaxPacketSize * frames" */
629 		.frames = 1,
630 		.flags = {.no_pipe_ok = 1,.short_xfer_ok = 1,},
631 		.callback = &uaudio_chan_play_sync_callback,
632 	},
633 };
634 
635 static const struct usb_config
636 	uaudio_mixer_config[1] = {
637 	[0] = {
638 		.type = UE_CONTROL,
639 		.endpoint = 0x00,	/* Control pipe */
640 		.direction = UE_DIR_ANY,
641 		.bufsize = (sizeof(struct usb_device_request) + 4),
642 		.callback = &uaudio_mixer_write_cfg_callback,
643 		.timeout = 1000,	/* 1 second */
644 	},
645 };
646 
647 static const
648 uint8_t	umidi_cmd_to_len[16] = {
649 	[0x0] = 0,			/* reserved */
650 	[0x1] = 0,			/* reserved */
651 	[0x2] = 2,			/* bytes */
652 	[0x3] = 3,			/* bytes */
653 	[0x4] = 3,			/* bytes */
654 	[0x5] = 1,			/* bytes */
655 	[0x6] = 2,			/* bytes */
656 	[0x7] = 3,			/* bytes */
657 	[0x8] = 3,			/* bytes */
658 	[0x9] = 3,			/* bytes */
659 	[0xA] = 3,			/* bytes */
660 	[0xB] = 3,			/* bytes */
661 	[0xC] = 2,			/* bytes */
662 	[0xD] = 2,			/* bytes */
663 	[0xE] = 3,			/* bytes */
664 	[0xF] = 1,			/* bytes */
665 };
666 
667 static const struct usb_config
668 	umidi_config[UMIDI_N_TRANSFER] = {
669 	[UMIDI_TX_TRANSFER] = {
670 		.type = UE_BULK,
671 		.endpoint = UE_ADDR_ANY,
672 		.direction = UE_DIR_OUT,
673 		.bufsize = UMIDI_TX_BUFFER,
674 		.flags = {.no_pipe_ok = 1},
675 		.callback = &umidi_bulk_write_callback,
676 	},
677 
678 	[UMIDI_RX_TRANSFER] = {
679 		.type = UE_BULK,
680 		.endpoint = UE_ADDR_ANY,
681 		.direction = UE_DIR_IN,
682 		.bufsize = 4,	/* bytes */
683 		.flags = {.short_xfer_ok = 1,.proxy_buffer = 1,.no_pipe_ok = 1},
684 		.callback = &umidi_bulk_read_callback,
685 	},
686 };
687 
688 static const struct usb_config
689 	uaudio_hid_config[UAUDIO_HID_N_TRANSFER] = {
690 	[UAUDIO_HID_RX_TRANSFER] = {
691 		.type = UE_INTERRUPT,
692 		.endpoint = UE_ADDR_ANY,
693 		.direction = UE_DIR_IN,
694 		.bufsize = 0,	/* use wMaxPacketSize */
695 		.flags = {.short_xfer_ok = 1,},
696 		.callback = &uaudio_hid_rx_callback,
697 	},
698 };
699 
700 static device_method_t uaudio_methods[] = {
701 	DEVMETHOD(device_probe, uaudio_probe),
702 	DEVMETHOD(device_attach, uaudio_attach),
703 	DEVMETHOD(device_detach, uaudio_detach),
704 	DEVMETHOD(device_suspend, bus_generic_suspend),
705 	DEVMETHOD(device_resume, bus_generic_resume),
706 	DEVMETHOD(device_shutdown, bus_generic_shutdown),
707 
708 	DEVMETHOD_END
709 };
710 
711 static driver_t uaudio_driver = {
712 	.name = "uaudio",
713 	.methods = uaudio_methods,
714 	.size = sizeof(struct uaudio_softc),
715 };
716 
717 /* The following table is derived from Linux's quirks-table.h */
718 static const STRUCT_USB_HOST_ID uaudio_vendor_midi[] = {
719 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1000, 0) }, /* UX256 */
720 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1001, 0) }, /* MU1000 */
721 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1002, 0) }, /* MU2000 */
722 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1003, 0) }, /* MU500 */
723 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1004, 3) }, /* UW500 */
724 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1005, 0) }, /* MOTIF6 */
725 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1006, 0) }, /* MOTIF7 */
726 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1007, 0) }, /* MOTIF8 */
727 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1008, 0) }, /* UX96 */
728 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1009, 0) }, /* UX16 */
729 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x100a, 3) }, /* EOS BX */
730 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x100c, 0) }, /* UC-MX */
731 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x100d, 0) }, /* UC-KX */
732 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x100e, 0) }, /* S08 */
733 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x100f, 0) }, /* CLP-150 */
734 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1010, 0) }, /* CLP-170 */
735 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1011, 0) }, /* P-250 */
736 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1012, 0) }, /* TYROS */
737 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1013, 0) }, /* PF-500 */
738 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1014, 0) }, /* S90 */
739 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1015, 0) }, /* MOTIF-R */
740 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1016, 0) }, /* MDP-5 */
741 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1017, 0) }, /* CVP-204 */
742 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1018, 0) }, /* CVP-206 */
743 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1019, 0) }, /* CVP-208 */
744 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x101a, 0) }, /* CVP-210 */
745 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x101b, 0) }, /* PSR-1100 */
746 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x101c, 0) }, /* PSR-2100 */
747 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x101d, 0) }, /* CLP-175 */
748 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x101e, 0) }, /* PSR-K1 */
749 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x101f, 0) }, /* EZ-J24 */
750 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1020, 0) }, /* EZ-250i */
751 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1021, 0) }, /* MOTIF ES 6 */
752 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1022, 0) }, /* MOTIF ES 7 */
753 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1023, 0) }, /* MOTIF ES 8 */
754 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1024, 0) }, /* CVP-301 */
755 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1025, 0) }, /* CVP-303 */
756 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1026, 0) }, /* CVP-305 */
757 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1027, 0) }, /* CVP-307 */
758 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1028, 0) }, /* CVP-309 */
759 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1029, 0) }, /* CVP-309GP */
760 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x102a, 0) }, /* PSR-1500 */
761 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x102b, 0) }, /* PSR-3000 */
762 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x102e, 0) }, /* ELS-01/01C */
763 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1030, 0) }, /* PSR-295/293 */
764 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1031, 0) }, /* DGX-205/203 */
765 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1032, 0) }, /* DGX-305 */
766 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1033, 0) }, /* DGX-505 */
767 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1034, 0) }, /* NULL */
768 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1035, 0) }, /* NULL */
769 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1036, 0) }, /* NULL */
770 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1037, 0) }, /* NULL */
771 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1038, 0) }, /* NULL */
772 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1039, 0) }, /* NULL */
773 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x103a, 0) }, /* NULL */
774 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x103b, 0) }, /* NULL */
775 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x103c, 0) }, /* NULL */
776 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x103d, 0) }, /* NULL */
777 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x103e, 0) }, /* NULL */
778 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x103f, 0) }, /* NULL */
779 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1040, 0) }, /* NULL */
780 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1041, 0) }, /* NULL */
781 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1042, 0) }, /* NULL */
782 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1043, 0) }, /* NULL */
783 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1044, 0) }, /* NULL */
784 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1045, 0) }, /* NULL */
785 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x104e, 0) }, /* NULL */
786 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x104f, 0) }, /* NULL */
787 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1050, 0) }, /* NULL */
788 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1051, 0) }, /* NULL */
789 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1052, 0) }, /* NULL */
790 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1053, 0) }, /* NULL */
791 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1054, 0) }, /* NULL */
792 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1055, 0) }, /* NULL */
793 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1056, 0) }, /* NULL */
794 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1057, 0) }, /* NULL */
795 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1058, 0) }, /* NULL */
796 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1059, 0) }, /* NULL */
797 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x105a, 0) }, /* NULL */
798 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x105b, 0) }, /* NULL */
799 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x105c, 0) }, /* NULL */
800 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x105d, 0) }, /* NULL */
801 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x1503, 3) }, /* MOX6/MOX8 */
802 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x2000, 0) }, /* DGP-7 */
803 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x2001, 0) }, /* DGP-5 */
804 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x2002, 0) }, /* NULL */
805 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x2003, 0) }, /* NULL */
806 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x5000, 0) }, /* CS1D */
807 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x5001, 0) }, /* DSP1D */
808 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x5002, 0) }, /* DME32 */
809 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x5003, 0) }, /* DM2000 */
810 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x5004, 0) }, /* 02R96 */
811 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x5005, 0) }, /* ACU16-C */
812 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x5006, 0) }, /* NHB32-C */
813 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x5007, 0) }, /* DM1000 */
814 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x5008, 0) }, /* 01V96 */
815 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x5009, 0) }, /* SPX2000 */
816 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x500a, 0) }, /* PM5D */
817 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x500b, 0) }, /* DME64N */
818 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x500c, 0) }, /* DME24N */
819 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x500d, 0) }, /* NULL */
820 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x500e, 0) }, /* NULL */
821 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x500f, 0) }, /* NULL */
822 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x7000, 0) }, /* DTX */
823 	{ USB_VPI(USB_VENDOR_YAMAHA, 0x7010, 0) }, /* UB99 */
824 };
825 
826 static const STRUCT_USB_HOST_ID __used uaudio_devs[] = {
827 	/* Generic USB audio class match */
828 	{USB_IFACE_CLASS(UICLASS_AUDIO),
829 	 USB_IFACE_SUBCLASS(UISUBCLASS_AUDIOCONTROL),},
830 	/* Generic USB MIDI class match */
831 	{USB_IFACE_CLASS(UICLASS_AUDIO),
832 	 USB_IFACE_SUBCLASS(UISUBCLASS_MIDISTREAM),},
833 };
834 
835 static unsigned
836 uaudio_get_child_index_by_dev(struct uaudio_softc *sc, device_t dev)
837 {
838 	unsigned i;
839 
840 	for (i = 0; i != UAUDIO_MAX_CHILD; i++) {
841 		if (dev == sc->sc_child[i].pcm_device)
842 			return (i);
843 	}
844 	panic("uaudio_get_child_index_dev: Invalid device: %p\n", dev);
845 	return (0);
846 }
847 
848 static unsigned
849 uaudio_get_child_index_by_chan(struct uaudio_softc *sc, struct uaudio_chan *ch)
850 {
851 	unsigned i;
852 
853 	for (i = 0; i != UAUDIO_MAX_CHILD; i++) {
854 		if ((sc->sc_play_chan + i) == ch ||
855 		    (sc->sc_rec_chan + i) == ch)
856 			return (i);
857 	}
858 	panic("uaudio_get_child_index_by_chan: Invalid chan: %p\n", ch);
859 	return (0);
860 }
861 
862 static int
863 uaudio_probe(device_t dev)
864 {
865 	struct usb_attach_arg *uaa = device_get_ivars(dev);
866 
867 	if (uaa->usb_mode != USB_MODE_HOST)
868 		return (ENXIO);
869 
870 	/* lookup non-standard device(s) */
871 
872 	if (usbd_lookup_id_by_uaa(uaudio_vendor_midi,
873 	    sizeof(uaudio_vendor_midi), uaa) == 0) {
874 		return (BUS_PROBE_SPECIFIC);
875 	}
876 
877 	if (uaa->info.bInterfaceClass != UICLASS_AUDIO) {
878 		if (uaa->info.bInterfaceClass != UICLASS_VENDOR ||
879 		    usb_test_quirk(uaa, UQ_AU_VENDOR_CLASS) == 0)
880 			return (ENXIO);
881 	}
882 
883 	/* check for AUDIO control interface */
884 
885 	if (uaa->info.bInterfaceSubClass == UISUBCLASS_AUDIOCONTROL) {
886 		if (usb_test_quirk(uaa, UQ_BAD_AUDIO))
887 			return (ENXIO);
888 		else
889 			return (BUS_PROBE_GENERIC);
890 	}
891 
892 	/* check for MIDI stream */
893 
894 	if (uaa->info.bInterfaceSubClass == UISUBCLASS_MIDISTREAM) {
895 		if (usb_test_quirk(uaa, UQ_BAD_MIDI))
896 			return (ENXIO);
897 		else
898 			return (BUS_PROBE_GENERIC);
899 	}
900 	return (ENXIO);
901 }
902 
903 /*
904  * Set Cmedia CM6206 S/PDIF settings
905  * Source: CM6206 Datasheet v2.3.
906  */
907 static int
908 uaudio_set_spdif_cm6206(struct uaudio_softc *sc, int flags)
909 {
910 	uint8_t cmd[2][4] = {
911 		{0x20, 0x20, 0x00, 0},
912 		{0x20, 0x30, 0x02, 1}
913 	};
914 	int i;
915 
916 	if (flags & UAUDIO_SPDIF_OUT)
917 		cmd[1][1] = 0x00;
918 	else
919 		cmd[1][1] = 0x02;
920 
921 	if (flags & UAUDIO_SPDIF_OUT_96K)
922 		cmd[0][1] = 0x60;	/* 96K: 3'b110 */
923 
924 	if (flags & UAUDIO_SPDIF_IN_MIX)
925 		cmd[1][1] = 0x03;	/* SPDIFMIX */
926 
927 	for (i = 0; i < 2; i++) {
928 		if (usbd_req_set_report(sc->sc_udev, NULL,
929 		    cmd[i], sizeof(cmd[0]),
930 		    sc->sc_mixer_iface_index, UHID_OUTPUT_REPORT, 0) != 0) {
931 			return (ENXIO);
932 		}
933 	}
934 	return (0);
935 }
936 
937 static int
938 uaudio_set_spdif_dummy(struct uaudio_softc *sc, int flags)
939 {
940 	return (0);
941 }
942 
943 static usb_error_t
944 uaudio_force_power_save(struct uaudio_softc *sc, uint8_t iface_index)
945 {
946 	struct usb_interface *iface;
947 	usb_error_t err;
948 
949 	iface = usbd_get_iface(sc->sc_udev, iface_index);
950 	if (iface == NULL || iface->idesc == NULL)
951 		return (USB_ERR_INVAL);
952 
953 	/* check if correct alternate setting is already selected */
954 	if (iface->alt_index == 0) {
955 		/* force power save mode by selecting default alternate setting */
956 		err = usbd_req_set_alt_interface_no(sc->sc_udev, NULL, iface_index,
957 		    iface->idesc->bAlternateSetting);
958 	} else {
959 		err = usbd_set_alt_interface_index(sc->sc_udev, iface_index, 0);
960 	}
961 	return (err);
962 }
963 
964 static int
965 uaudio_attach(device_t dev)
966 {
967 	struct usb_attach_arg *uaa = device_get_ivars(dev);
968 	struct uaudio_softc *sc = device_get_softc(dev);
969 	struct usb_interface_descriptor *id;
970 	usb_error_t err;
971 	unsigned i;
972 
973 	sc->sc_udev = uaa->device;
974 	sc->sc_mixer_iface_index = uaa->info.bIfaceIndex;
975 	sc->sc_mixer_iface_no = uaa->info.bIfaceNum;
976 	sc->sc_config_msg[0].hdr.pm_callback = &uaudio_configure_msg;
977 	sc->sc_config_msg[0].sc = sc;
978 	sc->sc_config_msg[1].hdr.pm_callback = &uaudio_configure_msg;
979 	sc->sc_config_msg[1].sc = sc;
980 
981 	if (usb_test_quirk(uaa, UQ_AUDIO_SWAP_LR))
982 		sc->sc_uq_audio_swap_lr = 1;
983 
984 	if (usb_test_quirk(uaa, UQ_AU_INP_ASYNC))
985 		sc->sc_uq_au_inp_async = 1;
986 
987 	if (usb_test_quirk(uaa, UQ_AU_NO_XU))
988 		sc->sc_uq_au_no_xu = 1;
989 
990 	if (usb_test_quirk(uaa, UQ_BAD_ADC))
991 		sc->sc_uq_bad_adc = 1;
992 
993 	if (usb_test_quirk(uaa, UQ_AU_VENDOR_CLASS))
994 		sc->sc_uq_au_vendor_class = 1;
995 
996 	/* set S/PDIF function */
997 	if (usb_test_quirk(uaa, UQ_AU_SET_SPDIF_CM6206))
998 		sc->sc_set_spdif_fn = uaudio_set_spdif_cm6206;
999 	else
1000 		sc->sc_set_spdif_fn = uaudio_set_spdif_dummy;
1001 
1002 	umidi_init(dev);
1003 
1004 	device_set_usb_desc(dev);
1005 
1006 	id = usbd_get_interface_descriptor(uaa->iface);
1007 
1008 	/* must fill mixer info before channel info */
1009 	uaudio_mixer_fill_info(sc, uaa->device, id);
1010 
1011 	/* fill channel info */
1012 	uaudio_chan_fill_info(sc, uaa->device);
1013 
1014 	DPRINTF("audio rev %d.%02x\n",
1015 	    sc->sc_audio_rev >> 8,
1016 	    sc->sc_audio_rev & 0xff);
1017 
1018 	if (sc->sc_mixer_count == 0) {
1019 		if (uaa->info.idVendor == USB_VENDOR_MAUDIO &&
1020 		    (uaa->info.idProduct == USB_PRODUCT_MAUDIO_FASTTRACKULTRA ||
1021 		    uaa->info.idProduct == USB_PRODUCT_MAUDIO_FASTTRACKULTRA8R)) {
1022 			DPRINTF("Generating mixer descriptors\n");
1023 			uaudio_mixer_controls_create_ftu(sc);
1024 		}
1025 	}
1026 
1027 	DPRINTF("%d mixer controls\n",
1028 	    sc->sc_mixer_count);
1029 
1030 	for (i = 0; i != UAUDIO_MAX_CHILD; i++) {
1031 		uint8_t x;
1032 
1033 		if (sc->sc_play_chan[i].num_alt <= 0)
1034 			break;
1035 
1036 		/*
1037 		 * Need to set a default alternate interface, else
1038 		 * some USB audio devices might go into an infinite
1039 		 * re-enumeration loop:
1040 		 */
1041 		err = uaudio_force_power_save(sc,
1042 		    sc->sc_play_chan[i].usb_alt[0].iface_index);
1043 		if (err) {
1044 			DPRINTF("setting of alternate index failed: %s!\n",
1045 			    usbd_errstr(err));
1046 		}
1047 
1048 		for (x = 0; x != sc->sc_play_chan[i].num_alt; x++) {
1049 			device_printf(dev, "Play[%u]: %d Hz, %d ch, %s format, "
1050 			    "2x%dms buffer.\n", i,
1051 			    sc->sc_play_chan[i].usb_alt[x].sample_rate,
1052 			    sc->sc_play_chan[i].usb_alt[x].channels,
1053 			    sc->sc_play_chan[i].usb_alt[x].p_fmt->description,
1054 			    uaudio_buffer_ms);
1055 		}
1056 	}
1057 	if (i == 0)
1058 		device_printf(dev, "No playback.\n");
1059 
1060 	for (i = 0; i != UAUDIO_MAX_CHILD; i++) {
1061 		uint8_t x;
1062 
1063 		if (sc->sc_rec_chan[i].num_alt <= 0)
1064 			break;
1065 
1066 		/*
1067 		 * Need to set a default alternate interface, else
1068 		 * some USB audio devices might go into an infinite
1069 		 * re-enumeration loop:
1070 		 */
1071 		err = uaudio_force_power_save(sc,
1072 		    sc->sc_rec_chan[i].usb_alt[0].iface_index);
1073 		if (err) {
1074 			DPRINTF("setting of alternate index failed: %s!\n",
1075 			    usbd_errstr(err));
1076 		}
1077 
1078 		for (x = 0; x != sc->sc_rec_chan[i].num_alt; x++) {
1079 			device_printf(dev, "Record[%u]: %d Hz, %d ch, %s format, "
1080 			    "2x%dms buffer.\n", i,
1081 			    sc->sc_rec_chan[i].usb_alt[x].sample_rate,
1082 			    sc->sc_rec_chan[i].usb_alt[x].channels,
1083 			    sc->sc_rec_chan[i].usb_alt[x].p_fmt->description,
1084 			    uaudio_buffer_ms);
1085 		}
1086 	}
1087 	if (i == 0)
1088 		device_printf(dev, "No recording.\n");
1089 
1090 	if (sc->sc_midi_chan.valid == 0) {
1091 		if (usbd_lookup_id_by_uaa(uaudio_vendor_midi,
1092 		    sizeof(uaudio_vendor_midi), uaa) == 0) {
1093 			sc->sc_midi_chan.iface_index =
1094 			    (uint8_t)uaa->driver_info;
1095 			sc->sc_midi_chan.iface_alt_index = 0;
1096 			sc->sc_midi_chan.valid = 1;
1097 		}
1098 	}
1099 
1100 	if (sc->sc_midi_chan.valid) {
1101 		if (umidi_probe(dev)) {
1102 			goto detach;
1103 		}
1104 		device_printf(dev, "MIDI sequencer.\n");
1105 	} else {
1106 		device_printf(dev, "No MIDI sequencer.\n");
1107 	}
1108 
1109 	DPRINTF("doing child attach\n");
1110 
1111 	/* attach the children */
1112 
1113 	sc->sc_sndcard_func.func = SCF_PCM;
1114 
1115 	/*
1116 	 * Only attach a PCM device if we have a playback, recording
1117 	 * or mixer device present:
1118 	 */
1119 	for (i = 0; i != UAUDIO_MAX_CHILD; i++) {
1120 		if (sc->sc_play_chan[i].num_alt <= 0 &&
1121 		    sc->sc_rec_chan[i].num_alt <= 0 &&
1122 		    sc->sc_child[i].mix_info == 0)
1123 			continue;
1124 		sc->sc_child[i].pcm_device =
1125 		    device_add_child(dev, "pcm", -1);
1126 
1127 		if (sc->sc_child[i].pcm_device == NULL) {
1128 			DPRINTF("out of memory\n");
1129 			goto detach;
1130 		}
1131 		device_set_ivars(sc->sc_child[i].pcm_device,
1132 		    &sc->sc_sndcard_func);
1133 	}
1134 
1135 	if (bus_generic_attach(dev)) {
1136 		DPRINTF("child attach failed\n");
1137 		goto detach;
1138 	}
1139 
1140 	if (uaudio_handle_hid) {
1141 		if (uaudio_hid_probe(sc, uaa) == 0) {
1142 			device_printf(dev, "HID volume keys found.\n");
1143 		} else {
1144 			device_printf(dev, "No HID volume keys found.\n");
1145 		}
1146 	}
1147 
1148 	/* reload all mixer settings */
1149 	uaudio_mixer_reload_all(sc);
1150 
1151 	/* enable S/PDIF output, if any */
1152 	if (sc->sc_set_spdif_fn(sc,
1153 	    UAUDIO_SPDIF_OUT | UAUDIO_SPDIF_OUT_48K) != 0) {
1154 		device_printf(dev, "Failed to enable S/PDIF at 48K\n");
1155 	}
1156 	return (0);			/* success */
1157 
1158 detach:
1159 	uaudio_detach(dev);
1160 	return (ENXIO);
1161 }
1162 
1163 static void
1164 uaudio_pcm_setflags(device_t dev, uint32_t flags)
1165 {
1166 	pcm_setflags(dev, pcm_getflags(dev) | flags);
1167 }
1168 
1169 int
1170 uaudio_attach_sub(device_t dev, kobj_class_t mixer_class, kobj_class_t chan_class)
1171 {
1172 	struct uaudio_softc *sc = device_get_softc(device_get_parent(dev));
1173 	unsigned i = uaudio_get_child_index_by_dev(sc, dev);
1174 	char status[SND_STATUSLEN], desc[128];
1175 
1176 	uaudio_mixer_init(sc, i);
1177 
1178 	if (sc->sc_uq_audio_swap_lr) {
1179 		DPRINTF("hardware has swapped left and right\n");
1180 		/* uaudio_pcm_setflags(dev, SD_F_PSWAPLR); */
1181 	}
1182 	if (sc->sc_play_chan[i].num_alt > 0 &&
1183 	    (sc->sc_child[i].mix_info & SOUND_MASK_PCM) == 0) {
1184 		DPRINTF("software controlled main volume\n");
1185 
1186 		/*
1187 		 * Emulate missing pcm mixer controller
1188 		 * through FEEDER_VOLUME
1189 		 */
1190 		uaudio_pcm_setflags(dev, SD_F_SOFTPCMVOL);
1191 	}
1192 	if (sc->sc_pcm_bitperfect) {
1193 		DPRINTF("device needs bitperfect by default\n");
1194 		uaudio_pcm_setflags(dev, SD_F_BITPERFECT);
1195 	}
1196 	if (mixer_init(dev, mixer_class, sc))
1197 		goto detach;
1198 	sc->sc_child[i].mixer_init = 1;
1199 
1200 	mixer_hwvol_init(dev);
1201 
1202 	snprintf(desc, sizeof(desc), "%s %s",
1203 	    usb_get_manufacturer(sc->sc_udev),
1204 	    usb_get_product(sc->sc_udev));
1205 	device_set_desc_copy(dev, desc);
1206 
1207 	snprintf(status, sizeof(status), "at %s %s",
1208 	    device_get_nameunit(device_get_parent(dev)),
1209 	    PCM_KLDSTRING(snd_uaudio));
1210 
1211 	if (pcm_register(dev, sc,
1212 	    (sc->sc_play_chan[i].num_alt > 0) ? 1 : 0,
1213 	    (sc->sc_rec_chan[i].num_alt > 0) ? 1 : 0)) {
1214 		goto detach;
1215 	}
1216 
1217 	uaudio_pcm_setflags(dev, SD_F_MPSAFE);
1218 	sc->sc_child[i].pcm_registered = 1;
1219 
1220 	if (sc->sc_play_chan[i].num_alt > 0) {
1221 		sc->sc_play_chan[i].priv_sc = sc;
1222 		pcm_addchan(dev, PCMDIR_PLAY, chan_class,
1223 		    &sc->sc_play_chan[i]);
1224 	}
1225 
1226 	if (sc->sc_rec_chan[i].num_alt > 0) {
1227 		sc->sc_rec_chan[i].priv_sc = sc;
1228 		pcm_addchan(dev, PCMDIR_REC, chan_class,
1229 		    &sc->sc_rec_chan[i]);
1230 	}
1231 	pcm_setstatus(dev, status);
1232 
1233 	uaudio_mixer_register_sysctl(sc, dev, i);
1234 
1235 	SYSCTL_ADD_INT(device_get_sysctl_ctx(dev),
1236 	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO,
1237 	    "feedback_rate", CTLFLAG_RD, &sc->sc_play_chan[i].feedback_rate,
1238 	    0, "Feedback sample rate in Hz");
1239 
1240 	return (0);			/* success */
1241 
1242 detach:
1243 	uaudio_detach_sub(dev);
1244 	return (ENXIO);
1245 }
1246 
1247 int
1248 uaudio_detach_sub(device_t dev)
1249 {
1250 	struct uaudio_softc *sc = device_get_softc(device_get_parent(dev));
1251 	unsigned i = uaudio_get_child_index_by_dev(sc, dev);
1252 	int error = 0;
1253 
1254 repeat:
1255 	if (sc->sc_child[i].pcm_registered) {
1256 		error = pcm_unregister(dev);
1257 	} else {
1258 		if (sc->sc_child[i].mixer_init)
1259 			error = mixer_uninit(dev);
1260 	}
1261 
1262 	if (error) {
1263 		device_printf(dev, "Waiting for sound application to exit!\n");
1264 		usb_pause_mtx(NULL, 2 * hz);
1265 		goto repeat;		/* try again */
1266 	}
1267 	return (0);			/* success */
1268 }
1269 
1270 static int
1271 uaudio_detach(device_t dev)
1272 {
1273 	struct uaudio_softc *sc = device_get_softc(dev);
1274 	unsigned i;
1275 
1276 	/*
1277 	 * Stop USB transfers early so that any audio applications
1278 	 * will time out and close opened /dev/dspX.Y device(s), if
1279 	 * any.
1280 	 */
1281 	usb_proc_explore_lock(sc->sc_udev);
1282 	for (i = 0; i != UAUDIO_MAX_CHILD; i++) {
1283 		sc->sc_play_chan[i].operation = CHAN_OP_DRAIN;
1284 		sc->sc_rec_chan[i].operation = CHAN_OP_DRAIN;
1285 	}
1286 	usb_proc_explore_mwait(sc->sc_udev,
1287 	    &sc->sc_config_msg[0], &sc->sc_config_msg[1]);
1288 	usb_proc_explore_unlock(sc->sc_udev);
1289 
1290 	for (i = 0; i != UAUDIO_MAX_CHILD; i++) {
1291 		usbd_transfer_unsetup(sc->sc_play_chan[i].xfer, UAUDIO_NCHANBUFS + 1);
1292 		usbd_transfer_unsetup(sc->sc_rec_chan[i].xfer, UAUDIO_NCHANBUFS + 1);
1293 	}
1294 
1295 	uaudio_hid_detach(sc);
1296 
1297 	if (bus_generic_detach(dev) != 0) {
1298 		DPRINTF("detach failed!\n");
1299 	}
1300 	sbuf_delete(&sc->sc_sndstat);
1301 	sc->sc_sndstat_valid = 0;
1302 
1303 	umidi_detach(dev);
1304 
1305 	/* free mixer data */
1306 
1307 	uaudio_mixer_ctl_free(sc);
1308 
1309 	/* disable S/PDIF output, if any */
1310 	(void) sc->sc_set_spdif_fn(sc, 0);
1311 
1312 	return (0);
1313 }
1314 
1315 static uint32_t
1316 uaudio_get_buffer_size(struct uaudio_chan *ch, uint8_t alt)
1317 {
1318 	struct uaudio_chan_alt *chan_alt = &ch->usb_alt[alt];
1319 	/* We use 2 times 8ms of buffer */
1320 	uint32_t buf_size = chan_alt->sample_size *
1321 	    howmany(chan_alt->sample_rate * (UAUDIO_NFRAMES / 8), 1000);
1322 	return (buf_size);
1323 }
1324 
1325 static void
1326 uaudio_configure_msg_sub(struct uaudio_softc *sc,
1327     struct uaudio_chan *chan, int dir)
1328 {
1329 	struct uaudio_chan_alt *chan_alt;
1330 	uint32_t frames;
1331 	uint32_t buf_size;
1332 	uint16_t fps;
1333 	uint8_t next_alt;
1334 	uint8_t fps_shift;
1335 	uint8_t operation;
1336 	usb_error_t err;
1337 
1338 	if (chan->num_alt <= 0)
1339 		return;
1340 
1341 	DPRINTF("\n");
1342 
1343 	usb_proc_explore_lock(sc->sc_udev);
1344 	operation = chan->operation;
1345 	switch (operation) {
1346 	case CHAN_OP_START:
1347 	case CHAN_OP_STOP:
1348 		chan->operation = CHAN_OP_NONE;
1349 		break;
1350 	default:
1351 		break;
1352 	}
1353 	usb_proc_explore_unlock(sc->sc_udev);
1354 
1355 	switch (operation) {
1356 	case CHAN_OP_STOP:
1357 		/* Unsetup prior USB transfers, if any. */
1358 		usbd_transfer_unsetup(chan->xfer, UAUDIO_NCHANBUFS + 1);
1359 
1360 		mtx_lock(chan->pcm_mtx);
1361 		chan->cur_alt = CHAN_MAX_ALT;
1362 		mtx_unlock(chan->pcm_mtx);
1363 
1364 		/*
1365 		 * The first alternate setting is typically used for
1366 		 * power saving mode. Set this alternate setting as
1367 		 * part of entering stop.
1368 		 */
1369 		err = usbd_set_alt_interface_index(sc->sc_udev, chan->iface_index, 0);
1370 		if (err) {
1371 			DPRINTF("setting of default alternate index failed: %s!\n",
1372 			    usbd_errstr(err));
1373 		}
1374 		return;
1375 
1376 	case CHAN_OP_START:
1377 		/* Unsetup prior USB transfers, if any. */
1378 		usbd_transfer_unsetup(chan->xfer, UAUDIO_NCHANBUFS + 1);
1379 		break;
1380 
1381 	default:
1382 		return;
1383 	}
1384 
1385 	mtx_lock(chan->pcm_mtx);
1386 	next_alt = chan->set_alt;
1387 	mtx_unlock(chan->pcm_mtx);
1388 
1389 	chan_alt = chan->usb_alt + next_alt;
1390 
1391 	err = usbd_set_alt_interface_index(sc->sc_udev,
1392 	    chan_alt->iface_index, chan_alt->iface_alt_index);
1393 	if (err) {
1394 		DPRINTF("setting of alternate index failed: %s!\n",
1395 		    usbd_errstr(err));
1396 		goto error;
1397 	}
1398 
1399 	/*
1400 	 * Only set the sample rate if the channel reports that it
1401 	 * supports the frequency control.
1402 	 */
1403 
1404 	if (sc->sc_audio_rev >= UAUDIO_VERSION_30) {
1405 		/* FALLTHROUGH */
1406 	} else if (sc->sc_audio_rev >= UAUDIO_VERSION_20) {
1407 		unsigned int x;
1408 
1409 		for (x = 0; x != 256; x++) {
1410 			if (dir == PCMDIR_PLAY) {
1411 				if (!(sc->sc_mixer_clocks.bit_output[x / 8] &
1412 				    (1 << (x % 8)))) {
1413 					continue;
1414 				}
1415 			} else {
1416 				if (!(sc->sc_mixer_clocks.bit_input[x / 8] &
1417 				    (1 << (x % 8)))) {
1418 					continue;
1419 				}
1420 			}
1421 
1422 			if (uaudio20_set_speed(sc->sc_udev,
1423 			    sc->sc_mixer_iface_no, x, chan_alt->sample_rate)) {
1424 				/*
1425 				 * If the endpoint is adaptive setting
1426 				 * the speed may fail.
1427 				 */
1428 				DPRINTF("setting of sample rate failed! "
1429 				    "(continuing anyway)\n");
1430 			}
1431 		}
1432 	} else if (chan_alt->p_sed.v1->bmAttributes & UA_SED_FREQ_CONTROL) {
1433 		if (uaudio_set_speed(sc->sc_udev,
1434 		    chan_alt->p_ed1->bEndpointAddress, chan_alt->sample_rate)) {
1435 			/*
1436 			 * If the endpoint is adaptive setting the
1437 			 * speed may fail.
1438 			 */
1439 			DPRINTF("setting of sample rate failed! "
1440 			    "(continuing anyway)\n");
1441 		}
1442 	}
1443 	if (usbd_transfer_setup(sc->sc_udev, &chan_alt->iface_index, chan->xfer,
1444 	    chan_alt->usb_cfg, UAUDIO_NCHANBUFS + 1, chan, chan->pcm_mtx)) {
1445 		DPRINTF("could not allocate USB transfers!\n");
1446 		goto error;
1447 	}
1448 
1449 	fps = usbd_get_isoc_fps(sc->sc_udev);
1450 
1451 	if (fps < 8000) {
1452 		/* FULL speed USB */
1453 		frames = uaudio_buffer_ms;
1454 	} else {
1455 		/* HIGH speed USB */
1456 		frames = uaudio_buffer_ms * 8;
1457 	}
1458 
1459 	fps_shift = usbd_xfer_get_fps_shift(chan->xfer[0]);
1460 
1461 	/* down shift number of frames per second, if any */
1462 	fps >>= fps_shift;
1463 	frames >>= fps_shift;
1464 
1465 	/* bytes per frame should not be zero */
1466 	chan->bytes_per_frame[0] =
1467 	    ((chan_alt->sample_rate / fps) * chan_alt->sample_size);
1468 	chan->bytes_per_frame[1] = howmany(chan_alt->sample_rate, fps) *
1469 	    chan_alt->sample_size;
1470 
1471 	/* setup data rate dithering, if any */
1472 	chan->frames_per_second = fps;
1473 	chan->sample_rem = chan_alt->sample_rate % fps;
1474 	chan->sample_curr = 0;
1475 
1476 	/* compute required buffer size */
1477 	buf_size = (chan->bytes_per_frame[1] * frames);
1478 
1479 	if (buf_size > (chan->end - chan->start)) {
1480 		DPRINTF("buffer size is too big\n");
1481 		goto error;
1482 	}
1483 
1484 	chan->intr_frames = frames;
1485 
1486 	DPRINTF("fps=%d sample_rem=%d\n", (int)fps, (int)chan->sample_rem);
1487 
1488 	if (chan->intr_frames == 0) {
1489 		DPRINTF("frame shift is too high!\n");
1490 		goto error;
1491 	}
1492 
1493 #if (UAUDIO_NCHANBUFS != 2)
1494 #error "Please update code below!"
1495 #endif
1496 
1497 	mtx_lock(chan->pcm_mtx);
1498 	chan->cur_alt = next_alt;
1499 	usbd_transfer_start(chan->xfer[0]);
1500 	usbd_transfer_start(chan->xfer[1]);
1501 	mtx_unlock(chan->pcm_mtx);
1502 	return;
1503 error:
1504 	usbd_transfer_unsetup(chan->xfer, UAUDIO_NCHANBUFS + 1);
1505 
1506 	mtx_lock(chan->pcm_mtx);
1507 	chan->cur_alt = CHAN_MAX_ALT;
1508 	mtx_unlock(chan->pcm_mtx);
1509 }
1510 
1511 static void
1512 uaudio_configure_msg(struct usb_proc_msg *pm)
1513 {
1514 	struct uaudio_softc *sc = ((struct uaudio_configure_msg *)pm)->sc;
1515 	unsigned i;
1516 
1517 	usb_proc_explore_unlock(sc->sc_udev);
1518 	for (i = 0; i != UAUDIO_MAX_CHILD; i++) {
1519 		uaudio_configure_msg_sub(sc, &sc->sc_play_chan[i], PCMDIR_PLAY);
1520 		uaudio_configure_msg_sub(sc, &sc->sc_rec_chan[i], PCMDIR_REC);
1521 	}
1522 	usb_proc_explore_lock(sc->sc_udev);
1523 }
1524 
1525 /*========================================================================*
1526  * AS - Audio Stream - routines
1527  *========================================================================*/
1528 
1529 #ifdef USB_DEBUG
1530 static void
1531 uaudio_chan_dump_ep_desc(const usb_endpoint_descriptor_audio_t *ed)
1532 {
1533 	if (ed) {
1534 		DPRINTF("endpoint=%p bLength=%d bDescriptorType=%d \n"
1535 		    "bEndpointAddress=%d bmAttributes=0x%x \n"
1536 		    "wMaxPacketSize=%d bInterval=%d \n"
1537 		    "bRefresh=%d bSynchAddress=%d\n",
1538 		    ed, ed->bLength, ed->bDescriptorType,
1539 		    ed->bEndpointAddress, ed->bmAttributes,
1540 		    UGETW(ed->wMaxPacketSize), ed->bInterval,
1541 		    UEP_HAS_REFRESH(ed) ? ed->bRefresh : 0,
1542 		    UEP_HAS_SYNCADDR(ed) ? ed->bSynchAddress : 0);
1543 	}
1544 }
1545 
1546 #endif
1547 
1548 /*
1549  * The following is a workaround for broken no-name USB audio devices
1550  * sold by dealextreme called "3D sound". The problem is that the
1551  * manufacturer computed wMaxPacketSize is too small to hold the
1552  * actual data sent. In other words the device sometimes sends more
1553  * data than it actually reports it can send in a single isochronous
1554  * packet.
1555  */
1556 static void
1557 uaudio_record_fix_fs(usb_endpoint_descriptor_audio_t *ep,
1558     uint32_t xps, uint32_t add)
1559 {
1560 	uint32_t mps;
1561 
1562 	mps = UGETW(ep->wMaxPacketSize);
1563 
1564 	/*
1565 	 * If the device indicates it can send more data than what the
1566 	 * sample rate indicates, we apply the workaround.
1567 	 */
1568 	if (mps > xps) {
1569 		/* allow additional data */
1570 		xps += add;
1571 
1572 		/* check against the maximum USB 1.x length */
1573 		if (xps > 1023)
1574 			xps = 1023;
1575 
1576 		/* check if we should do an update */
1577 		if (mps < xps) {
1578 			/* simply update the wMaxPacketSize field */
1579 			USETW(ep->wMaxPacketSize, xps);
1580 			DPRINTF("Workaround: Updated wMaxPacketSize "
1581 			    "from %d to %d bytes.\n",
1582 			    (int)mps, (int)xps);
1583 		}
1584 	}
1585 }
1586 
1587 static usb_error_t
1588 uaudio20_check_rate(struct usb_device *udev, uint8_t iface_no,
1589     uint8_t clockid, uint32_t rate)
1590 {
1591 	struct usb_device_request req;
1592 	usb_error_t error;
1593 #define	UAUDIO20_MAX_RATES 32	/* we support at maximum 32 rates */
1594 	uint8_t data[2 + UAUDIO20_MAX_RATES * 12];
1595 	uint16_t actlen;
1596 	uint16_t rates;
1597 	uint16_t x;
1598 
1599 	DPRINTFN(6, "ifaceno=%d clockid=%d rate=%u\n",
1600 	    iface_no, clockid, rate);
1601 
1602 	req.bmRequestType = UT_READ_CLASS_INTERFACE;
1603 	req.bRequest = UA20_CS_RANGE;
1604 	USETW2(req.wValue, UA20_CS_SAM_FREQ_CONTROL, 0);
1605 	USETW2(req.wIndex, clockid, iface_no);
1606 	/*
1607 	 * Assume there is at least one rate to begin with, else some
1608 	 * devices might refuse to return the USB descriptor:
1609 	 */
1610 	USETW(req.wLength, (2 + 1 * 12));
1611 
1612 	error = usbd_do_request_flags(udev, NULL, &req, data,
1613 	    USB_SHORT_XFER_OK, &actlen, USB_DEFAULT_TIMEOUT);
1614 
1615 	if (error != 0 || actlen < 2) {
1616 		/*
1617 		 * Likely the descriptor doesn't fit into the supplied
1618 		 * buffer. Try using a larger buffer and see if that
1619 		 * helps:
1620 		 */
1621 		rates = MIN(UAUDIO20_MAX_RATES, (255 - 2) / 12);
1622 		error = USB_ERR_INVAL;
1623 	} else {
1624 		rates = UGETW(data);
1625 
1626 		if (rates > UAUDIO20_MAX_RATES) {
1627 			DPRINTF("Too many rates truncating to %d\n", UAUDIO20_MAX_RATES);
1628 			rates = UAUDIO20_MAX_RATES;
1629 			error = USB_ERR_INVAL;
1630 		} else if (rates > 1) {
1631 			DPRINTF("Need to read full rate descriptor\n");
1632 			error = USB_ERR_INVAL;
1633 		}
1634 	}
1635 
1636 	if (error != 0) {
1637 		/*
1638 		 * Try to read full rate descriptor.
1639 		 */
1640 		actlen = (2 + rates * 12);
1641 
1642 		USETW(req.wLength, actlen);
1643 
1644 	        error = usbd_do_request_flags(udev, NULL, &req, data,
1645 		    USB_SHORT_XFER_OK, &actlen, USB_DEFAULT_TIMEOUT);
1646 
1647 		if (error != 0 || actlen < 2)
1648 			return (USB_ERR_INVAL);
1649 
1650 		rates = UGETW(data);
1651 	}
1652 
1653 	actlen = (actlen - 2) / 12;
1654 
1655 	if (rates > actlen) {
1656 		DPRINTF("Too many rates truncating to %d\n", actlen);
1657 		rates = actlen;
1658 	}
1659 
1660 	for (x = 0; x != rates; x++) {
1661 		uint32_t min = UGETDW(data + 2 + (12 * x));
1662 		uint32_t max = UGETDW(data + 6 + (12 * x));
1663 		uint32_t res = UGETDW(data + 10 + (12 * x));
1664 
1665 		if (res == 0) {
1666 			DPRINTF("Zero residue\n");
1667 			res = 1;
1668 		}
1669 
1670 		if (min > max) {
1671 			DPRINTF("Swapped max and min\n");
1672 			uint32_t temp;
1673 			temp = min;
1674 			min = max;
1675 			max = temp;
1676 		}
1677 
1678 		if (rate >= min && rate <= max &&
1679 		    (((rate - min) % res) == 0)) {
1680 			return (0);
1681 		}
1682 	}
1683 	return (USB_ERR_INVAL);
1684 }
1685 
1686 static struct uaudio_chan *
1687 uaudio_get_chan(struct uaudio_softc *sc, struct uaudio_chan *chan,
1688     uint8_t iface_index)
1689 {
1690 	unsigned i;
1691 
1692 	for (i = 0; i != UAUDIO_MAX_CHILD; i++, chan++) {
1693 		if (chan->num_alt == 0) {
1694 			chan->iface_index = iface_index;
1695 			return (chan);
1696 		} else if (chan->iface_index == iface_index)
1697 			return (chan);
1698 	}
1699 	return (NULL);
1700 }
1701 
1702 static void
1703 uaudio_chan_fill_info_sub(struct uaudio_softc *sc, struct usb_device *udev,
1704     uint32_t rate, uint8_t channels, uint8_t bit_resolution)
1705 {
1706 	struct usb_descriptor *desc = NULL;
1707 	union uaudio_asid asid = { NULL };
1708 	union uaudio_asf1d asf1d = { NULL };
1709 	union uaudio_sed sed = { NULL };
1710 	struct usb_midi_streaming_endpoint_descriptor *msid = NULL;
1711 	usb_endpoint_descriptor_audio_t *ed1 = NULL;
1712 	const struct usb_audio_control_descriptor *acdp = NULL;
1713 	struct usb_config_descriptor *cd = usbd_get_config_descriptor(udev);
1714 	struct usb_interface_descriptor *id;
1715 	const struct uaudio_format *p_fmt = NULL;
1716 	struct uaudio_chan *chan;
1717 	struct uaudio_chan_alt *chan_alt;
1718 	uint32_t format;
1719 	uint16_t curidx = 0xFFFF;
1720 	uint16_t lastidx = 0xFFFF;
1721 	uint16_t alt_index = 0;
1722 	uint16_t audio_rev = 0;
1723 	uint16_t x;
1724 	uint8_t ep_dir;
1725 	uint8_t bChannels;
1726 	uint8_t bBitResolution;
1727 	uint8_t audio_if = 0;
1728 	uint8_t midi_if = 0;
1729 	uint8_t uma_if_class;
1730 
1731 	while ((desc = usb_desc_foreach(cd, desc))) {
1732 		if ((desc->bDescriptorType == UDESC_INTERFACE) &&
1733 		    (desc->bLength >= sizeof(*id))) {
1734 			id = (void *)desc;
1735 
1736 			if (id->bInterfaceNumber != lastidx) {
1737 				lastidx = id->bInterfaceNumber;
1738 				curidx++;
1739 				alt_index = 0;
1740 
1741 			} else {
1742 				alt_index++;
1743 			}
1744 
1745 			if ((!(sc->sc_hid.flags & UAUDIO_HID_VALID)) &&
1746 			    (id->bInterfaceClass == UICLASS_HID) &&
1747 			    (id->bInterfaceSubClass == 0) &&
1748 			    (id->bInterfaceProtocol == 0) &&
1749 			    (alt_index == 0) &&
1750 			    usbd_get_iface(udev, curidx) != NULL) {
1751 				DPRINTF("Found HID interface at %d\n",
1752 				    curidx);
1753 				sc->sc_hid.flags |= UAUDIO_HID_VALID;
1754 				sc->sc_hid.iface_index = curidx;
1755 			}
1756 
1757 			uma_if_class =
1758 			    ((id->bInterfaceClass == UICLASS_AUDIO) ||
1759 			    ((id->bInterfaceClass == UICLASS_VENDOR) &&
1760 			    (sc->sc_uq_au_vendor_class != 0)));
1761 
1762 			if ((uma_if_class != 0) &&
1763 			    (id->bInterfaceSubClass == UISUBCLASS_AUDIOSTREAM)) {
1764 				audio_if = 1;
1765 			} else {
1766 				audio_if = 0;
1767 			}
1768 
1769 			if ((uma_if_class != 0) &&
1770 			    (id->bInterfaceSubClass == UISUBCLASS_MIDISTREAM)) {
1771 				/*
1772 				 * XXX could allow multiple MIDI interfaces
1773 				 */
1774 				midi_if = 1;
1775 
1776 				if ((sc->sc_midi_chan.valid == 0) &&
1777 				    (usbd_get_iface(udev, curidx) != NULL)) {
1778 					sc->sc_midi_chan.iface_index = curidx;
1779 					sc->sc_midi_chan.iface_alt_index = alt_index;
1780 					sc->sc_midi_chan.valid = 1;
1781 				}
1782 			} else {
1783 				midi_if = 0;
1784 			}
1785 			asid.v1 = NULL;
1786 			asf1d.v1 = NULL;
1787 			ed1 = NULL;
1788 			sed.v1 = NULL;
1789 
1790 			/*
1791 			 * There can only be one USB audio instance
1792 			 * per USB device. Grab all USB audio
1793 			 * interfaces on this USB device so that we
1794 			 * don't attach USB audio twice:
1795 			 */
1796 			if (alt_index == 0 && curidx != sc->sc_mixer_iface_index &&
1797 			    (id->bInterfaceClass == UICLASS_AUDIO || audio_if != 0 ||
1798 			    midi_if != 0)) {
1799 				usbd_set_parent_iface(sc->sc_udev, curidx,
1800 				    sc->sc_mixer_iface_index);
1801 			}
1802 		}
1803 
1804 		if (audio_if == 0) {
1805 			if (midi_if == 0) {
1806 				if ((acdp == NULL) &&
1807 				    (desc->bDescriptorType == UDESC_CS_INTERFACE) &&
1808 				    (desc->bDescriptorSubtype == UDESCSUB_AC_HEADER) &&
1809 				    (desc->bLength >= sizeof(*acdp))) {
1810 					acdp = (void *)desc;
1811 					audio_rev = UGETW(acdp->bcdADC);
1812 				}
1813 			} else {
1814 				msid = (void *)desc;
1815 
1816 				/* get the maximum number of embedded jacks in use, if any */
1817 				if (msid->bLength >= sizeof(*msid) &&
1818 				    msid->bDescriptorType == UDESC_CS_ENDPOINT &&
1819 				    msid->bDescriptorSubtype == MS_GENERAL &&
1820 				    msid->bNumEmbMIDIJack > sc->sc_midi_chan.max_emb_jack) {
1821 					sc->sc_midi_chan.max_emb_jack = msid->bNumEmbMIDIJack;
1822 				}
1823 			}
1824 			/*
1825 			 * Don't collect any USB audio descriptors if
1826 			 * this is not an USB audio stream interface.
1827 			 */
1828 			continue;
1829 		}
1830 
1831 		if ((acdp != NULL || sc->sc_uq_au_vendor_class != 0) &&
1832 		    (desc->bDescriptorType == UDESC_CS_INTERFACE) &&
1833 		    (desc->bDescriptorSubtype == AS_GENERAL) &&
1834 		    (asid.v1 == NULL)) {
1835 			if (audio_rev >= UAUDIO_VERSION_30) {
1836 				/* FALLTHROUGH */
1837 			} else if (audio_rev >= UAUDIO_VERSION_20) {
1838 				if (desc->bLength >= sizeof(*asid.v2)) {
1839 					asid.v2 = (void *)desc;
1840 				}
1841 			} else {
1842 				if (desc->bLength >= sizeof(*asid.v1)) {
1843 					asid.v1 = (void *)desc;
1844 				}
1845 			}
1846 		}
1847 		if ((acdp != NULL || sc->sc_uq_au_vendor_class != 0) &&
1848 		    (desc->bDescriptorType == UDESC_CS_INTERFACE) &&
1849 		    (desc->bDescriptorSubtype == FORMAT_TYPE) &&
1850 		    (asf1d.v1 == NULL)) {
1851 			if (audio_rev >= UAUDIO_VERSION_30) {
1852 				/* FALLTHROUGH */
1853 			} else if (audio_rev >= UAUDIO_VERSION_20) {
1854 				if (desc->bLength >= sizeof(*asf1d.v2))
1855 					asf1d.v2 = (void *)desc;
1856 			} else {
1857 				if (desc->bLength >= sizeof(*asf1d.v1)) {
1858 					asf1d.v1 = (void *)desc;
1859 
1860 					if (asf1d.v1->bFormatType != FORMAT_TYPE_I) {
1861 						DPRINTFN(11, "ignored bFormatType = %d\n",
1862 						    asf1d.v1->bFormatType);
1863 						asf1d.v1 = NULL;
1864 						continue;
1865 					}
1866 					if (desc->bLength < (sizeof(*asf1d.v1) +
1867 					    ((asf1d.v1->bSamFreqType == 0) ? 6 :
1868 					    (asf1d.v1->bSamFreqType * 3)))) {
1869 						DPRINTFN(11, "invalid descriptor, "
1870 						    "too short\n");
1871 						asf1d.v1 = NULL;
1872 						continue;
1873 					}
1874 				}
1875 			}
1876 		}
1877 		if ((desc->bDescriptorType == UDESC_ENDPOINT) &&
1878 		    (desc->bLength >= UEP_MINSIZE) &&
1879 		    (ed1 == NULL)) {
1880 			ed1 = (void *)desc;
1881 			if (UE_GET_XFERTYPE(ed1->bmAttributes) != UE_ISOCHRONOUS) {
1882 				ed1 = NULL;
1883 				continue;
1884 			}
1885 		}
1886 		if ((acdp != NULL || sc->sc_uq_au_vendor_class != 0) &&
1887 		    (desc->bDescriptorType == UDESC_CS_ENDPOINT) &&
1888 		    (desc->bDescriptorSubtype == AS_GENERAL) &&
1889 		    (sed.v1 == NULL)) {
1890 			if (audio_rev >= UAUDIO_VERSION_30) {
1891 				/* FALLTHROUGH */
1892 			} else if (audio_rev >= UAUDIO_VERSION_20) {
1893 				if (desc->bLength >= sizeof(*sed.v2))
1894 					sed.v2 = (void *)desc;
1895 			} else {
1896 				if (desc->bLength >= sizeof(*sed.v1))
1897 					sed.v1 = (void *)desc;
1898 			}
1899 		}
1900 		if (asid.v1 == NULL || asf1d.v1 == NULL ||
1901 		    ed1 == NULL || sed.v1 == NULL) {
1902 			/* need more descriptors */
1903 			continue;
1904 		}
1905 
1906 		ep_dir = UE_GET_DIR(ed1->bEndpointAddress);
1907 
1908 		/* We ignore sync endpoint information until further. */
1909 
1910 		if (audio_rev >= UAUDIO_VERSION_30) {
1911 			goto next_ep;
1912 		} else if (audio_rev >= UAUDIO_VERSION_20) {
1913 			uint32_t dwFormat;
1914 
1915 			dwFormat = UGETDW(asid.v2->bmFormats);
1916 			bChannels = asid.v2->bNrChannels;
1917 			bBitResolution = asf1d.v2->bSubslotSize * 8;
1918 
1919 			if ((bChannels != channels) ||
1920 			    (bBitResolution != bit_resolution)) {
1921 				DPRINTF("Wrong number of channels\n");
1922 				goto next_ep;
1923 			}
1924 
1925 			for (p_fmt = uaudio20_formats;
1926 			    p_fmt->wFormat != 0; p_fmt++) {
1927 				if ((p_fmt->wFormat & dwFormat) &&
1928 				    (p_fmt->bPrecision == bBitResolution))
1929 					break;
1930 			}
1931 
1932 			if (p_fmt->wFormat == 0) {
1933 				DPRINTF("Unsupported audio format\n");
1934 				goto next_ep;
1935 			}
1936 
1937 			for (x = 0; x != 256; x++) {
1938 				if (ep_dir == UE_DIR_OUT) {
1939 					if (!(sc->sc_mixer_clocks.bit_output[x / 8] &
1940 					    (1 << (x % 8)))) {
1941 						continue;
1942 					}
1943 				} else {
1944 					if (!(sc->sc_mixer_clocks.bit_input[x / 8] &
1945 					    (1 << (x % 8)))) {
1946 						continue;
1947 					}
1948 				}
1949 
1950 				DPRINTF("Checking clock ID=%d\n", x);
1951 
1952 				if (uaudio20_check_rate(udev,
1953 				    sc->sc_mixer_iface_no, x, rate)) {
1954 					DPRINTF("Unsupported sampling "
1955 					    "rate, id=%d\n", x);
1956 					goto next_ep;
1957 				}
1958 			}
1959 		} else {
1960 			uint16_t wFormat;
1961 
1962 			wFormat = UGETW(asid.v1->wFormatTag);
1963 			bChannels = UAUDIO_MAX_CHAN(asf1d.v1->bNrChannels);
1964 			bBitResolution = asf1d.v1->bSubFrameSize * 8;
1965 
1966 			if (asf1d.v1->bSamFreqType == 0) {
1967 				DPRINTFN(16, "Sample rate: %d-%dHz\n",
1968 				    UA_SAMP_LO(asf1d.v1),
1969 				    UA_SAMP_HI(asf1d.v1));
1970 
1971 				if ((rate >= UA_SAMP_LO(asf1d.v1)) &&
1972 				    (rate <= UA_SAMP_HI(asf1d.v1)))
1973 					goto found_rate;
1974 			} else {
1975 				for (x = 0; x < asf1d.v1->bSamFreqType; x++) {
1976 					DPRINTFN(16, "Sample rate = %dHz\n",
1977 					    UA_GETSAMP(asf1d.v1, x));
1978 
1979 					if (rate == UA_GETSAMP(asf1d.v1, x))
1980 						goto found_rate;
1981 				}
1982 			}
1983 			goto next_ep;
1984 
1985 	found_rate:
1986 			for (p_fmt = uaudio10_formats;
1987 			    p_fmt->wFormat != 0; p_fmt++) {
1988 				if ((p_fmt->wFormat == wFormat) &&
1989 				    (p_fmt->bPrecision == bBitResolution))
1990 					break;
1991 			}
1992 			if (p_fmt->wFormat == 0) {
1993 				DPRINTF("Unsupported audio format\n");
1994 				goto next_ep;
1995 			}
1996 
1997 			if ((bChannels != channels) ||
1998 			    (bBitResolution != bit_resolution)) {
1999 				DPRINTF("Wrong number of channels\n");
2000 				goto next_ep;
2001 			}
2002 		}
2003 
2004 		chan = uaudio_get_chan(sc, (ep_dir == UE_DIR_OUT) ? &sc->sc_play_chan[0] :
2005 		    &sc->sc_rec_chan[0], curidx);
2006 		if (chan == NULL) {
2007 			DPRINTF("More than %d sub devices. (skipped)\n", UAUDIO_MAX_CHILD);
2008 			goto next_ep;
2009 		}
2010 
2011 		if (usbd_get_iface(udev, curidx) == NULL) {
2012 			DPRINTF("Interface is not valid\n");
2013 			goto next_ep;
2014 		}
2015 		if (chan->num_alt == CHAN_MAX_ALT) {
2016 			DPRINTF("Too many alternate settings\n");
2017 			goto next_ep;
2018 		}
2019 		chan->set_alt = 0;
2020 		chan->cur_alt = CHAN_MAX_ALT;
2021 
2022 		chan_alt = &chan->usb_alt[chan->num_alt++];
2023 
2024 #ifdef USB_DEBUG
2025 		uaudio_chan_dump_ep_desc(ed1);
2026 #endif
2027 		DPRINTF("Sample rate = %dHz, channels = %d, "
2028 		    "bits = %d, format = %s, ep 0x%02x, chan %p\n", rate, channels,
2029 		    bit_resolution, p_fmt->description, ed1->bEndpointAddress, chan);
2030 
2031 		chan_alt->sample_rate = rate;
2032 		chan_alt->p_asf1d = asf1d;
2033 		chan_alt->p_ed1 = ed1;
2034 		chan_alt->p_fmt = p_fmt;
2035 		chan_alt->p_sed = sed;
2036 		chan_alt->iface_index = curidx;
2037 		chan_alt->iface_alt_index = alt_index;
2038 
2039 		if (ep_dir == UE_DIR_IN)
2040 			chan_alt->usb_cfg = uaudio_cfg_record;
2041 		else
2042 			chan_alt->usb_cfg = uaudio_cfg_play;
2043 
2044 		chan_alt->sample_size = (UAUDIO_MAX_CHAN(channels) *
2045 		    p_fmt->bPrecision) / 8;
2046 		chan_alt->channels = channels;
2047 
2048 		if (ep_dir == UE_DIR_IN &&
2049 		    usbd_get_speed(udev) == USB_SPEED_FULL) {
2050 			uaudio_record_fix_fs(ed1,
2051 			    chan_alt->sample_size * (rate / 1000),
2052 			    chan_alt->sample_size * (rate / 4000));
2053 		}
2054 
2055 		/* setup play/record format */
2056 
2057 		format = chan_alt->p_fmt->freebsd_fmt;
2058 
2059 		/* get default SND_FORMAT() */
2060 		format = SND_FORMAT(format, chan_alt->channels, 0);
2061 
2062 		switch (chan_alt->channels) {
2063 		uint32_t temp_fmt;
2064 		case 1:
2065 		case 2:
2066 			/* mono and stereo */
2067 			break;
2068 		default:
2069 			/* surround and more */
2070 			temp_fmt = feeder_matrix_default_format(format);
2071 			/* if multichannel, then format can be zero */
2072 			if (temp_fmt != 0)
2073 				format = temp_fmt;
2074 			break;
2075 		}
2076 
2077 		/* check if format is not supported */
2078 		if (format == 0) {
2079 			DPRINTF("The selected audio format is not supported\n");
2080 			chan->num_alt--;
2081 			goto next_ep;
2082 		}
2083 		if (chan->num_alt > 1) {
2084 			/* we only accumulate one format at different sample rates */
2085 			if (chan->pcm_format[0] != format) {
2086 				DPRINTF("Multiple formats is not supported\n");
2087 				chan->num_alt--;
2088 				goto next_ep;
2089 			}
2090 			/* ignore if duplicate sample rate entry */
2091 			if (rate == chan->usb_alt[chan->num_alt - 2].sample_rate) {
2092 				DPRINTF("Duplicate sample rate detected\n");
2093 				chan->num_alt--;
2094 				goto next_ep;
2095 			}
2096 		}
2097 		chan->pcm_cap.fmtlist = chan->pcm_format;
2098 		chan->pcm_cap.fmtlist[0] = format;
2099 
2100 		/* check if device needs bitperfect */
2101 		if (chan_alt->channels > UAUDIO_MATRIX_MAX)
2102 			sc->sc_pcm_bitperfect = 1;
2103 
2104 		if (rate < chan->pcm_cap.minspeed || chan->pcm_cap.minspeed == 0)
2105 			chan->pcm_cap.minspeed = rate;
2106 		if (rate > chan->pcm_cap.maxspeed || chan->pcm_cap.maxspeed == 0)
2107 			chan->pcm_cap.maxspeed = rate;
2108 
2109 		if (sc->sc_sndstat_valid != 0) {
2110 			sbuf_printf(&sc->sc_sndstat, "\n\t"
2111 			    "mode %d.%d:(%s) %dch, %dbit, %s, %dHz",
2112 			    curidx, alt_index,
2113 			    (ep_dir == UE_DIR_IN) ? "input" : "output",
2114 				    channels, p_fmt->bPrecision,
2115 				    p_fmt->description, rate);
2116 		}
2117 
2118 	next_ep:
2119 		sed.v1 = NULL;
2120 		ed1 = NULL;
2121 	}
2122 }
2123 
2124 /* This structure defines all the supported rates. */
2125 
2126 static const uint32_t uaudio_rate_list[CHAN_MAX_ALT] = {
2127 	384000,
2128 	352800,
2129 	192000,
2130 	176400,
2131 	96000,
2132 	88200,
2133 	88000,
2134 	80000,
2135 	72000,
2136 	64000,
2137 	56000,
2138 	48000,
2139 	44100,
2140 	40000,
2141 	32000,
2142 	24000,
2143 	22050,
2144 	16000,
2145 	11025,
2146 	8000,
2147 	0
2148 };
2149 
2150 static void
2151 uaudio_chan_fill_info(struct uaudio_softc *sc, struct usb_device *udev)
2152 {
2153 	uint32_t rate = uaudio_default_rate;
2154 	uint8_t z;
2155 	uint8_t bits = uaudio_default_bits;
2156 	uint8_t y;
2157 	uint8_t channels = uaudio_default_channels;
2158 	uint8_t x;
2159 
2160 	bits -= (bits % 8);
2161 	if ((bits == 0) || (bits > 32)) {
2162 		/* set a valid value */
2163 		bits = 32;
2164 	}
2165 	if (channels == 0) {
2166 		switch (usbd_get_speed(udev)) {
2167 		case USB_SPEED_LOW:
2168 		case USB_SPEED_FULL:
2169 			/*
2170 			 * Due to high bandwidth usage and problems
2171 			 * with HIGH-speed split transactions we
2172 			 * disable surround setups on FULL-speed USB
2173 			 * by default
2174 			 */
2175 			channels = 4;
2176 			break;
2177 		default:
2178 			channels = UAUDIO_CHANNELS_MAX;
2179 			break;
2180 		}
2181 	} else if (channels > UAUDIO_CHANNELS_MAX)
2182 		channels = UAUDIO_CHANNELS_MAX;
2183 
2184 	if (sbuf_new(&sc->sc_sndstat, NULL, 4096, SBUF_AUTOEXTEND))
2185 		sc->sc_sndstat_valid = 1;
2186 
2187 	/* try to search for a valid config */
2188 
2189 	for (x = channels; x; x--) {
2190 		for (y = bits; y; y -= 8) {
2191 			/* try user defined rate, if any */
2192 			if (rate != 0)
2193 				uaudio_chan_fill_info_sub(sc, udev, rate, x, y);
2194 
2195 			/* try find a matching rate, if any */
2196 			for (z = 0; uaudio_rate_list[z]; z++)
2197 				uaudio_chan_fill_info_sub(sc, udev, uaudio_rate_list[z], x, y);
2198 		}
2199 	}
2200 	if (sc->sc_sndstat_valid)
2201 		sbuf_finish(&sc->sc_sndstat);
2202 }
2203 
2204 static void
2205 uaudio_chan_play_sync_callback(struct usb_xfer *xfer, usb_error_t error)
2206 {
2207 	struct uaudio_chan *ch = usbd_xfer_softc(xfer);
2208 	struct usb_page_cache *pc;
2209 	uint64_t sample_rate;
2210 	uint8_t buf[4];
2211 	uint64_t temp;
2212 	unsigned i;
2213 	int len;
2214 	int actlen;
2215 	int nframes;
2216 
2217 	usbd_xfer_status(xfer, &actlen, NULL, NULL, &nframes);
2218 
2219 	i = uaudio_get_child_index_by_chan(ch->priv_sc, ch);
2220 
2221 	switch (USB_GET_STATE(xfer)) {
2222 	case USB_ST_TRANSFERRED:
2223 
2224 		DPRINTFN(6, "transferred %d bytes\n", actlen);
2225 
2226 		if (nframes == 0)
2227 			break;
2228 		len = usbd_xfer_frame_len(xfer, 0);
2229 		if (len == 0)
2230 			break;
2231 		if (len > sizeof(buf))
2232 			len = sizeof(buf);
2233 
2234 		memset(buf, 0, sizeof(buf));
2235 
2236 		pc = usbd_xfer_get_frame(xfer, 0);
2237 		usbd_copy_out(pc, 0, buf, len);
2238 
2239 		temp = UGETDW(buf);
2240 
2241 		DPRINTF("Value = 0x%08x\n", (int)temp);
2242 
2243 		/* auto-detect SYNC format */
2244 
2245 		if (len == 4)
2246 			temp &= 0x0fffffff;
2247 
2248 		/* check for no data */
2249 
2250 		if (temp == 0)
2251 			break;
2252 
2253 		temp *= 125ULL;
2254 
2255 		sample_rate = ch->usb_alt[ch->cur_alt].sample_rate;
2256 
2257 		/* auto adjust */
2258 		while (temp < (sample_rate - (sample_rate / 4)))
2259 			temp *= 2;
2260 
2261 		while (temp > (sample_rate + (sample_rate / 2)))
2262 			temp /= 2;
2263 
2264 		DPRINTF("Comparing %d Hz :: %d Hz\n",
2265 		    (int)temp, (int)sample_rate);
2266 
2267 		/*
2268 		 * Use feedback value as fallback when there is no
2269 		 * recording channel:
2270 		 */
2271 		if (ch->priv_sc->sc_rec_chan[i].num_alt == 0) {
2272 			int32_t jitter_max = howmany(sample_rate, 16000);
2273 
2274 			/*
2275 			 * Range check the jitter values to avoid
2276 			 * bogus sample rate adjustments. The expected
2277 			 * deviation should not be more than 1Hz per
2278 			 * second. The USB v2.0 specification also
2279 			 * mandates this requirement. Refer to chapter
2280 			 * 5.12.4.2 about feedback.
2281 			 */
2282 			ch->jitter_curr = temp - sample_rate;
2283 			if (ch->jitter_curr > jitter_max)
2284 				ch->jitter_curr = jitter_max;
2285 			else if (ch->jitter_curr < -jitter_max)
2286 				ch->jitter_curr = -jitter_max;
2287 		}
2288 		ch->feedback_rate = temp;
2289 		break;
2290 
2291 	case USB_ST_SETUP:
2292 		/*
2293 		 * Check if the recording stream can be used as a
2294 		 * source of jitter information to save some
2295 		 * isochronous bandwidth:
2296 		 */
2297 		if (ch->priv_sc->sc_rec_chan[i].num_alt != 0 &&
2298 		    uaudio_debug == 0)
2299 			break;
2300 		usbd_xfer_set_frames(xfer, 1);
2301 		usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_framelen(xfer));
2302 		usbd_transfer_submit(xfer);
2303 		break;
2304 
2305 	default:			/* Error */
2306 		break;
2307 	}
2308 }
2309 
2310 static int
2311 uaudio_chan_is_async(struct uaudio_chan *ch, uint8_t alt)
2312 {
2313 	uint8_t attr = ch->usb_alt[alt].p_ed1->bmAttributes;
2314 	return (UE_GET_ISO_TYPE(attr) == UE_ISO_ASYNC);
2315 }
2316 
2317 static void
2318 uaudio_chan_play_callback(struct usb_xfer *xfer, usb_error_t error)
2319 {
2320 	struct uaudio_chan *ch = usbd_xfer_softc(xfer);
2321 	struct uaudio_chan *ch_rec;
2322 	struct usb_page_cache *pc;
2323 	uint32_t mfl;
2324 	uint32_t total;
2325 	uint32_t blockcount;
2326 	uint32_t n;
2327 	uint32_t offset;
2328 	unsigned i;
2329 	int sample_size;
2330 	int actlen;
2331 	int sumlen;
2332 
2333 	if (ch->running == 0 || ch->start == ch->end) {
2334 		DPRINTF("not running or no buffer!\n");
2335 		return;
2336 	}
2337 
2338 	i = uaudio_get_child_index_by_chan(ch->priv_sc, ch);
2339 
2340 	/* check if there is a valid record channel */
2341 	ch_rec = ch->priv_sc->sc_rec_chan + i;
2342 
2343 	if (ch_rec->num_alt == 0)
2344 		ch_rec = NULL;
2345 
2346 	usbd_xfer_status(xfer, &actlen, &sumlen, NULL, NULL);
2347 
2348 	switch (USB_GET_STATE(xfer)) {
2349 	case USB_ST_SETUP:
2350 tr_setup:
2351 		if (ch_rec != NULL) {
2352 			/*
2353 			 * NOTE: The play and record callbacks are
2354 			 * executed from the same USB thread and
2355 			 * locking the record channel mutex here is
2356 			 * not needed. This avoids a LOR situation.
2357 			 */
2358 
2359 			/* reset receive jitter counters */
2360 			ch_rec->jitter_curr = 0;
2361 			ch_rec->jitter_rem = 0;
2362 		}
2363 
2364 		/* reset transmit jitter counters */
2365 		ch->jitter_curr = 0;
2366 		ch->jitter_rem = 0;
2367 
2368 		/* FALLTHROUGH */
2369 	case USB_ST_TRANSFERRED:
2370 		if (actlen < sumlen) {
2371 			DPRINTF("short transfer, "
2372 			    "%d of %d bytes\n", actlen, sumlen);
2373 		}
2374 		chn_intr(ch->pcm_ch);
2375 
2376 		/*
2377 		 * Check for asynchronous playback endpoint and that
2378 		 * the playback endpoint is properly configured:
2379 		 */
2380 		if (ch_rec != NULL &&
2381 		    uaudio_chan_is_async(ch, ch->cur_alt) != 0) {
2382 			uint32_t rec_alt = ch_rec->cur_alt;
2383 			if (rec_alt < ch_rec->num_alt) {
2384 				int64_t tx_jitter;
2385 				int64_t rx_rate;
2386 				/*
2387 				 * NOTE: The play and record callbacks
2388 				 * are executed from the same USB
2389 				 * thread and locking the record
2390 				 * channel mutex here is not needed.
2391 				 * This avoids a LOR situation.
2392 				 */
2393 
2394 				/* translate receive jitter into transmit jitter */
2395 				tx_jitter = ch->usb_alt[ch->cur_alt].sample_rate;
2396 				tx_jitter = (tx_jitter * ch_rec->jitter_curr) +
2397 				    ch->jitter_rem;
2398 
2399 				/* reset receive jitter counters */
2400 				ch_rec->jitter_curr = 0;
2401 				ch_rec->jitter_rem = 0;
2402 
2403 				/* compute exact number of transmit jitter samples */
2404 				rx_rate = ch_rec->usb_alt[rec_alt].sample_rate;
2405 				ch->jitter_curr += tx_jitter / rx_rate;
2406 				ch->jitter_rem = tx_jitter % rx_rate;
2407 			}
2408 		}
2409 
2410 		/* start the SYNC transfer one time per second, if any */
2411 		ch->intr_counter += ch->intr_frames;
2412 		if (ch->intr_counter >= ch->frames_per_second) {
2413 			ch->intr_counter -= ch->frames_per_second;
2414 			usbd_transfer_start(ch->xfer[UAUDIO_NCHANBUFS]);
2415 		}
2416 
2417 		mfl = usbd_xfer_max_framelen(xfer);
2418 
2419 		if (ch->bytes_per_frame[1] > mfl) {
2420 			DPRINTF("bytes per transfer, %d, "
2421 			    "exceeds maximum, %d!\n",
2422 			    ch->bytes_per_frame[1],
2423 			    mfl);
2424 			break;
2425 		}
2426 
2427 		blockcount = ch->intr_frames;
2428 
2429 		/* setup number of frames */
2430 		usbd_xfer_set_frames(xfer, blockcount);
2431 
2432 		/* get sample size */
2433 		sample_size = ch->usb_alt[ch->cur_alt].sample_size;
2434 
2435 		/* reset total length */
2436 		total = 0;
2437 
2438 		/* setup frame lengths */
2439 		for (n = 0; n != blockcount; n++) {
2440 			uint32_t frame_len;
2441 
2442 			ch->sample_curr += ch->sample_rem;
2443 			if (ch->sample_curr >= ch->frames_per_second) {
2444 				ch->sample_curr -= ch->frames_per_second;
2445 				frame_len = ch->bytes_per_frame[1];
2446 			} else {
2447 				frame_len = ch->bytes_per_frame[0];
2448 			}
2449 
2450 			/* handle free running clock case */
2451 			if (ch->jitter_curr > 0 &&
2452 			    (frame_len + sample_size) <= mfl) {
2453 				DPRINTFN(6, "sending one sample more\n");
2454 				ch->jitter_curr--;
2455 				frame_len += sample_size;
2456 			} else if (ch->jitter_curr < 0 &&
2457 			    frame_len >= sample_size) {
2458 				DPRINTFN(6, "sending one sample less\n");
2459 				ch->jitter_curr++;
2460 				frame_len -= sample_size;
2461 			}
2462 			usbd_xfer_set_frame_len(xfer, n, frame_len);
2463 			total += frame_len;
2464 		}
2465 
2466 		DPRINTFN(6, "transferring %d bytes\n", total);
2467 
2468 		offset = 0;
2469 
2470 		pc = usbd_xfer_get_frame(xfer, 0);
2471 		while (total > 0) {
2472 			n = (ch->end - ch->cur);
2473 			if (n > total)
2474 				n = total;
2475 
2476 			usbd_copy_in(pc, offset, ch->cur, n);
2477 
2478 			total -= n;
2479 			ch->cur += n;
2480 			offset += n;
2481 
2482 			if (ch->cur >= ch->end)
2483 				ch->cur = ch->start;
2484 		}
2485 		usbd_transfer_submit(xfer);
2486 		break;
2487 
2488 	default:			/* Error */
2489 		if (error != USB_ERR_CANCELLED)
2490 			goto tr_setup;
2491 		break;
2492 	}
2493 }
2494 
2495 static void
2496 uaudio_chan_record_sync_callback(struct usb_xfer *xfer, usb_error_t error)
2497 {
2498 	/* TODO */
2499 }
2500 
2501 static void
2502 uaudio_chan_record_callback(struct usb_xfer *xfer, usb_error_t error)
2503 {
2504 	struct uaudio_chan *ch = usbd_xfer_softc(xfer);
2505 	struct usb_page_cache *pc;
2506 	uint32_t offset0;
2507 	uint32_t mfl;
2508 	int m;
2509 	int n;
2510 	int len;
2511 	int actlen;
2512 	int nframes;
2513 	int expected_bytes;
2514 	int sample_size;
2515 
2516 	if (ch->start == ch->end) {
2517 		DPRINTF("no buffer!\n");
2518 		return;
2519 	}
2520 
2521 	usbd_xfer_status(xfer, &actlen, NULL, NULL, &nframes);
2522 	mfl = usbd_xfer_max_framelen(xfer);
2523 
2524 	switch (USB_GET_STATE(xfer)) {
2525 	case USB_ST_TRANSFERRED:
2526 
2527 		offset0 = 0;
2528 		pc = usbd_xfer_get_frame(xfer, 0);
2529 
2530 		/* try to compute the number of expected bytes */
2531 		ch->sample_curr += (ch->sample_rem * ch->intr_frames);
2532 
2533 		/* compute number of expected bytes */
2534 		expected_bytes = (ch->intr_frames * ch->bytes_per_frame[0]) +
2535 		    ((ch->sample_curr / ch->frames_per_second) *
2536 		    (ch->bytes_per_frame[1] - ch->bytes_per_frame[0]));
2537 
2538 		/* keep remainder */
2539 		ch->sample_curr %= ch->frames_per_second;
2540 
2541 		/* get current sample size */
2542 		sample_size = ch->usb_alt[ch->cur_alt].sample_size;
2543 
2544 		for (n = 0; n != nframes; n++) {
2545 			uint32_t offset1 = offset0;
2546 
2547 			len = usbd_xfer_frame_len(xfer, n);
2548 
2549 			/* make sure we only receive complete samples */
2550 			len = len - (len % sample_size);
2551 
2552 			/* subtract bytes received from expected payload */
2553 			expected_bytes -= len;
2554 
2555 			/* don't receive data when not ready */
2556 			if (ch->running == 0 || ch->cur_alt != ch->set_alt)
2557 				continue;
2558 
2559 			/* fill ring buffer with samples, if any */
2560 			while (len > 0) {
2561 				m = (ch->end - ch->cur);
2562 
2563 				if (m > len)
2564 					m = len;
2565 
2566 				usbd_copy_out(pc, offset1, ch->cur, m);
2567 
2568 				len -= m;
2569 				offset1 += m;
2570 				ch->cur += m;
2571 
2572 				if (ch->cur >= ch->end)
2573 					ch->cur = ch->start;
2574 			}
2575 
2576 			offset0 += mfl;
2577 		}
2578 
2579 		/* update current jitter */
2580 		ch->jitter_curr -= (expected_bytes / sample_size);
2581 
2582 		/* don't allow a huge amount of jitter to accumulate */
2583 		nframes = 2 * ch->intr_frames;
2584 
2585 		/* range check current jitter */
2586 		if (ch->jitter_curr < -nframes)
2587 			ch->jitter_curr = -nframes;
2588 		else if (ch->jitter_curr > nframes)
2589 			ch->jitter_curr = nframes;
2590 
2591 		DPRINTFN(6, "transferred %d bytes, jitter %d samples\n",
2592 		    actlen, ch->jitter_curr);
2593 
2594 		if (ch->running != 0)
2595 			chn_intr(ch->pcm_ch);
2596 
2597 	case USB_ST_SETUP:
2598 tr_setup:
2599 		nframes = ch->intr_frames;
2600 
2601 		usbd_xfer_set_frames(xfer, nframes);
2602 		for (n = 0; n != nframes; n++)
2603 			usbd_xfer_set_frame_len(xfer, n, mfl);
2604 
2605 		usbd_transfer_submit(xfer);
2606 		break;
2607 
2608 	default:			/* Error */
2609 		if (error != USB_ERR_CANCELLED)
2610 			goto tr_setup;
2611 		break;
2612 	}
2613 }
2614 
2615 void   *
2616 uaudio_chan_init(struct uaudio_chan *ch, struct snd_dbuf *b,
2617     struct pcm_channel *c, int dir)
2618 {
2619 	uint32_t buf_size;
2620 	uint8_t x;
2621 
2622 	/* store mutex and PCM channel */
2623 
2624 	ch->pcm_ch = c;
2625 	ch->pcm_mtx = c->lock;
2626 
2627 	/* compute worst case buffer */
2628 
2629 	buf_size = 0;
2630 	for (x = 0; x != ch->num_alt; x++) {
2631 		uint32_t temp = uaudio_get_buffer_size(ch, x);
2632 		if (temp > buf_size)
2633 			buf_size = temp;
2634 	}
2635 
2636 	/* allow double buffering */
2637 	buf_size *= 2;
2638 
2639 	DPRINTF("Worst case buffer is %d bytes\n", (int)buf_size);
2640 
2641 	ch->buf = malloc(buf_size, M_DEVBUF, M_WAITOK | M_ZERO);
2642 	if (ch->buf == NULL)
2643 		goto error;
2644 	if (sndbuf_setup(b, ch->buf, buf_size) != 0)
2645 		goto error;
2646 
2647 	ch->start = ch->buf;
2648 	ch->end = ch->buf + buf_size;
2649 	ch->cur = ch->buf;
2650 	ch->pcm_buf = b;
2651 	ch->max_buf = buf_size;
2652 
2653 	if (ch->pcm_mtx == NULL) {
2654 		DPRINTF("ERROR: PCM channels does not have a mutex!\n");
2655 		goto error;
2656 	}
2657 	return (ch);
2658 
2659 error:
2660 	uaudio_chan_free(ch);
2661 	return (NULL);
2662 }
2663 
2664 int
2665 uaudio_chan_free(struct uaudio_chan *ch)
2666 {
2667 	if (ch->buf != NULL) {
2668 		free(ch->buf, M_DEVBUF);
2669 		ch->buf = NULL;
2670 	}
2671 	usbd_transfer_unsetup(ch->xfer, UAUDIO_NCHANBUFS + 1);
2672 
2673 	ch->num_alt = 0;
2674 
2675 	return (0);
2676 }
2677 
2678 int
2679 uaudio_chan_set_param_blocksize(struct uaudio_chan *ch, uint32_t blocksize)
2680 {
2681 	uint32_t temp = 2 * uaudio_get_buffer_size(ch, ch->set_alt);
2682 	sndbuf_setup(ch->pcm_buf, ch->buf, temp);
2683 	return (temp / 2);
2684 }
2685 
2686 int
2687 uaudio_chan_set_param_fragments(struct uaudio_chan *ch, uint32_t blocksize,
2688     uint32_t blockcount)
2689 {
2690 	return (1);
2691 }
2692 
2693 int
2694 uaudio_chan_set_param_speed(struct uaudio_chan *ch, uint32_t speed)
2695 {
2696 	struct uaudio_softc *sc;
2697 	uint8_t x;
2698 
2699 	sc = ch->priv_sc;
2700 
2701 	for (x = 0; x < ch->num_alt; x++) {
2702 		if (ch->usb_alt[x].sample_rate < speed) {
2703 			/* sample rate is too low */
2704 			break;
2705 		}
2706 	}
2707 
2708 	if (x != 0)
2709 		x--;
2710 
2711 	usb_proc_explore_lock(sc->sc_udev);
2712 	ch->set_alt = x;
2713 	usb_proc_explore_unlock(sc->sc_udev);
2714 
2715 	DPRINTF("Selecting alt %d\n", (int)x);
2716 
2717 	return (ch->usb_alt[x].sample_rate);
2718 }
2719 
2720 int
2721 uaudio_chan_getptr(struct uaudio_chan *ch)
2722 {
2723 	return (ch->cur - ch->start);
2724 }
2725 
2726 struct pcmchan_caps *
2727 uaudio_chan_getcaps(struct uaudio_chan *ch)
2728 {
2729 	return (&ch->pcm_cap);
2730 }
2731 
2732 static struct pcmchan_matrix uaudio_chan_matrix_swap_2_0 = {
2733 	.id = SND_CHN_MATRIX_DRV,
2734 	.channels = 2,
2735 	.ext = 0,
2736 	.map = {
2737 		/* Right */
2738 		[0] = {
2739 			.type = SND_CHN_T_FR,
2740 			.members =
2741 			    SND_CHN_T_MASK_FR | SND_CHN_T_MASK_FC |
2742 			    SND_CHN_T_MASK_LF | SND_CHN_T_MASK_BR |
2743 			    SND_CHN_T_MASK_BC | SND_CHN_T_MASK_SR
2744 		},
2745 		/* Left */
2746 		[1] = {
2747 			.type = SND_CHN_T_FL,
2748 			.members =
2749 			    SND_CHN_T_MASK_FL | SND_CHN_T_MASK_FC |
2750 			    SND_CHN_T_MASK_LF | SND_CHN_T_MASK_BL |
2751 			    SND_CHN_T_MASK_BC | SND_CHN_T_MASK_SL
2752 		},
2753 		[2] = {
2754 			.type = SND_CHN_T_MAX,
2755 			.members = 0
2756 		}
2757 	},
2758 	.mask = SND_CHN_T_MASK_FR | SND_CHN_T_MASK_FL,
2759 	.offset = {  1,  0, -1, -1, -1, -1, -1, -1, -1,
2760 		    -1, -1, -1, -1, -1, -1, -1, -1, -1  }
2761 };
2762 
2763 struct pcmchan_matrix *
2764 uaudio_chan_getmatrix(struct uaudio_chan *ch, uint32_t format)
2765 {
2766 	struct uaudio_softc *sc;
2767 
2768 	sc = ch->priv_sc;
2769 
2770 	if (sc != NULL && sc->sc_uq_audio_swap_lr != 0 &&
2771 	    AFMT_CHANNEL(format) == 2)
2772 		return (&uaudio_chan_matrix_swap_2_0);
2773 
2774 	return (feeder_matrix_format_map(format));
2775 }
2776 
2777 int
2778 uaudio_chan_set_param_format(struct uaudio_chan *ch, uint32_t format)
2779 {
2780 	DPRINTF("Selecting format 0x%08x\n", (unsigned int)format);
2781 	return (0);
2782 }
2783 
2784 static void
2785 uaudio_chan_reconfigure(struct uaudio_chan *ch, uint8_t operation)
2786 {
2787 	struct uaudio_softc *sc = ch->priv_sc;
2788 
2789 	/* Check for shutdown. */
2790 	if (ch->operation == CHAN_OP_DRAIN)
2791 		return;
2792 
2793 	/* Set next operation. */
2794 	ch->operation = operation;
2795 
2796 	/*
2797 	 * Because changing the alternate setting modifies the USB
2798 	 * configuration, this part must be executed from the USB
2799 	 * explore process.
2800 	 */
2801 	(void)usb_proc_explore_msignal(sc->sc_udev,
2802 	    &sc->sc_config_msg[0], &sc->sc_config_msg[1]);
2803 }
2804 
2805 static int
2806 uaudio_chan_need_both(struct uaudio_chan *pchan, struct uaudio_chan *rchan)
2807 {
2808 	return (pchan->num_alt > 0 &&
2809 	    pchan->running != 0 &&
2810 	    uaudio_chan_is_async(pchan, pchan->set_alt) != 0 &&
2811 	    rchan->num_alt > 0 &&
2812 	    rchan->running == 0);
2813 }
2814 
2815 static int
2816 uaudio_chan_need_none(struct uaudio_chan *pchan, struct uaudio_chan *rchan)
2817 {
2818 	return (pchan->num_alt > 0 &&
2819 	    pchan->running == 0 &&
2820 	    rchan->num_alt > 0 &&
2821 	    rchan->running == 0);
2822 }
2823 
2824 void
2825 uaudio_chan_start(struct uaudio_chan *ch)
2826 {
2827 	struct uaudio_softc *sc = ch->priv_sc;
2828 	unsigned i = uaudio_get_child_index_by_chan(sc, ch);
2829 
2830 	/* make operation atomic */
2831 	usb_proc_explore_lock(sc->sc_udev);
2832 
2833 	/* check if not running */
2834 	if (ch->running == 0) {
2835 		uint32_t temp;
2836 
2837 		/* get current buffer size */
2838 		temp = 2 * uaudio_get_buffer_size(ch, ch->set_alt);
2839 
2840 		/* set running flag */
2841 		ch->running = 1;
2842 
2843 		/* ensure the hardware buffer is reset */
2844 		ch->start = ch->buf;
2845 		ch->end = ch->buf + temp;
2846 		ch->cur = ch->buf;
2847 
2848 		if (uaudio_chan_need_both(
2849 		    &sc->sc_play_chan[i],
2850 		    &sc->sc_rec_chan[i])) {
2851 			/*
2852 			 * Start both endpoints because of need for
2853 			 * jitter information:
2854 			 */
2855 			uaudio_chan_reconfigure(&sc->sc_rec_chan[i], CHAN_OP_START);
2856 			uaudio_chan_reconfigure(&sc->sc_play_chan[i], CHAN_OP_START);
2857 		} else {
2858 			uaudio_chan_reconfigure(ch, CHAN_OP_START);
2859 		}
2860 	}
2861 
2862 	/* exit atomic operation */
2863 	usb_proc_explore_unlock(sc->sc_udev);
2864 }
2865 
2866 void
2867 uaudio_chan_stop(struct uaudio_chan *ch)
2868 {
2869 	struct uaudio_softc *sc = ch->priv_sc;
2870 	unsigned i = uaudio_get_child_index_by_chan(sc, ch);
2871 
2872 	/* make operation atomic */
2873 	usb_proc_explore_lock(sc->sc_udev);
2874 
2875 	/* check if running */
2876 	if (ch->running != 0) {
2877 		/* clear running flag */
2878 		ch->running = 0;
2879 
2880 		if (uaudio_chan_need_both(
2881 		    &sc->sc_play_chan[i],
2882 		    &sc->sc_rec_chan[i])) {
2883 			/*
2884 			 * Leave the endpoints running because we need
2885 			 * information about jitter!
2886 			 */
2887 		} else if (uaudio_chan_need_none(
2888 		    &sc->sc_play_chan[i],
2889 		    &sc->sc_rec_chan[i])) {
2890 			/*
2891 			 * Stop both endpoints in case the one was used for
2892 			 * jitter information:
2893 			 */
2894 			uaudio_chan_reconfigure(&sc->sc_rec_chan[i], CHAN_OP_STOP);
2895 			uaudio_chan_reconfigure(&sc->sc_play_chan[i], CHAN_OP_STOP);
2896 		} else {
2897 			uaudio_chan_reconfigure(ch, CHAN_OP_STOP);
2898 		}
2899 	}
2900 
2901 	/* exit atomic operation */
2902 	usb_proc_explore_unlock(sc->sc_udev);
2903 }
2904 
2905 /*========================================================================*
2906  * AC - Audio Controller - routines
2907  *========================================================================*/
2908 
2909 static int
2910 uaudio_mixer_sysctl_handler(SYSCTL_HANDLER_ARGS)
2911 {
2912 	struct uaudio_softc *sc;
2913 	struct uaudio_mixer_node *pmc;
2914 	int hint;
2915 	int error;
2916 	int temp = 0;
2917 	int chan = 0;
2918 
2919 	sc = (struct uaudio_softc *)oidp->oid_arg1;
2920 	hint = oidp->oid_arg2;
2921 
2922 	if (sc->sc_child[0].mixer_lock == NULL)
2923 		return (ENXIO);
2924 
2925 	/* lookup mixer node */
2926 
2927 	mtx_lock(sc->sc_child[0].mixer_lock);
2928 	for (pmc = sc->sc_mixer_root; pmc != NULL; pmc = pmc->next) {
2929 		for (chan = 0; chan != (int)pmc->nchan; chan++) {
2930 			if (pmc->wValue[chan] != -1 &&
2931 			    pmc->wValue[chan] == hint) {
2932 				temp = pmc->wData[chan];
2933 				goto found;
2934 			}
2935 		}
2936 	}
2937 found:
2938 	mtx_unlock(sc->sc_child[0].mixer_lock);
2939 
2940 	error = sysctl_handle_int(oidp, &temp, 0, req);
2941 	if (error != 0 || req->newptr == NULL)
2942 		return (error);
2943 
2944 	/* update mixer value */
2945 
2946 	mtx_lock(sc->sc_child[0].mixer_lock);
2947 	if (pmc != NULL &&
2948 	    temp >= pmc->minval &&
2949 	    temp <= pmc->maxval) {
2950 		pmc->wData[chan] = temp;
2951 		pmc->update[(chan / 8)] |= (1 << (chan % 8));
2952 
2953 		/* start the transfer, if not already started */
2954 		usbd_transfer_start(sc->sc_mixer_xfer[0]);
2955 	}
2956 	mtx_unlock(sc->sc_child[0].mixer_lock);
2957 
2958 	return (0);
2959 }
2960 
2961 static void
2962 uaudio_mixer_ctl_free(struct uaudio_softc *sc)
2963 {
2964 	struct uaudio_mixer_node *p_mc;
2965 
2966 	while ((p_mc = sc->sc_mixer_root) != NULL) {
2967 		sc->sc_mixer_root = p_mc->next;
2968 		free(p_mc, M_USBDEV);
2969 	}
2970 }
2971 
2972 static void
2973 uaudio_mixer_register_sysctl(struct uaudio_softc *sc, device_t dev,
2974     unsigned index)
2975 {
2976 	struct uaudio_mixer_node *pmc;
2977 	struct sysctl_oid *mixer_tree;
2978 	struct sysctl_oid *control_tree;
2979 	char buf[32];
2980 	int chan;
2981 	int n;
2982 
2983 	if (index != 0)
2984 		return;
2985 
2986 	mixer_tree = SYSCTL_ADD_NODE(device_get_sysctl_ctx(dev),
2987 	    SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO, "mixer",
2988 	    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "");
2989 
2990 	if (mixer_tree == NULL)
2991 		return;
2992 
2993 	for (n = 0, pmc = sc->sc_mixer_root; pmc != NULL;
2994 	    pmc = pmc->next, n++) {
2995 		for (chan = 0; chan < pmc->nchan; chan++) {
2996 			if (pmc->nchan > 1) {
2997 				snprintf(buf, sizeof(buf), "%s_%d_%d",
2998 				    pmc->name, n, chan);
2999 			} else {
3000 				snprintf(buf, sizeof(buf), "%s_%d",
3001 				    pmc->name, n);
3002 			}
3003 
3004 			control_tree = SYSCTL_ADD_NODE(device_get_sysctl_ctx(dev),
3005 			    SYSCTL_CHILDREN(mixer_tree), OID_AUTO, buf,
3006 			    CTLFLAG_RD | CTLFLAG_MPSAFE, NULL,
3007 			    "Mixer control nodes");
3008 
3009 			if (control_tree == NULL)
3010 				continue;
3011 
3012 			SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
3013 			    SYSCTL_CHILDREN(control_tree),
3014 			    OID_AUTO, "val",
3015 			    CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_MPSAFE,
3016 			    sc, pmc->wValue[chan],
3017 			    uaudio_mixer_sysctl_handler, "I", "Current value");
3018 
3019 			SYSCTL_ADD_INT(device_get_sysctl_ctx(dev),
3020 			    SYSCTL_CHILDREN(control_tree),
3021 			    OID_AUTO, "min", CTLFLAG_RD, 0, pmc->minval,
3022 			    "Minimum value");
3023 
3024 			SYSCTL_ADD_INT(device_get_sysctl_ctx(dev),
3025 			    SYSCTL_CHILDREN(control_tree),
3026 			    OID_AUTO, "max", CTLFLAG_RD, 0, pmc->maxval,
3027 			    "Maximum value");
3028 
3029 			SYSCTL_ADD_STRING(device_get_sysctl_ctx(dev),
3030 			    SYSCTL_CHILDREN(control_tree),
3031 			    OID_AUTO, "desc", CTLFLAG_RD, pmc->desc, 0,
3032 			    "Description");
3033 		}
3034 	}
3035 }
3036 
3037 /* M-Audio FastTrack Ultra Mixer Description */
3038 /* Origin: Linux USB Audio driver */
3039 static void
3040 uaudio_mixer_controls_create_ftu(struct uaudio_softc *sc)
3041 {
3042 	int chx;
3043 	int chy;
3044 
3045 	memset(&MIX(sc), 0, sizeof(MIX(sc)));
3046 	MIX(sc).wIndex = MAKE_WORD(6, sc->sc_mixer_iface_no);
3047 	MIX(sc).wValue[0] = MAKE_WORD(8, 0);
3048 	MIX(sc).type = MIX_UNSIGNED_16;
3049 	MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3050 	MIX(sc).name = "effect";
3051 	MIX(sc).minval = 0;
3052 	MIX(sc).maxval = 7;
3053 	MIX(sc).mul = 7;
3054 	MIX(sc).nchan = 1;
3055 	MIX(sc).update[0] = 1;
3056 	strlcpy(MIX(sc).desc, "Room1,2,3,Hall1,2,Plate,Delay,Echo", sizeof(MIX(sc).desc));
3057 	uaudio_mixer_add_ctl_sub(sc, &MIX(sc));
3058 
3059 	memset(&MIX(sc), 0, sizeof(MIX(sc)));
3060 	MIX(sc).wIndex = MAKE_WORD(5, sc->sc_mixer_iface_no);
3061 
3062 	for (chx = 0; chx != 8; chx++) {
3063 		for (chy = 0; chy != 8; chy++) {
3064 			MIX(sc).wValue[0] = MAKE_WORD(chx + 1, chy + 1);
3065 			MIX(sc).type = MIX_SIGNED_16;
3066 			MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3067 			MIX(sc).name = "mix_rec";
3068 			MIX(sc).nchan = 1;
3069 			MIX(sc).update[0] = 1;
3070 			MIX(sc).val_default = 0;
3071 			snprintf(MIX(sc).desc, sizeof(MIX(sc).desc),
3072 			    "AIn%d - Out%d Record Volume", chy + 1, chx + 1);
3073 
3074 			uaudio_mixer_add_ctl(sc, &MIX(sc));
3075 
3076 			MIX(sc).wValue[0] = MAKE_WORD(chx + 1, chy + 1 + 8);
3077 			MIX(sc).type = MIX_SIGNED_16;
3078 			MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3079 			MIX(sc).name = "mix_play";
3080 			MIX(sc).nchan = 1;
3081 			MIX(sc).update[0] = 1;
3082 			MIX(sc).val_default = (chx == chy) ? 2 : 0;
3083 			snprintf(MIX(sc).desc, sizeof(MIX(sc).desc),
3084 			    "DIn%d - Out%d Playback Volume", chy + 1, chx + 1);
3085 
3086 			uaudio_mixer_add_ctl(sc, &MIX(sc));
3087 		}
3088 	}
3089 
3090 	memset(&MIX(sc), 0, sizeof(MIX(sc)));
3091 	MIX(sc).wIndex = MAKE_WORD(6, sc->sc_mixer_iface_no);
3092 	MIX(sc).wValue[0] = MAKE_WORD(2, 0);
3093 	MIX(sc).type = MIX_SIGNED_8;
3094 	MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3095 	MIX(sc).name = "effect_vol";
3096 	MIX(sc).nchan = 1;
3097 	MIX(sc).update[0] = 1;
3098 	MIX(sc).minval = 0;
3099 	MIX(sc).maxval = 0x7f;
3100 	MIX(sc).mul = 0x7f;
3101 	MIX(sc).nchan = 1;
3102 	MIX(sc).update[0] = 1;
3103 	strlcpy(MIX(sc).desc, "Effect Volume", sizeof(MIX(sc).desc));
3104 	uaudio_mixer_add_ctl_sub(sc, &MIX(sc));
3105 
3106 	memset(&MIX(sc), 0, sizeof(MIX(sc)));
3107 	MIX(sc).wIndex = MAKE_WORD(6, sc->sc_mixer_iface_no);
3108 	MIX(sc).wValue[0] = MAKE_WORD(3, 0);
3109 	MIX(sc).type = MIX_SIGNED_16;
3110 	MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3111 	MIX(sc).name = "effect_dur";
3112 	MIX(sc).nchan = 1;
3113 	MIX(sc).update[0] = 1;
3114 	MIX(sc).minval = 0;
3115 	MIX(sc).maxval = 0x7f00;
3116 	MIX(sc).mul = 0x7f00;
3117 	MIX(sc).nchan = 1;
3118 	MIX(sc).update[0] = 1;
3119 	strlcpy(MIX(sc).desc, "Effect Duration", sizeof(MIX(sc).desc));
3120 	uaudio_mixer_add_ctl_sub(sc, &MIX(sc));
3121 
3122 	memset(&MIX(sc), 0, sizeof(MIX(sc)));
3123 	MIX(sc).wIndex = MAKE_WORD(6, sc->sc_mixer_iface_no);
3124 	MIX(sc).wValue[0] = MAKE_WORD(4, 0);
3125 	MIX(sc).type = MIX_SIGNED_8;
3126 	MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3127 	MIX(sc).name = "effect_fb";
3128 	MIX(sc).nchan = 1;
3129 	MIX(sc).update[0] = 1;
3130 	MIX(sc).minval = 0;
3131 	MIX(sc).maxval = 0x7f;
3132 	MIX(sc).mul = 0x7f;
3133 	MIX(sc).nchan = 1;
3134 	MIX(sc).update[0] = 1;
3135 	strlcpy(MIX(sc).desc, "Effect Feedback Volume", sizeof(MIX(sc).desc));
3136 	uaudio_mixer_add_ctl_sub(sc, &MIX(sc));
3137 
3138 	memset(&MIX(sc), 0, sizeof(MIX(sc)));
3139 	MIX(sc).wIndex = MAKE_WORD(7, sc->sc_mixer_iface_no);
3140 	for (chy = 0; chy != 4; chy++) {
3141 		MIX(sc).wValue[0] = MAKE_WORD(7, chy + 1);
3142 		MIX(sc).type = MIX_SIGNED_16;
3143 		MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3144 		MIX(sc).name = "effect_ret";
3145 		MIX(sc).nchan = 1;
3146 		MIX(sc).update[0] = 1;
3147 		snprintf(MIX(sc).desc, sizeof(MIX(sc).desc),
3148 		    "Effect Return %d Volume", chy + 1);
3149 
3150 		uaudio_mixer_add_ctl(sc, &MIX(sc));
3151 	}
3152 
3153 	memset(&MIX(sc), 0, sizeof(MIX(sc)));
3154 	MIX(sc).wIndex = MAKE_WORD(5, sc->sc_mixer_iface_no);
3155 
3156 	for (chy = 0; chy != 8; chy++) {
3157 		MIX(sc).wValue[0] = MAKE_WORD(9, chy + 1);
3158 		MIX(sc).type = MIX_SIGNED_16;
3159 		MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3160 		MIX(sc).name = "effect_send";
3161 		MIX(sc).nchan = 1;
3162 		MIX(sc).update[0] = 1;
3163 		snprintf(MIX(sc).desc, sizeof(MIX(sc).desc),
3164 		    "Effect Send AIn%d Volume", chy + 1);
3165 
3166 		uaudio_mixer_add_ctl(sc, &MIX(sc));
3167 
3168 		MIX(sc).wValue[0] = MAKE_WORD(9, chy + 1 + 8);
3169 		MIX(sc).type = MIX_SIGNED_16;
3170 		MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3171 		MIX(sc).name = "effect_send";
3172 		MIX(sc).nchan = 1;
3173 		MIX(sc).update[0] = 1;
3174 		snprintf(MIX(sc).desc, sizeof(MIX(sc).desc),
3175 		    "Effect Send DIn%d Volume", chy + 1);
3176 
3177 		uaudio_mixer_add_ctl(sc, &MIX(sc));
3178 	}
3179 }
3180 
3181 static void
3182 uaudio_mixer_reload_all(struct uaudio_softc *sc)
3183 {
3184 	struct uaudio_mixer_node *pmc;
3185 	int chan;
3186 
3187 	if (sc->sc_child[0].mixer_lock == NULL)
3188 		return;
3189 
3190 	mtx_lock(sc->sc_child[0].mixer_lock);
3191 	for (pmc = sc->sc_mixer_root; pmc != NULL; pmc = pmc->next) {
3192 		/* use reset defaults for non-oss controlled settings */
3193 		if (pmc->ctl == SOUND_MIXER_NRDEVICES)
3194 			continue;
3195 		for (chan = 0; chan < pmc->nchan; chan++)
3196 			pmc->update[chan / 8] |= (1 << (chan % 8));
3197 	}
3198 	usbd_transfer_start(sc->sc_mixer_xfer[0]);
3199 
3200 	/* start HID volume keys, if any */
3201 	usbd_transfer_start(sc->sc_hid.xfer[0]);
3202 	mtx_unlock(sc->sc_child[0].mixer_lock);
3203 }
3204 
3205 static void
3206 uaudio_mixer_add_ctl_sub(struct uaudio_softc *sc, struct uaudio_mixer_node *mc)
3207 {
3208 	struct uaudio_mixer_node *p_mc_new =
3209 	    malloc(sizeof(*p_mc_new), M_USBDEV, M_WAITOK);
3210 	int ch;
3211 
3212 	if (p_mc_new != NULL) {
3213 		memcpy(p_mc_new, mc, sizeof(*p_mc_new));
3214 		p_mc_new->next = sc->sc_mixer_root;
3215 		sc->sc_mixer_root = p_mc_new;
3216 		sc->sc_mixer_count++;
3217 
3218 		/* set default value for all channels */
3219 		for (ch = 0; ch < p_mc_new->nchan; ch++) {
3220 			switch (p_mc_new->val_default) {
3221 			case 1:
3222 				/* 50% */
3223 				p_mc_new->wData[ch] = (p_mc_new->maxval + p_mc_new->minval) / 2;
3224 				break;
3225 			case 2:
3226 				/* 100% */
3227 				p_mc_new->wData[ch] = p_mc_new->maxval;
3228 				break;
3229 			default:
3230 				/* 0% */
3231 				p_mc_new->wData[ch] = p_mc_new->minval;
3232 				break;
3233 			}
3234 		}
3235 	} else {
3236 		DPRINTF("out of memory\n");
3237 	}
3238 }
3239 
3240 static void
3241 uaudio_mixer_add_ctl(struct uaudio_softc *sc, struct uaudio_mixer_node *mc)
3242 {
3243 	int32_t res;
3244 
3245 	DPRINTF("adding %d\n", mc->ctl);
3246 
3247 	if (mc->type == MIX_ON_OFF) {
3248 		mc->minval = 0;
3249 		mc->maxval = 1;
3250 	} else if (mc->type == MIX_SELECTOR) {
3251 	} else {
3252 		/* determine min and max values */
3253 
3254 		mc->minval = uaudio_mixer_get(sc->sc_udev,
3255 		    sc->sc_audio_rev, GET_MIN, mc);
3256 		mc->maxval = uaudio_mixer_get(sc->sc_udev,
3257 		    sc->sc_audio_rev, GET_MAX, mc);
3258 
3259 		/* check if max and min was swapped */
3260 
3261 		if (mc->maxval < mc->minval) {
3262 			res = mc->maxval;
3263 			mc->maxval = mc->minval;
3264 			mc->minval = res;
3265 		}
3266 
3267 		/* compute value range */
3268 		mc->mul = mc->maxval - mc->minval;
3269 		if (mc->mul == 0)
3270 			mc->mul = 1;
3271 
3272 		/* compute value alignment */
3273 		res = uaudio_mixer_get(sc->sc_udev,
3274 		    sc->sc_audio_rev, GET_RES, mc);
3275 
3276 		DPRINTF("Resolution = %d\n", (int)res);
3277 	}
3278 
3279 	uaudio_mixer_add_ctl_sub(sc, mc);
3280 
3281 #ifdef USB_DEBUG
3282 	if (uaudio_debug > 2) {
3283 		uint8_t i;
3284 
3285 		for (i = 0; i < mc->nchan; i++) {
3286 			DPRINTF("[mix] wValue=%04x\n", mc->wValue[0]);
3287 		}
3288 		DPRINTF("[mix] wIndex=%04x type=%d ctl='%d' "
3289 		    "min=%d max=%d\n",
3290 		    mc->wIndex, mc->type, mc->ctl,
3291 		    mc->minval, mc->maxval);
3292 	}
3293 #endif
3294 }
3295 
3296 static void
3297 uaudio_mixer_add_mixer(struct uaudio_softc *sc,
3298     const struct uaudio_terminal_node *iot, int id)
3299 {
3300 	const struct usb_audio_mixer_unit_0 *d0 = iot[id].u.mu_v1;
3301 	const struct usb_audio_mixer_unit_1 *d1;
3302 
3303 	uint32_t bno;			/* bit number */
3304 	uint32_t p;			/* bit number accumulator */
3305 	uint32_t mo;			/* matching outputs */
3306 	uint32_t mc;			/* matching channels */
3307 	uint32_t ichs;			/* input channels */
3308 	uint32_t ochs;			/* output channels */
3309 	uint32_t c;
3310 	uint32_t chs;			/* channels */
3311 	uint32_t i;
3312 	uint32_t o;
3313 
3314 	DPRINTFN(3, "bUnitId=%d bNrInPins=%d\n",
3315 	    d0->bUnitId, d0->bNrInPins);
3316 
3317 	/* compute the number of input channels */
3318 
3319 	ichs = 0;
3320 	for (i = 0; i < d0->bNrInPins; i++) {
3321 		ichs += uaudio_mixer_get_cluster(
3322 		    d0->baSourceId[i], iot).bNrChannels;
3323 	}
3324 
3325 	d1 = (const void *)(d0->baSourceId + d0->bNrInPins);
3326 
3327 	/* and the number of output channels */
3328 
3329 	ochs = d1->bNrChannels;
3330 
3331 	DPRINTFN(3, "ichs=%d ochs=%d\n", ichs, ochs);
3332 
3333 	memset(&MIX(sc), 0, sizeof(MIX(sc)));
3334 
3335 	MIX(sc).wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no);
3336 	MIX(sc).type = MIX_SIGNED_16;
3337 
3338 	if (uaudio_mixer_verify_desc(d0, ((ichs * ochs) + 7) / 8) == NULL)
3339 		return;
3340 
3341 	for (p = i = 0; i < d0->bNrInPins; i++) {
3342 		chs = uaudio_mixer_get_cluster(
3343 		    d0->baSourceId[i], iot).bNrChannels;
3344 		mc = 0;
3345 		for (c = 0; c < chs; c++) {
3346 			mo = 0;
3347 			for (o = 0; o < ochs; o++) {
3348 				bno = ((p + c) * ochs) + o;
3349 				if (BIT_TEST(d1->bmControls, bno))
3350 					mo++;
3351 			}
3352 			if (mo == 1)
3353 				mc++;
3354 		}
3355 		if ((mc == chs) && (chs <= MIX_MAX_CHAN)) {
3356 			/* repeat bit-scan */
3357 
3358 			mc = 0;
3359 			for (c = 0; c < chs; c++) {
3360 				for (o = 0; o < ochs; o++) {
3361 					bno = ((p + c) * ochs) + o;
3362 					if (BIT_TEST(d1->bmControls, bno))
3363 						MIX(sc).wValue[mc++] = MAKE_WORD(p + c + 1, o + 1);
3364 				}
3365 			}
3366 			MIX(sc).nchan = chs;
3367 			uaudio_mixer_add_ctl(sc, &MIX(sc));
3368 		}
3369 		p += chs;
3370 	}
3371 }
3372 
3373 static void
3374 uaudio20_mixer_add_mixer(struct uaudio_softc *sc,
3375     const struct uaudio_terminal_node *iot, int id)
3376 {
3377 	const struct usb_audio20_mixer_unit_0 *d0 = iot[id].u.mu_v2;
3378 	const struct usb_audio20_mixer_unit_1 *d1;
3379 
3380 	uint32_t bno;			/* bit number */
3381 	uint32_t p;			/* bit number accumulator */
3382 	uint32_t mo;			/* matching outputs */
3383 	uint32_t mc;			/* matching channels */
3384 	uint32_t ichs;			/* input channels */
3385 	uint32_t ochs;			/* output channels */
3386 	uint32_t c;
3387 	uint32_t chs;			/* channels */
3388 	uint32_t i;
3389 	uint32_t o;
3390 
3391 	DPRINTFN(3, "bUnitId=%d bNrInPins=%d\n",
3392 	    d0->bUnitId, d0->bNrInPins);
3393 
3394 	/* compute the number of input channels */
3395 
3396 	ichs = 0;
3397 	for (i = 0; i < d0->bNrInPins; i++) {
3398 		ichs += uaudio20_mixer_get_cluster(
3399 		    d0->baSourceId[i], iot).bNrChannels;
3400 	}
3401 
3402 	d1 = (const void *)(d0->baSourceId + d0->bNrInPins);
3403 
3404 	/* and the number of output channels */
3405 
3406 	ochs = d1->bNrChannels;
3407 
3408 	DPRINTFN(3, "ichs=%d ochs=%d\n", ichs, ochs);
3409 
3410 	memset(&MIX(sc), 0, sizeof(MIX(sc)));
3411 
3412 	MIX(sc).wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no);
3413 	MIX(sc).type = MIX_SIGNED_16;
3414 
3415 	if (uaudio20_mixer_verify_desc(d0, ((ichs * ochs) + 7) / 8) == NULL)
3416 		return;
3417 
3418 	for (p = i = 0; i < d0->bNrInPins; i++) {
3419 		chs = uaudio20_mixer_get_cluster(
3420 		    d0->baSourceId[i], iot).bNrChannels;
3421 		mc = 0;
3422 		for (c = 0; c < chs; c++) {
3423 			mo = 0;
3424 			for (o = 0; o < ochs; o++) {
3425 				bno = ((p + c) * ochs) + o;
3426 				if (BIT_TEST(d1->bmControls, bno))
3427 					mo++;
3428 			}
3429 			if (mo == 1)
3430 				mc++;
3431 		}
3432 		if ((mc == chs) && (chs <= MIX_MAX_CHAN)) {
3433 			/* repeat bit-scan */
3434 
3435 			mc = 0;
3436 			for (c = 0; c < chs; c++) {
3437 				for (o = 0; o < ochs; o++) {
3438 					bno = ((p + c) * ochs) + o;
3439 					if (BIT_TEST(d1->bmControls, bno))
3440 						MIX(sc).wValue[mc++] = MAKE_WORD(p + c + 1, o + 1);
3441 				}
3442 			}
3443 			MIX(sc).nchan = chs;
3444 			uaudio_mixer_add_ctl(sc, &MIX(sc));
3445 		}
3446 		p += chs;
3447 	}
3448 }
3449 
3450 static void
3451 uaudio_mixer_check_selectors(struct uaudio_softc *sc)
3452 {
3453 	uint8_t reserve_feature[] = {
3454 	    SOUND_MIXER_LINE,
3455 	    SOUND_MIXER_LINE1,
3456 	    SOUND_MIXER_LINE2,
3457 	    SOUND_MIXER_LINE3,
3458 	    SOUND_MIXER_DIGITAL1,
3459 	    SOUND_MIXER_DIGITAL2,
3460 	    SOUND_MIXER_DIGITAL3,
3461 	};
3462 	const uint16_t reserve_max =
3463 	    sizeof(reserve_feature) / sizeof(reserve_feature[0]);
3464 	uint16_t i;
3465 	uint16_t j;
3466 	uint16_t k;
3467 
3468 	/* remove existing selector types from the reserve */
3469 	for (i = 0; i < MIX(sc).maxval; i++) {
3470 		if (MIX(sc).slctrtype[i] == SOUND_MIXER_NRDEVICES)
3471 			continue;
3472 		for (j = 0; j != reserve_max; j++) {
3473 			if (reserve_feature[j] == MIX(sc).slctrtype[i])
3474 				reserve_feature[j] = SOUND_MIXER_NRDEVICES;
3475 		}
3476 	}
3477 
3478 	/* make sure selector types are not overlapping */
3479 	for (i = 0; i < MIX(sc).maxval; i++) {
3480 		if (MIX(sc).slctrtype[i] == SOUND_MIXER_NRDEVICES)
3481 			continue;
3482 		for (j = i + 1; j < MIX(sc).maxval; j++) {
3483 			if (MIX(sc).slctrtype[j] == SOUND_MIXER_NRDEVICES)
3484 				continue;
3485 			if (MIX(sc).slctrtype[i] != MIX(sc).slctrtype[j])
3486 				continue;
3487 			for (k = 0; k != reserve_max; k++) {
3488 				if (reserve_feature[k] == SOUND_MIXER_NRDEVICES)
3489 					continue;
3490 				MIX(sc).slctrtype[j] = reserve_feature[k];
3491 				reserve_feature[k] = SOUND_MIXER_NRDEVICES;
3492 				break;
3493 			}
3494 			if (k == reserve_max) {
3495 				DPRINTF("Selector type %d is not selectable!\n", j);
3496 				MIX(sc).slctrtype[j] = SOUND_MIXER_NRDEVICES;
3497 			}
3498 		}
3499 	}
3500 }
3501 
3502 static void
3503 uaudio_mixer_add_selector(struct uaudio_softc *sc,
3504     const struct uaudio_terminal_node *iot, int id)
3505 {
3506 	const struct usb_audio_selector_unit *d = iot[id].u.su_v1;
3507 	uint16_t i;
3508 
3509 	DPRINTFN(3, "bUnitId=%d bNrInPins=%d\n",
3510 	    d->bUnitId, d->bNrInPins);
3511 
3512 	if (d->bNrInPins == 0)
3513 		return;
3514 
3515 	memset(&MIX(sc), 0, sizeof(MIX(sc)));
3516 
3517 	MIX(sc).wIndex = MAKE_WORD(d->bUnitId, sc->sc_mixer_iface_no);
3518 	MIX(sc).wValue[0] = MAKE_WORD(0, 0);
3519 	MIX(sc).nchan = 1;
3520 	MIX(sc).type = MIX_SELECTOR;
3521 	MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3522 	MIX(sc).minval = 1;
3523 	MIX(sc).maxval = d->bNrInPins;
3524 	MIX(sc).name = "selector";
3525 
3526 	i = d->baSourceId[d->bNrInPins];
3527 	if (i == 0 ||
3528 	    usbd_req_get_string_any(sc->sc_udev, NULL,
3529 	    MIX(sc).desc, sizeof(MIX(sc).desc), i) != 0) {
3530 		MIX(sc).desc[0] = 0;
3531 	}
3532 
3533 	if (MIX(sc).maxval > MAX_SELECTOR_INPUT_PIN)
3534 		MIX(sc).maxval = MAX_SELECTOR_INPUT_PIN;
3535 
3536 	MIX(sc).mul = MIX(sc).maxval - MIX(sc).minval;
3537 
3538 	for (i = 0; i < MIX(sc).maxval; i++) {
3539 		MIX(sc).slctrtype[i] =
3540 		    uaudio_mixer_determine_class(&iot[d->baSourceId[i]]);
3541 	}
3542 	for (; i < MAX_SELECTOR_INPUT_PIN; i++)
3543 		MIX(sc).slctrtype[i] = SOUND_MIXER_NRDEVICES;
3544 
3545 	uaudio_mixer_check_selectors(sc);
3546 	uaudio_mixer_add_ctl(sc, &MIX(sc));
3547 }
3548 
3549 static void
3550 uaudio20_mixer_add_selector(struct uaudio_softc *sc,
3551     const struct uaudio_terminal_node *iot, int id)
3552 {
3553 	const struct usb_audio20_selector_unit *d = iot[id].u.su_v2;
3554 	uint16_t i;
3555 
3556 	DPRINTFN(3, "bUnitId=%d bNrInPins=%d\n",
3557 	    d->bUnitId, d->bNrInPins);
3558 
3559 	if (d->bNrInPins == 0)
3560 		return;
3561 
3562 	memset(&MIX(sc), 0, sizeof(MIX(sc)));
3563 
3564 	MIX(sc).wIndex = MAKE_WORD(d->bUnitId, sc->sc_mixer_iface_no);
3565 	MIX(sc).wValue[0] = MAKE_WORD(0, 0);
3566 	MIX(sc).nchan = 1;
3567 	MIX(sc).type = MIX_SELECTOR;
3568 	MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3569 	MIX(sc).minval = 1;
3570 	MIX(sc).maxval = d->bNrInPins;
3571 	MIX(sc).name = "selector";
3572 
3573 	i = d->baSourceId[d->bNrInPins];
3574 	if (i == 0 ||
3575 	    usbd_req_get_string_any(sc->sc_udev, NULL,
3576 	    MIX(sc).desc, sizeof(MIX(sc).desc), i) != 0) {
3577 		MIX(sc).desc[0] = 0;
3578 	}
3579 
3580 	if (MIX(sc).maxval > MAX_SELECTOR_INPUT_PIN)
3581 		MIX(sc).maxval = MAX_SELECTOR_INPUT_PIN;
3582 
3583 	MIX(sc).mul = MIX(sc).maxval - MIX(sc).minval;
3584 
3585 	for (i = 0; i < MIX(sc).maxval; i++) {
3586 		MIX(sc).slctrtype[i] =
3587 		    uaudio20_mixer_determine_class(&iot[d->baSourceId[i]]);
3588 	}
3589 	for (; i < MAX_SELECTOR_INPUT_PIN; i++)
3590 		MIX(sc).slctrtype[i] = SOUND_MIXER_NRDEVICES;
3591 
3592 	uaudio_mixer_check_selectors(sc);
3593 	uaudio_mixer_add_ctl(sc, &MIX(sc));
3594 }
3595 
3596 static uint32_t
3597 uaudio_mixer_feature_get_bmaControls(const struct usb_audio_feature_unit *d,
3598     uint8_t i)
3599 {
3600 	uint32_t temp = 0;
3601 	uint32_t offset = (i * d->bControlSize);
3602 
3603 	if (d->bControlSize > 0) {
3604 		temp |= d->bmaControls[offset];
3605 		if (d->bControlSize > 1) {
3606 			temp |= d->bmaControls[offset + 1] << 8;
3607 			if (d->bControlSize > 2) {
3608 				temp |= d->bmaControls[offset + 2] << 16;
3609 				if (d->bControlSize > 3) {
3610 					temp |= d->bmaControls[offset + 3] << 24;
3611 				}
3612 			}
3613 		}
3614 	}
3615 	return (temp);
3616 }
3617 
3618 static void
3619 uaudio_mixer_add_feature(struct uaudio_softc *sc,
3620     const struct uaudio_terminal_node *iot, int id)
3621 {
3622 	const struct usb_audio_feature_unit *d = iot[id].u.fu_v1;
3623 	uint32_t fumask;
3624 	uint32_t mmask;
3625 	uint32_t cmask;
3626 	uint16_t mixernumber;
3627 	uint8_t nchan;
3628 	uint8_t chan;
3629 	uint8_t ctl;
3630 	uint8_t i;
3631 
3632 	if (d->bControlSize == 0)
3633 		return;
3634 
3635 	memset(&MIX(sc), 0, sizeof(MIX(sc)));
3636 
3637 	nchan = (d->bLength - 7) / d->bControlSize;
3638 	mmask = uaudio_mixer_feature_get_bmaControls(d, 0);
3639 	cmask = 0;
3640 
3641 	if (nchan == 0)
3642 		return;
3643 
3644 	/* figure out what we can control */
3645 
3646 	for (chan = 1; chan < nchan; chan++) {
3647 		DPRINTFN(10, "chan=%d mask=%x\n",
3648 		    chan, uaudio_mixer_feature_get_bmaControls(d, chan));
3649 
3650 		cmask |= uaudio_mixer_feature_get_bmaControls(d, chan);
3651 	}
3652 
3653 	MIX(sc).wIndex = MAKE_WORD(d->bUnitId, sc->sc_mixer_iface_no);
3654 
3655 	i = d->bmaControls[nchan * d->bControlSize];
3656 	if (i == 0 ||
3657 	    usbd_req_get_string_any(sc->sc_udev, NULL,
3658 	    MIX(sc).desc, sizeof(MIX(sc).desc), i) != 0) {
3659 		MIX(sc).desc[0] = 0;
3660 	}
3661 
3662 	if (nchan > MIX_MAX_CHAN)
3663 		nchan = MIX_MAX_CHAN;
3664 
3665 	for (ctl = 1; ctl <= LOUDNESS_CONTROL; ctl++) {
3666 		fumask = FU_MASK(ctl);
3667 
3668 		DPRINTFN(5, "ctl=%d fumask=0x%04x\n",
3669 		    ctl, fumask);
3670 
3671 		if (mmask & fumask) {
3672 			MIX(sc).nchan = 1;
3673 			MIX(sc).wValue[0] = MAKE_WORD(ctl, 0);
3674 		} else if (cmask & fumask) {
3675 			MIX(sc).nchan = nchan - 1;
3676 			for (i = 1; i < nchan; i++) {
3677 				if (uaudio_mixer_feature_get_bmaControls(d, i) & fumask)
3678 					MIX(sc).wValue[i - 1] = MAKE_WORD(ctl, i);
3679 				else
3680 					MIX(sc).wValue[i - 1] = -1;
3681 			}
3682 		} else {
3683 			continue;
3684 		}
3685 
3686 		mixernumber = uaudio_mixer_determine_class(&iot[id]);
3687 
3688 		switch (ctl) {
3689 		case MUTE_CONTROL:
3690 			MIX(sc).type = MIX_ON_OFF;
3691 			MIX(sc).ctl = SOUND_MIXER_MUTE;
3692 			MIX(sc).name = "mute";
3693 			break;
3694 
3695 		case VOLUME_CONTROL:
3696 			MIX(sc).type = MIX_SIGNED_16;
3697 			MIX(sc).ctl = mixernumber;
3698 			MIX(sc).name = "vol";
3699 			break;
3700 
3701 		case BASS_CONTROL:
3702 			MIX(sc).type = MIX_SIGNED_8;
3703 			MIX(sc).ctl = SOUND_MIXER_BASS;
3704 			MIX(sc).name = "bass";
3705 			break;
3706 
3707 		case MID_CONTROL:
3708 			MIX(sc).type = MIX_SIGNED_8;
3709 			MIX(sc).ctl = SOUND_MIXER_NRDEVICES;	/* XXXXX */
3710 			MIX(sc).name = "mid";
3711 			break;
3712 
3713 		case TREBLE_CONTROL:
3714 			MIX(sc).type = MIX_SIGNED_8;
3715 			MIX(sc).ctl = SOUND_MIXER_TREBLE;
3716 			MIX(sc).name = "treble";
3717 			break;
3718 
3719 		case GRAPHIC_EQUALIZER_CONTROL:
3720 			continue;	/* XXX don't add anything */
3721 
3722 		case AGC_CONTROL:
3723 			MIX(sc).type = MIX_ON_OFF;
3724 			MIX(sc).ctl = SOUND_MIXER_NRDEVICES;	/* XXXXX */
3725 			MIX(sc).name = "agc";
3726 			break;
3727 
3728 		case DELAY_CONTROL:
3729 			MIX(sc).type = MIX_UNSIGNED_16;
3730 			MIX(sc).ctl = SOUND_MIXER_NRDEVICES;	/* XXXXX */
3731 			MIX(sc).name = "delay";
3732 			break;
3733 
3734 		case BASS_BOOST_CONTROL:
3735 			MIX(sc).type = MIX_ON_OFF;
3736 			MIX(sc).ctl = SOUND_MIXER_NRDEVICES;	/* XXXXX */
3737 			MIX(sc).name = "boost";
3738 			break;
3739 
3740 		case LOUDNESS_CONTROL:
3741 			MIX(sc).type = MIX_ON_OFF;
3742 			MIX(sc).ctl = SOUND_MIXER_LOUD;	/* Is this correct ? */
3743 			MIX(sc).name = "loudness";
3744 			break;
3745 
3746 		default:
3747 			MIX(sc).type = MIX_UNKNOWN;
3748 			break;
3749 		}
3750 
3751 		if (MIX(sc).type != MIX_UNKNOWN)
3752 			uaudio_mixer_add_ctl(sc, &MIX(sc));
3753 	}
3754 }
3755 
3756 static void
3757 uaudio20_mixer_add_feature(struct uaudio_softc *sc,
3758     const struct uaudio_terminal_node *iot, int id)
3759 {
3760 	const struct usb_audio20_feature_unit *d = iot[id].u.fu_v2;
3761 	uint32_t ctl;
3762 	uint32_t mmask;
3763 	uint32_t cmask;
3764 	uint16_t mixernumber;
3765 	uint8_t nchan;
3766 	uint8_t chan;
3767 	uint8_t i;
3768 	uint8_t what;
3769 
3770 	if (UGETDW(d->bmaControls[0]) == 0)
3771 		return;
3772 
3773 	memset(&MIX(sc), 0, sizeof(MIX(sc)));
3774 
3775 	nchan = (d->bLength - 6) / 4;
3776 	mmask = UGETDW(d->bmaControls[0]);
3777 	cmask = 0;
3778 
3779 	if (nchan == 0)
3780 		return;
3781 
3782 	/* figure out what we can control */
3783 
3784 	for (chan = 1; chan < nchan; chan++)
3785 		cmask |= UGETDW(d->bmaControls[chan]);
3786 
3787 	MIX(sc).wIndex = MAKE_WORD(d->bUnitId, sc->sc_mixer_iface_no);
3788 
3789 	i = d->bmaControls[nchan][0];
3790 	if (i == 0 ||
3791 	    usbd_req_get_string_any(sc->sc_udev, NULL,
3792 	    MIX(sc).desc, sizeof(MIX(sc).desc), i) != 0) {
3793 		MIX(sc).desc[0] = 0;
3794 	}
3795 
3796 	if (nchan > MIX_MAX_CHAN)
3797 		nchan = MIX_MAX_CHAN;
3798 
3799 	for (ctl = 3; ctl != 0; ctl <<= 2) {
3800 		mixernumber = uaudio20_mixer_determine_class(&iot[id]);
3801 
3802 		switch (ctl) {
3803 		case (3 << 0):
3804 			MIX(sc).type = MIX_ON_OFF;
3805 			MIX(sc).ctl = SOUND_MIXER_MUTE;
3806 			MIX(sc).name = "mute";
3807 			what = MUTE_CONTROL;
3808 			break;
3809 		case (3 << 2):
3810 			MIX(sc).type = MIX_SIGNED_16;
3811 			MIX(sc).ctl = mixernumber;
3812 			MIX(sc).name = "vol";
3813 			what = VOLUME_CONTROL;
3814 			break;
3815 		case (3 << 4):
3816 			MIX(sc).type = MIX_SIGNED_8;
3817 			MIX(sc).ctl = SOUND_MIXER_BASS;
3818 			MIX(sc).name = "bass";
3819 			what = BASS_CONTROL;
3820 			break;
3821 		case (3 << 6):
3822 			MIX(sc).type = MIX_SIGNED_8;
3823 			MIX(sc).ctl = SOUND_MIXER_NRDEVICES;	/* XXXXX */
3824 			MIX(sc).name = "mid";
3825 			what = MID_CONTROL;
3826 			break;
3827 		case (3 << 8):
3828 			MIX(sc).type = MIX_SIGNED_8;
3829 			MIX(sc).ctl = SOUND_MIXER_TREBLE;
3830 			MIX(sc).name = "treble";
3831 			what = TREBLE_CONTROL;
3832 			break;
3833 		case (3 << 12):
3834 			MIX(sc).type = MIX_ON_OFF;
3835 			MIX(sc).ctl = SOUND_MIXER_NRDEVICES;	/* XXXXX */
3836 			MIX(sc).name = "agc";
3837 			what = AGC_CONTROL;
3838 			break;
3839 		case (3 << 14):
3840 			MIX(sc).type = MIX_UNSIGNED_16;
3841 			MIX(sc).ctl = SOUND_MIXER_NRDEVICES;	/* XXXXX */
3842 			MIX(sc).name = "delay";
3843 			what = DELAY_CONTROL;
3844 			break;
3845 		case (3 << 16):
3846 			MIX(sc).type = MIX_ON_OFF;
3847 			MIX(sc).ctl = SOUND_MIXER_NRDEVICES;	/* XXXXX */
3848 			MIX(sc).name = "boost";
3849 			what = BASS_BOOST_CONTROL;
3850 			break;
3851 		case (3 << 18):
3852 			MIX(sc).type = MIX_ON_OFF;
3853 			MIX(sc).ctl = SOUND_MIXER_LOUD;	/* Is this correct ? */
3854 			MIX(sc).name = "loudness";
3855 			what = LOUDNESS_CONTROL;
3856 			break;
3857 		case (3 << 20):
3858 			MIX(sc).type = MIX_SIGNED_16;
3859 			MIX(sc).ctl = mixernumber;
3860 			MIX(sc).name = "igain";
3861 			what = INPUT_GAIN_CONTROL;
3862 			break;
3863 		case (3 << 22):
3864 			MIX(sc).type = MIX_SIGNED_16;
3865 			MIX(sc).ctl = mixernumber;
3866 			MIX(sc).name = "igainpad";
3867 			what = INPUT_GAIN_PAD_CONTROL;
3868 			break;
3869 		default:
3870 			continue;
3871 		}
3872 
3873 		if ((mmask & ctl) == ctl) {
3874 			MIX(sc).nchan = 1;
3875 			MIX(sc).wValue[0] = MAKE_WORD(what, 0);
3876 		} else if ((cmask & ctl) == ctl) {
3877 			MIX(sc).nchan = nchan - 1;
3878 			for (i = 1; i < nchan; i++) {
3879 				if ((UGETDW(d->bmaControls[i]) & ctl) == ctl)
3880 					MIX(sc).wValue[i - 1] = MAKE_WORD(what, i);
3881 				else
3882 					MIX(sc).wValue[i - 1] = -1;
3883 			}
3884 		} else {
3885 			continue;
3886 		}
3887 
3888 		if (MIX(sc).type != MIX_UNKNOWN)
3889 			uaudio_mixer_add_ctl(sc, &MIX(sc));
3890 	}
3891 }
3892 
3893 static void
3894 uaudio_mixer_add_processing_updown(struct uaudio_softc *sc,
3895     const struct uaudio_terminal_node *iot, int id)
3896 {
3897 	const struct usb_audio_processing_unit_0 *d0 = iot[id].u.pu_v1;
3898 	const struct usb_audio_processing_unit_1 *d1 =
3899 	    (const void *)(d0->baSourceId + d0->bNrInPins);
3900 	const struct usb_audio_processing_unit_updown *ud =
3901 	    (const void *)(d1->bmControls + d1->bControlSize);
3902 	uint8_t i;
3903 
3904 	if (uaudio_mixer_verify_desc(d0, sizeof(*ud)) == NULL) {
3905 		return;
3906 	}
3907 	if (uaudio_mixer_verify_desc(d0, sizeof(*ud) + (2 * ud->bNrModes))
3908 	    == NULL) {
3909 		return;
3910 	}
3911 	DPRINTFN(3, "bUnitId=%d bNrModes=%d\n",
3912 	    d0->bUnitId, ud->bNrModes);
3913 
3914 	if (!(d1->bmControls[0] & UA_PROC_MASK(UD_MODE_SELECT_CONTROL))) {
3915 		DPRINTF("no mode select\n");
3916 		return;
3917 	}
3918 	memset(&MIX(sc), 0, sizeof(MIX(sc)));
3919 
3920 	MIX(sc).wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no);
3921 	MIX(sc).nchan = 1;
3922 	MIX(sc).wValue[0] = MAKE_WORD(UD_MODE_SELECT_CONTROL, 0);
3923 	MIX(sc).type = MIX_ON_OFF;		/* XXX */
3924 
3925 	for (i = 0; i < ud->bNrModes; i++) {
3926 		DPRINTFN(3, "i=%d bm=0x%x\n", i, UGETW(ud->waModes[i]));
3927 		/* XXX */
3928 	}
3929 
3930 	uaudio_mixer_add_ctl(sc, &MIX(sc));
3931 }
3932 
3933 static void
3934 uaudio_mixer_add_processing(struct uaudio_softc *sc,
3935     const struct uaudio_terminal_node *iot, int id)
3936 {
3937 	const struct usb_audio_processing_unit_0 *d0 = iot[id].u.pu_v1;
3938 	const struct usb_audio_processing_unit_1 *d1 =
3939 	    (const void *)(d0->baSourceId + d0->bNrInPins);
3940 	uint16_t ptype;
3941 
3942 	memset(&MIX(sc), 0, sizeof(MIX(sc)));
3943 
3944 	ptype = UGETW(d0->wProcessType);
3945 
3946 	DPRINTFN(3, "wProcessType=%d bUnitId=%d "
3947 	    "bNrInPins=%d\n", ptype, d0->bUnitId, d0->bNrInPins);
3948 
3949 	if (d1->bControlSize == 0) {
3950 		return;
3951 	}
3952 	if (d1->bmControls[0] & UA_PROC_ENABLE_MASK) {
3953 		MIX(sc).wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no);
3954 		MIX(sc).nchan = 1;
3955 		MIX(sc).wValue[0] = MAKE_WORD(XX_ENABLE_CONTROL, 0);
3956 		MIX(sc).type = MIX_ON_OFF;
3957 		uaudio_mixer_add_ctl(sc, &MIX(sc));
3958 	}
3959 	switch (ptype) {
3960 	case UPDOWNMIX_PROCESS:
3961 		uaudio_mixer_add_processing_updown(sc, iot, id);
3962 		break;
3963 
3964 	case DOLBY_PROLOGIC_PROCESS:
3965 	case P3D_STEREO_EXTENDER_PROCESS:
3966 	case REVERBATION_PROCESS:
3967 	case CHORUS_PROCESS:
3968 	case DYN_RANGE_COMP_PROCESS:
3969 	default:
3970 		DPRINTF("unit %d, type=%d is not implemented\n",
3971 		    d0->bUnitId, ptype);
3972 		break;
3973 	}
3974 }
3975 
3976 static void
3977 uaudio_mixer_add_extension(struct uaudio_softc *sc,
3978     const struct uaudio_terminal_node *iot, int id)
3979 {
3980 	const struct usb_audio_extension_unit_0 *d0 = iot[id].u.eu_v1;
3981 	const struct usb_audio_extension_unit_1 *d1 =
3982 	    (const void *)(d0->baSourceId + d0->bNrInPins);
3983 
3984 	DPRINTFN(3, "bUnitId=%d bNrInPins=%d\n",
3985 	    d0->bUnitId, d0->bNrInPins);
3986 
3987 	if (sc->sc_uq_au_no_xu) {
3988 		return;
3989 	}
3990 	if (d1->bControlSize == 0) {
3991 		return;
3992 	}
3993 	if (d1->bmControls[0] & UA_EXT_ENABLE_MASK) {
3994 		memset(&MIX(sc), 0, sizeof(MIX(sc)));
3995 
3996 		MIX(sc).wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no);
3997 		MIX(sc).nchan = 1;
3998 		MIX(sc).wValue[0] = MAKE_WORD(UA_EXT_ENABLE, 0);
3999 		MIX(sc).type = MIX_ON_OFF;
4000 
4001 		uaudio_mixer_add_ctl(sc, &MIX(sc));
4002 	}
4003 }
4004 
4005 static const void *
4006 uaudio_mixer_verify_desc(const void *arg, uint32_t len)
4007 {
4008 	const struct usb_audio_mixer_unit_1 *d1;
4009 	const struct usb_audio_extension_unit_1 *e1;
4010 	const struct usb_audio_processing_unit_1 *u1;
4011 
4012 	union {
4013 		const struct usb_descriptor *desc;
4014 		const struct usb_audio_input_terminal *it;
4015 		const struct usb_audio_output_terminal *ot;
4016 		const struct usb_audio_mixer_unit_0 *mu;
4017 		const struct usb_audio_selector_unit *su;
4018 		const struct usb_audio_feature_unit *fu;
4019 		const struct usb_audio_processing_unit_0 *pu;
4020 		const struct usb_audio_extension_unit_0 *eu;
4021 	}     u;
4022 
4023 	u.desc = arg;
4024 
4025 	if (u.desc == NULL) {
4026 		goto error;
4027 	}
4028 	if (u.desc->bDescriptorType != UDESC_CS_INTERFACE) {
4029 		goto error;
4030 	}
4031 	switch (u.desc->bDescriptorSubtype) {
4032 	case UDESCSUB_AC_INPUT:
4033 		len += sizeof(*u.it);
4034 		break;
4035 
4036 	case UDESCSUB_AC_OUTPUT:
4037 		len += sizeof(*u.ot);
4038 		break;
4039 
4040 	case UDESCSUB_AC_MIXER:
4041 		len += sizeof(*u.mu);
4042 
4043 		if (u.desc->bLength < len) {
4044 			goto error;
4045 		}
4046 		len += u.mu->bNrInPins;
4047 
4048 		if (u.desc->bLength < len) {
4049 			goto error;
4050 		}
4051 		d1 = (const void *)(u.mu->baSourceId + u.mu->bNrInPins);
4052 
4053 		len += sizeof(*d1);
4054 		break;
4055 
4056 	case UDESCSUB_AC_SELECTOR:
4057 		len += sizeof(*u.su);
4058 
4059 		if (u.desc->bLength < len) {
4060 			goto error;
4061 		}
4062 		len += u.su->bNrInPins + 1;
4063 		break;
4064 
4065 	case UDESCSUB_AC_FEATURE:
4066 		len += sizeof(*u.fu) + 1;
4067 
4068 		if (u.desc->bLength < len)
4069 			goto error;
4070 
4071 		len += u.fu->bControlSize;
4072 		break;
4073 
4074 	case UDESCSUB_AC_PROCESSING:
4075 		len += sizeof(*u.pu);
4076 
4077 		if (u.desc->bLength < len) {
4078 			goto error;
4079 		}
4080 		len += u.pu->bNrInPins;
4081 
4082 		if (u.desc->bLength < len) {
4083 			goto error;
4084 		}
4085 		u1 = (const void *)(u.pu->baSourceId + u.pu->bNrInPins);
4086 
4087 		len += sizeof(*u1);
4088 
4089 		if (u.desc->bLength < len) {
4090 			goto error;
4091 		}
4092 		len += u1->bControlSize;
4093 
4094 		break;
4095 
4096 	case UDESCSUB_AC_EXTENSION:
4097 		len += sizeof(*u.eu);
4098 
4099 		if (u.desc->bLength < len) {
4100 			goto error;
4101 		}
4102 		len += u.eu->bNrInPins;
4103 
4104 		if (u.desc->bLength < len) {
4105 			goto error;
4106 		}
4107 		e1 = (const void *)(u.eu->baSourceId + u.eu->bNrInPins);
4108 
4109 		len += sizeof(*e1);
4110 
4111 		if (u.desc->bLength < len) {
4112 			goto error;
4113 		}
4114 		len += e1->bControlSize;
4115 		break;
4116 
4117 	default:
4118 		goto error;
4119 	}
4120 
4121 	if (u.desc->bLength < len) {
4122 		goto error;
4123 	}
4124 	return (u.desc);
4125 
4126 error:
4127 	if (u.desc) {
4128 		DPRINTF("invalid descriptor, type=%d, "
4129 		    "sub_type=%d, len=%d of %d bytes\n",
4130 		    u.desc->bDescriptorType,
4131 		    u.desc->bDescriptorSubtype,
4132 		    u.desc->bLength, len);
4133 	}
4134 	return (NULL);
4135 }
4136 
4137 static const void *
4138 uaudio20_mixer_verify_desc(const void *arg, uint32_t len)
4139 {
4140 	const struct usb_audio20_mixer_unit_1 *d1;
4141 	const struct usb_audio20_extension_unit_1 *e1;
4142 	const struct usb_audio20_processing_unit_1 *u1;
4143 	const struct usb_audio20_clock_selector_unit_1 *c1;
4144 
4145 	union {
4146 		const struct usb_descriptor *desc;
4147 		const struct usb_audio20_clock_source_unit *csrc;
4148 		const struct usb_audio20_clock_selector_unit_0 *csel;
4149 		const struct usb_audio20_clock_multiplier_unit *cmul;
4150 		const struct usb_audio20_input_terminal *it;
4151 		const struct usb_audio20_output_terminal *ot;
4152 		const struct usb_audio20_mixer_unit_0 *mu;
4153 		const struct usb_audio20_selector_unit *su;
4154 		const struct usb_audio20_feature_unit *fu;
4155 		const struct usb_audio20_sample_rate_unit *ru;
4156 		const struct usb_audio20_processing_unit_0 *pu;
4157 		const struct usb_audio20_extension_unit_0 *eu;
4158 		const struct usb_audio20_effect_unit *ef;
4159 	}     u;
4160 
4161 	u.desc = arg;
4162 
4163 	if (u.desc == NULL)
4164 		goto error;
4165 
4166 	if (u.desc->bDescriptorType != UDESC_CS_INTERFACE)
4167 		goto error;
4168 
4169 	switch (u.desc->bDescriptorSubtype) {
4170 	case UDESCSUB_AC_INPUT:
4171 		len += sizeof(*u.it);
4172 		break;
4173 
4174 	case UDESCSUB_AC_OUTPUT:
4175 		len += sizeof(*u.ot);
4176 		break;
4177 
4178 	case UDESCSUB_AC_MIXER:
4179 		len += sizeof(*u.mu);
4180 
4181 		if (u.desc->bLength < len)
4182 			goto error;
4183 		len += u.mu->bNrInPins;
4184 
4185 		if (u.desc->bLength < len)
4186 			goto error;
4187 
4188 		d1 = (const void *)(u.mu->baSourceId + u.mu->bNrInPins);
4189 
4190 		len += sizeof(*d1) + d1->bNrChannels;
4191 		break;
4192 
4193 	case UDESCSUB_AC_SELECTOR:
4194 		len += sizeof(*u.su);
4195 
4196 		if (u.desc->bLength < len)
4197 			goto error;
4198 
4199 		len += u.su->bNrInPins + 1;
4200 		break;
4201 
4202 	case UDESCSUB_AC_FEATURE:
4203 		len += sizeof(*u.fu) + 1;
4204 		break;
4205 
4206 	case UDESCSUB_AC_EFFECT:
4207 		len += sizeof(*u.ef) + 4;
4208 		break;
4209 
4210 	case UDESCSUB_AC_PROCESSING_V2:
4211 		len += sizeof(*u.pu);
4212 
4213 		if (u.desc->bLength < len)
4214 			goto error;
4215 
4216 		len += u.pu->bNrInPins;
4217 
4218 		if (u.desc->bLength < len)
4219 			goto error;
4220 
4221 		u1 = (const void *)(u.pu->baSourceId + u.pu->bNrInPins);
4222 
4223 		len += sizeof(*u1);
4224 		break;
4225 
4226 	case UDESCSUB_AC_EXTENSION_V2:
4227 		len += sizeof(*u.eu);
4228 
4229 		if (u.desc->bLength < len)
4230 			goto error;
4231 
4232 		len += u.eu->bNrInPins;
4233 
4234 		if (u.desc->bLength < len)
4235 			goto error;
4236 
4237 		e1 = (const void *)(u.eu->baSourceId + u.eu->bNrInPins);
4238 
4239 		len += sizeof(*e1);
4240 		break;
4241 
4242 	case UDESCSUB_AC_CLOCK_SRC:
4243 		len += sizeof(*u.csrc);
4244 		break;
4245 
4246 	case UDESCSUB_AC_CLOCK_SEL:
4247 		len += sizeof(*u.csel);
4248 
4249 		if (u.desc->bLength < len)
4250 			goto error;
4251 
4252 		len += u.csel->bNrInPins;
4253 
4254 		if (u.desc->bLength < len)
4255 			goto error;
4256 
4257 		c1 = (const void *)(u.csel->baCSourceId + u.csel->bNrInPins);
4258 
4259 		len += sizeof(*c1);
4260 		break;
4261 
4262 	case UDESCSUB_AC_CLOCK_MUL:
4263 		len += sizeof(*u.cmul);
4264 		break;
4265 
4266 	case UDESCSUB_AC_SAMPLE_RT:
4267 		len += sizeof(*u.ru);
4268 		break;
4269 
4270 	default:
4271 		goto error;
4272 	}
4273 
4274 	if (u.desc->bLength < len)
4275 		goto error;
4276 
4277 	return (u.desc);
4278 
4279 error:
4280 	if (u.desc) {
4281 		DPRINTF("invalid descriptor, type=%d, "
4282 		    "sub_type=%d, len=%d of %d bytes\n",
4283 		    u.desc->bDescriptorType,
4284 		    u.desc->bDescriptorSubtype,
4285 		    u.desc->bLength, len);
4286 	}
4287 	return (NULL);
4288 }
4289 
4290 static struct usb_audio_cluster
4291 uaudio_mixer_get_cluster(uint8_t id, const struct uaudio_terminal_node *iot)
4292 {
4293 	struct usb_audio_cluster r;
4294 	const struct usb_descriptor *dp;
4295 	uint8_t i;
4296 
4297 	for (i = 0; i < UAUDIO_RECURSE_LIMIT; i++) {	/* avoid infinite loops */
4298 		dp = iot[id].u.desc;
4299 		if (dp == NULL) {
4300 			goto error;
4301 		}
4302 		switch (dp->bDescriptorSubtype) {
4303 		case UDESCSUB_AC_INPUT:
4304 			r.bNrChannels = iot[id].u.it_v1->bNrChannels;
4305 			r.wChannelConfig[0] = iot[id].u.it_v1->wChannelConfig[0];
4306 			r.wChannelConfig[1] = iot[id].u.it_v1->wChannelConfig[1];
4307 			r.iChannelNames = iot[id].u.it_v1->iChannelNames;
4308 			goto done;
4309 
4310 		case UDESCSUB_AC_OUTPUT:
4311 			id = iot[id].u.ot_v1->bSourceId;
4312 			break;
4313 
4314 		case UDESCSUB_AC_MIXER:
4315 			r = *(const struct usb_audio_cluster *)
4316 			    &iot[id].u.mu_v1->baSourceId[
4317 			    iot[id].u.mu_v1->bNrInPins];
4318 			goto done;
4319 
4320 		case UDESCSUB_AC_SELECTOR:
4321 			if (iot[id].u.su_v1->bNrInPins > 0) {
4322 				/* XXX This is not really right */
4323 				id = iot[id].u.su_v1->baSourceId[0];
4324 			}
4325 			break;
4326 
4327 		case UDESCSUB_AC_FEATURE:
4328 			id = iot[id].u.fu_v1->bSourceId;
4329 			break;
4330 
4331 		case UDESCSUB_AC_PROCESSING:
4332 			r = *((const struct usb_audio_cluster *)
4333 			    &iot[id].u.pu_v1->baSourceId[
4334 			    iot[id].u.pu_v1->bNrInPins]);
4335 			goto done;
4336 
4337 		case UDESCSUB_AC_EXTENSION:
4338 			r = *((const struct usb_audio_cluster *)
4339 			    &iot[id].u.eu_v1->baSourceId[
4340 			    iot[id].u.eu_v1->bNrInPins]);
4341 			goto done;
4342 
4343 		default:
4344 			goto error;
4345 		}
4346 	}
4347 error:
4348 	DPRINTF("bad data\n");
4349 	memset(&r, 0, sizeof(r));
4350 done:
4351 	return (r);
4352 }
4353 
4354 static struct usb_audio20_cluster
4355 uaudio20_mixer_get_cluster(uint8_t id, const struct uaudio_terminal_node *iot)
4356 {
4357 	struct usb_audio20_cluster r;
4358 	const struct usb_descriptor *dp;
4359 	uint8_t i;
4360 
4361 	for (i = 0; i < UAUDIO_RECURSE_LIMIT; i++) {	/* avoid infinite loops */
4362 		dp = iot[id].u.desc;
4363 		if (dp == NULL)
4364 			goto error;
4365 
4366 		switch (dp->bDescriptorSubtype) {
4367 		case UDESCSUB_AC_INPUT:
4368 			r.bNrChannels = iot[id].u.it_v2->bNrChannels;
4369 			r.bmChannelConfig[0] = iot[id].u.it_v2->bmChannelConfig[0];
4370 			r.bmChannelConfig[1] = iot[id].u.it_v2->bmChannelConfig[1];
4371 			r.bmChannelConfig[2] = iot[id].u.it_v2->bmChannelConfig[2];
4372 			r.bmChannelConfig[3] = iot[id].u.it_v2->bmChannelConfig[3];
4373 			r.iChannelNames = iot[id].u.it_v2->iTerminal;
4374 			goto done;
4375 
4376 		case UDESCSUB_AC_OUTPUT:
4377 			id = iot[id].u.ot_v2->bSourceId;
4378 			break;
4379 
4380 		case UDESCSUB_AC_MIXER:
4381 			r = *(const struct usb_audio20_cluster *)
4382 			    &iot[id].u.mu_v2->baSourceId[
4383 			    iot[id].u.mu_v2->bNrInPins];
4384 			goto done;
4385 
4386 		case UDESCSUB_AC_SELECTOR:
4387 			if (iot[id].u.su_v2->bNrInPins > 0) {
4388 				/* XXX This is not really right */
4389 				id = iot[id].u.su_v2->baSourceId[0];
4390 			}
4391 			break;
4392 
4393 		case UDESCSUB_AC_SAMPLE_RT:
4394 			id = iot[id].u.ru_v2->bSourceId;
4395 			break;
4396 
4397 		case UDESCSUB_AC_EFFECT:
4398 			id = iot[id].u.ef_v2->bSourceId;
4399 			break;
4400 
4401 		case UDESCSUB_AC_FEATURE:
4402 			id = iot[id].u.fu_v2->bSourceId;
4403 			break;
4404 
4405 		case UDESCSUB_AC_PROCESSING_V2:
4406 			r = *((const struct usb_audio20_cluster *)
4407 			    &iot[id].u.pu_v2->baSourceId[
4408 			    iot[id].u.pu_v2->bNrInPins]);
4409 			goto done;
4410 
4411 		case UDESCSUB_AC_EXTENSION_V2:
4412 			r = *((const struct usb_audio20_cluster *)
4413 			    &iot[id].u.eu_v2->baSourceId[
4414 			    iot[id].u.eu_v2->bNrInPins]);
4415 			goto done;
4416 
4417 		default:
4418 			goto error;
4419 		}
4420 	}
4421 error:
4422 	DPRINTF("Bad data!\n");
4423 	memset(&r, 0, sizeof(r));
4424 done:
4425 	return (r);
4426 }
4427 
4428 static bool
4429 uaudio_mixer_foreach_input(const struct uaudio_terminal_node *iot, uint8_t *pindex)
4430 {
4431 	uint8_t n;
4432 
4433 	n = *pindex;
4434 
4435 	while (1) {
4436 		if (!n--)
4437 			n = iot->usr.id_max;
4438 		if (n == 0)
4439 			return (false);
4440 		if (iot->usr.bit_input[n / 8] & (1 << (n % 8)))
4441 			break;
4442 	}
4443 	*pindex = n;
4444 	return (true);
4445 }
4446 
4447 static bool
4448 uaudio_mixer_foreach_output(const struct uaudio_terminal_node *iot, uint8_t *pindex)
4449 {
4450 	uint8_t n;
4451 
4452 	n = *pindex;
4453 
4454 	while (1) {
4455 		if (!n--)
4456 			n = iot->usr.id_max;
4457 		if (n == 0)
4458 			return (false);
4459 		if (iot->usr.bit_output[n / 8] & (1 << (n % 8)))
4460 			break;
4461 	}
4462 	*pindex = n;
4463 	return (true);
4464 }
4465 
4466 struct uaudio_tt_to_feature {
4467 	uint16_t terminal_type;
4468 	uint16_t feature;
4469 };
4470 
4471 static const struct uaudio_tt_to_feature uaudio_tt_to_feature[] = {
4472 	{UATI_MICROPHONE, SOUND_MIXER_MIC},
4473 	{UATI_DESKMICROPHONE, SOUND_MIXER_MIC},
4474 	{UATI_PERSONALMICROPHONE, SOUND_MIXER_MIC},
4475 	{UATI_OMNIMICROPHONE, SOUND_MIXER_MIC},
4476 	{UATI_MICROPHONEARRAY, SOUND_MIXER_MIC},
4477 	{UATI_PROCMICROPHONEARR, SOUND_MIXER_MIC},
4478 
4479 	{UATE_ANALOGCONN, SOUND_MIXER_LINE},
4480 	{UATE_LINECONN, SOUND_MIXER_LINE},
4481 	{UATE_LEGACYCONN, SOUND_MIXER_LINE},
4482 
4483 	{UATE_DIGITALAUIFC, SOUND_MIXER_ALTPCM},
4484 	{UATE_SPDIF, SOUND_MIXER_ALTPCM},
4485 	{UATE_1394DA, SOUND_MIXER_ALTPCM},
4486 	{UATE_1394DV, SOUND_MIXER_ALTPCM},
4487 
4488 	{UATF_CDPLAYER, SOUND_MIXER_CD},
4489 
4490 	{UATF_SYNTHESIZER, SOUND_MIXER_SYNTH},
4491 
4492 	{UATF_VIDEODISCAUDIO, SOUND_MIXER_VIDEO},
4493 	{UATF_DVDAUDIO, SOUND_MIXER_VIDEO},
4494 	{UATF_TVTUNERAUDIO, SOUND_MIXER_VIDEO},
4495 
4496 	{UATF_RADIORECV, SOUND_MIXER_RADIO},
4497 	{UATF_RADIOXMIT, SOUND_MIXER_RADIO},
4498 
4499 	{}	/* END */
4500 };
4501 
4502 static uint16_t
4503 uaudio_mixer_get_feature_by_tt(uint16_t terminal_type, uint16_t default_type)
4504 {
4505 	const struct uaudio_tt_to_feature *uat = uaudio_tt_to_feature;
4506 	uint16_t retval;
4507 
4508 	if (terminal_type == 0) {
4509 		retval = default_type;
4510 	} else while (1) {
4511 		if (uat->terminal_type == 0) {
4512 			switch (terminal_type >> 8) {
4513 			case UATI_UNDEFINED >> 8:
4514 				retval = SOUND_MIXER_RECLEV;
4515 				goto done;
4516 			case UATO_UNDEFINED >> 8:
4517 				retval = SOUND_MIXER_PCM;
4518 				goto done;
4519 			case UATT_UNDEFINED >> 8:
4520 				retval = SOUND_MIXER_PHONEIN;
4521 				goto done;
4522 			default:
4523 				retval = default_type;
4524 				goto done;
4525 			}
4526 		} else if (uat->terminal_type == terminal_type) {
4527 			retval = uat->feature;
4528 			goto done;
4529 		}
4530 		uat++;
4531 	}
4532 done:
4533 	DPRINTF("terminal_type=0x%04x RET=%d DEF=%d\n",
4534 	    terminal_type, retval, default_type);
4535 	return (retval);
4536 }
4537 
4538 static uint16_t
4539 uaudio_mixer_determine_class(const struct uaudio_terminal_node *iot)
4540 {
4541 	const struct uaudio_terminal_node *ptr;
4542 	uint16_t terminal_type_input = 0;
4543 	uint16_t terminal_type_output = 0;
4544 	uint16_t temp;
4545 	uint8_t match = 0;
4546 	uint8_t i;
4547 
4548 	for (i = 0; uaudio_mixer_foreach_input(iot, &i); ) {
4549 		ptr = iot->root + i;
4550 		temp = UGETW(ptr->u.it_v1->wTerminalType);
4551 
4552 		if (temp == 0)
4553 			continue;
4554 		else if (temp == UAT_STREAM)
4555 			match |= 1;
4556 		else if ((temp & 0xFF00) != (UAT_UNDEFINED & 0xff00))
4557 			terminal_type_input = temp;
4558 	}
4559 
4560 	for (i = 0; uaudio_mixer_foreach_output(iot, &i); ) {
4561 		ptr = iot->root + i;
4562 		temp = UGETW(ptr->u.ot_v1->wTerminalType);
4563 
4564 		if (temp == 0)
4565 			continue;
4566 		else if (temp == UAT_STREAM)
4567 			match |= 2;
4568 		else if ((temp & 0xFF00) != (UAT_UNDEFINED & 0xff00))
4569 			terminal_type_output = temp;
4570 	}
4571 
4572 	DPRINTF("MATCH=%d IN=0x%04x OUT=0x%04x\n",
4573 	    match, terminal_type_input, terminal_type_output);
4574 
4575 	switch (match) {
4576 	case 0:	/* not connected to USB */
4577 		if (terminal_type_output != 0) {
4578 			return (uaudio_mixer_get_feature_by_tt(
4579 			    terminal_type_output, SOUND_MIXER_MONITOR));
4580 		} else {
4581 			return (uaudio_mixer_get_feature_by_tt(
4582 			    terminal_type_input, SOUND_MIXER_MONITOR));
4583 		}
4584 	case 3:	/* connected to both USB input and USB output */
4585 		return (SOUND_MIXER_IMIX);
4586 	case 2:	/* connected to USB output */
4587 		return (uaudio_mixer_get_feature_by_tt(
4588 		    terminal_type_input, SOUND_MIXER_RECLEV));
4589 	case 1: /* connected to USB input */
4590 		return (uaudio_mixer_get_feature_by_tt(
4591 		    terminal_type_output, SOUND_MIXER_PCM));
4592 	default:
4593 		return (SOUND_MIXER_NRDEVICES);
4594 	}
4595 }
4596 
4597 static uint16_t
4598 uaudio20_mixer_determine_class(const struct uaudio_terminal_node *iot)
4599 {
4600 	const struct uaudio_terminal_node *ptr;
4601 	uint16_t terminal_type_input = 0;
4602 	uint16_t terminal_type_output = 0;
4603 	uint16_t temp;
4604 	uint8_t match = 0;
4605 	uint8_t i;
4606 
4607 	for (i = 0; uaudio_mixer_foreach_input(iot, &i); ) {
4608 		ptr = iot->root + i;
4609 		temp = UGETW(ptr->u.it_v2->wTerminalType);
4610 
4611 		if (temp == 0)
4612 			continue;
4613 		else if (temp == UAT_STREAM)
4614 			match |= 1;
4615 		else if ((temp & 0xFF00) != (UAT_UNDEFINED & 0xff00))
4616 			terminal_type_input = temp;
4617 	}
4618 
4619 	for (i = 0; uaudio_mixer_foreach_output(iot, &i); ) {
4620 		ptr = iot->root + i;
4621 		temp = UGETW(ptr->u.ot_v2->wTerminalType);
4622 
4623 		if (temp == 0)
4624 			continue;
4625 		else if (temp == UAT_STREAM)
4626 			match |= 2;
4627 		else if ((temp & 0xFF00) != (UAT_UNDEFINED & 0xff00))
4628 			terminal_type_output = temp;
4629 	}
4630 
4631 	DPRINTF("MATCH=%d IN=0x%04x OUT=0x%04x\n",
4632 	    match, terminal_type_input, terminal_type_output);
4633 
4634 	switch (match) {
4635 	case 0:	/* not connected to USB */
4636 		if (terminal_type_output != 0) {
4637 			return (uaudio_mixer_get_feature_by_tt(
4638 			    terminal_type_output, SOUND_MIXER_MONITOR));
4639 		} else {
4640 			return (uaudio_mixer_get_feature_by_tt(
4641 			    terminal_type_input, SOUND_MIXER_MONITOR));
4642 		}
4643 	case 3:	/* connected to both USB input and USB output */
4644 		return (SOUND_MIXER_IMIX);
4645 	case 2:	/* connected to USB output */
4646 		return (uaudio_mixer_get_feature_by_tt(
4647 		    terminal_type_input, SOUND_MIXER_RECLEV));
4648 	case 1: /* connected to USB input */
4649 		return (uaudio_mixer_get_feature_by_tt(
4650 		    terminal_type_output, SOUND_MIXER_PCM));
4651 	default:
4652 		return (SOUND_MIXER_NRDEVICES);
4653 	}
4654 }
4655 
4656 static void
4657 uaudio_mixer_merge_outputs(struct uaudio_search_result *dst,
4658     const struct uaudio_search_result *src)
4659 {
4660 	const uint8_t max = sizeof(src->bit_output) / sizeof(src->bit_output[0]);
4661 	uint8_t x;
4662 
4663 	for (x = 0; x != max; x++)
4664 		dst->bit_output[x] |= src->bit_output[x];
4665 }
4666 
4667 static void
4668 uaudio_mixer_find_inputs_sub(struct uaudio_terminal_node *root,
4669     const uint8_t *p_id, uint8_t n_id,
4670     struct uaudio_search_result *info)
4671 {
4672 	struct uaudio_terminal_node *iot;
4673 	uint8_t n;
4674 	uint8_t i;
4675 
4676 	for (n = 0; n < n_id; n++) {
4677 		i = p_id[n];
4678 
4679 		if (info->recurse_level == UAUDIO_RECURSE_LIMIT) {
4680 			DPRINTF("avoided going into a circle at id=%d!\n", i);
4681 			return;
4682 		}
4683 
4684 		info->recurse_level++;
4685 
4686 		iot = (root + i);
4687 
4688 		if (iot->u.desc == NULL)
4689 			continue;
4690 
4691 		switch (iot->u.desc->bDescriptorSubtype) {
4692 		case UDESCSUB_AC_INPUT:
4693 			uaudio_mixer_merge_outputs(&iot->usr, info);
4694 			info->bit_input[i / 8] |= (1 << (i % 8));
4695 			break;
4696 
4697 		case UDESCSUB_AC_FEATURE:
4698 			uaudio_mixer_merge_outputs(&iot->usr, info);
4699 			uaudio_mixer_find_inputs_sub(
4700 			    root, &iot->u.fu_v1->bSourceId, 1, info);
4701 			break;
4702 
4703 		case UDESCSUB_AC_OUTPUT:
4704 			info->bit_output[i / 8] |= (1 << (i % 8));
4705 			uaudio_mixer_find_inputs_sub(
4706 			    root, &iot->u.ot_v1->bSourceId, 1, info);
4707 			info->bit_output[i / 8] &= ~(1 << (i % 8));
4708 			break;
4709 
4710 		case UDESCSUB_AC_MIXER:
4711 			uaudio_mixer_merge_outputs(&iot->usr, info);
4712 			uaudio_mixer_find_inputs_sub(
4713 			    root, iot->u.mu_v1->baSourceId,
4714 			    iot->u.mu_v1->bNrInPins, info);
4715 			break;
4716 
4717 		case UDESCSUB_AC_SELECTOR:
4718 			uaudio_mixer_merge_outputs(&iot->usr, info);
4719 			uaudio_mixer_find_inputs_sub(
4720 			    root, iot->u.su_v1->baSourceId,
4721 			    iot->u.su_v1->bNrInPins, info);
4722 			break;
4723 
4724 		case UDESCSUB_AC_PROCESSING:
4725 			uaudio_mixer_merge_outputs(&iot->usr, info);
4726 			uaudio_mixer_find_inputs_sub(
4727 			    root, iot->u.pu_v1->baSourceId,
4728 			    iot->u.pu_v1->bNrInPins, info);
4729 			break;
4730 
4731 		case UDESCSUB_AC_EXTENSION:
4732 			uaudio_mixer_merge_outputs(&iot->usr, info);
4733 			uaudio_mixer_find_inputs_sub(
4734 			    root, iot->u.eu_v1->baSourceId,
4735 			    iot->u.eu_v1->bNrInPins, info);
4736 			break;
4737 
4738 		default:
4739 			break;
4740 		}
4741 	}
4742 }
4743 
4744 static void
4745 uaudio20_mixer_find_inputs_sub(struct uaudio_terminal_node *root,
4746     const uint8_t *p_id, uint8_t n_id,
4747     struct uaudio_search_result *info)
4748 {
4749 	struct uaudio_terminal_node *iot;
4750 	uint8_t n;
4751 	uint8_t i;
4752 
4753 	for (n = 0; n < n_id; n++) {
4754 		i = p_id[n];
4755 
4756 		if (info->recurse_level == UAUDIO_RECURSE_LIMIT) {
4757 			DPRINTF("avoided going into a circle at id=%d!\n", i);
4758 			return;
4759 		}
4760 
4761 		info->recurse_level++;
4762 
4763 		iot = (root + i);
4764 
4765 		if (iot->u.desc == NULL)
4766 			continue;
4767 
4768 		switch (iot->u.desc->bDescriptorSubtype) {
4769 		case UDESCSUB_AC_INPUT:
4770 			uaudio_mixer_merge_outputs(&iot->usr, info);
4771 			info->bit_input[i / 8] |= (1 << (i % 8));
4772 			break;
4773 
4774 		case UDESCSUB_AC_OUTPUT:
4775 			info->bit_output[i / 8] |= (1 << (i % 8));
4776 			uaudio20_mixer_find_inputs_sub(
4777 			    root, &iot->u.ot_v2->bSourceId, 1, info);
4778 			info->bit_output[i / 8] &= ~(1 << (i % 8));
4779 			break;
4780 
4781 		case UDESCSUB_AC_MIXER:
4782 			uaudio_mixer_merge_outputs(&iot->usr, info);
4783 			uaudio20_mixer_find_inputs_sub(
4784 			    root, iot->u.mu_v2->baSourceId,
4785 			    iot->u.mu_v2->bNrInPins, info);
4786 			break;
4787 
4788 		case UDESCSUB_AC_SELECTOR:
4789 			uaudio_mixer_merge_outputs(&iot->usr, info);
4790 			uaudio20_mixer_find_inputs_sub(
4791 			    root, iot->u.su_v2->baSourceId,
4792 			    iot->u.su_v2->bNrInPins, info);
4793 			break;
4794 
4795 		case UDESCSUB_AC_SAMPLE_RT:
4796 			uaudio_mixer_merge_outputs(&iot->usr, info);
4797 			uaudio20_mixer_find_inputs_sub(
4798 			    root, &iot->u.ru_v2->bSourceId,
4799 			    1, info);
4800 			break;
4801 
4802 		case UDESCSUB_AC_EFFECT:
4803 			uaudio_mixer_merge_outputs(&iot->usr, info);
4804 			uaudio20_mixer_find_inputs_sub(
4805 			    root, &iot->u.ef_v2->bSourceId,
4806 			    1, info);
4807 			break;
4808 
4809 		case UDESCSUB_AC_FEATURE:
4810 			uaudio_mixer_merge_outputs(&iot->usr, info);
4811 			uaudio20_mixer_find_inputs_sub(
4812 			    root, &iot->u.fu_v2->bSourceId, 1, info);
4813 			break;
4814 
4815 		case UDESCSUB_AC_PROCESSING_V2:
4816 			uaudio_mixer_merge_outputs(&iot->usr, info);
4817 			uaudio20_mixer_find_inputs_sub(
4818 			    root, iot->u.pu_v2->baSourceId,
4819 			    iot->u.pu_v2->bNrInPins, info);
4820 			break;
4821 
4822 		case UDESCSUB_AC_EXTENSION_V2:
4823 			uaudio_mixer_merge_outputs(&iot->usr, info);
4824 			uaudio20_mixer_find_inputs_sub(
4825 			    root, iot->u.eu_v2->baSourceId,
4826 			    iot->u.eu_v2->bNrInPins, info);
4827 			break;
4828 		default:
4829 			break;
4830 		}
4831 	}
4832 }
4833 
4834 static void
4835 uaudio20_mixer_find_clocks_sub(struct uaudio_terminal_node *root,
4836     const uint8_t *p_id, uint8_t n_id,
4837     struct uaudio_search_result *info)
4838 {
4839 	struct uaudio_terminal_node *iot;
4840 	uint8_t n;
4841 	uint8_t i;
4842 	uint8_t is_last;
4843 	uint8_t id;
4844 
4845 top:
4846 	for (n = 0; n < n_id; n++) {
4847 		i = p_id[n];
4848 
4849 		if (info->recurse_level == UAUDIO_RECURSE_LIMIT) {
4850 			DPRINTF("avoided going into a circle at id=%d!\n", i);
4851 			return;
4852 		}
4853 
4854 		info->recurse_level++;
4855 
4856 		iot = (root + i);
4857 
4858 		if (iot->u.desc == NULL)
4859 			continue;
4860 
4861 		is_last = ((n + 1) == n_id);
4862 
4863 		switch (iot->u.desc->bDescriptorSubtype) {
4864 		case UDESCSUB_AC_INPUT:
4865 			info->is_input = 1;
4866 			if (is_last) {
4867 				p_id = &iot->u.it_v2->bCSourceId;
4868 				n_id = 1;
4869 				goto top;
4870 			}
4871 			uaudio20_mixer_find_clocks_sub(root,
4872 			    &iot->u.it_v2->bCSourceId, 1, info);
4873 			break;
4874 
4875 		case UDESCSUB_AC_OUTPUT:
4876 			info->is_input = 0;
4877 			if (is_last) {
4878 				p_id = &iot->u.ot_v2->bCSourceId;
4879 				n_id = 1;
4880 				goto top;
4881 			}
4882 			uaudio20_mixer_find_clocks_sub(root,
4883 			    &iot->u.ot_v2->bCSourceId, 1, info);
4884 			break;
4885 
4886 		case UDESCSUB_AC_CLOCK_SEL:
4887 			if (is_last) {
4888 				p_id = iot->u.csel_v2->baCSourceId;
4889 				n_id = iot->u.csel_v2->bNrInPins;
4890 				goto top;
4891 			}
4892 			uaudio20_mixer_find_clocks_sub(root,
4893 			    iot->u.csel_v2->baCSourceId,
4894 			    iot->u.csel_v2->bNrInPins, info);
4895 			break;
4896 
4897 		case UDESCSUB_AC_CLOCK_MUL:
4898 			if (is_last) {
4899 				p_id = &iot->u.cmul_v2->bCSourceId;
4900 				n_id = 1;
4901 				goto top;
4902 			}
4903 			uaudio20_mixer_find_clocks_sub(root,
4904 			    &iot->u.cmul_v2->bCSourceId,
4905 			    1, info);
4906 			break;
4907 
4908 		case UDESCSUB_AC_CLOCK_SRC:
4909 
4910 			id = iot->u.csrc_v2->bClockId;
4911 
4912 			switch (info->is_input) {
4913 			case 0:
4914 				info->bit_output[id / 8] |= (1 << (id % 8));
4915 				break;
4916 			case 1:
4917 				info->bit_input[id / 8] |= (1 << (id % 8));
4918 				break;
4919 			default:
4920 				break;
4921 			}
4922 			break;
4923 
4924 		default:
4925 			break;
4926 		}
4927 	}
4928 }
4929 
4930 static void
4931 uaudio_mixer_fill_info(struct uaudio_softc *sc,
4932     struct usb_device *udev, void *desc)
4933 {
4934 	const struct usb_audio_control_descriptor *acdp;
4935 	struct usb_config_descriptor *cd = usbd_get_config_descriptor(udev);
4936 	const struct usb_descriptor *dp;
4937 	const struct usb_audio_unit *au;
4938 	struct uaudio_terminal_node *iot = NULL;
4939 	uint16_t wTotalLen;
4940 	uint8_t ID_max = 0;		/* inclusive */
4941 	uint8_t i;
4942 
4943 	desc = usb_desc_foreach(cd, desc);
4944 
4945 	if (desc == NULL) {
4946 		DPRINTF("no Audio Control header\n");
4947 		goto done;
4948 	}
4949 	acdp = desc;
4950 
4951 	if ((acdp->bLength < sizeof(*acdp)) ||
4952 	    (acdp->bDescriptorType != UDESC_CS_INTERFACE) ||
4953 	    (acdp->bDescriptorSubtype != UDESCSUB_AC_HEADER)) {
4954 		DPRINTF("invalid Audio Control header\n");
4955 		goto done;
4956 	}
4957 	/* "wTotalLen" is allowed to be corrupt */
4958 	wTotalLen = UGETW(acdp->wTotalLength) - acdp->bLength;
4959 
4960 	/* get USB audio revision */
4961 	sc->sc_audio_rev = UGETW(acdp->bcdADC);
4962 
4963 	DPRINTFN(3, "found AC header, vers=%03x, len=%d\n",
4964 	    sc->sc_audio_rev, wTotalLen);
4965 
4966 	iot = malloc(sizeof(struct uaudio_terminal_node) * 256, M_TEMP,
4967 	    M_WAITOK | M_ZERO);
4968 
4969 	while ((desc = usb_desc_foreach(cd, desc))) {
4970 		dp = desc;
4971 
4972 		if (dp->bLength > wTotalLen) {
4973 			break;
4974 		} else {
4975 			wTotalLen -= dp->bLength;
4976 		}
4977 
4978 		if (sc->sc_audio_rev >= UAUDIO_VERSION_30)
4979 			au = NULL;
4980 		else if (sc->sc_audio_rev >= UAUDIO_VERSION_20)
4981 			au = uaudio20_mixer_verify_desc(dp, 0);
4982 		else
4983 			au = uaudio_mixer_verify_desc(dp, 0);
4984 
4985 		if (au) {
4986 			iot[au->bUnitId].u.desc = (const void *)au;
4987 			if (au->bUnitId > ID_max)
4988 				ID_max = au->bUnitId;
4989 		}
4990 	}
4991 
4992 	DPRINTF("Maximum ID=%d\n", ID_max);
4993 
4994 	/*
4995 	 * determine sourcing inputs for
4996 	 * all nodes in the tree:
4997 	 */
4998 	i = ID_max;
4999 	do {
5000 		if (sc->sc_audio_rev >= UAUDIO_VERSION_30) {
5001 			/* FALLTHROUGH */
5002 		} else if (sc->sc_audio_rev >= UAUDIO_VERSION_20) {
5003 			uaudio20_mixer_find_inputs_sub(iot,
5004 			    &i, 1, &((iot + i)->usr));
5005 
5006 			sc->sc_mixer_clocks.is_input = 255;
5007 			sc->sc_mixer_clocks.recurse_level = 0;
5008 
5009 			uaudio20_mixer_find_clocks_sub(iot,
5010 			    &i, 1, &sc->sc_mixer_clocks);
5011 		} else {
5012 			uaudio_mixer_find_inputs_sub(iot,
5013 			    &i, 1, &((iot + i)->usr));
5014 		}
5015 	} while (i--);
5016 
5017 	/* set "id_max" and "root" */
5018 
5019 	i = ID_max;
5020 	do {
5021 		(iot + i)->usr.id_max = ID_max;
5022 		(iot + i)->root = iot;
5023 	} while (i--);
5024 
5025 	/*
5026 	 * Scan the config to create a linked list of "mixer" nodes:
5027 	 */
5028 
5029 	i = ID_max;
5030 	do {
5031 		dp = iot[i].u.desc;
5032 
5033 		if (dp == NULL)
5034 			continue;
5035 
5036 		DPRINTFN(11, "id=%d subtype=%d\n",
5037 		    i, dp->bDescriptorSubtype);
5038 
5039 		if (sc->sc_audio_rev >= UAUDIO_VERSION_30) {
5040 			continue;
5041 		} else if (sc->sc_audio_rev >= UAUDIO_VERSION_20) {
5042 			switch (dp->bDescriptorSubtype) {
5043 			case UDESCSUB_AC_HEADER:
5044 				DPRINTF("unexpected AC header\n");
5045 				break;
5046 
5047 			case UDESCSUB_AC_INPUT:
5048 			case UDESCSUB_AC_OUTPUT:
5049 			case UDESCSUB_AC_PROCESSING_V2:
5050 			case UDESCSUB_AC_EXTENSION_V2:
5051 			case UDESCSUB_AC_EFFECT:
5052 			case UDESCSUB_AC_CLOCK_SRC:
5053 			case UDESCSUB_AC_CLOCK_SEL:
5054 			case UDESCSUB_AC_CLOCK_MUL:
5055 			case UDESCSUB_AC_SAMPLE_RT:
5056 				break;
5057 
5058 			case UDESCSUB_AC_MIXER:
5059 				uaudio20_mixer_add_mixer(sc, iot, i);
5060 				break;
5061 
5062 			case UDESCSUB_AC_SELECTOR:
5063 				uaudio20_mixer_add_selector(sc, iot, i);
5064 				break;
5065 
5066 			case UDESCSUB_AC_FEATURE:
5067 				uaudio20_mixer_add_feature(sc, iot, i);
5068 				break;
5069 
5070 			default:
5071 				DPRINTF("bad AC desc subtype=0x%02x\n",
5072 				    dp->bDescriptorSubtype);
5073 				break;
5074 			}
5075 			continue;
5076 		}
5077 
5078 		switch (dp->bDescriptorSubtype) {
5079 		case UDESCSUB_AC_HEADER:
5080 			DPRINTF("unexpected AC header\n");
5081 			break;
5082 
5083 		case UDESCSUB_AC_INPUT:
5084 		case UDESCSUB_AC_OUTPUT:
5085 			break;
5086 
5087 		case UDESCSUB_AC_MIXER:
5088 			uaudio_mixer_add_mixer(sc, iot, i);
5089 			break;
5090 
5091 		case UDESCSUB_AC_SELECTOR:
5092 			uaudio_mixer_add_selector(sc, iot, i);
5093 			break;
5094 
5095 		case UDESCSUB_AC_FEATURE:
5096 			uaudio_mixer_add_feature(sc, iot, i);
5097 			break;
5098 
5099 		case UDESCSUB_AC_PROCESSING:
5100 			uaudio_mixer_add_processing(sc, iot, i);
5101 			break;
5102 
5103 		case UDESCSUB_AC_EXTENSION:
5104 			uaudio_mixer_add_extension(sc, iot, i);
5105 			break;
5106 
5107 		default:
5108 			DPRINTF("bad AC desc subtype=0x%02x\n",
5109 			    dp->bDescriptorSubtype);
5110 			break;
5111 		}
5112 
5113 	} while (i--);
5114 
5115 done:
5116 	free(iot, M_TEMP);
5117 }
5118 
5119 static int
5120 uaudio_mixer_get(struct usb_device *udev, uint16_t audio_rev,
5121     uint8_t what, struct uaudio_mixer_node *mc)
5122 {
5123 	struct usb_device_request req;
5124 	int val;
5125 	uint8_t data[2 + (2 * 3)];
5126 	usb_error_t err;
5127 
5128 	if (mc->wValue[0] == -1)
5129 		return (0);
5130 
5131 	if (audio_rev >= UAUDIO_VERSION_30)
5132 		return (0);
5133 	else if (audio_rev >= UAUDIO_VERSION_20) {
5134 		if (what == GET_CUR) {
5135 			req.bRequest = UA20_CS_CUR;
5136 			USETW(req.wLength, 2);
5137 		} else {
5138 			req.bRequest = UA20_CS_RANGE;
5139 			USETW(req.wLength, 8);
5140 		}
5141 	} else {
5142 		uint16_t len = MIX_SIZE(mc->type);
5143 
5144 		req.bRequest = what;
5145 		USETW(req.wLength, len);
5146 	}
5147 
5148 	req.bmRequestType = UT_READ_CLASS_INTERFACE;
5149 	USETW(req.wValue, mc->wValue[0]);
5150 	USETW(req.wIndex, mc->wIndex);
5151 
5152 	memset(data, 0, sizeof(data));
5153 
5154 	err = usbd_do_request(udev, NULL, &req, data);
5155 	if (err) {
5156 		DPRINTF("err=%s\n", usbd_errstr(err));
5157 		return (0);
5158 	}
5159 
5160 	if (audio_rev >= UAUDIO_VERSION_30) {
5161 		val = 0;
5162 	} else if (audio_rev >= UAUDIO_VERSION_20) {
5163 		switch (what) {
5164 		case GET_CUR:
5165 			val = (data[0] | (data[1] << 8));
5166 			break;
5167 		case GET_MIN:
5168 			val = (data[2] | (data[3] << 8));
5169 			break;
5170 		case GET_MAX:
5171 			val = (data[4] | (data[5] << 8));
5172 			break;
5173 		case GET_RES:
5174 			val = (data[6] | (data[7] << 8));
5175 			break;
5176 		default:
5177 			val = 0;
5178 			break;
5179 		}
5180 	} else {
5181 		val = (data[0] | (data[1] << 8));
5182 	}
5183 
5184 	if (what == GET_CUR || what == GET_MIN || what == GET_MAX)
5185 		val = uaudio_mixer_signext(mc->type, val);
5186 
5187 	DPRINTFN(3, "val=%d\n", val);
5188 
5189 	return (val);
5190 }
5191 
5192 static void
5193 uaudio_mixer_write_cfg_callback(struct usb_xfer *xfer, usb_error_t error)
5194 {
5195 	struct usb_device_request req;
5196 	struct uaudio_softc *sc = usbd_xfer_softc(xfer);
5197 	struct uaudio_mixer_node *mc = sc->sc_mixer_curr;
5198 	struct usb_page_cache *pc;
5199 	uint16_t len;
5200 	uint8_t repeat = 1;
5201 	uint8_t update;
5202 	uint8_t chan;
5203 	uint8_t buf[2];
5204 
5205 	DPRINTF("\n");
5206 
5207 	switch (USB_GET_STATE(xfer)) {
5208 	case USB_ST_TRANSFERRED:
5209 tr_transferred:
5210 	case USB_ST_SETUP:
5211 tr_setup:
5212 
5213 		if (mc == NULL) {
5214 			mc = sc->sc_mixer_root;
5215 			sc->sc_mixer_curr = mc;
5216 			sc->sc_mixer_chan = 0;
5217 			repeat = 0;
5218 		}
5219 		while (mc) {
5220 			while (sc->sc_mixer_chan < mc->nchan) {
5221 				chan = sc->sc_mixer_chan;
5222 
5223 				sc->sc_mixer_chan++;
5224 
5225 				update = ((mc->update[chan / 8] & (1 << (chan % 8))) &&
5226 				    (mc->wValue[chan] != -1));
5227 
5228 				mc->update[chan / 8] &= ~(1 << (chan % 8));
5229 
5230 				if (update) {
5231 					req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
5232 					USETW(req.wValue, mc->wValue[chan]);
5233 					USETW(req.wIndex, mc->wIndex);
5234 
5235 					if (sc->sc_audio_rev >= UAUDIO_VERSION_30) {
5236 						return;
5237 					} else if (sc->sc_audio_rev >= UAUDIO_VERSION_20) {
5238 						len = 2;
5239 						req.bRequest = UA20_CS_CUR;
5240 						USETW(req.wLength, len);
5241 					} else {
5242 						len = MIX_SIZE(mc->type);
5243 						req.bRequest = SET_CUR;
5244 						USETW(req.wLength, len);
5245 					}
5246 
5247 					buf[0] = (mc->wData[chan] & 0xFF);
5248 					buf[1] = (mc->wData[chan] >> 8) & 0xFF;
5249 
5250 					pc = usbd_xfer_get_frame(xfer, 0);
5251 					usbd_copy_in(pc, 0, &req, sizeof(req));
5252 					pc = usbd_xfer_get_frame(xfer, 1);
5253 					usbd_copy_in(pc, 0, buf, len);
5254 
5255 					usbd_xfer_set_frame_len(xfer, 0, sizeof(req));
5256 					usbd_xfer_set_frame_len(xfer, 1, len);
5257 					usbd_xfer_set_frames(xfer, len ? 2 : 1);
5258 					usbd_transfer_submit(xfer);
5259 					return;
5260 				}
5261 			}
5262 
5263 			mc = mc->next;
5264 			sc->sc_mixer_curr = mc;
5265 			sc->sc_mixer_chan = 0;
5266 		}
5267 
5268 		if (repeat) {
5269 			goto tr_setup;
5270 		}
5271 		break;
5272 
5273 	default:			/* Error */
5274 		DPRINTF("error=%s\n", usbd_errstr(error));
5275 		if (error == USB_ERR_CANCELLED) {
5276 			/* do nothing - we are detaching */
5277 			break;
5278 		}
5279 		goto tr_transferred;
5280 	}
5281 }
5282 
5283 static usb_error_t
5284 uaudio_set_speed(struct usb_device *udev, uint8_t endpt, uint32_t speed)
5285 {
5286 	struct usb_device_request req;
5287 	uint8_t data[3];
5288 
5289 	DPRINTFN(6, "endpt=%d speed=%u\n", endpt, speed);
5290 
5291 	req.bmRequestType = UT_WRITE_CLASS_ENDPOINT;
5292 	req.bRequest = SET_CUR;
5293 	USETW2(req.wValue, SAMPLING_FREQ_CONTROL, 0);
5294 	USETW(req.wIndex, endpt);
5295 	USETW(req.wLength, 3);
5296 	data[0] = speed;
5297 	data[1] = speed >> 8;
5298 	data[2] = speed >> 16;
5299 
5300 	return (usbd_do_request(udev, NULL, &req, data));
5301 }
5302 
5303 static usb_error_t
5304 uaudio20_set_speed(struct usb_device *udev, uint8_t iface_no,
5305     uint8_t clockid, uint32_t speed)
5306 {
5307 	struct usb_device_request req;
5308 	uint8_t data[4];
5309 
5310 	DPRINTFN(6, "ifaceno=%d clockid=%d speed=%u\n",
5311 	    iface_no, clockid, speed);
5312 
5313 	req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
5314 	req.bRequest = UA20_CS_CUR;
5315 	USETW2(req.wValue, UA20_CS_SAM_FREQ_CONTROL, 0);
5316 	USETW2(req.wIndex, clockid, iface_no);
5317 	USETW(req.wLength, 4);
5318 	data[0] = speed;
5319 	data[1] = speed >> 8;
5320 	data[2] = speed >> 16;
5321 	data[3] = speed >> 24;
5322 
5323 	return (usbd_do_request(udev, NULL, &req, data));
5324 }
5325 
5326 static int
5327 uaudio_mixer_signext(uint8_t type, int val)
5328 {
5329 	if (!MIX_UNSIGNED(type)) {
5330 		if (MIX_SIZE(type) == 2) {
5331 			val = (int16_t)val;
5332 		} else {
5333 			val = (int8_t)val;
5334 		}
5335 	}
5336 	return (val);
5337 }
5338 
5339 static int
5340 uaudio_mixer_bsd2value(struct uaudio_mixer_node *mc, int val)
5341 {
5342 	if (mc->type == MIX_ON_OFF) {
5343 		val = (val != 0);
5344 	} else if (mc->type != MIX_SELECTOR) {
5345 		/* compute actual volume */
5346 		val = (val * mc->mul) / 100;
5347 
5348 		/* add lower offset */
5349 		val = val + mc->minval;
5350 	}
5351 	/* make sure we don't write a value out of range */
5352 	if (val > mc->maxval)
5353 		val = mc->maxval;
5354 	else if (val < mc->minval)
5355 		val = mc->minval;
5356 
5357 	DPRINTFN(6, "type=0x%03x val=%d min=%d max=%d val=%d\n",
5358 	    mc->type, val, mc->minval, mc->maxval, val);
5359 	return (val);
5360 }
5361 
5362 static void
5363 uaudio_mixer_ctl_set(struct uaudio_softc *sc, struct uaudio_mixer_node *mc,
5364     uint8_t chan, int val)
5365 {
5366 	val = uaudio_mixer_bsd2value(mc, val);
5367 
5368 	mc->update[chan / 8] |= (1 << (chan % 8));
5369 	mc->wData[chan] = val;
5370 
5371 	/* start the transfer, if not already started */
5372 
5373 	usbd_transfer_start(sc->sc_mixer_xfer[0]);
5374 }
5375 
5376 static void
5377 uaudio_mixer_init(struct uaudio_softc *sc, unsigned index)
5378 {
5379 	struct uaudio_mixer_node *mc;
5380 	int32_t i;
5381 
5382 	if (index != 0)
5383 		return;
5384 	for (mc = sc->sc_mixer_root; mc; mc = mc->next) {
5385 		if (mc->ctl != SOUND_MIXER_NRDEVICES) {
5386 			/*
5387 			 * Set device mask bits. See
5388 			 * /usr/include/machine/soundcard.h
5389 			 */
5390 			sc->sc_child[index].mix_info |= 1U << mc->ctl;
5391 		}
5392 		if ((mc->ctl == SOUND_MIXER_NRDEVICES) &&
5393 		    (mc->type == MIX_SELECTOR)) {
5394 			for (i = mc->minval; (i > 0) && (i <= mc->maxval); i++) {
5395 				if (mc->slctrtype[i - 1] == SOUND_MIXER_NRDEVICES)
5396 					continue;
5397 				sc->sc_child[index].recsrc_info |= 1U << mc->slctrtype[i - 1];
5398 			}
5399 		}
5400 	}
5401 }
5402 
5403 int
5404 uaudio_mixer_init_sub(struct uaudio_softc *sc, struct snd_mixer *m)
5405 {
5406 	unsigned i = uaudio_get_child_index_by_dev(sc, mix_get_dev(m));
5407 
5408 	DPRINTF("child=%u\n", i);
5409 
5410 	sc->sc_child[i].mixer_lock = mixer_get_lock(m);
5411 	sc->sc_child[i].mixer_dev = m;
5412 
5413 	if (i == 0 &&
5414 	    usbd_transfer_setup(sc->sc_udev, &sc->sc_mixer_iface_index,
5415 	    sc->sc_mixer_xfer, uaudio_mixer_config, 1, sc,
5416 	    sc->sc_child[i].mixer_lock)) {
5417 		DPRINTFN(0, "could not allocate USB transfer for mixer!\n");
5418 		return (ENOMEM);
5419 	}
5420 
5421 	if (sc->sc_play_chan[i].num_alt > 0 &&
5422 	    (sc->sc_child[i].mix_info & SOUND_MASK_VOLUME) == 0) {
5423 		mix_setparentchild(m, SOUND_MIXER_VOLUME, SOUND_MASK_PCM);
5424 		mix_setrealdev(m, SOUND_MIXER_VOLUME, SOUND_MIXER_NONE);
5425 	}
5426 	mix_setdevs(m, sc->sc_child[i].mix_info);
5427 	mix_setrecdevs(m, sc->sc_child[i].recsrc_info);
5428 	return (0);
5429 }
5430 
5431 int
5432 uaudio_mixer_uninit_sub(struct uaudio_softc *sc, struct snd_mixer *m)
5433 {
5434   	unsigned index = uaudio_get_child_index_by_dev(sc, mix_get_dev(m));
5435 
5436 	DPRINTF("child=%u\n", index);
5437 
5438 	if (index == 0)
5439 		usbd_transfer_unsetup(sc->sc_mixer_xfer, 1);
5440 
5441 	sc->sc_child[index].mixer_lock = NULL;
5442 
5443 	return (0);
5444 }
5445 
5446 void
5447 uaudio_mixer_set(struct uaudio_softc *sc, struct snd_mixer *m,
5448     unsigned type, unsigned left, unsigned right)
5449 {
5450     	unsigned index = uaudio_get_child_index_by_dev(sc, mix_get_dev(m));
5451 	struct uaudio_mixer_node *mc;
5452 	int chan;
5453 
5454 	if (index != 0)
5455 		return;
5456 	for (mc = sc->sc_mixer_root; mc != NULL; mc = mc->next) {
5457 		if (mc->ctl == type) {
5458 			for (chan = 0; chan < mc->nchan; chan++) {
5459 				uaudio_mixer_ctl_set(sc, mc, chan,
5460 				    chan == 0 ? left : right);
5461 			}
5462 		}
5463 	}
5464 }
5465 
5466 uint32_t
5467 uaudio_mixer_setrecsrc(struct uaudio_softc *sc, struct snd_mixer *m, uint32_t src)
5468 {
5469       	unsigned index = uaudio_get_child_index_by_dev(sc, mix_get_dev(m));
5470 	struct uaudio_mixer_node *mc;
5471 	uint32_t mask;
5472 	uint32_t temp;
5473 	int32_t i;
5474 
5475 	if (index != 0)
5476 		return (0);
5477 	for (mc = sc->sc_mixer_root; mc; mc = mc->next) {
5478 		if ((mc->ctl == SOUND_MIXER_NRDEVICES) &&
5479 		    (mc->type == MIX_SELECTOR)) {
5480 			/* compute selector mask */
5481 
5482 			mask = 0;
5483 			for (i = mc->minval; (i > 0) && (i <= mc->maxval); i++)
5484 				mask |= 1U << mc->slctrtype[i - 1];
5485 
5486 			temp = mask & src;
5487 			if (temp == 0)
5488 				continue;
5489 
5490 			/* find the first set bit */
5491 			temp = (-temp) & temp;
5492 
5493 			/* update "src" */
5494 			src &= ~mask;
5495 			src |= temp;
5496 
5497 			for (i = mc->minval; (i > 0) && (i <= mc->maxval); i++) {
5498 				if (temp != (1U << mc->slctrtype[i - 1]))
5499 					continue;
5500 				uaudio_mixer_ctl_set(sc, mc, 0, i);
5501 				break;
5502 			}
5503 		}
5504 	}
5505 	return (src);
5506 }
5507 
5508 /*========================================================================*
5509  * MIDI support routines
5510  *========================================================================*/
5511 
5512 static void
5513 umidi_bulk_read_callback(struct usb_xfer *xfer, usb_error_t error)
5514 {
5515 	struct umidi_chan *chan = usbd_xfer_softc(xfer);
5516 	struct umidi_sub_chan *sub;
5517 	struct usb_page_cache *pc;
5518 	uint8_t buf[4];
5519 	uint8_t cmd_len;
5520 	uint8_t cn;
5521 	uint16_t pos;
5522 	int actlen;
5523 
5524 	usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
5525 
5526 	switch (USB_GET_STATE(xfer)) {
5527 	case USB_ST_TRANSFERRED:
5528 
5529 		DPRINTF("actlen=%d bytes\n", actlen);
5530 
5531 		pos = 0;
5532 		pc = usbd_xfer_get_frame(xfer, 0);
5533 
5534 		while (actlen >= 4) {
5535 			/* copy out the MIDI data */
5536 			usbd_copy_out(pc, pos, buf, 4);
5537 			/* command length */
5538 			cmd_len = umidi_cmd_to_len[buf[0] & 0xF];
5539 			/* cable number */
5540 			cn = buf[0] >> 4;
5541 			/*
5542 			 * Lookup sub-channel. The index is range
5543 			 * checked below.
5544 			 */
5545 			sub = &chan->sub[cn];
5546 
5547 			if ((cmd_len != 0) && (cn < chan->max_emb_jack) &&
5548 			    (sub->read_open != 0)) {
5549 				/* Send data to the application */
5550 				usb_fifo_put_data_linear(
5551 				    sub->fifo.fp[USB_FIFO_RX],
5552 				    buf + 1, cmd_len, 1);
5553 			}
5554 			actlen -= 4;
5555 			pos += 4;
5556 		}
5557 
5558 	case USB_ST_SETUP:
5559 		DPRINTF("start\n");
5560 tr_setup:
5561 		usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
5562 		usbd_transfer_submit(xfer);
5563 		break;
5564 
5565 	default:
5566 		DPRINTF("error=%s\n", usbd_errstr(error));
5567 
5568 		if (error != USB_ERR_CANCELLED) {
5569 			/* try to clear stall first */
5570 			usbd_xfer_set_stall(xfer);
5571 			goto tr_setup;
5572 		}
5573 		break;
5574 	}
5575 }
5576 
5577 /*
5578  * The following statemachine, that converts MIDI commands to
5579  * USB MIDI packets, derives from Linux's usbmidi.c, which
5580  * was written by "Clemens Ladisch":
5581  *
5582  * Returns:
5583  *    0: No command
5584  * Else: Command is complete
5585  */
5586 static uint8_t
5587 umidi_convert_to_usb(struct umidi_sub_chan *sub, uint8_t cn, uint8_t b)
5588 {
5589 	uint8_t p0 = (cn << 4);
5590 
5591 	if (b >= 0xf8) {
5592 		sub->temp_0[0] = p0 | 0x0f;
5593 		sub->temp_0[1] = b;
5594 		sub->temp_0[2] = 0;
5595 		sub->temp_0[3] = 0;
5596 		sub->temp_cmd = sub->temp_0;
5597 		return (1);
5598 
5599 	} else if (b >= 0xf0) {
5600 		switch (b) {
5601 		case 0xf0:		/* system exclusive begin */
5602 			sub->temp_1[1] = b;
5603 			sub->state = UMIDI_ST_SYSEX_1;
5604 			break;
5605 		case 0xf1:		/* MIDI time code */
5606 		case 0xf3:		/* song select */
5607 			sub->temp_1[1] = b;
5608 			sub->state = UMIDI_ST_1PARAM;
5609 			break;
5610 		case 0xf2:		/* song position pointer */
5611 			sub->temp_1[1] = b;
5612 			sub->state = UMIDI_ST_2PARAM_1;
5613 			break;
5614 		case 0xf4:		/* unknown */
5615 		case 0xf5:		/* unknown */
5616 			sub->state = UMIDI_ST_UNKNOWN;
5617 			break;
5618 		case 0xf6:		/* tune request */
5619 			sub->temp_1[0] = p0 | 0x05;
5620 			sub->temp_1[1] = 0xf6;
5621 			sub->temp_1[2] = 0;
5622 			sub->temp_1[3] = 0;
5623 			sub->temp_cmd = sub->temp_1;
5624 			sub->state = UMIDI_ST_UNKNOWN;
5625 			return (1);
5626 
5627 		case 0xf7:		/* system exclusive end */
5628 			switch (sub->state) {
5629 			case UMIDI_ST_SYSEX_0:
5630 				sub->temp_1[0] = p0 | 0x05;
5631 				sub->temp_1[1] = 0xf7;
5632 				sub->temp_1[2] = 0;
5633 				sub->temp_1[3] = 0;
5634 				sub->temp_cmd = sub->temp_1;
5635 				sub->state = UMIDI_ST_UNKNOWN;
5636 				return (1);
5637 			case UMIDI_ST_SYSEX_1:
5638 				sub->temp_1[0] = p0 | 0x06;
5639 				sub->temp_1[2] = 0xf7;
5640 				sub->temp_1[3] = 0;
5641 				sub->temp_cmd = sub->temp_1;
5642 				sub->state = UMIDI_ST_UNKNOWN;
5643 				return (1);
5644 			case UMIDI_ST_SYSEX_2:
5645 				sub->temp_1[0] = p0 | 0x07;
5646 				sub->temp_1[3] = 0xf7;
5647 				sub->temp_cmd = sub->temp_1;
5648 				sub->state = UMIDI_ST_UNKNOWN;
5649 				return (1);
5650 			}
5651 			sub->state = UMIDI_ST_UNKNOWN;
5652 			break;
5653 		}
5654 	} else if (b >= 0x80) {
5655 		sub->temp_1[1] = b;
5656 		if ((b >= 0xc0) && (b <= 0xdf)) {
5657 			sub->state = UMIDI_ST_1PARAM;
5658 		} else {
5659 			sub->state = UMIDI_ST_2PARAM_1;
5660 		}
5661 	} else {			/* b < 0x80 */
5662 		switch (sub->state) {
5663 		case UMIDI_ST_1PARAM:
5664 			if (sub->temp_1[1] < 0xf0) {
5665 				p0 |= sub->temp_1[1] >> 4;
5666 			} else {
5667 				p0 |= 0x02;
5668 				sub->state = UMIDI_ST_UNKNOWN;
5669 			}
5670 			sub->temp_1[0] = p0;
5671 			sub->temp_1[2] = b;
5672 			sub->temp_1[3] = 0;
5673 			sub->temp_cmd = sub->temp_1;
5674 			return (1);
5675 		case UMIDI_ST_2PARAM_1:
5676 			sub->temp_1[2] = b;
5677 			sub->state = UMIDI_ST_2PARAM_2;
5678 			break;
5679 		case UMIDI_ST_2PARAM_2:
5680 			if (sub->temp_1[1] < 0xf0) {
5681 				p0 |= sub->temp_1[1] >> 4;
5682 				sub->state = UMIDI_ST_2PARAM_1;
5683 			} else {
5684 				p0 |= 0x03;
5685 				sub->state = UMIDI_ST_UNKNOWN;
5686 			}
5687 			sub->temp_1[0] = p0;
5688 			sub->temp_1[3] = b;
5689 			sub->temp_cmd = sub->temp_1;
5690 			return (1);
5691 		case UMIDI_ST_SYSEX_0:
5692 			sub->temp_1[1] = b;
5693 			sub->state = UMIDI_ST_SYSEX_1;
5694 			break;
5695 		case UMIDI_ST_SYSEX_1:
5696 			sub->temp_1[2] = b;
5697 			sub->state = UMIDI_ST_SYSEX_2;
5698 			break;
5699 		case UMIDI_ST_SYSEX_2:
5700 			sub->temp_1[0] = p0 | 0x04;
5701 			sub->temp_1[3] = b;
5702 			sub->temp_cmd = sub->temp_1;
5703 			sub->state = UMIDI_ST_SYSEX_0;
5704 			return (1);
5705 		default:
5706 			break;
5707 		}
5708 	}
5709 	return (0);
5710 }
5711 
5712 static void
5713 umidi_bulk_write_callback(struct usb_xfer *xfer, usb_error_t error)
5714 {
5715 	struct umidi_chan *chan = usbd_xfer_softc(xfer);
5716 	struct umidi_sub_chan *sub;
5717 	struct usb_page_cache *pc;
5718 	uint32_t actlen;
5719 	uint16_t nframes;
5720 	uint8_t buf;
5721 	uint8_t start_cable;
5722 	uint8_t tr_any;
5723 	int len;
5724 
5725 	usbd_xfer_status(xfer, &len, NULL, NULL, NULL);
5726 
5727 	/*
5728 	 * NOTE: Some MIDI devices only accept 4 bytes of data per
5729 	 * short terminated USB transfer.
5730 	 */
5731 	switch (USB_GET_STATE(xfer)) {
5732 	case USB_ST_TRANSFERRED:
5733 		DPRINTF("actlen=%d bytes\n", len);
5734 
5735 	case USB_ST_SETUP:
5736 tr_setup:
5737 		DPRINTF("start\n");
5738 
5739 		nframes = 0;	/* reset */
5740 		start_cable = chan->curr_cable;
5741 		tr_any = 0;
5742 		pc = usbd_xfer_get_frame(xfer, 0);
5743 
5744 		while (1) {
5745 			/* round robin de-queueing */
5746 
5747 			sub = &chan->sub[chan->curr_cable];
5748 
5749 			if (sub->write_open) {
5750 				usb_fifo_get_data_linear(sub->fifo.fp[USB_FIFO_TX],
5751 				    &buf, 1, &actlen, 0);
5752 			} else {
5753 				actlen = 0;
5754 			}
5755 
5756 			if (actlen) {
5757 				tr_any = 1;
5758 
5759 				DPRINTF("byte=0x%02x from FIFO %u\n", buf,
5760 				    (unsigned int)chan->curr_cable);
5761 
5762 				if (umidi_convert_to_usb(sub, chan->curr_cable, buf)) {
5763 					DPRINTF("sub=0x%02x 0x%02x 0x%02x 0x%02x\n",
5764 					    sub->temp_cmd[0], sub->temp_cmd[1],
5765 					    sub->temp_cmd[2], sub->temp_cmd[3]);
5766 
5767 					usbd_copy_in(pc, nframes * 4, sub->temp_cmd, 4);
5768 
5769 					nframes++;
5770 
5771 					if ((nframes >= UMIDI_TX_FRAMES) || (chan->single_command != 0))
5772 						break;
5773 				} else {
5774 					continue;
5775 				}
5776 			}
5777 
5778 			chan->curr_cable++;
5779 			if (chan->curr_cable >= chan->max_emb_jack)
5780 				chan->curr_cable = 0;
5781 
5782 			if (chan->curr_cable == start_cable) {
5783 				if (tr_any == 0)
5784 					break;
5785 				tr_any = 0;
5786 			}
5787 		}
5788 
5789 		if (nframes != 0) {
5790 			DPRINTF("Transferring %d frames\n", (int)nframes);
5791 			usbd_xfer_set_frame_len(xfer, 0, 4 * nframes);
5792 			usbd_transfer_submit(xfer);
5793 		}
5794 		break;
5795 
5796 	default:			/* Error */
5797 
5798 		DPRINTF("error=%s\n", usbd_errstr(error));
5799 
5800 		if (error != USB_ERR_CANCELLED) {
5801 			/* try to clear stall first */
5802 			usbd_xfer_set_stall(xfer);
5803 			goto tr_setup;
5804 		}
5805 		break;
5806 	}
5807 }
5808 
5809 static struct umidi_sub_chan *
5810 umidi_sub_by_fifo(struct usb_fifo *fifo)
5811 {
5812 	struct umidi_chan *chan = usb_fifo_softc(fifo);
5813 	struct umidi_sub_chan *sub;
5814 	uint32_t n;
5815 
5816 	for (n = 0; n < UMIDI_EMB_JACK_MAX; n++) {
5817 		sub = &chan->sub[n];
5818 		if ((sub->fifo.fp[USB_FIFO_RX] == fifo) ||
5819 		    (sub->fifo.fp[USB_FIFO_TX] == fifo)) {
5820 			return (sub);
5821 		}
5822 	}
5823 
5824 	panic("%s:%d cannot find usb_fifo!\n",
5825 	    __FILE__, __LINE__);
5826 
5827 	return (NULL);
5828 }
5829 
5830 static void
5831 umidi_start_read(struct usb_fifo *fifo)
5832 {
5833 	struct umidi_chan *chan = usb_fifo_softc(fifo);
5834 
5835 	usbd_transfer_start(chan->xfer[UMIDI_RX_TRANSFER]);
5836 }
5837 
5838 static void
5839 umidi_stop_read(struct usb_fifo *fifo)
5840 {
5841 	struct umidi_chan *chan = usb_fifo_softc(fifo);
5842 	struct umidi_sub_chan *sub = umidi_sub_by_fifo(fifo);
5843 
5844 	DPRINTF("\n");
5845 
5846 	sub->read_open = 0;
5847 
5848 	if (--(chan->read_open_refcount) == 0) {
5849 		/*
5850 		 * XXX don't stop the read transfer here, hence that causes
5851 		 * problems with some MIDI adapters
5852 		 */
5853 		DPRINTF("(stopping read transfer)\n");
5854 	}
5855 }
5856 
5857 static void
5858 umidi_start_write(struct usb_fifo *fifo)
5859 {
5860 	struct umidi_chan *chan = usb_fifo_softc(fifo);
5861 
5862 	if (chan->xfer[UMIDI_TX_TRANSFER] == NULL) {
5863 		uint8_t buf[1];
5864 		int actlen;
5865 		do {
5866 			/* dump data */
5867 			usb_fifo_get_data_linear(fifo, buf, 1, &actlen, 0);
5868 		} while (actlen > 0);
5869 	} else {
5870 		usbd_transfer_start(chan->xfer[UMIDI_TX_TRANSFER]);
5871 	}
5872 }
5873 
5874 static void
5875 umidi_stop_write(struct usb_fifo *fifo)
5876 {
5877 	struct umidi_chan *chan = usb_fifo_softc(fifo);
5878 	struct umidi_sub_chan *sub = umidi_sub_by_fifo(fifo);
5879 
5880 	DPRINTF("\n");
5881 
5882 	sub->write_open = 0;
5883 
5884 	if (--(chan->write_open_refcount) == 0) {
5885 		DPRINTF("(stopping write transfer)\n");
5886 		usbd_transfer_stop(chan->xfer[UMIDI_TX_TRANSFER]);
5887 	}
5888 }
5889 
5890 static int
5891 umidi_open(struct usb_fifo *fifo, int fflags)
5892 {
5893 	struct umidi_chan *chan = usb_fifo_softc(fifo);
5894 	struct umidi_sub_chan *sub = umidi_sub_by_fifo(fifo);
5895 
5896 	if (fflags & FREAD) {
5897 		if (usb_fifo_alloc_buffer(fifo, 4, (1024 / 4))) {
5898 			return (ENOMEM);
5899 		}
5900 		mtx_lock(&chan->mtx);
5901 		chan->read_open_refcount++;
5902 		sub->read_open = 1;
5903 		mtx_unlock(&chan->mtx);
5904 	}
5905 	if (fflags & FWRITE) {
5906 		if (usb_fifo_alloc_buffer(fifo, 32, (1024 / 32))) {
5907 			return (ENOMEM);
5908 		}
5909 		/* clear stall first */
5910 		mtx_lock(&chan->mtx);
5911 		chan->write_open_refcount++;
5912 		sub->write_open = 1;
5913 
5914 		/* reset */
5915 		sub->state = UMIDI_ST_UNKNOWN;
5916 		mtx_unlock(&chan->mtx);
5917 	}
5918 	return (0);			/* success */
5919 }
5920 
5921 static void
5922 umidi_close(struct usb_fifo *fifo, int fflags)
5923 {
5924 	if (fflags & FREAD) {
5925 		usb_fifo_free_buffer(fifo);
5926 	}
5927 	if (fflags & FWRITE) {
5928 		usb_fifo_free_buffer(fifo);
5929 	}
5930 }
5931 
5932 static int
5933 umidi_ioctl(struct usb_fifo *fifo, u_long cmd, void *data,
5934     int fflags)
5935 {
5936 	return (ENODEV);
5937 }
5938 
5939 static void
5940 umidi_init(device_t dev)
5941 {
5942 	struct uaudio_softc *sc = device_get_softc(dev);
5943 	struct umidi_chan *chan = &sc->sc_midi_chan;
5944 
5945 	mtx_init(&chan->mtx, "umidi lock", NULL, MTX_DEF | MTX_RECURSE);
5946 }
5947 
5948 static struct usb_fifo_methods umidi_fifo_methods = {
5949 	.f_start_read = &umidi_start_read,
5950 	.f_start_write = &umidi_start_write,
5951 	.f_stop_read = &umidi_stop_read,
5952 	.f_stop_write = &umidi_stop_write,
5953 	.f_open = &umidi_open,
5954 	.f_close = &umidi_close,
5955 	.f_ioctl = &umidi_ioctl,
5956 	.basename[0] = "umidi",
5957 };
5958 
5959 static int
5960 umidi_probe(device_t dev)
5961 {
5962 	struct uaudio_softc *sc = device_get_softc(dev);
5963 	struct usb_attach_arg *uaa = device_get_ivars(dev);
5964 	struct umidi_chan *chan = &sc->sc_midi_chan;
5965 	struct umidi_sub_chan *sub;
5966 	int unit = device_get_unit(dev);
5967 	int error;
5968 	uint32_t n;
5969 
5970 	if (usb_test_quirk(uaa, UQ_SINGLE_CMD_MIDI))
5971 		chan->single_command = 1;
5972 
5973 	error = usbd_set_alt_interface_index(sc->sc_udev,
5974 	    chan->iface_index, chan->iface_alt_index);
5975 	if (error) {
5976 		DPRINTF("setting of alternate index failed: %s\n",
5977 		    usbd_errstr(error));
5978 		goto detach;
5979 	}
5980 	usbd_set_parent_iface(sc->sc_udev, chan->iface_index,
5981 	    sc->sc_mixer_iface_index);
5982 
5983 	error = usbd_transfer_setup(uaa->device, &chan->iface_index,
5984 	    chan->xfer, umidi_config, UMIDI_N_TRANSFER,
5985 	    chan, &chan->mtx);
5986 	if (error) {
5987 		DPRINTF("error=%s\n", usbd_errstr(error));
5988 		goto detach;
5989 	}
5990 	if (chan->xfer[UMIDI_TX_TRANSFER] == NULL &&
5991 	    chan->xfer[UMIDI_RX_TRANSFER] == NULL) {
5992 		DPRINTF("no BULK or INTERRUPT MIDI endpoint(s) found\n");
5993 		goto detach;
5994 	}
5995 
5996 	/*
5997 	 * Some USB MIDI device makers couldn't resist using
5998 	 * wMaxPacketSize = 4 for RX and TX BULK endpoints, although
5999 	 * that size is an unsupported value for FULL speed BULK
6000 	 * endpoints. The same applies to some HIGH speed MIDI devices
6001 	 * which are using a wMaxPacketSize different from 512 bytes.
6002 	 *
6003 	 * Refer to section 5.8.3 in USB 2.0 PDF: Cite: "All Host
6004 	 * Controllers are required to have support for 8-, 16-, 32-,
6005 	 * and 64-byte maximum packet sizes for full-speed bulk
6006 	 * endpoints and 512 bytes for high-speed bulk endpoints."
6007 	 */
6008 	if (chan->xfer[UMIDI_TX_TRANSFER] != NULL &&
6009 	    usbd_xfer_maxp_was_clamped(chan->xfer[UMIDI_TX_TRANSFER]))
6010 		chan->single_command = 1;
6011 
6012 	if (chan->single_command != 0)
6013 		device_printf(dev, "Single command MIDI quirk enabled\n");
6014 
6015 	if ((chan->max_emb_jack == 0) ||
6016 	    (chan->max_emb_jack > UMIDI_EMB_JACK_MAX)) {
6017 		chan->max_emb_jack = UMIDI_EMB_JACK_MAX;
6018 	}
6019 
6020 	for (n = 0; n < chan->max_emb_jack; n++) {
6021 		sub = &chan->sub[n];
6022 
6023 		error = usb_fifo_attach(sc->sc_udev, chan, &chan->mtx,
6024 		    &umidi_fifo_methods, &sub->fifo, unit, n,
6025 		    chan->iface_index,
6026 		    UID_ROOT, GID_OPERATOR, 0666);
6027 		if (error) {
6028 			goto detach;
6029 		}
6030 	}
6031 
6032 	mtx_lock(&chan->mtx);
6033 
6034 	/*
6035 	 * NOTE: At least one device will not work properly unless the
6036 	 * BULK IN pipe is open all the time. This might have to do
6037 	 * about that the internal queues of the device overflow if we
6038 	 * don't read them regularly.
6039 	 */
6040 	usbd_transfer_start(chan->xfer[UMIDI_RX_TRANSFER]);
6041 
6042 	mtx_unlock(&chan->mtx);
6043 
6044 	return (0);			/* success */
6045 
6046 detach:
6047 	return (ENXIO);			/* failure */
6048 }
6049 
6050 static int
6051 umidi_detach(device_t dev)
6052 {
6053 	struct uaudio_softc *sc = device_get_softc(dev);
6054 	struct umidi_chan *chan = &sc->sc_midi_chan;
6055 	uint32_t n;
6056 
6057 	for (n = 0; n < UMIDI_EMB_JACK_MAX; n++)
6058 		usb_fifo_detach(&chan->sub[n].fifo);
6059 
6060 	mtx_lock(&chan->mtx);
6061 
6062 	usbd_transfer_stop(chan->xfer[UMIDI_RX_TRANSFER]);
6063 
6064 	mtx_unlock(&chan->mtx);
6065 
6066 	usbd_transfer_unsetup(chan->xfer, UMIDI_N_TRANSFER);
6067 
6068 	mtx_destroy(&chan->mtx);
6069 
6070 	return (0);
6071 }
6072 
6073 static void
6074 uaudio_hid_rx_callback(struct usb_xfer *xfer, usb_error_t error)
6075 {
6076 	struct uaudio_softc *sc = usbd_xfer_softc(xfer);
6077 	const uint8_t *buffer = usbd_xfer_get_frame_buffer(xfer, 0);
6078 	struct snd_mixer *m;
6079 	uint8_t id;
6080 	int actlen;
6081 
6082 	usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
6083 
6084 	switch (USB_GET_STATE(xfer)) {
6085 	case USB_ST_TRANSFERRED:
6086 		DPRINTF("actlen=%d\n", actlen);
6087 
6088 		if (actlen != 0 &&
6089 		    (sc->sc_hid.flags & UAUDIO_HID_HAS_ID)) {
6090 			id = *buffer;
6091 			buffer++;
6092 			actlen--;
6093 		} else {
6094 			id = 0;
6095 		}
6096 
6097 		m = sc->sc_child[0].mixer_dev;
6098 
6099 		if ((sc->sc_hid.flags & UAUDIO_HID_HAS_MUTE) &&
6100 		    (sc->sc_hid.mute_id == id) &&
6101 		    hid_get_data(buffer, actlen,
6102 		    &sc->sc_hid.mute_loc)) {
6103 			DPRINTF("Mute toggle\n");
6104 
6105 			mixer_hwvol_mute_locked(m);
6106 		}
6107 
6108 		if ((sc->sc_hid.flags & UAUDIO_HID_HAS_VOLUME_UP) &&
6109 		    (sc->sc_hid.volume_up_id == id) &&
6110 		    hid_get_data(buffer, actlen,
6111 		    &sc->sc_hid.volume_up_loc)) {
6112 			DPRINTF("Volume Up\n");
6113 
6114 			mixer_hwvol_step_locked(m, 1, 1);
6115 		}
6116 
6117 		if ((sc->sc_hid.flags & UAUDIO_HID_HAS_VOLUME_DOWN) &&
6118 		    (sc->sc_hid.volume_down_id == id) &&
6119 		    hid_get_data(buffer, actlen,
6120 		    &sc->sc_hid.volume_down_loc)) {
6121 			DPRINTF("Volume Down\n");
6122 
6123 			mixer_hwvol_step_locked(m, -1, -1);
6124 		}
6125 
6126 	case USB_ST_SETUP:
6127 tr_setup:
6128 		/* check if we can put more data into the FIFO */
6129 		usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
6130 		usbd_transfer_submit(xfer);
6131 		break;
6132 
6133 	default:			/* Error */
6134 
6135 		DPRINTF("error=%s\n", usbd_errstr(error));
6136 
6137 		if (error != USB_ERR_CANCELLED) {
6138 			/* try to clear stall first */
6139 			usbd_xfer_set_stall(xfer);
6140 			goto tr_setup;
6141 		}
6142 		break;
6143 	}
6144 }
6145 
6146 static int
6147 uaudio_hid_probe(struct uaudio_softc *sc,
6148     struct usb_attach_arg *uaa)
6149 {
6150 	void *d_ptr;
6151 	uint32_t flags;
6152 	uint16_t d_len;
6153 	uint8_t id;
6154 	int error;
6155 
6156 	if (!(sc->sc_hid.flags & UAUDIO_HID_VALID))
6157 		return (-1);
6158 
6159 	if (sc->sc_child[0].mixer_lock == NULL)
6160 		return (-1);
6161 
6162 	/* Get HID descriptor */
6163 	error = usbd_req_get_hid_desc(uaa->device, NULL, &d_ptr,
6164 	    &d_len, M_TEMP, sc->sc_hid.iface_index);
6165 
6166 	if (error) {
6167 		DPRINTF("error reading report description\n");
6168 		return (-1);
6169 	}
6170 
6171 	/* check if there is an ID byte */
6172 	hid_report_size_max(d_ptr, d_len, hid_input, &id);
6173 
6174 	if (id != 0)
6175 		sc->sc_hid.flags |= UAUDIO_HID_HAS_ID;
6176 
6177 	if (hid_locate(d_ptr, d_len,
6178 	    HID_USAGE2(HUP_CONSUMER, 0xE9 /* Volume Increment */),
6179 	    hid_input, 0, &sc->sc_hid.volume_up_loc, &flags,
6180 	    &sc->sc_hid.volume_up_id)) {
6181 		if (flags & HIO_VARIABLE)
6182 			sc->sc_hid.flags |= UAUDIO_HID_HAS_VOLUME_UP;
6183 		DPRINTFN(1, "Found Volume Up key\n");
6184 	}
6185 
6186 	if (hid_locate(d_ptr, d_len,
6187 	    HID_USAGE2(HUP_CONSUMER, 0xEA /* Volume Decrement */),
6188 	    hid_input, 0, &sc->sc_hid.volume_down_loc, &flags,
6189 	    &sc->sc_hid.volume_down_id)) {
6190 		if (flags & HIO_VARIABLE)
6191 			sc->sc_hid.flags |= UAUDIO_HID_HAS_VOLUME_DOWN;
6192 		DPRINTFN(1, "Found Volume Down key\n");
6193 	}
6194 
6195 	if (hid_locate(d_ptr, d_len,
6196 	    HID_USAGE2(HUP_CONSUMER, 0xE2 /* Mute */),
6197 	    hid_input, 0, &sc->sc_hid.mute_loc, &flags,
6198 	    &sc->sc_hid.mute_id)) {
6199 		if (flags & HIO_VARIABLE)
6200 			sc->sc_hid.flags |= UAUDIO_HID_HAS_MUTE;
6201 		DPRINTFN(1, "Found Mute key\n");
6202 	}
6203 
6204 	free(d_ptr, M_TEMP);
6205 
6206 	if (!(sc->sc_hid.flags & (UAUDIO_HID_HAS_VOLUME_UP |
6207 	    UAUDIO_HID_HAS_VOLUME_DOWN |
6208 	    UAUDIO_HID_HAS_MUTE))) {
6209 		DPRINTFN(1, "Did not find any volume related keys\n");
6210 		return (-1);
6211 	}
6212 
6213 	/* prevent the uhid driver from attaching */
6214 	usbd_set_parent_iface(uaa->device, sc->sc_hid.iface_index,
6215 	    sc->sc_mixer_iface_index);
6216 
6217 	/* allocate USB transfers */
6218 	error = usbd_transfer_setup(uaa->device, &sc->sc_hid.iface_index,
6219 	    sc->sc_hid.xfer, uaudio_hid_config, UAUDIO_HID_N_TRANSFER,
6220 	    sc, sc->sc_child[0].mixer_lock);
6221 	if (error) {
6222 		DPRINTF("error=%s\n", usbd_errstr(error));
6223 		return (-1);
6224 	}
6225 	return (0);
6226 }
6227 
6228 static void
6229 uaudio_hid_detach(struct uaudio_softc *sc)
6230 {
6231 	usbd_transfer_unsetup(sc->sc_hid.xfer, UAUDIO_HID_N_TRANSFER);
6232 }
6233 
6234 DRIVER_MODULE_ORDERED(uaudio, uhub, uaudio_driver, NULL, NULL, SI_ORDER_ANY);
6235 MODULE_DEPEND(uaudio, usb, 1, 1, 1);
6236 MODULE_DEPEND(uaudio, sound, SOUND_MINVER, SOUND_PREFVER, SOUND_MAXVER);
6237 MODULE_DEPEND(uaudio, hid, 1, 1, 1);
6238 MODULE_VERSION(uaudio, 1);
6239 USB_PNP_HOST_INFO(uaudio_devs);
6240 USB_PNP_HOST_INFO(uaudio_vendor_midi);
6241