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