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