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