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
1208 device_set_descf(dev, "%s %s",
1209 usb_get_manufacturer(sc->sc_udev),
1210 usb_get_product(sc->sc_udev));
1211
1212 snprintf(status, sizeof(status), "on %s",
1213 device_get_nameunit(device_get_parent(dev)));
1214
1215 pcm_init(dev, sc);
1216
1217 uaudio_pcm_setflags(dev, SD_F_MPSAFE);
1218
1219 if (mixer_init(dev, mixer_class, sc))
1220 goto detach;
1221 mix_set(sc->sc_child[i].mixer_dev, SOUND_MIXER_MONITOR,
1222 UAUDIO_DEFAULT_MONITOR, UAUDIO_DEFAULT_MONITOR);
1223 sc->sc_child[i].mixer_init = 1;
1224
1225 mixer_hwvol_init(dev);
1226
1227 if (sc->sc_play_chan[i].num_alt > 0) {
1228 sc->sc_play_chan[i].priv_sc = sc;
1229 pcm_addchan(dev, PCMDIR_PLAY, chan_class,
1230 &sc->sc_play_chan[i]);
1231 }
1232
1233 if (sc->sc_rec_chan[i].num_alt > 0) {
1234 sc->sc_rec_chan[i].priv_sc = sc;
1235 pcm_addchan(dev, PCMDIR_REC, chan_class,
1236 &sc->sc_rec_chan[i]);
1237 }
1238 if (pcm_register(dev, status))
1239 goto detach;
1240 sc->sc_child[i].pcm_registered = 1;
1241
1242 uaudio_mixer_register_sysctl(sc, dev, i);
1243
1244 SYSCTL_ADD_INT(device_get_sysctl_ctx(dev),
1245 SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO,
1246 "feedback_rate", CTLFLAG_RD, &sc->sc_play_chan[i].feedback_rate,
1247 0, "Feedback sample rate in Hz");
1248
1249 return (0); /* success */
1250
1251 detach:
1252 uaudio_detach_sub(dev);
1253 return (ENXIO);
1254 }
1255
1256 int
uaudio_detach_sub(device_t dev)1257 uaudio_detach_sub(device_t dev)
1258 {
1259 struct uaudio_softc *sc = device_get_softc(device_get_parent(dev));
1260 unsigned i = uaudio_get_child_index_by_dev(sc, dev);
1261 int error = 0;
1262
1263 if (sc->sc_child[i].pcm_registered) {
1264 error = pcm_unregister(dev);
1265 } else if (sc->sc_child[i].mixer_init) {
1266 error = mixer_uninit(dev);
1267 }
1268
1269 return (error);
1270 }
1271
1272 static int
uaudio_detach(device_t dev)1273 uaudio_detach(device_t dev)
1274 {
1275 struct uaudio_softc *sc = device_get_softc(dev);
1276 unsigned i;
1277
1278 /*
1279 * Stop USB transfers early so that any audio applications
1280 * will time out and close opened /dev/dspX.Y device(s), if
1281 * any.
1282 */
1283 usb_proc_explore_lock(sc->sc_udev);
1284 for (i = 0; i != UAUDIO_MAX_CHILD; i++) {
1285 sc->sc_play_chan[i].operation = CHAN_OP_DRAIN;
1286 sc->sc_rec_chan[i].operation = CHAN_OP_DRAIN;
1287 }
1288 usb_proc_explore_mwait(sc->sc_udev,
1289 &sc->sc_config_msg[0], &sc->sc_config_msg[1]);
1290 usb_proc_explore_unlock(sc->sc_udev);
1291
1292 for (i = 0; i != UAUDIO_MAX_CHILD; i++) {
1293 usbd_transfer_unsetup(sc->sc_play_chan[i].xfer, UAUDIO_NCHANBUFS + 1);
1294 usbd_transfer_unsetup(sc->sc_rec_chan[i].xfer, UAUDIO_NCHANBUFS + 1);
1295 }
1296
1297 uaudio_hid_detach(sc);
1298
1299 if (bus_generic_detach(dev) != 0) {
1300 DPRINTF("detach failed!\n");
1301 }
1302
1303 umidi_detach(dev);
1304
1305 /* free mixer data */
1306
1307 uaudio_mixer_ctl_free(sc);
1308
1309 /* disable S/PDIF output, if any */
1310 (void) sc->sc_set_spdif_fn(sc, 0);
1311
1312 return (0);
1313 }
1314
1315 static uint32_t
uaudio_get_interval_frames(const usb_endpoint_descriptor_audio_t * ed)1316 uaudio_get_interval_frames(const usb_endpoint_descriptor_audio_t *ed)
1317 {
1318 uint32_t frames = 1;
1319 /* Isochronous transfer interval is 2^(bInterval - 1) frames. */
1320 if (ed->bInterval >= 1 && ed->bInterval <= 16)
1321 frames = (1 << (ed->bInterval - 1));
1322 /* Limit transfer interval to maximum number of frames. */
1323 if (frames > UAUDIO_NFRAMES)
1324 frames = UAUDIO_NFRAMES;
1325 return (frames);
1326 }
1327
1328 static uint32_t
uaudio_get_buffer_ms(struct uaudio_softc * sc,uint32_t int_frames)1329 uaudio_get_buffer_ms(struct uaudio_softc *sc, uint32_t int_frames)
1330 {
1331 uint32_t ms = 1;
1332 uint32_t fps = usbd_get_isoc_fps(sc->sc_udev);
1333 /* Make sure a whole USB transfer interval fits into the buffer. */
1334 if (fps >= 1000 && int_frames > 0 && int_frames <= UAUDIO_NFRAMES) {
1335 /* Convert interval frames to milliseconds. */
1336 ms = ((int_frames * 1000) / fps);
1337 }
1338 /* Respect minimum buffer length set through buffer_ms tunable. */
1339 if (ms < uaudio_buffer_ms)
1340 ms = uaudio_buffer_ms;
1341 /* Limit buffer length to 8 milliseconds. */
1342 if (ms > UAUDIO_BUFFER_MS_MAX)
1343 ms = UAUDIO_BUFFER_MS_MAX;
1344 return (ms);
1345 }
1346
1347 static uint32_t
uaudio_get_buffer_size(struct uaudio_chan * ch,uint8_t alt)1348 uaudio_get_buffer_size(struct uaudio_chan *ch, uint8_t alt)
1349 {
1350 struct uaudio_chan_alt *chan_alt = &ch->usb_alt[alt];
1351 uint32_t int_frames, ms, buf_size;
1352 /* USB transfer interval in frames, from endpoint descriptor. */
1353 int_frames = uaudio_get_interval_frames(chan_alt->p_ed1);
1354 /* Buffer length in milliseconds, and in bytes of audio data. */
1355 ms = uaudio_get_buffer_ms(ch->priv_sc, int_frames);
1356 buf_size = chan_alt->sample_size *
1357 howmany(chan_alt->sample_rate * ms, 1000);
1358 return (buf_size);
1359 }
1360
1361 static uint32_t
uaudio_max_buffer_size(struct uaudio_chan * ch,uint8_t alt)1362 uaudio_max_buffer_size(struct uaudio_chan *ch, uint8_t alt)
1363 {
1364 struct uaudio_chan_alt *chan_alt = &ch->usb_alt[alt];
1365 uint32_t buf_size;
1366 /* Maximum buffer length is 8 milliseconds. */
1367 buf_size = chan_alt->sample_size *
1368 howmany(chan_alt->sample_rate * UAUDIO_BUFFER_MS_MAX, 1000);
1369 return (buf_size);
1370 }
1371
1372 static bool
uaudio20_clock_is_shared(struct uaudio_softc * sc,unsigned int x)1373 uaudio20_clock_is_shared(struct uaudio_softc *sc, unsigned int x)
1374 {
1375 /*
1376 * A clock entity that feeds both an OUTPUT (playback) and an
1377 * INPUT (capture) terminal shows up in both bitmaps: it is a
1378 * sample clock shared between the two directions.
1379 */
1380 return ((sc->sc_mixer_clocks.bit_output[x / 8] & (1 << (x % 8))) != 0 &&
1381 (sc->sc_mixer_clocks.bit_input[x / 8] & (1 << (x % 8))) != 0);
1382 }
1383
1384 static uint32_t
uaudio_dir_running_rate(struct uaudio_chan * chans)1385 uaudio_dir_running_rate(struct uaudio_chan *chans)
1386 {
1387 unsigned int i;
1388
1389 for (i = 0; i != UAUDIO_MAX_CHILD; i++) {
1390 struct uaudio_chan *ch = &chans[i];
1391
1392 if (ch->running != 0 && ch->cur_alt < ch->num_alt)
1393 return (ch->usb_alt[ch->cur_alt].sample_rate);
1394 }
1395 return (0); /* nothing streaming in this direction */
1396 }
1397
1398 static bool
uaudio_chan_match_rate(struct uaudio_chan * ch,uint32_t rate,uint8_t * p_alt)1399 uaudio_chan_match_rate(struct uaudio_chan *ch, uint32_t rate, uint8_t *p_alt)
1400 {
1401 uint8_t x;
1402
1403 for (x = 0; x != ch->num_alt; x++) {
1404 if (ch->usb_alt[x].sample_rate == rate) {
1405 *p_alt = x;
1406 return (true);
1407 }
1408 }
1409 return (false);
1410 }
1411
1412 static void
uaudio_configure_msg_sub(struct uaudio_softc * sc,struct uaudio_chan * chan,int dir)1413 uaudio_configure_msg_sub(struct uaudio_softc *sc,
1414 struct uaudio_chan *chan, int dir)
1415 {
1416 struct uaudio_chan_alt *chan_alt;
1417 uint32_t frames;
1418 uint32_t buf_size;
1419 uint16_t fps;
1420 uint8_t next_alt;
1421 uint8_t fps_shift;
1422 uint8_t operation;
1423 usb_error_t err;
1424
1425 if (chan->num_alt <= 0)
1426 return;
1427
1428 DPRINTF("\n");
1429
1430 usb_proc_explore_lock(sc->sc_udev);
1431 operation = chan->operation;
1432 switch (operation) {
1433 case CHAN_OP_START:
1434 case CHAN_OP_STOP:
1435 chan->operation = CHAN_OP_NONE;
1436 break;
1437 default:
1438 break;
1439 }
1440 usb_proc_explore_unlock(sc->sc_udev);
1441
1442 switch (operation) {
1443 case CHAN_OP_STOP:
1444 /* Unsetup prior USB transfers, if any. */
1445 usbd_transfer_unsetup(chan->xfer, UAUDIO_NCHANBUFS + 1);
1446
1447 mtx_lock(&chan->lock);
1448 chan->cur_alt = CHAN_MAX_ALT;
1449 mtx_unlock(&chan->lock);
1450
1451 /*
1452 * The first alternate setting is typically used for
1453 * power saving mode. Set this alternate setting as
1454 * part of entering stop.
1455 */
1456 err = usbd_set_alt_interface_index(sc->sc_udev, chan->iface_index, 0);
1457 if (err) {
1458 DPRINTF("setting of default alternate index failed: %s!\n",
1459 usbd_errstr(err));
1460 }
1461 return;
1462
1463 case CHAN_OP_START:
1464 /* Unsetup prior USB transfers, if any. */
1465 usbd_transfer_unsetup(chan->xfer, UAUDIO_NCHANBUFS + 1);
1466 break;
1467
1468 default:
1469 return;
1470 }
1471
1472 mtx_lock(&chan->lock);
1473 next_alt = chan->set_alt;
1474 mtx_unlock(&chan->lock);
1475
1476 chan_alt = chan->usb_alt + next_alt;
1477
1478 err = usbd_set_alt_interface_index(sc->sc_udev,
1479 chan_alt->iface_index, chan_alt->iface_alt_index);
1480 if (err) {
1481 DPRINTF("setting of alternate index failed: %s!\n",
1482 usbd_errstr(err));
1483 goto error;
1484 }
1485
1486 /*
1487 * Only set the sample rate if the channel reports that it
1488 * supports the frequency control.
1489 */
1490
1491 if (sc->sc_audio_rev >= UAUDIO_VERSION_30) {
1492 /* FALLTHROUGH */
1493 } else if (sc->sc_audio_rev >= UAUDIO_VERSION_20) {
1494 unsigned int x;
1495
1496 for (x = 0; x != 256; x++) {
1497 if (dir == PCMDIR_PLAY) {
1498 if (!(sc->sc_mixer_clocks.bit_output[x / 8] &
1499 (1 << (x % 8)))) {
1500 continue;
1501 }
1502 } else {
1503 if (!(sc->sc_mixer_clocks.bit_input[x / 8] &
1504 (1 << (x % 8)))) {
1505 continue;
1506 }
1507 }
1508
1509 /*
1510 * Shared-clock guard. If this clock entity is
1511 * shared between the playback and capture paths,
1512 * and the OTHER direction is already streaming at
1513 * a different rate, do not reprogram the clock --
1514 * the rate that is already locked wins. This
1515 * stops an idle or secondary stream from yanking
1516 * the shared clock out from under an active
1517 * stream and dropping USB stream lock. The first
1518 * active stream owns the clock; a later one
1519 * follows it (see uaudio_chan_start(), which
1520 * re-aligns the jitter-info record stream to the
1521 * playback rate before it is started).
1522 */
1523 if (uaudio20_clock_is_shared(sc, x)) {
1524 uint32_t other = (dir == PCMDIR_PLAY) ?
1525 uaudio_dir_running_rate(sc->sc_rec_chan) :
1526 uaudio_dir_running_rate(sc->sc_play_chan);
1527
1528 if (other != 0 &&
1529 other != chan_alt->sample_rate) {
1530 DPRINTF("shared clock ID=%u busy at "
1531 "%u Hz; not reprogramming to "
1532 "%u Hz\n", x, other,
1533 chan_alt->sample_rate);
1534 continue;
1535 }
1536 }
1537
1538 if (uaudio20_set_speed(sc->sc_udev,
1539 sc->sc_mixer_iface_no, x, chan_alt->sample_rate)) {
1540 /*
1541 * If the endpoint is adaptive setting
1542 * the speed may fail.
1543 */
1544 DPRINTF("setting of sample rate failed! "
1545 "(continuing anyway)\n");
1546 }
1547 }
1548 } else if (chan_alt->p_sed.v1->bmAttributes & UA_SED_FREQ_CONTROL) {
1549 if (uaudio_set_speed(sc->sc_udev,
1550 chan_alt->p_ed1->bEndpointAddress, chan_alt->sample_rate)) {
1551 /*
1552 * If the endpoint is adaptive setting the
1553 * speed may fail.
1554 */
1555 DPRINTF("setting of sample rate failed! "
1556 "(continuing anyway)\n");
1557 }
1558 }
1559 if (usbd_transfer_setup(sc->sc_udev, &chan_alt->iface_index, chan->xfer,
1560 chan_alt->usb_cfg, UAUDIO_NCHANBUFS + 1, chan, &chan->lock)) {
1561 DPRINTF("could not allocate USB transfers!\n");
1562 goto error;
1563 }
1564
1565 fps = usbd_get_isoc_fps(sc->sc_udev);
1566
1567 if (fps < 8000) {
1568 /* FULL speed USB */
1569 frames = uaudio_buffer_ms;
1570 } else {
1571 /* HIGH speed USB */
1572 frames = uaudio_buffer_ms * 8;
1573 }
1574
1575 fps_shift = usbd_xfer_get_fps_shift(chan->xfer[0]);
1576
1577 /* down shift number of frames per second, if any */
1578 fps >>= fps_shift;
1579 frames >>= fps_shift;
1580
1581 /* bytes per frame should not be zero */
1582 chan->bytes_per_frame[0] =
1583 ((chan_alt->sample_rate / fps) * chan_alt->sample_size);
1584 chan->bytes_per_frame[1] = howmany(chan_alt->sample_rate, fps) *
1585 chan_alt->sample_size;
1586
1587 /* setup data rate dithering, if any */
1588 chan->frames_per_second = fps;
1589 chan->sample_rem = chan_alt->sample_rate % fps;
1590 chan->sample_curr = 0;
1591
1592 /* compute required buffer size */
1593 buf_size = (chan->bytes_per_frame[1] * frames);
1594
1595 if (buf_size > (chan->end - chan->start)) {
1596 DPRINTF("buffer size is too big\n");
1597 goto error;
1598 }
1599
1600 chan->intr_frames = frames;
1601
1602 DPRINTF("fps=%d sample_rem=%d\n", (int)fps, (int)chan->sample_rem);
1603
1604 if (chan->intr_frames == 0) {
1605 DPRINTF("frame shift is too high!\n");
1606 goto error;
1607 }
1608
1609 #if (UAUDIO_NCHANBUFS != 2)
1610 #error "Please update code below!"
1611 #endif
1612
1613 mtx_lock(&chan->lock);
1614 chan->cur_alt = next_alt;
1615 usbd_transfer_start(chan->xfer[0]);
1616 usbd_transfer_start(chan->xfer[1]);
1617 mtx_unlock(&chan->lock);
1618 return;
1619 error:
1620 usbd_transfer_unsetup(chan->xfer, UAUDIO_NCHANBUFS + 1);
1621
1622 mtx_lock(&chan->lock);
1623 chan->cur_alt = CHAN_MAX_ALT;
1624 mtx_unlock(&chan->lock);
1625 }
1626
1627 static void
uaudio_configure_msg(struct usb_proc_msg * pm)1628 uaudio_configure_msg(struct usb_proc_msg *pm)
1629 {
1630 struct uaudio_softc *sc = ((struct uaudio_configure_msg *)pm)->sc;
1631 unsigned i;
1632
1633 usb_proc_explore_unlock(sc->sc_udev);
1634 for (i = 0; i != UAUDIO_MAX_CHILD; i++) {
1635 uaudio_configure_msg_sub(sc, &sc->sc_play_chan[i], PCMDIR_PLAY);
1636 uaudio_configure_msg_sub(sc, &sc->sc_rec_chan[i], PCMDIR_REC);
1637 }
1638 usb_proc_explore_lock(sc->sc_udev);
1639 }
1640
1641 /*========================================================================*
1642 * AS - Audio Stream - routines
1643 *========================================================================*/
1644
1645 #ifdef USB_DEBUG
1646 static void
uaudio_chan_dump_ep_desc(const usb_endpoint_descriptor_audio_t * ed)1647 uaudio_chan_dump_ep_desc(const usb_endpoint_descriptor_audio_t *ed)
1648 {
1649 if (ed) {
1650 DPRINTF("endpoint=%p bLength=%d bDescriptorType=%d \n"
1651 "bEndpointAddress=%d bmAttributes=0x%x \n"
1652 "wMaxPacketSize=%d bInterval=%d \n"
1653 "bRefresh=%d bSynchAddress=%d\n",
1654 ed, ed->bLength, ed->bDescriptorType,
1655 ed->bEndpointAddress, ed->bmAttributes,
1656 UGETW(ed->wMaxPacketSize), ed->bInterval,
1657 UEP_HAS_REFRESH(ed) ? ed->bRefresh : 0,
1658 UEP_HAS_SYNCADDR(ed) ? ed->bSynchAddress : 0);
1659 }
1660 }
1661
1662 #endif
1663
1664 /*
1665 * The following is a workaround for broken no-name USB audio devices
1666 * sold by dealextreme called "3D sound". The problem is that the
1667 * manufacturer computed wMaxPacketSize is too small to hold the
1668 * actual data sent. In other words the device sometimes sends more
1669 * data than it actually reports it can send in a single isochronous
1670 * packet.
1671 */
1672 static void
uaudio_record_fix_fs(usb_endpoint_descriptor_audio_t * ep,uint32_t xps,uint32_t add)1673 uaudio_record_fix_fs(usb_endpoint_descriptor_audio_t *ep,
1674 uint32_t xps, uint32_t add)
1675 {
1676 uint32_t mps;
1677
1678 mps = UGETW(ep->wMaxPacketSize);
1679
1680 /*
1681 * If the device indicates it can send more data than what the
1682 * sample rate indicates, we apply the workaround.
1683 */
1684 if (mps > xps) {
1685 /* allow additional data */
1686 xps += add;
1687
1688 /* check against the maximum USB 1.x length */
1689 if (xps > 1023)
1690 xps = 1023;
1691
1692 /* check if we should do an update */
1693 if (mps < xps) {
1694 /* simply update the wMaxPacketSize field */
1695 USETW(ep->wMaxPacketSize, xps);
1696 DPRINTF("Workaround: Updated wMaxPacketSize "
1697 "from %d to %d bytes.\n",
1698 (int)mps, (int)xps);
1699 }
1700 }
1701 }
1702
1703 static usb_error_t
uaudio20_check_rate(struct usb_device * udev,uint8_t iface_no,uint8_t clockid,uint32_t rate)1704 uaudio20_check_rate(struct usb_device *udev, uint8_t iface_no,
1705 uint8_t clockid, uint32_t rate)
1706 {
1707 struct usb_device_request req;
1708 usb_error_t error;
1709 #define UAUDIO20_MAX_RATES 32 /* we support at maximum 32 rates */
1710 uint8_t data[2 + UAUDIO20_MAX_RATES * 12];
1711 uint16_t actlen;
1712 uint16_t rates;
1713 uint16_t x;
1714
1715 DPRINTFN(6, "ifaceno=%d clockid=%d rate=%u\n",
1716 iface_no, clockid, rate);
1717
1718 req.bmRequestType = UT_READ_CLASS_INTERFACE;
1719 req.bRequest = UA20_CS_RANGE;
1720 USETW2(req.wValue, UA20_CS_SAM_FREQ_CONTROL, 0);
1721 USETW2(req.wIndex, clockid, iface_no);
1722 /*
1723 * Assume there is at least one rate to begin with, else some
1724 * devices might refuse to return the USB descriptor:
1725 */
1726 USETW(req.wLength, (2 + 1 * 12));
1727
1728 error = usbd_do_request_flags(udev, NULL, &req, data,
1729 USB_SHORT_XFER_OK, &actlen, USB_DEFAULT_TIMEOUT);
1730
1731 if (error != 0 || actlen < 2) {
1732 /*
1733 * Likely the descriptor doesn't fit into the supplied
1734 * buffer. Try using a larger buffer and see if that
1735 * helps:
1736 */
1737 rates = min(UAUDIO20_MAX_RATES, (255 - 2) / 12);
1738 error = USB_ERR_INVAL;
1739 } else {
1740 rates = UGETW(data);
1741
1742 if (rates > UAUDIO20_MAX_RATES) {
1743 DPRINTF("Too many rates truncating to %d\n", UAUDIO20_MAX_RATES);
1744 rates = UAUDIO20_MAX_RATES;
1745 error = USB_ERR_INVAL;
1746 } else if (rates > 1) {
1747 DPRINTF("Need to read full rate descriptor\n");
1748 error = USB_ERR_INVAL;
1749 }
1750 }
1751
1752 if (error != 0) {
1753 /*
1754 * Try to read full rate descriptor.
1755 */
1756 actlen = (2 + rates * 12);
1757
1758 USETW(req.wLength, actlen);
1759
1760 error = usbd_do_request_flags(udev, NULL, &req, data,
1761 USB_SHORT_XFER_OK, &actlen, USB_DEFAULT_TIMEOUT);
1762
1763 if (error != 0 || actlen < 2)
1764 return (USB_ERR_INVAL);
1765
1766 rates = UGETW(data);
1767 }
1768
1769 actlen = (actlen - 2) / 12;
1770
1771 if (rates > actlen) {
1772 DPRINTF("Too many rates truncating to %d\n", actlen);
1773 rates = actlen;
1774 }
1775
1776 for (x = 0; x != rates; x++) {
1777 uint32_t min = UGETDW(data + 2 + (12 * x));
1778 uint32_t max = UGETDW(data + 6 + (12 * x));
1779 uint32_t res = UGETDW(data + 10 + (12 * x));
1780
1781 if (res == 0) {
1782 DPRINTF("Zero residue\n");
1783 res = 1;
1784 }
1785
1786 if (min > max) {
1787 DPRINTF("Swapped max and min\n");
1788 uint32_t temp;
1789 temp = min;
1790 min = max;
1791 max = temp;
1792 }
1793
1794 if (rate >= min && rate <= max &&
1795 (((rate - min) % res) == 0)) {
1796 return (0);
1797 }
1798 }
1799 return (USB_ERR_INVAL);
1800 }
1801
1802 static struct uaudio_chan *
uaudio_get_chan(struct uaudio_softc * sc,struct uaudio_chan * chan,uint8_t iface_index)1803 uaudio_get_chan(struct uaudio_softc *sc, struct uaudio_chan *chan,
1804 uint8_t iface_index)
1805 {
1806 unsigned i;
1807
1808 for (i = 0; i != UAUDIO_MAX_CHILD; i++, chan++) {
1809 if (chan->num_alt == 0) {
1810 chan->iface_index = iface_index;
1811 return (chan);
1812 } else if (chan->iface_index == iface_index)
1813 return (chan);
1814 }
1815 return (NULL);
1816 }
1817
1818 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)1819 uaudio_chan_fill_info_sub(struct uaudio_softc *sc, struct usb_device *udev,
1820 uint32_t rate, uint8_t channels, uint8_t bit_resolution)
1821 {
1822 struct usb_descriptor *desc = NULL;
1823 union uaudio_asid asid = { NULL };
1824 union uaudio_asf1d asf1d = { NULL };
1825 union uaudio_sed sed = { NULL };
1826 struct usb_midi_streaming_endpoint_descriptor *msid = NULL;
1827 usb_endpoint_descriptor_audio_t *ed1 = NULL;
1828 const struct usb_audio_control_descriptor *acdp = NULL;
1829 struct usb_config_descriptor *cd = usbd_get_config_descriptor(udev);
1830 struct usb_interface_descriptor *id;
1831 const struct uaudio_format *p_fmt = NULL;
1832 struct uaudio_chan *chan;
1833 struct uaudio_chan_alt *chan_alt;
1834 uint32_t format;
1835 uint16_t curidx = 0xFFFF;
1836 uint16_t lastidx = 0xFFFF;
1837 uint16_t alt_index = 0;
1838 uint16_t audio_rev = 0;
1839 uint16_t x;
1840 uint8_t ep_dir;
1841 uint8_t bChannels;
1842 uint8_t bBitResolution;
1843 uint8_t audio_if = 0;
1844 uint8_t midi_if = 0;
1845 uint8_t uma_if_class;
1846
1847 while ((desc = usb_desc_foreach(cd, desc))) {
1848 if ((desc->bDescriptorType == UDESC_INTERFACE) &&
1849 (desc->bLength >= sizeof(*id))) {
1850 id = (void *)desc;
1851
1852 if (id->bInterfaceNumber != lastidx) {
1853 lastidx = id->bInterfaceNumber;
1854 curidx++;
1855 alt_index = 0;
1856
1857 } else {
1858 alt_index++;
1859 }
1860
1861 if ((!(sc->sc_hid.flags & UAUDIO_HID_VALID)) &&
1862 (id->bInterfaceClass == UICLASS_HID) &&
1863 (id->bInterfaceSubClass == 0) &&
1864 (id->bInterfaceProtocol == 0) &&
1865 (alt_index == 0) &&
1866 usbd_get_iface(udev, curidx) != NULL) {
1867 DPRINTF("Found HID interface at %d\n",
1868 curidx);
1869 sc->sc_hid.flags |= UAUDIO_HID_VALID;
1870 sc->sc_hid.iface_index = curidx;
1871 }
1872
1873 uma_if_class =
1874 ((id->bInterfaceClass == UICLASS_AUDIO) ||
1875 ((id->bInterfaceClass == UICLASS_VENDOR) &&
1876 (sc->sc_uq_au_vendor_class != 0)));
1877
1878 if ((uma_if_class != 0) &&
1879 (id->bInterfaceSubClass == UISUBCLASS_AUDIOSTREAM)) {
1880 audio_if = 1;
1881 } else {
1882 audio_if = 0;
1883 }
1884
1885 if ((uma_if_class != 0) &&
1886 (id->bInterfaceSubClass == UISUBCLASS_MIDISTREAM)) {
1887 /*
1888 * XXX could allow multiple MIDI interfaces
1889 */
1890 midi_if = 1;
1891
1892 if ((sc->sc_midi_chan.valid == 0) &&
1893 (usbd_get_iface(udev, curidx) != NULL)) {
1894 sc->sc_midi_chan.iface_index = curidx;
1895 sc->sc_midi_chan.iface_alt_index = alt_index;
1896 sc->sc_midi_chan.valid = 1;
1897 }
1898 } else {
1899 midi_if = 0;
1900 }
1901 asid.v1 = NULL;
1902 asf1d.v1 = NULL;
1903 ed1 = NULL;
1904 sed.v1 = NULL;
1905
1906 /*
1907 * There can only be one USB audio instance
1908 * per USB device. Grab all USB audio
1909 * interfaces on this USB device so that we
1910 * don't attach USB audio twice:
1911 */
1912 if (alt_index == 0 && curidx != sc->sc_mixer_iface_index &&
1913 (id->bInterfaceClass == UICLASS_AUDIO || audio_if != 0 ||
1914 midi_if != 0)) {
1915 usbd_set_parent_iface(sc->sc_udev, curidx,
1916 sc->sc_mixer_iface_index);
1917 }
1918 }
1919
1920 if (audio_if == 0) {
1921 if (midi_if == 0) {
1922 if ((acdp == NULL) &&
1923 (desc->bDescriptorType == UDESC_CS_INTERFACE) &&
1924 (desc->bDescriptorSubtype == UDESCSUB_AC_HEADER) &&
1925 (desc->bLength >= sizeof(*acdp))) {
1926 acdp = (void *)desc;
1927 audio_rev = UGETW(acdp->bcdADC);
1928 }
1929 } else {
1930 msid = (void *)desc;
1931
1932 /* get the maximum number of embedded jacks in use, if any */
1933 if (msid->bLength >= sizeof(*msid) &&
1934 msid->bDescriptorType == UDESC_CS_ENDPOINT &&
1935 msid->bDescriptorSubtype == MS_GENERAL &&
1936 msid->bNumEmbMIDIJack > sc->sc_midi_chan.max_emb_jack) {
1937 sc->sc_midi_chan.max_emb_jack = msid->bNumEmbMIDIJack;
1938 }
1939 }
1940 /*
1941 * Don't collect any USB audio descriptors if
1942 * this is not an USB audio stream interface.
1943 */
1944 continue;
1945 }
1946
1947 if ((acdp != NULL || sc->sc_uq_au_vendor_class != 0) &&
1948 (desc->bDescriptorType == UDESC_CS_INTERFACE) &&
1949 (desc->bDescriptorSubtype == AS_GENERAL) &&
1950 (asid.v1 == NULL)) {
1951 if (audio_rev >= UAUDIO_VERSION_30) {
1952 /* FALLTHROUGH */
1953 } else if (audio_rev >= UAUDIO_VERSION_20) {
1954 if (desc->bLength >= sizeof(*asid.v2)) {
1955 asid.v2 = (void *)desc;
1956 }
1957 } else {
1958 if (desc->bLength >= sizeof(*asid.v1)) {
1959 asid.v1 = (void *)desc;
1960 }
1961 }
1962 }
1963 if ((acdp != NULL || sc->sc_uq_au_vendor_class != 0) &&
1964 (desc->bDescriptorType == UDESC_CS_INTERFACE) &&
1965 (desc->bDescriptorSubtype == FORMAT_TYPE) &&
1966 (asf1d.v1 == NULL)) {
1967 if (audio_rev >= UAUDIO_VERSION_30) {
1968 /* FALLTHROUGH */
1969 } else if (audio_rev >= UAUDIO_VERSION_20) {
1970 if (desc->bLength >= sizeof(*asf1d.v2))
1971 asf1d.v2 = (void *)desc;
1972 } else {
1973 if (desc->bLength >= sizeof(*asf1d.v1)) {
1974 asf1d.v1 = (void *)desc;
1975
1976 if (asf1d.v1->bFormatType != FORMAT_TYPE_I) {
1977 DPRINTFN(11, "ignored bFormatType = %d\n",
1978 asf1d.v1->bFormatType);
1979 asf1d.v1 = NULL;
1980 continue;
1981 }
1982 if (desc->bLength < (sizeof(*asf1d.v1) +
1983 ((asf1d.v1->bSamFreqType == 0) ? 6 :
1984 (asf1d.v1->bSamFreqType * 3)))) {
1985 DPRINTFN(11, "invalid descriptor, "
1986 "too short\n");
1987 asf1d.v1 = NULL;
1988 continue;
1989 }
1990 }
1991 }
1992 }
1993 if ((desc->bDescriptorType == UDESC_ENDPOINT) &&
1994 (desc->bLength >= UEP_MINSIZE) &&
1995 (ed1 == NULL)) {
1996 ed1 = (void *)desc;
1997 if (UE_GET_XFERTYPE(ed1->bmAttributes) != UE_ISOCHRONOUS) {
1998 ed1 = NULL;
1999 continue;
2000 }
2001 }
2002 if ((acdp != NULL || sc->sc_uq_au_vendor_class != 0) &&
2003 (desc->bDescriptorType == UDESC_CS_ENDPOINT) &&
2004 (desc->bDescriptorSubtype == AS_GENERAL) &&
2005 (sed.v1 == NULL)) {
2006 if (audio_rev >= UAUDIO_VERSION_30) {
2007 /* FALLTHROUGH */
2008 } else if (audio_rev >= UAUDIO_VERSION_20) {
2009 if (desc->bLength >= sizeof(*sed.v2))
2010 sed.v2 = (void *)desc;
2011 } else {
2012 if (desc->bLength >= sizeof(*sed.v1))
2013 sed.v1 = (void *)desc;
2014 }
2015 }
2016 if (asid.v1 == NULL || asf1d.v1 == NULL ||
2017 ed1 == NULL || sed.v1 == NULL) {
2018 /* need more descriptors */
2019 continue;
2020 }
2021
2022 ep_dir = UE_GET_DIR(ed1->bEndpointAddress);
2023
2024 /* We ignore sync endpoint information until further. */
2025
2026 if (audio_rev >= UAUDIO_VERSION_30) {
2027 goto next_ep;
2028 } else if (audio_rev >= UAUDIO_VERSION_20) {
2029 uint32_t dwFormat;
2030
2031 dwFormat = UGETDW(asid.v2->bmFormats);
2032 bChannels = asid.v2->bNrChannels;
2033 bBitResolution = asf1d.v2->bSubslotSize * 8;
2034
2035 if ((bChannels != channels) ||
2036 (bBitResolution != bit_resolution)) {
2037 DPRINTF("Wrong number of channels\n");
2038 goto next_ep;
2039 }
2040
2041 for (p_fmt = uaudio20_formats;
2042 p_fmt->wFormat != 0; p_fmt++) {
2043 if ((p_fmt->wFormat & dwFormat) &&
2044 (p_fmt->bPrecision == bBitResolution))
2045 break;
2046 }
2047
2048 if (p_fmt->wFormat == 0) {
2049 DPRINTF("Unsupported audio format\n");
2050 goto next_ep;
2051 }
2052
2053 for (x = 0; x != 256; x++) {
2054 if (ep_dir == UE_DIR_OUT) {
2055 if (!(sc->sc_mixer_clocks.bit_output[x / 8] &
2056 (1 << (x % 8)))) {
2057 continue;
2058 }
2059 } else {
2060 if (!(sc->sc_mixer_clocks.bit_input[x / 8] &
2061 (1 << (x % 8)))) {
2062 continue;
2063 }
2064 }
2065
2066 DPRINTF("Checking clock ID=%d\n", x);
2067
2068 if (uaudio20_check_rate(udev,
2069 sc->sc_mixer_iface_no, x, rate)) {
2070 DPRINTF("Unsupported sampling "
2071 "rate, id=%d\n", x);
2072 goto next_ep;
2073 }
2074 }
2075 } else {
2076 uint16_t wFormat;
2077
2078 wFormat = UGETW(asid.v1->wFormatTag);
2079 bChannels = asf1d.v1->bNrChannels;
2080 bBitResolution = asf1d.v1->bSubFrameSize * 8;
2081
2082 if (asf1d.v1->bSamFreqType == 0) {
2083 DPRINTFN(16, "Sample rate: %d-%dHz\n",
2084 UA_SAMP_LO(asf1d.v1),
2085 UA_SAMP_HI(asf1d.v1));
2086
2087 if ((rate >= UA_SAMP_LO(asf1d.v1)) &&
2088 (rate <= UA_SAMP_HI(asf1d.v1)))
2089 goto found_rate;
2090 } else {
2091 for (x = 0; x < asf1d.v1->bSamFreqType; x++) {
2092 DPRINTFN(16, "Sample rate = %dHz\n",
2093 UA_GETSAMP(asf1d.v1, x));
2094
2095 if (rate == UA_GETSAMP(asf1d.v1, x))
2096 goto found_rate;
2097 }
2098 }
2099 goto next_ep;
2100
2101 found_rate:
2102 for (p_fmt = uaudio10_formats;
2103 p_fmt->wFormat != 0; p_fmt++) {
2104 if ((p_fmt->wFormat == wFormat) &&
2105 (p_fmt->bPrecision == bBitResolution))
2106 break;
2107 }
2108 if (p_fmt->wFormat == 0) {
2109 DPRINTF("Unsupported audio format\n");
2110 goto next_ep;
2111 }
2112
2113 if ((bChannels != channels) ||
2114 (bBitResolution != bit_resolution)) {
2115 DPRINTF("Wrong number of channels\n");
2116 goto next_ep;
2117 }
2118 }
2119
2120 chan = uaudio_get_chan(sc, (ep_dir == UE_DIR_OUT) ? &sc->sc_play_chan[0] :
2121 &sc->sc_rec_chan[0], curidx);
2122 if (chan == NULL) {
2123 DPRINTF("More than %d sub devices. (skipped)\n", UAUDIO_MAX_CHILD);
2124 goto next_ep;
2125 }
2126
2127 if (usbd_get_iface(udev, curidx) == NULL) {
2128 DPRINTF("Interface is not valid\n");
2129 goto next_ep;
2130 }
2131 if (chan->num_alt == CHAN_MAX_ALT) {
2132 DPRINTF("Too many alternate settings\n");
2133 goto next_ep;
2134 }
2135 chan->set_alt = 0;
2136 chan->cur_alt = CHAN_MAX_ALT;
2137
2138 chan_alt = &chan->usb_alt[chan->num_alt++];
2139
2140 #ifdef USB_DEBUG
2141 uaudio_chan_dump_ep_desc(ed1);
2142 #endif
2143 DPRINTF("Sample rate = %dHz, channels = %d, "
2144 "bits = %d, format = %s, ep 0x%02x, chan %p\n", rate, channels,
2145 bit_resolution, p_fmt->description, ed1->bEndpointAddress, chan);
2146
2147 chan_alt->sample_rate = rate;
2148 chan_alt->p_asf1d = asf1d;
2149 chan_alt->p_ed1 = ed1;
2150 chan_alt->p_fmt = p_fmt;
2151 chan_alt->p_sed = sed;
2152 chan_alt->iface_index = curidx;
2153 chan_alt->iface_alt_index = alt_index;
2154
2155 if (ep_dir == UE_DIR_IN)
2156 chan_alt->usb_cfg = uaudio_cfg_record;
2157 else
2158 chan_alt->usb_cfg = uaudio_cfg_play;
2159
2160 chan_alt->sample_size = (channels * p_fmt->bPrecision) / 8;
2161 chan_alt->channels = channels;
2162
2163 if (ep_dir == UE_DIR_IN &&
2164 usbd_get_speed(udev) == USB_SPEED_FULL) {
2165 uaudio_record_fix_fs(ed1,
2166 chan_alt->sample_size * (rate / 1000),
2167 chan_alt->sample_size * (rate / 4000));
2168 }
2169
2170 /* setup play/record format */
2171
2172 format = chan_alt->p_fmt->freebsd_fmt;
2173
2174 /* get default SND_FORMAT() */
2175 format = SND_FORMAT(format, chan_alt->channels, 0);
2176
2177 switch (chan_alt->channels) {
2178 uint32_t temp_fmt;
2179 case 1:
2180 case 2:
2181 /* mono and stereo */
2182 break;
2183 default:
2184 /* surround and more */
2185 temp_fmt = feeder_matrix_default_format(format);
2186 /* if multichannel, then format can be zero */
2187 if (temp_fmt != 0)
2188 format = temp_fmt;
2189 break;
2190 }
2191
2192 /* check if format is not supported */
2193 if (format == 0) {
2194 DPRINTF("The selected audio format is not supported\n");
2195 chan->num_alt--;
2196 goto next_ep;
2197 }
2198 if (chan->num_alt > 1) {
2199 /* we only accumulate one format at different sample rates */
2200 if (chan->pcm_format[0] != format) {
2201 DPRINTF("Multiple formats is not supported\n");
2202 chan->num_alt--;
2203 goto next_ep;
2204 }
2205 /* ignore if duplicate sample rate entry */
2206 if (rate == chan->usb_alt[chan->num_alt - 2].sample_rate) {
2207 DPRINTF("Duplicate sample rate detected\n");
2208 chan->num_alt--;
2209 goto next_ep;
2210 }
2211 }
2212 chan->pcm_cap.fmtlist = chan->pcm_format;
2213 chan->pcm_cap.fmtlist[0] = format;
2214
2215 /* check if device needs bitperfect */
2216 if (chan_alt->channels > UAUDIO_MATRIX_MAX)
2217 sc->sc_pcm_bitperfect = 1;
2218
2219 if (rate < chan->pcm_cap.minspeed || chan->pcm_cap.minspeed == 0)
2220 chan->pcm_cap.minspeed = rate;
2221 if (rate > chan->pcm_cap.maxspeed || chan->pcm_cap.maxspeed == 0)
2222 chan->pcm_cap.maxspeed = rate;
2223
2224 next_ep:
2225 sed.v1 = NULL;
2226 ed1 = NULL;
2227 }
2228 }
2229
2230 /* This structure defines all the supported rates. */
2231
2232 static const uint32_t uaudio_rate_list[CHAN_MAX_ALT] = {
2233 384000,
2234 352800,
2235 192000,
2236 176400,
2237 96000,
2238 88200,
2239 88000,
2240 80000,
2241 72000,
2242 64000,
2243 56000,
2244 48000,
2245 44100,
2246 40000,
2247 32000,
2248 24000,
2249 22050,
2250 16000,
2251 11025,
2252 8000,
2253 0
2254 };
2255
2256 static void
uaudio_chan_fill_info(struct uaudio_softc * sc,struct usb_device * udev)2257 uaudio_chan_fill_info(struct uaudio_softc *sc, struct usb_device *udev)
2258 {
2259 uint32_t rate = uaudio_default_rate;
2260 uint8_t z;
2261 uint8_t bits = uaudio_default_bits;
2262 uint8_t y;
2263 uint8_t channels = uaudio_default_channels;
2264 uint8_t channels_max;
2265 uint8_t x;
2266
2267 bits -= (bits % 8);
2268 if ((bits == 0) || (bits > UAUDIO_BITS_MAX)) {
2269 /* set a valid value */
2270 bits = UAUDIO_BITS_MAX;
2271 }
2272
2273 if (channels > UAUDIO_CHANNELS_MAX)
2274 channels = UAUDIO_CHANNELS_MAX;
2275 switch (usbd_get_speed(udev)) {
2276 case USB_SPEED_LOW:
2277 case USB_SPEED_FULL:
2278 /*
2279 * Due to high bandwidth usage and problems
2280 * with HIGH-speed split transactions we
2281 * disable surround setups on FULL-speed USB
2282 * by default
2283 */
2284 channels_max = 4;
2285 /* more channels on request */
2286 if (channels > channels_max)
2287 channels_max = channels;
2288 break;
2289 default:
2290 channels_max = UAUDIO_CHANNELS_MAX;
2291 break;
2292 }
2293 if (channels == 0)
2294 channels = channels_max;
2295
2296 /* try to search for a valid config */
2297
2298 for (x = channels; x; x--) {
2299 for (y = bits; y; y -= 8) {
2300 /* try user defined rate, if any */
2301 if (rate != 0)
2302 uaudio_chan_fill_info_sub(sc, udev, rate, x, y);
2303
2304 /* try find a matching rate, if any */
2305 for (z = 0; uaudio_rate_list[z]; z++) {
2306 if (uaudio_rate_list[z] != rate)
2307 uaudio_chan_fill_info_sub(sc, udev,
2308 uaudio_rate_list[z], x, y);
2309 }
2310
2311 /* after default value in first round, proceed with max bits */
2312 if (y == bits)
2313 y = UAUDIO_BITS_MAX + 8;
2314 /* skip default value subsequently */
2315 if (y == (bits + 8))
2316 y -= 8;
2317 }
2318
2319 /* after default value in first round, proceed with max channels */
2320 if (x == channels)
2321 x = channels_max + 1;
2322 /* skip default value subsequently */
2323 if (x == (channels + 1))
2324 x--;
2325 }
2326 }
2327
2328 static void
uaudio_chan_play_sync_callback(struct usb_xfer * xfer,usb_error_t error)2329 uaudio_chan_play_sync_callback(struct usb_xfer *xfer, usb_error_t error)
2330 {
2331 struct uaudio_chan *ch = usbd_xfer_softc(xfer);
2332 struct usb_page_cache *pc;
2333 uint64_t sample_rate;
2334 uint8_t buf[4];
2335 uint64_t temp;
2336 unsigned i;
2337 int len;
2338 int actlen;
2339 int nframes;
2340
2341 usbd_xfer_status(xfer, &actlen, NULL, NULL, &nframes);
2342
2343 i = uaudio_get_child_index_by_chan(ch->priv_sc, ch);
2344
2345 switch (USB_GET_STATE(xfer)) {
2346 case USB_ST_TRANSFERRED:
2347
2348 DPRINTFN(6, "transferred %d bytes\n", actlen);
2349
2350 if (nframes == 0)
2351 break;
2352 len = usbd_xfer_frame_len(xfer, 0);
2353 if (len == 0)
2354 break;
2355 if (len > sizeof(buf))
2356 len = sizeof(buf);
2357
2358 memset(buf, 0, sizeof(buf));
2359
2360 pc = usbd_xfer_get_frame(xfer, 0);
2361 usbd_copy_out(pc, 0, buf, len);
2362
2363 temp = UGETDW(buf);
2364
2365 DPRINTF("Value = 0x%08x\n", (int)temp);
2366
2367 /* auto-detect SYNC format */
2368
2369 if (len == 4)
2370 temp &= 0x0fffffff;
2371
2372 /* check for no data */
2373
2374 if (temp == 0)
2375 break;
2376
2377 temp *= 125ULL;
2378
2379 sample_rate = ch->usb_alt[ch->cur_alt].sample_rate;
2380
2381 /* auto adjust */
2382 while (temp < (sample_rate - (sample_rate / 4)))
2383 temp *= 2;
2384
2385 while (temp > (sample_rate + (sample_rate / 2)))
2386 temp /= 2;
2387
2388 DPRINTF("Comparing %d Hz :: %d Hz\n",
2389 (int)temp, (int)sample_rate);
2390
2391 /*
2392 * Use feedback value as fallback when there is no
2393 * recording channel:
2394 */
2395 if (ch->priv_sc->sc_rec_chan[i].num_alt == 0) {
2396 int32_t jitter_max = howmany(sample_rate, 16000);
2397
2398 /*
2399 * Range check the jitter values to avoid
2400 * bogus sample rate adjustments. The expected
2401 * deviation should not be more than 1Hz per
2402 * second. The USB v2.0 specification also
2403 * mandates this requirement. Refer to chapter
2404 * 5.12.4.2 about feedback.
2405 */
2406 ch->jitter_curr = temp - sample_rate;
2407 if (ch->jitter_curr > jitter_max)
2408 ch->jitter_curr = jitter_max;
2409 else if (ch->jitter_curr < -jitter_max)
2410 ch->jitter_curr = -jitter_max;
2411 }
2412 ch->feedback_rate = temp;
2413 break;
2414
2415 case USB_ST_SETUP:
2416 /*
2417 * Submit the transfer even when the recording stream
2418 * provides the jitter information, so that the feedback
2419 * rate keeps being sampled for diagnostic purposes.
2420 */
2421 usbd_xfer_set_frames(xfer, 1);
2422 usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_framelen(xfer));
2423 usbd_transfer_submit(xfer);
2424 break;
2425
2426 default: /* Error */
2427 break;
2428 }
2429 }
2430
2431 static int
uaudio_chan_is_async(struct uaudio_chan * ch,uint8_t alt)2432 uaudio_chan_is_async(struct uaudio_chan *ch, uint8_t alt)
2433 {
2434 uint8_t attr = ch->usb_alt[alt].p_ed1->bmAttributes;
2435 return (UE_GET_ISO_TYPE(attr) == UE_ISO_ASYNC);
2436 }
2437
2438 static void
uaudio_chan_play_callback(struct usb_xfer * xfer,usb_error_t error)2439 uaudio_chan_play_callback(struct usb_xfer *xfer, usb_error_t error)
2440 {
2441 struct uaudio_chan *ch = usbd_xfer_softc(xfer);
2442 struct uaudio_chan *ch_rec;
2443 struct usb_page_cache *pc;
2444 uint32_t mfl;
2445 uint32_t total;
2446 uint32_t blockcount;
2447 uint32_t n;
2448 uint32_t offset;
2449 unsigned i;
2450 int sample_size;
2451 int actlen;
2452 int sumlen;
2453
2454 if (ch->running == 0 || ch->start == ch->end) {
2455 DPRINTF("not running or no buffer!\n");
2456 return;
2457 }
2458
2459 i = uaudio_get_child_index_by_chan(ch->priv_sc, ch);
2460
2461 /* check if there is a valid record channel */
2462 ch_rec = ch->priv_sc->sc_rec_chan + i;
2463
2464 if (ch_rec->num_alt == 0)
2465 ch_rec = NULL;
2466
2467 usbd_xfer_status(xfer, &actlen, &sumlen, NULL, NULL);
2468
2469 switch (USB_GET_STATE(xfer)) {
2470 case USB_ST_SETUP:
2471 tr_setup:
2472 if (ch_rec != NULL) {
2473 /*
2474 * NOTE: The play and record callbacks are
2475 * executed from the same USB thread and
2476 * locking the record channel mutex here is
2477 * not needed. This avoids a LOR situation.
2478 */
2479
2480 /* reset receive jitter counters */
2481 ch_rec->jitter_curr = 0;
2482 ch_rec->jitter_rem = 0;
2483 }
2484
2485 /* reset transmit jitter counters */
2486 ch->jitter_curr = 0;
2487 ch->jitter_rem = 0;
2488
2489 /* FALLTHROUGH */
2490 case USB_ST_TRANSFERRED:
2491 if (actlen < sumlen) {
2492 DPRINTF("short transfer, "
2493 "%d of %d bytes\n", actlen, sumlen);
2494 }
2495 chn_intr(ch->pcm_ch);
2496
2497 /*
2498 * Check for asynchronous playback endpoint and that
2499 * the playback endpoint is properly configured:
2500 */
2501 if (ch_rec != NULL &&
2502 uaudio_chan_is_async(ch, ch->cur_alt) != 0) {
2503 uint32_t rec_alt = ch_rec->cur_alt;
2504 if (rec_alt < ch_rec->num_alt) {
2505 int64_t tx_jitter;
2506 int64_t rx_rate;
2507 /*
2508 * NOTE: The play and record callbacks
2509 * are executed from the same USB
2510 * thread and locking the record
2511 * channel mutex here is not needed.
2512 * This avoids a LOR situation.
2513 */
2514
2515 /* translate receive jitter into transmit jitter */
2516 tx_jitter = ch->usb_alt[ch->cur_alt].sample_rate;
2517 tx_jitter = (tx_jitter * ch_rec->jitter_curr) +
2518 ch->jitter_rem;
2519
2520 /* reset receive jitter counters */
2521 ch_rec->jitter_curr = 0;
2522 ch_rec->jitter_rem = 0;
2523
2524 /* compute exact number of transmit jitter samples */
2525 rx_rate = ch_rec->usb_alt[rec_alt].sample_rate;
2526 ch->jitter_curr += tx_jitter / rx_rate;
2527 ch->jitter_rem = tx_jitter % rx_rate;
2528 }
2529 }
2530
2531 /* start the SYNC transfer one time per second, if any */
2532 ch->intr_counter += ch->intr_frames;
2533 if (ch->intr_counter >= ch->frames_per_second) {
2534 ch->intr_counter -= ch->frames_per_second;
2535 usbd_transfer_start(ch->xfer[UAUDIO_NCHANBUFS]);
2536 }
2537
2538 mfl = usbd_xfer_max_framelen(xfer);
2539
2540 if (ch->bytes_per_frame[1] > mfl) {
2541 DPRINTF("bytes per transfer, %d, "
2542 "exceeds maximum, %d!\n",
2543 ch->bytes_per_frame[1],
2544 mfl);
2545 break;
2546 }
2547
2548 blockcount = ch->intr_frames;
2549
2550 /* setup number of frames */
2551 usbd_xfer_set_frames(xfer, blockcount);
2552
2553 /* get sample size */
2554 sample_size = ch->usb_alt[ch->cur_alt].sample_size;
2555
2556 /* reset total length */
2557 total = 0;
2558
2559 /* setup frame lengths */
2560 for (n = 0; n != blockcount; n++) {
2561 uint32_t frame_len;
2562
2563 ch->sample_curr += ch->sample_rem;
2564 if (ch->sample_curr >= ch->frames_per_second) {
2565 ch->sample_curr -= ch->frames_per_second;
2566 frame_len = ch->bytes_per_frame[1];
2567 } else {
2568 frame_len = ch->bytes_per_frame[0];
2569 }
2570
2571 /* handle free running clock case */
2572 if (ch->jitter_curr > 0 &&
2573 (frame_len + sample_size) <= mfl) {
2574 DPRINTFN(6, "sending one sample more\n");
2575 ch->jitter_curr--;
2576 frame_len += sample_size;
2577 } else if (ch->jitter_curr < 0 &&
2578 frame_len >= sample_size) {
2579 DPRINTFN(6, "sending one sample less\n");
2580 ch->jitter_curr++;
2581 frame_len -= sample_size;
2582 }
2583 usbd_xfer_set_frame_len(xfer, n, frame_len);
2584 total += frame_len;
2585 }
2586
2587 DPRINTFN(6, "transferring %d bytes\n", total);
2588
2589 offset = 0;
2590
2591 pc = usbd_xfer_get_frame(xfer, 0);
2592 while (total > 0) {
2593 n = (ch->end - ch->cur);
2594 if (n > total)
2595 n = total;
2596
2597 usbd_copy_in(pc, offset, ch->cur, n);
2598
2599 total -= n;
2600 ch->cur += n;
2601 offset += n;
2602
2603 if (ch->cur >= ch->end)
2604 ch->cur = ch->start;
2605 }
2606 usbd_transfer_submit(xfer);
2607 break;
2608
2609 default: /* Error */
2610 if (error != USB_ERR_CANCELLED)
2611 goto tr_setup;
2612 break;
2613 }
2614 }
2615
2616 static void
uaudio_chan_record_sync_callback(struct usb_xfer * xfer,usb_error_t error)2617 uaudio_chan_record_sync_callback(struct usb_xfer *xfer, usb_error_t error)
2618 {
2619 /* TODO */
2620 }
2621
2622 static void
uaudio_chan_record_callback(struct usb_xfer * xfer,usb_error_t error)2623 uaudio_chan_record_callback(struct usb_xfer *xfer, usb_error_t error)
2624 {
2625 struct uaudio_chan *ch = usbd_xfer_softc(xfer);
2626 struct usb_page_cache *pc;
2627 uint32_t offset0;
2628 uint32_t mfl;
2629 int m;
2630 int n;
2631 int len;
2632 int actlen;
2633 int nframes;
2634 int expected_bytes;
2635 int sample_size;
2636
2637 if (ch->start == ch->end) {
2638 DPRINTF("no buffer!\n");
2639 return;
2640 }
2641
2642 usbd_xfer_status(xfer, &actlen, NULL, NULL, &nframes);
2643 mfl = usbd_xfer_max_framelen(xfer);
2644
2645 switch (USB_GET_STATE(xfer)) {
2646 case USB_ST_TRANSFERRED:
2647
2648 offset0 = 0;
2649 pc = usbd_xfer_get_frame(xfer, 0);
2650
2651 /* try to compute the number of expected bytes */
2652 ch->sample_curr += (ch->sample_rem * ch->intr_frames);
2653
2654 /* compute number of expected bytes */
2655 expected_bytes = (ch->intr_frames * ch->bytes_per_frame[0]) +
2656 ((ch->sample_curr / ch->frames_per_second) *
2657 (ch->bytes_per_frame[1] - ch->bytes_per_frame[0]));
2658
2659 /* keep remainder */
2660 ch->sample_curr %= ch->frames_per_second;
2661
2662 /* get current sample size */
2663 sample_size = ch->usb_alt[ch->cur_alt].sample_size;
2664
2665 for (n = 0; n != nframes; n++) {
2666 uint32_t offset1 = offset0;
2667
2668 len = usbd_xfer_frame_len(xfer, n);
2669
2670 /* make sure we only receive complete samples */
2671 len = len - (len % sample_size);
2672
2673 /* subtract bytes received from expected payload */
2674 expected_bytes -= len;
2675
2676 /* don't receive data when not ready */
2677 if (ch->running == 0 || ch->cur_alt != ch->set_alt)
2678 continue;
2679
2680 /* fill ring buffer with samples, if any */
2681 while (len > 0) {
2682 m = (ch->end - ch->cur);
2683
2684 if (m > len)
2685 m = len;
2686
2687 usbd_copy_out(pc, offset1, ch->cur, m);
2688
2689 len -= m;
2690 offset1 += m;
2691 ch->cur += m;
2692
2693 if (ch->cur >= ch->end)
2694 ch->cur = ch->start;
2695 }
2696
2697 offset0 += mfl;
2698 }
2699
2700 /* update current jitter */
2701 ch->jitter_curr -= (expected_bytes / sample_size);
2702
2703 /* don't allow a huge amount of jitter to accumulate */
2704 nframes = 2 * ch->intr_frames;
2705
2706 /* range check current jitter */
2707 if (ch->jitter_curr < -nframes)
2708 ch->jitter_curr = -nframes;
2709 else if (ch->jitter_curr > nframes)
2710 ch->jitter_curr = nframes;
2711
2712 DPRINTFN(6, "transferred %d bytes, jitter %d samples\n",
2713 actlen, ch->jitter_curr);
2714
2715 if (ch->running != 0)
2716 chn_intr(ch->pcm_ch);
2717
2718 case USB_ST_SETUP:
2719 tr_setup:
2720 nframes = ch->intr_frames;
2721
2722 usbd_xfer_set_frames(xfer, nframes);
2723 for (n = 0; n != nframes; n++)
2724 usbd_xfer_set_frame_len(xfer, n, mfl);
2725
2726 usbd_transfer_submit(xfer);
2727 break;
2728
2729 default: /* Error */
2730 if (error != USB_ERR_CANCELLED)
2731 goto tr_setup;
2732 break;
2733 }
2734 }
2735
2736 void *
uaudio_chan_init(struct uaudio_chan * ch,struct snd_dbuf * b,struct pcm_channel * c,int dir)2737 uaudio_chan_init(struct uaudio_chan *ch, struct snd_dbuf *b,
2738 struct pcm_channel *c, int dir)
2739 {
2740 uint32_t buf_size;
2741 uint8_t x;
2742
2743 /* store mutex and PCM channel */
2744
2745 ch->pcm_ch = c;
2746 mtx_init(&ch->lock, "uaudio_chan lock", NULL, MTX_DEF);
2747
2748 /* compute worst case buffer */
2749
2750 buf_size = 0;
2751 for (x = 0; x != ch->num_alt; x++) {
2752 uint32_t temp = uaudio_max_buffer_size(ch, x);
2753 if (temp > buf_size)
2754 buf_size = temp;
2755 }
2756
2757 /* allow double buffering */
2758 buf_size *= 2;
2759
2760 DPRINTF("Worst case buffer is %d bytes\n", (int)buf_size);
2761
2762 ch->buf = malloc(buf_size, M_DEVBUF, M_WAITOK | M_ZERO);
2763 if (sndbuf_setup(b, ch->buf, buf_size) != 0)
2764 goto error;
2765
2766 ch->start = ch->buf;
2767 ch->end = ch->buf + buf_size;
2768 ch->cur = ch->buf;
2769 ch->pcm_buf = b;
2770 ch->max_buf = buf_size;
2771
2772 return (ch);
2773
2774 error:
2775 uaudio_chan_free(ch);
2776 return (NULL);
2777 }
2778
2779 int
uaudio_chan_free(struct uaudio_chan * ch)2780 uaudio_chan_free(struct uaudio_chan *ch)
2781 {
2782 free(ch->buf, M_DEVBUF);
2783 ch->buf = NULL;
2784 usbd_transfer_unsetup(ch->xfer, UAUDIO_NCHANBUFS + 1);
2785 mtx_destroy(&ch->lock);
2786
2787 ch->num_alt = 0;
2788
2789 return (0);
2790 }
2791
2792 int
uaudio_chan_set_param_blocksize(struct uaudio_chan * ch,uint32_t blocksize)2793 uaudio_chan_set_param_blocksize(struct uaudio_chan *ch, uint32_t blocksize)
2794 {
2795 uint32_t temp = 2 * uaudio_get_buffer_size(ch, ch->set_alt);
2796 sndbuf_setup(ch->pcm_buf, ch->buf, temp);
2797 return (temp / 2);
2798 }
2799
2800 int
uaudio_chan_set_param_fragments(struct uaudio_chan * ch,uint32_t blocksize,uint32_t blockcount)2801 uaudio_chan_set_param_fragments(struct uaudio_chan *ch, uint32_t blocksize,
2802 uint32_t blockcount)
2803 {
2804 return (1);
2805 }
2806
2807 int
uaudio_chan_set_param_speed(struct uaudio_chan * ch,uint32_t speed)2808 uaudio_chan_set_param_speed(struct uaudio_chan *ch, uint32_t speed)
2809 {
2810 struct uaudio_softc *sc;
2811 uint8_t x, y;
2812
2813 sc = ch->priv_sc;
2814
2815 for (x = 0, y = 1; y < ch->num_alt; y++) {
2816 /* prefer sample rate closer to and greater than requested */
2817 if ((ch->usb_alt[x].sample_rate < speed &&
2818 ch->usb_alt[x].sample_rate < ch->usb_alt[y].sample_rate) ||
2819 (speed <= ch->usb_alt[y].sample_rate &&
2820 ch->usb_alt[y].sample_rate < ch->usb_alt[x].sample_rate))
2821 x = y;
2822 }
2823
2824 usb_proc_explore_lock(sc->sc_udev);
2825 ch->set_alt = x;
2826 usb_proc_explore_unlock(sc->sc_udev);
2827
2828 DPRINTF("Selecting alt %d\n", (int)x);
2829
2830 return (ch->usb_alt[x].sample_rate);
2831 }
2832
2833 int
uaudio_chan_getptr(struct uaudio_chan * ch)2834 uaudio_chan_getptr(struct uaudio_chan *ch)
2835 {
2836 return (ch->cur - ch->start);
2837 }
2838
2839 struct pcmchan_caps *
uaudio_chan_getcaps(struct uaudio_chan * ch)2840 uaudio_chan_getcaps(struct uaudio_chan *ch)
2841 {
2842 return (&ch->pcm_cap);
2843 }
2844
2845 static struct pcmchan_matrix uaudio_chan_matrix_swap_2_0 = {
2846 .id = SND_CHN_MATRIX_DRV,
2847 .channels = 2,
2848 .ext = 0,
2849 .map = {
2850 /* Right */
2851 [0] = {
2852 .type = SND_CHN_T_FR,
2853 .members =
2854 SND_CHN_T_MASK_FR | SND_CHN_T_MASK_FC |
2855 SND_CHN_T_MASK_LF | SND_CHN_T_MASK_BR |
2856 SND_CHN_T_MASK_BC | SND_CHN_T_MASK_SR
2857 },
2858 /* Left */
2859 [1] = {
2860 .type = SND_CHN_T_FL,
2861 .members =
2862 SND_CHN_T_MASK_FL | SND_CHN_T_MASK_FC |
2863 SND_CHN_T_MASK_LF | SND_CHN_T_MASK_BL |
2864 SND_CHN_T_MASK_BC | SND_CHN_T_MASK_SL
2865 },
2866 [2] = {
2867 .type = SND_CHN_T_MAX,
2868 .members = 0
2869 }
2870 },
2871 .mask = SND_CHN_T_MASK_FR | SND_CHN_T_MASK_FL,
2872 .offset = { 1, 0, -1, -1, -1, -1, -1, -1, -1,
2873 -1, -1, -1, -1, -1, -1, -1, -1, -1 }
2874 };
2875
2876 struct pcmchan_matrix *
uaudio_chan_getmatrix(struct uaudio_chan * ch,uint32_t format)2877 uaudio_chan_getmatrix(struct uaudio_chan *ch, uint32_t format)
2878 {
2879 struct uaudio_softc *sc;
2880
2881 sc = ch->priv_sc;
2882
2883 if (sc != NULL && sc->sc_uq_audio_swap_lr != 0 &&
2884 AFMT_CHANNEL(format) == 2)
2885 return (&uaudio_chan_matrix_swap_2_0);
2886
2887 return (feeder_matrix_format_map(format));
2888 }
2889
2890 int
uaudio_chan_set_param_format(struct uaudio_chan * ch,uint32_t format)2891 uaudio_chan_set_param_format(struct uaudio_chan *ch, uint32_t format)
2892 {
2893 DPRINTF("Selecting format 0x%08x\n", (unsigned int)format);
2894 return (0);
2895 }
2896
2897 static void
uaudio_chan_reconfigure(struct uaudio_chan * ch,uint8_t operation)2898 uaudio_chan_reconfigure(struct uaudio_chan *ch, uint8_t operation)
2899 {
2900 struct uaudio_softc *sc = ch->priv_sc;
2901
2902 /* Check for shutdown. */
2903 if (ch->operation == CHAN_OP_DRAIN)
2904 return;
2905
2906 /* Set next operation. */
2907 ch->operation = operation;
2908
2909 /*
2910 * Because changing the alternate setting modifies the USB
2911 * configuration, this part must be executed from the USB
2912 * explore process.
2913 */
2914 (void)usb_proc_explore_msignal(sc->sc_udev,
2915 &sc->sc_config_msg[0], &sc->sc_config_msg[1]);
2916 }
2917
2918 static int
uaudio_chan_need_both(struct uaudio_chan * pchan,struct uaudio_chan * rchan)2919 uaudio_chan_need_both(struct uaudio_chan *pchan, struct uaudio_chan *rchan)
2920 {
2921 return (pchan->num_alt > 0 &&
2922 pchan->running != 0 &&
2923 uaudio_chan_is_async(pchan, pchan->set_alt) != 0 &&
2924 rchan->num_alt > 0 &&
2925 rchan->running == 0);
2926 }
2927
2928 static int
uaudio_chan_need_none(struct uaudio_chan * pchan,struct uaudio_chan * rchan)2929 uaudio_chan_need_none(struct uaudio_chan *pchan, struct uaudio_chan *rchan)
2930 {
2931 return (pchan->num_alt > 0 &&
2932 pchan->running == 0 &&
2933 rchan->num_alt > 0 &&
2934 rchan->running == 0);
2935 }
2936
2937 void
uaudio_chan_start(struct uaudio_chan * ch)2938 uaudio_chan_start(struct uaudio_chan *ch)
2939 {
2940 struct uaudio_softc *sc = ch->priv_sc;
2941 unsigned i = uaudio_get_child_index_by_chan(sc, ch);
2942
2943 /* make operation atomic */
2944 usb_proc_explore_lock(sc->sc_udev);
2945
2946 /* check if not running */
2947 if (ch->running == 0) {
2948 uint32_t temp;
2949
2950 /* get current buffer size */
2951 temp = 2 * uaudio_get_buffer_size(ch, ch->set_alt);
2952
2953 /* set running flag */
2954 ch->running = 1;
2955
2956 /* ensure the hardware buffer is reset */
2957 ch->start = ch->buf;
2958 ch->end = ch->buf + temp;
2959 ch->cur = ch->buf;
2960
2961 if (uaudio_chan_need_both(
2962 &sc->sc_play_chan[i],
2963 &sc->sc_rec_chan[i])) {
2964 struct uaudio_chan *ch_play = &sc->sc_play_chan[i];
2965 struct uaudio_chan *ch_rec = &sc->sc_rec_chan[i];
2966 uint8_t rec_alt;
2967
2968 /*
2969 * The recording channel is only being started as a
2970 * source of jitter information for the playback
2971 * stream. Align its nominal rate with the
2972 * playback rate so that (a) it does not reprogram
2973 * a sample clock shared with the playback path to
2974 * a conflicting rate, and (b) its expected frame
2975 * sizes match what the device actually produces,
2976 * keeping the derived jitter information valid.
2977 * The USB explore lock is held here, which also
2978 * serializes against uaudio_chan_set_param_speed().
2979 */
2980 if (uaudio_chan_match_rate(ch_rec,
2981 ch_play->usb_alt[ch_play->set_alt].sample_rate,
2982 &rec_alt))
2983 ch_rec->set_alt = rec_alt;
2984
2985 /*
2986 * Start both endpoints because of need for
2987 * jitter information:
2988 */
2989 uaudio_chan_reconfigure(ch_rec, CHAN_OP_START);
2990 uaudio_chan_reconfigure(ch_play, CHAN_OP_START);
2991 } else {
2992 uaudio_chan_reconfigure(ch, CHAN_OP_START);
2993 }
2994 }
2995
2996 /* exit atomic operation */
2997 usb_proc_explore_unlock(sc->sc_udev);
2998 }
2999
3000 void
uaudio_chan_stop(struct uaudio_chan * ch)3001 uaudio_chan_stop(struct uaudio_chan *ch)
3002 {
3003 struct uaudio_softc *sc = ch->priv_sc;
3004 unsigned i = uaudio_get_child_index_by_chan(sc, ch);
3005
3006 /* make operation atomic */
3007 usb_proc_explore_lock(sc->sc_udev);
3008
3009 /* check if running */
3010 if (ch->running != 0) {
3011 /* clear running flag */
3012 ch->running = 0;
3013
3014 if (uaudio_chan_need_both(
3015 &sc->sc_play_chan[i],
3016 &sc->sc_rec_chan[i])) {
3017 /*
3018 * Leave the endpoints running because we need
3019 * information about jitter!
3020 */
3021 } else if (uaudio_chan_need_none(
3022 &sc->sc_play_chan[i],
3023 &sc->sc_rec_chan[i])) {
3024 /*
3025 * Stop both endpoints in case the one was used for
3026 * jitter information:
3027 */
3028 uaudio_chan_reconfigure(&sc->sc_rec_chan[i], CHAN_OP_STOP);
3029 uaudio_chan_reconfigure(&sc->sc_play_chan[i], CHAN_OP_STOP);
3030 } else {
3031 uaudio_chan_reconfigure(ch, CHAN_OP_STOP);
3032 }
3033 }
3034
3035 /* exit atomic operation */
3036 usb_proc_explore_unlock(sc->sc_udev);
3037 }
3038
3039 /*========================================================================*
3040 * AC - Audio Controller - routines
3041 *========================================================================*/
3042
3043 static int
uaudio_mixer_sysctl_handler(SYSCTL_HANDLER_ARGS)3044 uaudio_mixer_sysctl_handler(SYSCTL_HANDLER_ARGS)
3045 {
3046 struct uaudio_softc *sc;
3047 struct uaudio_mixer_node *pmc;
3048 int hint;
3049 int error;
3050 int temp = 0;
3051 int chan = 0;
3052
3053 sc = (struct uaudio_softc *)oidp->oid_arg1;
3054 hint = oidp->oid_arg2;
3055
3056 /* lookup mixer node */
3057
3058 mtx_lock(&sc->sc_child[0].mixer_lock);
3059 for (pmc = sc->sc_mixer_root; pmc != NULL; pmc = pmc->next) {
3060 for (chan = 0; chan != (int)pmc->nchan; chan++) {
3061 if (pmc->wValue[chan] != -1 &&
3062 pmc->wValue[chan] == hint) {
3063 temp = pmc->wData[chan];
3064 goto found;
3065 }
3066 }
3067 }
3068 found:
3069 mtx_unlock(&sc->sc_child[0].mixer_lock);
3070
3071 error = sysctl_handle_int(oidp, &temp, 0, req);
3072 if (error != 0 || req->newptr == NULL)
3073 return (error);
3074
3075 /* update mixer value */
3076
3077 mtx_lock(&sc->sc_child[0].mixer_lock);
3078 if (pmc != NULL &&
3079 temp >= pmc->minval &&
3080 temp <= pmc->maxval) {
3081 pmc->wData[chan] = temp;
3082 pmc->update[(chan / 8)] |= (1 << (chan % 8));
3083
3084 /* start the transfer, if not already started */
3085 usbd_transfer_start(sc->sc_mixer_xfer[0]);
3086 }
3087 mtx_unlock(&sc->sc_child[0].mixer_lock);
3088
3089 return (0);
3090 }
3091
3092 static void
uaudio_mixer_ctl_free(struct uaudio_softc * sc)3093 uaudio_mixer_ctl_free(struct uaudio_softc *sc)
3094 {
3095 struct uaudio_mixer_node *p_mc;
3096
3097 while ((p_mc = sc->sc_mixer_root) != NULL) {
3098 sc->sc_mixer_root = p_mc->next;
3099 free(p_mc, M_USBDEV);
3100 }
3101 }
3102
3103 static void
uaudio_mixer_register_sysctl(struct uaudio_softc * sc,device_t dev,unsigned index)3104 uaudio_mixer_register_sysctl(struct uaudio_softc *sc, device_t dev,
3105 unsigned index)
3106 {
3107 struct uaudio_mixer_node *pmc;
3108 struct sysctl_oid *mixer_tree;
3109 struct sysctl_oid *control_tree;
3110 char buf[32];
3111 int chan;
3112 int n;
3113
3114 if (index != 0)
3115 return;
3116
3117 mixer_tree = SYSCTL_ADD_NODE(device_get_sysctl_ctx(dev),
3118 SYSCTL_CHILDREN(device_get_sysctl_tree(dev)), OID_AUTO, "mixer",
3119 CTLFLAG_RD | CTLFLAG_MPSAFE, NULL, "");
3120
3121 if (mixer_tree == NULL)
3122 return;
3123
3124 for (n = 0, pmc = sc->sc_mixer_root; pmc != NULL;
3125 pmc = pmc->next, n++) {
3126 for (chan = 0; chan < pmc->nchan; chan++) {
3127 if (pmc->nchan > 1) {
3128 snprintf(buf, sizeof(buf), "%s_%d_%d",
3129 pmc->name, n, chan);
3130 } else {
3131 snprintf(buf, sizeof(buf), "%s_%d",
3132 pmc->name, n);
3133 }
3134
3135 control_tree = SYSCTL_ADD_NODE(device_get_sysctl_ctx(dev),
3136 SYSCTL_CHILDREN(mixer_tree), OID_AUTO, buf,
3137 CTLFLAG_RD | CTLFLAG_MPSAFE, NULL,
3138 "Mixer control nodes");
3139
3140 if (control_tree == NULL)
3141 continue;
3142
3143 SYSCTL_ADD_PROC(device_get_sysctl_ctx(dev),
3144 SYSCTL_CHILDREN(control_tree),
3145 OID_AUTO, "val",
3146 CTLTYPE_INT | CTLFLAG_RWTUN | CTLFLAG_MPSAFE,
3147 sc, pmc->wValue[chan],
3148 uaudio_mixer_sysctl_handler, "I", "Current value");
3149
3150 SYSCTL_ADD_INT(device_get_sysctl_ctx(dev),
3151 SYSCTL_CHILDREN(control_tree),
3152 OID_AUTO, "min", CTLFLAG_RD, 0, pmc->minval,
3153 "Minimum value");
3154
3155 SYSCTL_ADD_INT(device_get_sysctl_ctx(dev),
3156 SYSCTL_CHILDREN(control_tree),
3157 OID_AUTO, "max", CTLFLAG_RD, 0, pmc->maxval,
3158 "Maximum value");
3159
3160 SYSCTL_ADD_STRING(device_get_sysctl_ctx(dev),
3161 SYSCTL_CHILDREN(control_tree),
3162 OID_AUTO, "desc", CTLFLAG_RD, pmc->desc, 0,
3163 "Description");
3164 }
3165 }
3166 }
3167
3168 /* M-Audio FastTrack Ultra Mixer Description */
3169 /* Origin: Linux USB Audio driver */
3170 static void
uaudio_mixer_controls_create_ftu(struct uaudio_softc * sc)3171 uaudio_mixer_controls_create_ftu(struct uaudio_softc *sc)
3172 {
3173 int chx;
3174 int chy;
3175
3176 memset(&MIX(sc), 0, sizeof(MIX(sc)));
3177 MIX(sc).wIndex = MAKE_WORD(6, sc->sc_mixer_iface_no);
3178 MIX(sc).wValue[0] = MAKE_WORD(8, 0);
3179 MIX(sc).type = MIX_UNSIGNED_16;
3180 MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3181 MIX(sc).name = "effect";
3182 MIX(sc).minval = 0;
3183 MIX(sc).maxval = 7;
3184 MIX(sc).mul = 7;
3185 MIX(sc).nchan = 1;
3186 MIX(sc).update[0] = 1;
3187 strlcpy(MIX(sc).desc, "Room1,2,3,Hall1,2,Plate,Delay,Echo", sizeof(MIX(sc).desc));
3188 uaudio_mixer_add_ctl_sub(sc, &MIX(sc));
3189
3190 memset(&MIX(sc), 0, sizeof(MIX(sc)));
3191 MIX(sc).wIndex = MAKE_WORD(5, sc->sc_mixer_iface_no);
3192
3193 for (chx = 0; chx != 8; chx++) {
3194 for (chy = 0; chy != 8; chy++) {
3195 MIX(sc).wValue[0] = MAKE_WORD(chx + 1, chy + 1);
3196 MIX(sc).type = MIX_SIGNED_16;
3197 MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3198 MIX(sc).name = "mix_rec";
3199 MIX(sc).nchan = 1;
3200 MIX(sc).update[0] = 1;
3201 MIX(sc).val_default = 0;
3202 snprintf(MIX(sc).desc, sizeof(MIX(sc).desc),
3203 "AIn%d - Out%d Record Volume", chy + 1, chx + 1);
3204
3205 uaudio_mixer_add_ctl(sc, &MIX(sc));
3206
3207 MIX(sc).wValue[0] = MAKE_WORD(chx + 1, chy + 1 + 8);
3208 MIX(sc).type = MIX_SIGNED_16;
3209 MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3210 MIX(sc).name = "mix_play";
3211 MIX(sc).nchan = 1;
3212 MIX(sc).update[0] = 1;
3213 MIX(sc).val_default = (chx == chy) ? 2 : 0;
3214 snprintf(MIX(sc).desc, sizeof(MIX(sc).desc),
3215 "DIn%d - Out%d Playback Volume", chy + 1, chx + 1);
3216
3217 uaudio_mixer_add_ctl(sc, &MIX(sc));
3218 }
3219 }
3220
3221 memset(&MIX(sc), 0, sizeof(MIX(sc)));
3222 MIX(sc).wIndex = MAKE_WORD(6, sc->sc_mixer_iface_no);
3223 MIX(sc).wValue[0] = MAKE_WORD(2, 0);
3224 MIX(sc).type = MIX_SIGNED_8;
3225 MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3226 MIX(sc).name = "effect_vol";
3227 MIX(sc).nchan = 1;
3228 MIX(sc).update[0] = 1;
3229 MIX(sc).minval = 0;
3230 MIX(sc).maxval = 0x7f;
3231 MIX(sc).mul = 0x7f;
3232 MIX(sc).nchan = 1;
3233 MIX(sc).update[0] = 1;
3234 strlcpy(MIX(sc).desc, "Effect Volume", sizeof(MIX(sc).desc));
3235 uaudio_mixer_add_ctl_sub(sc, &MIX(sc));
3236
3237 memset(&MIX(sc), 0, sizeof(MIX(sc)));
3238 MIX(sc).wIndex = MAKE_WORD(6, sc->sc_mixer_iface_no);
3239 MIX(sc).wValue[0] = MAKE_WORD(3, 0);
3240 MIX(sc).type = MIX_SIGNED_16;
3241 MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3242 MIX(sc).name = "effect_dur";
3243 MIX(sc).nchan = 1;
3244 MIX(sc).update[0] = 1;
3245 MIX(sc).minval = 0;
3246 MIX(sc).maxval = 0x7f00;
3247 MIX(sc).mul = 0x7f00;
3248 MIX(sc).nchan = 1;
3249 MIX(sc).update[0] = 1;
3250 strlcpy(MIX(sc).desc, "Effect Duration", sizeof(MIX(sc).desc));
3251 uaudio_mixer_add_ctl_sub(sc, &MIX(sc));
3252
3253 memset(&MIX(sc), 0, sizeof(MIX(sc)));
3254 MIX(sc).wIndex = MAKE_WORD(6, sc->sc_mixer_iface_no);
3255 MIX(sc).wValue[0] = MAKE_WORD(4, 0);
3256 MIX(sc).type = MIX_SIGNED_8;
3257 MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3258 MIX(sc).name = "effect_fb";
3259 MIX(sc).nchan = 1;
3260 MIX(sc).update[0] = 1;
3261 MIX(sc).minval = 0;
3262 MIX(sc).maxval = 0x7f;
3263 MIX(sc).mul = 0x7f;
3264 MIX(sc).nchan = 1;
3265 MIX(sc).update[0] = 1;
3266 strlcpy(MIX(sc).desc, "Effect Feedback Volume", sizeof(MIX(sc).desc));
3267 uaudio_mixer_add_ctl_sub(sc, &MIX(sc));
3268
3269 memset(&MIX(sc), 0, sizeof(MIX(sc)));
3270 MIX(sc).wIndex = MAKE_WORD(7, sc->sc_mixer_iface_no);
3271 for (chy = 0; chy != 4; chy++) {
3272 MIX(sc).wValue[0] = MAKE_WORD(7, chy + 1);
3273 MIX(sc).type = MIX_SIGNED_16;
3274 MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3275 MIX(sc).name = "effect_ret";
3276 MIX(sc).nchan = 1;
3277 MIX(sc).update[0] = 1;
3278 snprintf(MIX(sc).desc, sizeof(MIX(sc).desc),
3279 "Effect Return %d Volume", chy + 1);
3280
3281 uaudio_mixer_add_ctl(sc, &MIX(sc));
3282 }
3283
3284 memset(&MIX(sc), 0, sizeof(MIX(sc)));
3285 MIX(sc).wIndex = MAKE_WORD(5, sc->sc_mixer_iface_no);
3286
3287 for (chy = 0; chy != 8; chy++) {
3288 MIX(sc).wValue[0] = MAKE_WORD(9, chy + 1);
3289 MIX(sc).type = MIX_SIGNED_16;
3290 MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3291 MIX(sc).name = "effect_send";
3292 MIX(sc).nchan = 1;
3293 MIX(sc).update[0] = 1;
3294 snprintf(MIX(sc).desc, sizeof(MIX(sc).desc),
3295 "Effect Send AIn%d Volume", chy + 1);
3296
3297 uaudio_mixer_add_ctl(sc, &MIX(sc));
3298
3299 MIX(sc).wValue[0] = MAKE_WORD(9, chy + 1 + 8);
3300 MIX(sc).type = MIX_SIGNED_16;
3301 MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3302 MIX(sc).name = "effect_send";
3303 MIX(sc).nchan = 1;
3304 MIX(sc).update[0] = 1;
3305 snprintf(MIX(sc).desc, sizeof(MIX(sc).desc),
3306 "Effect Send DIn%d Volume", chy + 1);
3307
3308 uaudio_mixer_add_ctl(sc, &MIX(sc));
3309 }
3310 }
3311
3312 static void
uaudio_mixer_reload_all(struct uaudio_softc * sc)3313 uaudio_mixer_reload_all(struct uaudio_softc *sc)
3314 {
3315 struct uaudio_mixer_node *pmc;
3316 int chan;
3317
3318 mtx_lock(&sc->sc_child[0].mixer_lock);
3319 for (pmc = sc->sc_mixer_root; pmc != NULL; pmc = pmc->next) {
3320 /* use reset defaults for non-oss controlled settings */
3321 if (pmc->ctl == SOUND_MIXER_NRDEVICES)
3322 continue;
3323 for (chan = 0; chan < pmc->nchan; chan++)
3324 pmc->update[chan / 8] |= (1 << (chan % 8));
3325 }
3326 usbd_transfer_start(sc->sc_mixer_xfer[0]);
3327
3328 /* start HID volume keys, if any */
3329 usbd_transfer_start(sc->sc_hid.xfer[0]);
3330 mtx_unlock(&sc->sc_child[0].mixer_lock);
3331 }
3332
3333 static void
uaudio_mixer_add_ctl_sub(struct uaudio_softc * sc,struct uaudio_mixer_node * mc)3334 uaudio_mixer_add_ctl_sub(struct uaudio_softc *sc, struct uaudio_mixer_node *mc)
3335 {
3336 struct uaudio_mixer_node *p_mc_new =
3337 malloc(sizeof(*p_mc_new), M_USBDEV, M_WAITOK);
3338 int ch;
3339
3340 memcpy(p_mc_new, mc, sizeof(*p_mc_new));
3341 p_mc_new->next = sc->sc_mixer_root;
3342 sc->sc_mixer_root = p_mc_new;
3343 sc->sc_mixer_count++;
3344
3345 /* set default value for all channels */
3346 for (ch = 0; ch < p_mc_new->nchan; ch++) {
3347 switch (p_mc_new->val_default) {
3348 case 1:
3349 /* 50% */
3350 p_mc_new->wData[ch] = (p_mc_new->maxval + p_mc_new->minval) / 2;
3351 break;
3352 case 2:
3353 /* 100% */
3354 p_mc_new->wData[ch] = p_mc_new->maxval;
3355 break;
3356 default:
3357 /* 0% */
3358 p_mc_new->wData[ch] = p_mc_new->minval;
3359 break;
3360 }
3361 }
3362 }
3363
3364 static void
uaudio_mixer_add_ctl(struct uaudio_softc * sc,struct uaudio_mixer_node * mc)3365 uaudio_mixer_add_ctl(struct uaudio_softc *sc, struct uaudio_mixer_node *mc)
3366 {
3367 int32_t res;
3368
3369 DPRINTF("adding %d\n", mc->ctl);
3370
3371 if (mc->type == MIX_ON_OFF) {
3372 mc->minval = 0;
3373 mc->maxval = 1;
3374 } else if (mc->type == MIX_SELECTOR) {
3375 } else {
3376 /* determine min and max values */
3377
3378 mc->minval = uaudio_mixer_get(sc->sc_udev,
3379 sc->sc_audio_rev, GET_MIN, mc);
3380 mc->maxval = uaudio_mixer_get(sc->sc_udev,
3381 sc->sc_audio_rev, GET_MAX, mc);
3382
3383 /* check if max and min was swapped */
3384
3385 if (mc->maxval < mc->minval) {
3386 res = mc->maxval;
3387 mc->maxval = mc->minval;
3388 mc->minval = res;
3389 }
3390
3391 /* compute value range */
3392 mc->mul = mc->maxval - mc->minval;
3393 if (mc->mul == 0)
3394 mc->mul = 1;
3395
3396 /* compute value alignment */
3397 res = uaudio_mixer_get(sc->sc_udev,
3398 sc->sc_audio_rev, GET_RES, mc);
3399
3400 DPRINTF("Resolution = %d\n", (int)res);
3401 }
3402
3403 uaudio_mixer_add_ctl_sub(sc, mc);
3404
3405 #ifdef USB_DEBUG
3406 if (uaudio_debug > 2) {
3407 uint8_t i;
3408
3409 for (i = 0; i < mc->nchan; i++) {
3410 DPRINTF("[mix] wValue=%04x\n", mc->wValue[0]);
3411 }
3412 DPRINTF("[mix] wIndex=%04x type=%d ctl='%d' "
3413 "min=%d max=%d\n",
3414 mc->wIndex, mc->type, mc->ctl,
3415 mc->minval, mc->maxval);
3416 }
3417 #endif
3418 }
3419
3420 static void
uaudio_mixer_add_mixer(struct uaudio_softc * sc,const struct uaudio_terminal_node * iot,int id)3421 uaudio_mixer_add_mixer(struct uaudio_softc *sc,
3422 const struct uaudio_terminal_node *iot, int id)
3423 {
3424 const struct usb_audio_mixer_unit_0 *d0 = iot[id].u.mu_v1;
3425 const struct usb_audio_mixer_unit_1 *d1;
3426
3427 uint32_t bno; /* bit number */
3428 uint32_t p; /* bit number accumulator */
3429 uint32_t mo; /* matching outputs */
3430 uint32_t mc; /* matching channels */
3431 uint32_t ichs; /* input channels */
3432 uint32_t ochs; /* output channels */
3433 uint32_t c;
3434 uint32_t chs; /* channels */
3435 uint32_t i;
3436 uint32_t o;
3437
3438 DPRINTFN(3, "bUnitId=%d bNrInPins=%d\n",
3439 d0->bUnitId, d0->bNrInPins);
3440
3441 /* compute the number of input channels */
3442
3443 ichs = 0;
3444 for (i = 0; i < d0->bNrInPins; i++) {
3445 ichs += uaudio_mixer_get_cluster(
3446 d0->baSourceId[i], iot).bNrChannels;
3447 }
3448
3449 d1 = (const void *)(d0->baSourceId + d0->bNrInPins);
3450
3451 /* and the number of output channels */
3452
3453 ochs = d1->bNrChannels;
3454
3455 DPRINTFN(3, "ichs=%d ochs=%d\n", ichs, ochs);
3456
3457 memset(&MIX(sc), 0, sizeof(MIX(sc)));
3458
3459 MIX(sc).wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no);
3460 MIX(sc).type = MIX_SIGNED_16;
3461
3462 if (uaudio_mixer_verify_desc(d0, ((ichs * ochs) + 7) / 8) == NULL)
3463 return;
3464
3465 for (p = i = 0; i < d0->bNrInPins; i++) {
3466 chs = uaudio_mixer_get_cluster(
3467 d0->baSourceId[i], iot).bNrChannels;
3468 mc = 0;
3469 for (c = 0; c < chs; c++) {
3470 mo = 0;
3471 for (o = 0; o < ochs; o++) {
3472 bno = ((p + c) * ochs) + o;
3473 if (BIT_TEST(d1->bmControls, bno))
3474 mo++;
3475 }
3476 if (mo == 1)
3477 mc++;
3478 }
3479 if ((mc == chs) && (chs <= MIX_MAX_CHAN)) {
3480 /* repeat bit-scan */
3481
3482 mc = 0;
3483 for (c = 0; c < chs; c++) {
3484 for (o = 0; o < ochs; o++) {
3485 bno = ((p + c) * ochs) + o;
3486 if (BIT_TEST(d1->bmControls, bno))
3487 MIX(sc).wValue[mc++] = MAKE_WORD(p + c + 1, o + 1);
3488 }
3489 }
3490 MIX(sc).nchan = chs;
3491 uaudio_mixer_add_ctl(sc, &MIX(sc));
3492 }
3493 p += chs;
3494 }
3495 }
3496
3497 static void
uaudio20_mixer_add_mixer(struct uaudio_softc * sc,const struct uaudio_terminal_node * iot,int id)3498 uaudio20_mixer_add_mixer(struct uaudio_softc *sc,
3499 const struct uaudio_terminal_node *iot, int id)
3500 {
3501 const struct usb_audio20_mixer_unit_0 *d0 = iot[id].u.mu_v2;
3502 const struct usb_audio20_mixer_unit_1 *d1;
3503
3504 uint32_t bno; /* bit number */
3505 uint32_t p; /* bit number accumulator */
3506 uint32_t mo; /* matching outputs */
3507 uint32_t mc; /* matching channels */
3508 uint32_t ichs; /* input channels */
3509 uint32_t ochs; /* output channels */
3510 uint32_t c;
3511 uint32_t chs; /* channels */
3512 uint32_t i;
3513 uint32_t o;
3514
3515 DPRINTFN(3, "bUnitId=%d bNrInPins=%d\n",
3516 d0->bUnitId, d0->bNrInPins);
3517
3518 /* compute the number of input channels */
3519
3520 ichs = 0;
3521 for (i = 0; i < d0->bNrInPins; i++) {
3522 ichs += uaudio20_mixer_get_cluster(
3523 d0->baSourceId[i], iot).bNrChannels;
3524 }
3525
3526 d1 = (const void *)(d0->baSourceId + d0->bNrInPins);
3527
3528 /* and the number of output channels */
3529
3530 ochs = d1->bNrChannels;
3531
3532 DPRINTFN(3, "ichs=%d ochs=%d\n", ichs, ochs);
3533
3534 memset(&MIX(sc), 0, sizeof(MIX(sc)));
3535
3536 MIX(sc).wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no);
3537 MIX(sc).type = MIX_SIGNED_16;
3538
3539 if (uaudio20_mixer_verify_desc(d0, ((ichs * ochs) + 7) / 8) == NULL)
3540 return;
3541
3542 for (p = i = 0; i < d0->bNrInPins; i++) {
3543 chs = uaudio20_mixer_get_cluster(
3544 d0->baSourceId[i], iot).bNrChannels;
3545 mc = 0;
3546 for (c = 0; c < chs; c++) {
3547 mo = 0;
3548 for (o = 0; o < ochs; o++) {
3549 bno = ((p + c) * ochs) + o;
3550 if (BIT_TEST(d1->bmControls, bno))
3551 mo++;
3552 }
3553 if (mo == 1)
3554 mc++;
3555 }
3556 if ((mc == chs) && (chs <= MIX_MAX_CHAN)) {
3557 /* repeat bit-scan */
3558
3559 mc = 0;
3560 for (c = 0; c < chs; c++) {
3561 for (o = 0; o < ochs; o++) {
3562 bno = ((p + c) * ochs) + o;
3563 if (BIT_TEST(d1->bmControls, bno))
3564 MIX(sc).wValue[mc++] = MAKE_WORD(p + c + 1, o + 1);
3565 }
3566 }
3567 MIX(sc).nchan = chs;
3568 uaudio_mixer_add_ctl(sc, &MIX(sc));
3569 }
3570 p += chs;
3571 }
3572 }
3573
3574 static void
uaudio_mixer_check_selectors(struct uaudio_softc * sc)3575 uaudio_mixer_check_selectors(struct uaudio_softc *sc)
3576 {
3577 uint8_t reserve_feature[] = {
3578 SOUND_MIXER_LINE,
3579 SOUND_MIXER_LINE1,
3580 SOUND_MIXER_LINE2,
3581 SOUND_MIXER_LINE3,
3582 SOUND_MIXER_DIGITAL1,
3583 SOUND_MIXER_DIGITAL2,
3584 SOUND_MIXER_DIGITAL3,
3585 };
3586 const uint16_t reserve_max =
3587 sizeof(reserve_feature) / sizeof(reserve_feature[0]);
3588 uint16_t i;
3589 uint16_t j;
3590 uint16_t k;
3591
3592 /* remove existing selector types from the reserve */
3593 for (i = 0; i < MIX(sc).maxval; i++) {
3594 if (MIX(sc).slctrtype[i] == SOUND_MIXER_NRDEVICES)
3595 continue;
3596 for (j = 0; j != reserve_max; j++) {
3597 if (reserve_feature[j] == MIX(sc).slctrtype[i])
3598 reserve_feature[j] = SOUND_MIXER_NRDEVICES;
3599 }
3600 }
3601
3602 /* make sure selector types are not overlapping */
3603 for (i = 0; i < MIX(sc).maxval; i++) {
3604 if (MIX(sc).slctrtype[i] == SOUND_MIXER_NRDEVICES)
3605 continue;
3606 for (j = i + 1; j < MIX(sc).maxval; j++) {
3607 if (MIX(sc).slctrtype[j] == SOUND_MIXER_NRDEVICES)
3608 continue;
3609 if (MIX(sc).slctrtype[i] != MIX(sc).slctrtype[j])
3610 continue;
3611 for (k = 0; k != reserve_max; k++) {
3612 if (reserve_feature[k] == SOUND_MIXER_NRDEVICES)
3613 continue;
3614 MIX(sc).slctrtype[j] = reserve_feature[k];
3615 reserve_feature[k] = SOUND_MIXER_NRDEVICES;
3616 break;
3617 }
3618 if (k == reserve_max) {
3619 DPRINTF("Selector type %d is not selectable!\n", j);
3620 MIX(sc).slctrtype[j] = SOUND_MIXER_NRDEVICES;
3621 }
3622 }
3623 }
3624 }
3625
3626 static void
uaudio_mixer_add_selector(struct uaudio_softc * sc,const struct uaudio_terminal_node * iot,int id)3627 uaudio_mixer_add_selector(struct uaudio_softc *sc,
3628 const struct uaudio_terminal_node *iot, int id)
3629 {
3630 const struct usb_audio_selector_unit *d = iot[id].u.su_v1;
3631 uint16_t i;
3632
3633 DPRINTFN(3, "bUnitId=%d bNrInPins=%d\n",
3634 d->bUnitId, d->bNrInPins);
3635
3636 if (d->bNrInPins == 0)
3637 return;
3638
3639 memset(&MIX(sc), 0, sizeof(MIX(sc)));
3640
3641 MIX(sc).wIndex = MAKE_WORD(d->bUnitId, sc->sc_mixer_iface_no);
3642 MIX(sc).wValue[0] = MAKE_WORD(0, 0);
3643 MIX(sc).nchan = 1;
3644 MIX(sc).type = MIX_SELECTOR;
3645 MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3646 MIX(sc).minval = 1;
3647 MIX(sc).maxval = d->bNrInPins;
3648 MIX(sc).name = "selector";
3649
3650 i = d->baSourceId[d->bNrInPins];
3651 if (i == 0 ||
3652 usbd_req_get_string_any(sc->sc_udev, NULL,
3653 MIX(sc).desc, sizeof(MIX(sc).desc), i) != 0) {
3654 MIX(sc).desc[0] = 0;
3655 }
3656
3657 if (MIX(sc).maxval > MAX_SELECTOR_INPUT_PIN)
3658 MIX(sc).maxval = MAX_SELECTOR_INPUT_PIN;
3659
3660 MIX(sc).mul = MIX(sc).maxval - MIX(sc).minval;
3661
3662 for (i = 0; i < MIX(sc).maxval; i++) {
3663 MIX(sc).slctrtype[i] =
3664 uaudio_mixer_determine_class(&iot[d->baSourceId[i]]);
3665 }
3666 for (; i < MAX_SELECTOR_INPUT_PIN; i++)
3667 MIX(sc).slctrtype[i] = SOUND_MIXER_NRDEVICES;
3668
3669 uaudio_mixer_check_selectors(sc);
3670 uaudio_mixer_add_ctl(sc, &MIX(sc));
3671 }
3672
3673 static void
uaudio20_mixer_add_selector(struct uaudio_softc * sc,const struct uaudio_terminal_node * iot,int id)3674 uaudio20_mixer_add_selector(struct uaudio_softc *sc,
3675 const struct uaudio_terminal_node *iot, int id)
3676 {
3677 const struct usb_audio20_selector_unit *d = iot[id].u.su_v2;
3678 uint16_t i;
3679
3680 DPRINTFN(3, "bUnitId=%d bNrInPins=%d\n",
3681 d->bUnitId, d->bNrInPins);
3682
3683 if (d->bNrInPins == 0)
3684 return;
3685
3686 memset(&MIX(sc), 0, sizeof(MIX(sc)));
3687
3688 MIX(sc).wIndex = MAKE_WORD(d->bUnitId, sc->sc_mixer_iface_no);
3689 MIX(sc).wValue[0] = MAKE_WORD(0, 0);
3690 MIX(sc).nchan = 1;
3691 MIX(sc).type = MIX_SELECTOR;
3692 MIX(sc).ctl = SOUND_MIXER_NRDEVICES;
3693 MIX(sc).minval = 1;
3694 MIX(sc).maxval = d->bNrInPins;
3695 MIX(sc).name = "selector";
3696
3697 i = d->baSourceId[d->bNrInPins];
3698 if (i == 0 ||
3699 usbd_req_get_string_any(sc->sc_udev, NULL,
3700 MIX(sc).desc, sizeof(MIX(sc).desc), i) != 0) {
3701 MIX(sc).desc[0] = 0;
3702 }
3703
3704 if (MIX(sc).maxval > MAX_SELECTOR_INPUT_PIN)
3705 MIX(sc).maxval = MAX_SELECTOR_INPUT_PIN;
3706
3707 MIX(sc).mul = MIX(sc).maxval - MIX(sc).minval;
3708
3709 for (i = 0; i < MIX(sc).maxval; i++) {
3710 MIX(sc).slctrtype[i] =
3711 uaudio20_mixer_determine_class(&iot[d->baSourceId[i]]);
3712 }
3713 for (; i < MAX_SELECTOR_INPUT_PIN; i++)
3714 MIX(sc).slctrtype[i] = SOUND_MIXER_NRDEVICES;
3715
3716 uaudio_mixer_check_selectors(sc);
3717 uaudio_mixer_add_ctl(sc, &MIX(sc));
3718 }
3719
3720 static uint32_t
uaudio_mixer_feature_get_bmaControls(const struct usb_audio_feature_unit * d,uint8_t i)3721 uaudio_mixer_feature_get_bmaControls(const struct usb_audio_feature_unit *d,
3722 uint8_t i)
3723 {
3724 uint32_t temp = 0;
3725 uint32_t offset = (i * d->bControlSize);
3726
3727 if (d->bControlSize > 0) {
3728 temp |= d->bmaControls[offset];
3729 if (d->bControlSize > 1) {
3730 temp |= d->bmaControls[offset + 1] << 8;
3731 if (d->bControlSize > 2) {
3732 temp |= d->bmaControls[offset + 2] << 16;
3733 if (d->bControlSize > 3) {
3734 temp |= d->bmaControls[offset + 3] << 24;
3735 }
3736 }
3737 }
3738 }
3739 return (temp);
3740 }
3741
3742 static void
uaudio_mixer_add_feature(struct uaudio_softc * sc,const struct uaudio_terminal_node * iot,int id)3743 uaudio_mixer_add_feature(struct uaudio_softc *sc,
3744 const struct uaudio_terminal_node *iot, int id)
3745 {
3746 const struct usb_audio_feature_unit *d = iot[id].u.fu_v1;
3747 uint32_t fumask;
3748 uint32_t mmask;
3749 uint32_t cmask;
3750 uint16_t mixernumber;
3751 uint8_t nchan;
3752 uint8_t chan;
3753 uint8_t ctl;
3754 uint8_t i;
3755
3756 if (d->bControlSize == 0)
3757 return;
3758
3759 memset(&MIX(sc), 0, sizeof(MIX(sc)));
3760
3761 nchan = (d->bLength - 7) / d->bControlSize;
3762 mmask = uaudio_mixer_feature_get_bmaControls(d, 0);
3763 cmask = 0;
3764
3765 if (nchan == 0)
3766 return;
3767
3768 /* figure out what we can control */
3769
3770 for (chan = 1; chan < nchan; chan++) {
3771 DPRINTFN(10, "chan=%d mask=%x\n",
3772 chan, uaudio_mixer_feature_get_bmaControls(d, chan));
3773
3774 cmask |= uaudio_mixer_feature_get_bmaControls(d, chan);
3775 }
3776
3777 MIX(sc).wIndex = MAKE_WORD(d->bUnitId, sc->sc_mixer_iface_no);
3778
3779 i = d->bmaControls[nchan * d->bControlSize];
3780 if (i == 0 ||
3781 usbd_req_get_string_any(sc->sc_udev, NULL,
3782 MIX(sc).desc, sizeof(MIX(sc).desc), i) != 0) {
3783 MIX(sc).desc[0] = 0;
3784 }
3785
3786 if (nchan > MIX_MAX_CHAN)
3787 nchan = MIX_MAX_CHAN;
3788
3789 for (ctl = 1; ctl <= LOUDNESS_CONTROL; ctl++) {
3790 fumask = FU_MASK(ctl);
3791
3792 DPRINTFN(5, "ctl=%d fumask=0x%04x\n",
3793 ctl, fumask);
3794
3795 if (mmask & fumask) {
3796 MIX(sc).nchan = 1;
3797 MIX(sc).wValue[0] = MAKE_WORD(ctl, 0);
3798 } else if (cmask & fumask) {
3799 MIX(sc).nchan = nchan - 1;
3800 for (i = 1; i < nchan; i++) {
3801 if (uaudio_mixer_feature_get_bmaControls(d, i) & fumask)
3802 MIX(sc).wValue[i - 1] = MAKE_WORD(ctl, i);
3803 else
3804 MIX(sc).wValue[i - 1] = -1;
3805 }
3806 } else {
3807 continue;
3808 }
3809
3810 mixernumber = uaudio_mixer_determine_class(&iot[id]);
3811
3812 switch (ctl) {
3813 case MUTE_CONTROL:
3814 MIX(sc).type = MIX_ON_OFF;
3815 MIX(sc).ctl = SOUND_MIXER_MUTE;
3816 MIX(sc).name = "mute";
3817 break;
3818
3819 case VOLUME_CONTROL:
3820 MIX(sc).type = MIX_SIGNED_16;
3821 MIX(sc).ctl = mixernumber;
3822 MIX(sc).name = "vol";
3823 break;
3824
3825 case BASS_CONTROL:
3826 MIX(sc).type = MIX_SIGNED_8;
3827 MIX(sc).ctl = SOUND_MIXER_BASS;
3828 MIX(sc).name = "bass";
3829 break;
3830
3831 case MID_CONTROL:
3832 MIX(sc).type = MIX_SIGNED_8;
3833 MIX(sc).ctl = SOUND_MIXER_NRDEVICES; /* XXXXX */
3834 MIX(sc).name = "mid";
3835 break;
3836
3837 case TREBLE_CONTROL:
3838 MIX(sc).type = MIX_SIGNED_8;
3839 MIX(sc).ctl = SOUND_MIXER_TREBLE;
3840 MIX(sc).name = "treble";
3841 break;
3842
3843 case GRAPHIC_EQUALIZER_CONTROL:
3844 continue; /* XXX don't add anything */
3845
3846 case AGC_CONTROL:
3847 MIX(sc).type = MIX_ON_OFF;
3848 MIX(sc).ctl = SOUND_MIXER_NRDEVICES; /* XXXXX */
3849 MIX(sc).name = "agc";
3850 break;
3851
3852 case DELAY_CONTROL:
3853 MIX(sc).type = MIX_UNSIGNED_16;
3854 MIX(sc).ctl = SOUND_MIXER_NRDEVICES; /* XXXXX */
3855 MIX(sc).name = "delay";
3856 break;
3857
3858 case BASS_BOOST_CONTROL:
3859 MIX(sc).type = MIX_ON_OFF;
3860 MIX(sc).ctl = SOUND_MIXER_NRDEVICES; /* XXXXX */
3861 MIX(sc).name = "boost";
3862 break;
3863
3864 case LOUDNESS_CONTROL:
3865 MIX(sc).type = MIX_ON_OFF;
3866 MIX(sc).ctl = SOUND_MIXER_LOUD; /* Is this correct ? */
3867 MIX(sc).name = "loudness";
3868 break;
3869
3870 default:
3871 MIX(sc).type = MIX_UNKNOWN;
3872 break;
3873 }
3874
3875 if (MIX(sc).type != MIX_UNKNOWN)
3876 uaudio_mixer_add_ctl(sc, &MIX(sc));
3877 }
3878 }
3879
3880 static void
uaudio20_mixer_add_feature(struct uaudio_softc * sc,const struct uaudio_terminal_node * iot,int id)3881 uaudio20_mixer_add_feature(struct uaudio_softc *sc,
3882 const struct uaudio_terminal_node *iot, int id)
3883 {
3884 const struct usb_audio20_feature_unit *d = iot[id].u.fu_v2;
3885 uint32_t ctl;
3886 uint32_t mmask;
3887 uint32_t cmask;
3888 uint16_t mixernumber;
3889 uint8_t nchan;
3890 uint8_t chan;
3891 uint8_t i;
3892 uint8_t what;
3893
3894 if (UGETDW(d->bmaControls[0]) == 0)
3895 return;
3896
3897 memset(&MIX(sc), 0, sizeof(MIX(sc)));
3898
3899 nchan = (d->bLength - 6) / 4;
3900 mmask = UGETDW(d->bmaControls[0]);
3901 cmask = 0;
3902
3903 if (nchan == 0)
3904 return;
3905
3906 /* figure out what we can control */
3907
3908 for (chan = 1; chan < nchan; chan++)
3909 cmask |= UGETDW(d->bmaControls[chan]);
3910
3911 MIX(sc).wIndex = MAKE_WORD(d->bUnitId, sc->sc_mixer_iface_no);
3912
3913 i = d->bmaControls[nchan][0];
3914 if (i == 0 ||
3915 usbd_req_get_string_any(sc->sc_udev, NULL,
3916 MIX(sc).desc, sizeof(MIX(sc).desc), i) != 0) {
3917 MIX(sc).desc[0] = 0;
3918 }
3919
3920 if (nchan > MIX_MAX_CHAN)
3921 nchan = MIX_MAX_CHAN;
3922
3923 for (ctl = 3; ctl != 0; ctl <<= 2) {
3924 mixernumber = uaudio20_mixer_determine_class(&iot[id]);
3925
3926 switch (ctl) {
3927 case (3 << 0):
3928 MIX(sc).type = MIX_ON_OFF;
3929 MIX(sc).ctl = SOUND_MIXER_MUTE;
3930 MIX(sc).name = "mute";
3931 what = MUTE_CONTROL;
3932 break;
3933 case (3 << 2):
3934 MIX(sc).type = MIX_SIGNED_16;
3935 MIX(sc).ctl = mixernumber;
3936 MIX(sc).name = "vol";
3937 what = VOLUME_CONTROL;
3938 break;
3939 case (3 << 4):
3940 MIX(sc).type = MIX_SIGNED_8;
3941 MIX(sc).ctl = SOUND_MIXER_BASS;
3942 MIX(sc).name = "bass";
3943 what = BASS_CONTROL;
3944 break;
3945 case (3 << 6):
3946 MIX(sc).type = MIX_SIGNED_8;
3947 MIX(sc).ctl = SOUND_MIXER_NRDEVICES; /* XXXXX */
3948 MIX(sc).name = "mid";
3949 what = MID_CONTROL;
3950 break;
3951 case (3 << 8):
3952 MIX(sc).type = MIX_SIGNED_8;
3953 MIX(sc).ctl = SOUND_MIXER_TREBLE;
3954 MIX(sc).name = "treble";
3955 what = TREBLE_CONTROL;
3956 break;
3957 case (3 << 12):
3958 MIX(sc).type = MIX_ON_OFF;
3959 MIX(sc).ctl = SOUND_MIXER_NRDEVICES; /* XXXXX */
3960 MIX(sc).name = "agc";
3961 what = AGC_CONTROL;
3962 break;
3963 case (3 << 14):
3964 MIX(sc).type = MIX_UNSIGNED_16;
3965 MIX(sc).ctl = SOUND_MIXER_NRDEVICES; /* XXXXX */
3966 MIX(sc).name = "delay";
3967 what = DELAY_CONTROL;
3968 break;
3969 case (3 << 16):
3970 MIX(sc).type = MIX_ON_OFF;
3971 MIX(sc).ctl = SOUND_MIXER_NRDEVICES; /* XXXXX */
3972 MIX(sc).name = "boost";
3973 what = BASS_BOOST_CONTROL;
3974 break;
3975 case (3 << 18):
3976 MIX(sc).type = MIX_ON_OFF;
3977 MIX(sc).ctl = SOUND_MIXER_LOUD; /* Is this correct ? */
3978 MIX(sc).name = "loudness";
3979 what = LOUDNESS_CONTROL;
3980 break;
3981 case (3 << 20):
3982 MIX(sc).type = MIX_SIGNED_16;
3983 MIX(sc).ctl = mixernumber;
3984 MIX(sc).name = "igain";
3985 what = INPUT_GAIN_CONTROL;
3986 break;
3987 case (3 << 22):
3988 MIX(sc).type = MIX_SIGNED_16;
3989 MIX(sc).ctl = mixernumber;
3990 MIX(sc).name = "igainpad";
3991 what = INPUT_GAIN_PAD_CONTROL;
3992 break;
3993 default:
3994 continue;
3995 }
3996
3997 if ((mmask & ctl) == ctl) {
3998 MIX(sc).nchan = 1;
3999 MIX(sc).wValue[0] = MAKE_WORD(what, 0);
4000 } else if ((cmask & ctl) == ctl) {
4001 MIX(sc).nchan = nchan - 1;
4002 for (i = 1; i < nchan; i++) {
4003 if ((UGETDW(d->bmaControls[i]) & ctl) == ctl)
4004 MIX(sc).wValue[i - 1] = MAKE_WORD(what, i);
4005 else
4006 MIX(sc).wValue[i - 1] = -1;
4007 }
4008 } else {
4009 continue;
4010 }
4011
4012 if (MIX(sc).type != MIX_UNKNOWN)
4013 uaudio_mixer_add_ctl(sc, &MIX(sc));
4014 }
4015 }
4016
4017 static void
uaudio_mixer_add_processing_updown(struct uaudio_softc * sc,const struct uaudio_terminal_node * iot,int id)4018 uaudio_mixer_add_processing_updown(struct uaudio_softc *sc,
4019 const struct uaudio_terminal_node *iot, int id)
4020 {
4021 const struct usb_audio_processing_unit_0 *d0 = iot[id].u.pu_v1;
4022 const struct usb_audio_processing_unit_1 *d1 =
4023 (const void *)(d0->baSourceId + d0->bNrInPins);
4024 const struct usb_audio_processing_unit_updown *ud =
4025 (const void *)(d1->bmControls + d1->bControlSize);
4026 uint8_t i;
4027
4028 if (uaudio_mixer_verify_desc(d0, sizeof(*ud)) == NULL) {
4029 return;
4030 }
4031 if (uaudio_mixer_verify_desc(d0, sizeof(*ud) + (2 * ud->bNrModes))
4032 == NULL) {
4033 return;
4034 }
4035 DPRINTFN(3, "bUnitId=%d bNrModes=%d\n",
4036 d0->bUnitId, ud->bNrModes);
4037
4038 if (!(d1->bmControls[0] & UA_PROC_MASK(UD_MODE_SELECT_CONTROL))) {
4039 DPRINTF("no mode select\n");
4040 return;
4041 }
4042 memset(&MIX(sc), 0, sizeof(MIX(sc)));
4043
4044 MIX(sc).wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no);
4045 MIX(sc).nchan = 1;
4046 MIX(sc).wValue[0] = MAKE_WORD(UD_MODE_SELECT_CONTROL, 0);
4047 MIX(sc).type = MIX_ON_OFF; /* XXX */
4048
4049 for (i = 0; i < ud->bNrModes; i++) {
4050 DPRINTFN(3, "i=%d bm=0x%x\n", i, UGETW(ud->waModes[i]));
4051 /* XXX */
4052 }
4053
4054 uaudio_mixer_add_ctl(sc, &MIX(sc));
4055 }
4056
4057 static void
uaudio_mixer_add_processing(struct uaudio_softc * sc,const struct uaudio_terminal_node * iot,int id)4058 uaudio_mixer_add_processing(struct uaudio_softc *sc,
4059 const struct uaudio_terminal_node *iot, int id)
4060 {
4061 const struct usb_audio_processing_unit_0 *d0 = iot[id].u.pu_v1;
4062 const struct usb_audio_processing_unit_1 *d1 =
4063 (const void *)(d0->baSourceId + d0->bNrInPins);
4064 uint16_t ptype;
4065
4066 memset(&MIX(sc), 0, sizeof(MIX(sc)));
4067
4068 ptype = UGETW(d0->wProcessType);
4069
4070 DPRINTFN(3, "wProcessType=%d bUnitId=%d "
4071 "bNrInPins=%d\n", ptype, d0->bUnitId, d0->bNrInPins);
4072
4073 if (d1->bControlSize == 0) {
4074 return;
4075 }
4076 if (d1->bmControls[0] & UA_PROC_ENABLE_MASK) {
4077 MIX(sc).wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no);
4078 MIX(sc).nchan = 1;
4079 MIX(sc).wValue[0] = MAKE_WORD(XX_ENABLE_CONTROL, 0);
4080 MIX(sc).type = MIX_ON_OFF;
4081 uaudio_mixer_add_ctl(sc, &MIX(sc));
4082 }
4083 switch (ptype) {
4084 case UPDOWNMIX_PROCESS:
4085 uaudio_mixer_add_processing_updown(sc, iot, id);
4086 break;
4087
4088 case DOLBY_PROLOGIC_PROCESS:
4089 case P3D_STEREO_EXTENDER_PROCESS:
4090 case REVERBATION_PROCESS:
4091 case CHORUS_PROCESS:
4092 case DYN_RANGE_COMP_PROCESS:
4093 default:
4094 DPRINTF("unit %d, type=%d is not implemented\n",
4095 d0->bUnitId, ptype);
4096 break;
4097 }
4098 }
4099
4100 static void
uaudio_mixer_add_extension(struct uaudio_softc * sc,const struct uaudio_terminal_node * iot,int id)4101 uaudio_mixer_add_extension(struct uaudio_softc *sc,
4102 const struct uaudio_terminal_node *iot, int id)
4103 {
4104 const struct usb_audio_extension_unit_0 *d0 = iot[id].u.eu_v1;
4105 const struct usb_audio_extension_unit_1 *d1 =
4106 (const void *)(d0->baSourceId + d0->bNrInPins);
4107
4108 DPRINTFN(3, "bUnitId=%d bNrInPins=%d\n",
4109 d0->bUnitId, d0->bNrInPins);
4110
4111 if (sc->sc_uq_au_no_xu) {
4112 return;
4113 }
4114 if (d1->bControlSize == 0) {
4115 return;
4116 }
4117 if (d1->bmControls[0] & UA_EXT_ENABLE_MASK) {
4118 memset(&MIX(sc), 0, sizeof(MIX(sc)));
4119
4120 MIX(sc).wIndex = MAKE_WORD(d0->bUnitId, sc->sc_mixer_iface_no);
4121 MIX(sc).nchan = 1;
4122 MIX(sc).wValue[0] = MAKE_WORD(UA_EXT_ENABLE, 0);
4123 MIX(sc).type = MIX_ON_OFF;
4124
4125 uaudio_mixer_add_ctl(sc, &MIX(sc));
4126 }
4127 }
4128
4129 static const void *
uaudio_mixer_verify_desc(const void * arg,uint32_t len)4130 uaudio_mixer_verify_desc(const void *arg, uint32_t len)
4131 {
4132 const struct usb_audio_mixer_unit_1 *d1;
4133 const struct usb_audio_extension_unit_1 *e1;
4134 const struct usb_audio_processing_unit_1 *u1;
4135
4136 union {
4137 const struct usb_descriptor *desc;
4138 const struct usb_audio_input_terminal *it;
4139 const struct usb_audio_output_terminal *ot;
4140 const struct usb_audio_mixer_unit_0 *mu;
4141 const struct usb_audio_selector_unit *su;
4142 const struct usb_audio_feature_unit *fu;
4143 const struct usb_audio_processing_unit_0 *pu;
4144 const struct usb_audio_extension_unit_0 *eu;
4145 } u;
4146
4147 u.desc = arg;
4148
4149 if (u.desc == NULL) {
4150 goto error;
4151 }
4152 if (u.desc->bDescriptorType != UDESC_CS_INTERFACE) {
4153 goto error;
4154 }
4155 switch (u.desc->bDescriptorSubtype) {
4156 case UDESCSUB_AC_INPUT:
4157 len += sizeof(*u.it);
4158 break;
4159
4160 case UDESCSUB_AC_OUTPUT:
4161 len += sizeof(*u.ot);
4162 break;
4163
4164 case UDESCSUB_AC_MIXER:
4165 len += sizeof(*u.mu);
4166
4167 if (u.desc->bLength < len) {
4168 goto error;
4169 }
4170 len += u.mu->bNrInPins;
4171
4172 if (u.desc->bLength < len) {
4173 goto error;
4174 }
4175 d1 = (const void *)(u.mu->baSourceId + u.mu->bNrInPins);
4176
4177 len += sizeof(*d1);
4178 break;
4179
4180 case UDESCSUB_AC_SELECTOR:
4181 len += sizeof(*u.su);
4182
4183 if (u.desc->bLength < len) {
4184 goto error;
4185 }
4186 len += u.su->bNrInPins + 1;
4187 break;
4188
4189 case UDESCSUB_AC_FEATURE:
4190 len += sizeof(*u.fu) + 1;
4191
4192 if (u.desc->bLength < len)
4193 goto error;
4194
4195 len += u.fu->bControlSize;
4196 break;
4197
4198 case UDESCSUB_AC_PROCESSING:
4199 len += sizeof(*u.pu);
4200
4201 if (u.desc->bLength < len) {
4202 goto error;
4203 }
4204 len += u.pu->bNrInPins;
4205
4206 if (u.desc->bLength < len) {
4207 goto error;
4208 }
4209 u1 = (const void *)(u.pu->baSourceId + u.pu->bNrInPins);
4210
4211 len += sizeof(*u1);
4212
4213 if (u.desc->bLength < len) {
4214 goto error;
4215 }
4216 len += u1->bControlSize;
4217
4218 break;
4219
4220 case UDESCSUB_AC_EXTENSION:
4221 len += sizeof(*u.eu);
4222
4223 if (u.desc->bLength < len) {
4224 goto error;
4225 }
4226 len += u.eu->bNrInPins;
4227
4228 if (u.desc->bLength < len) {
4229 goto error;
4230 }
4231 e1 = (const void *)(u.eu->baSourceId + u.eu->bNrInPins);
4232
4233 len += sizeof(*e1);
4234
4235 if (u.desc->bLength < len) {
4236 goto error;
4237 }
4238 len += e1->bControlSize;
4239 break;
4240
4241 default:
4242 goto error;
4243 }
4244
4245 if (u.desc->bLength < len) {
4246 goto error;
4247 }
4248 return (u.desc);
4249
4250 error:
4251 if (u.desc) {
4252 DPRINTF("invalid descriptor, type=%d, "
4253 "sub_type=%d, len=%d of %d bytes\n",
4254 u.desc->bDescriptorType,
4255 u.desc->bDescriptorSubtype,
4256 u.desc->bLength, len);
4257 }
4258 return (NULL);
4259 }
4260
4261 static const void *
uaudio20_mixer_verify_desc(const void * arg,uint32_t len)4262 uaudio20_mixer_verify_desc(const void *arg, uint32_t len)
4263 {
4264 const struct usb_audio20_mixer_unit_1 *d1;
4265 const struct usb_audio20_extension_unit_1 *e1;
4266 const struct usb_audio20_processing_unit_1 *u1;
4267 const struct usb_audio20_clock_selector_unit_1 *c1;
4268
4269 union {
4270 const struct usb_descriptor *desc;
4271 const struct usb_audio20_clock_source_unit *csrc;
4272 const struct usb_audio20_clock_selector_unit_0 *csel;
4273 const struct usb_audio20_clock_multiplier_unit *cmul;
4274 const struct usb_audio20_input_terminal *it;
4275 const struct usb_audio20_output_terminal *ot;
4276 const struct usb_audio20_mixer_unit_0 *mu;
4277 const struct usb_audio20_selector_unit *su;
4278 const struct usb_audio20_feature_unit *fu;
4279 const struct usb_audio20_sample_rate_unit *ru;
4280 const struct usb_audio20_processing_unit_0 *pu;
4281 const struct usb_audio20_extension_unit_0 *eu;
4282 const struct usb_audio20_effect_unit *ef;
4283 } u;
4284
4285 u.desc = arg;
4286
4287 if (u.desc == NULL)
4288 goto error;
4289
4290 if (u.desc->bDescriptorType != UDESC_CS_INTERFACE)
4291 goto error;
4292
4293 switch (u.desc->bDescriptorSubtype) {
4294 case UDESCSUB_AC_INPUT:
4295 len += sizeof(*u.it);
4296 break;
4297
4298 case UDESCSUB_AC_OUTPUT:
4299 len += sizeof(*u.ot);
4300 break;
4301
4302 case UDESCSUB_AC_MIXER:
4303 len += sizeof(*u.mu);
4304
4305 if (u.desc->bLength < len)
4306 goto error;
4307 len += u.mu->bNrInPins;
4308
4309 if (u.desc->bLength < len)
4310 goto error;
4311
4312 d1 = (const void *)(u.mu->baSourceId + u.mu->bNrInPins);
4313
4314 len += sizeof(*d1) + d1->bNrChannels;
4315 break;
4316
4317 case UDESCSUB_AC_SELECTOR:
4318 len += sizeof(*u.su);
4319
4320 if (u.desc->bLength < len)
4321 goto error;
4322
4323 len += u.su->bNrInPins + 1;
4324 break;
4325
4326 case UDESCSUB_AC_FEATURE:
4327 len += sizeof(*u.fu) + 1;
4328 break;
4329
4330 case UDESCSUB_AC_EFFECT:
4331 len += sizeof(*u.ef) + 4;
4332 break;
4333
4334 case UDESCSUB_AC_PROCESSING_V2:
4335 len += sizeof(*u.pu);
4336
4337 if (u.desc->bLength < len)
4338 goto error;
4339
4340 len += u.pu->bNrInPins;
4341
4342 if (u.desc->bLength < len)
4343 goto error;
4344
4345 u1 = (const void *)(u.pu->baSourceId + u.pu->bNrInPins);
4346
4347 len += sizeof(*u1);
4348 break;
4349
4350 case UDESCSUB_AC_EXTENSION_V2:
4351 len += sizeof(*u.eu);
4352
4353 if (u.desc->bLength < len)
4354 goto error;
4355
4356 len += u.eu->bNrInPins;
4357
4358 if (u.desc->bLength < len)
4359 goto error;
4360
4361 e1 = (const void *)(u.eu->baSourceId + u.eu->bNrInPins);
4362
4363 len += sizeof(*e1);
4364 break;
4365
4366 case UDESCSUB_AC_CLOCK_SRC:
4367 len += sizeof(*u.csrc);
4368 break;
4369
4370 case UDESCSUB_AC_CLOCK_SEL:
4371 len += sizeof(*u.csel);
4372
4373 if (u.desc->bLength < len)
4374 goto error;
4375
4376 len += u.csel->bNrInPins;
4377
4378 if (u.desc->bLength < len)
4379 goto error;
4380
4381 c1 = (const void *)(u.csel->baCSourceId + u.csel->bNrInPins);
4382
4383 len += sizeof(*c1);
4384 break;
4385
4386 case UDESCSUB_AC_CLOCK_MUL:
4387 len += sizeof(*u.cmul);
4388 break;
4389
4390 case UDESCSUB_AC_SAMPLE_RT:
4391 len += sizeof(*u.ru);
4392 break;
4393
4394 default:
4395 goto error;
4396 }
4397
4398 if (u.desc->bLength < len)
4399 goto error;
4400
4401 return (u.desc);
4402
4403 error:
4404 if (u.desc) {
4405 DPRINTF("invalid descriptor, type=%d, "
4406 "sub_type=%d, len=%d of %d bytes\n",
4407 u.desc->bDescriptorType,
4408 u.desc->bDescriptorSubtype,
4409 u.desc->bLength, len);
4410 }
4411 return (NULL);
4412 }
4413
4414 static struct usb_audio_cluster
uaudio_mixer_get_cluster(uint8_t id,const struct uaudio_terminal_node * iot)4415 uaudio_mixer_get_cluster(uint8_t id, const struct uaudio_terminal_node *iot)
4416 {
4417 struct usb_audio_cluster r;
4418 const struct usb_descriptor *dp;
4419 uint8_t i;
4420
4421 for (i = 0; i < UAUDIO_RECURSE_LIMIT; i++) { /* avoid infinite loops */
4422 dp = iot[id].u.desc;
4423 if (dp == NULL) {
4424 goto error;
4425 }
4426 switch (dp->bDescriptorSubtype) {
4427 case UDESCSUB_AC_INPUT:
4428 r.bNrChannels = iot[id].u.it_v1->bNrChannels;
4429 r.wChannelConfig[0] = iot[id].u.it_v1->wChannelConfig[0];
4430 r.wChannelConfig[1] = iot[id].u.it_v1->wChannelConfig[1];
4431 r.iChannelNames = iot[id].u.it_v1->iChannelNames;
4432 goto done;
4433
4434 case UDESCSUB_AC_OUTPUT:
4435 id = iot[id].u.ot_v1->bSourceId;
4436 break;
4437
4438 case UDESCSUB_AC_MIXER:
4439 r = *(const struct usb_audio_cluster *)
4440 &iot[id].u.mu_v1->baSourceId[
4441 iot[id].u.mu_v1->bNrInPins];
4442 goto done;
4443
4444 case UDESCSUB_AC_SELECTOR:
4445 if (iot[id].u.su_v1->bNrInPins > 0) {
4446 /* XXX This is not really right */
4447 id = iot[id].u.su_v1->baSourceId[0];
4448 }
4449 break;
4450
4451 case UDESCSUB_AC_FEATURE:
4452 id = iot[id].u.fu_v1->bSourceId;
4453 break;
4454
4455 case UDESCSUB_AC_PROCESSING:
4456 r = *((const struct usb_audio_cluster *)
4457 &iot[id].u.pu_v1->baSourceId[
4458 iot[id].u.pu_v1->bNrInPins]);
4459 goto done;
4460
4461 case UDESCSUB_AC_EXTENSION:
4462 r = *((const struct usb_audio_cluster *)
4463 &iot[id].u.eu_v1->baSourceId[
4464 iot[id].u.eu_v1->bNrInPins]);
4465 goto done;
4466
4467 default:
4468 goto error;
4469 }
4470 }
4471 error:
4472 DPRINTF("bad data\n");
4473 memset(&r, 0, sizeof(r));
4474 done:
4475 return (r);
4476 }
4477
4478 static struct usb_audio20_cluster
uaudio20_mixer_get_cluster(uint8_t id,const struct uaudio_terminal_node * iot)4479 uaudio20_mixer_get_cluster(uint8_t id, const struct uaudio_terminal_node *iot)
4480 {
4481 struct usb_audio20_cluster r;
4482 const struct usb_descriptor *dp;
4483 uint8_t i;
4484
4485 for (i = 0; i < UAUDIO_RECURSE_LIMIT; i++) { /* avoid infinite loops */
4486 dp = iot[id].u.desc;
4487 if (dp == NULL)
4488 goto error;
4489
4490 switch (dp->bDescriptorSubtype) {
4491 case UDESCSUB_AC_INPUT:
4492 r.bNrChannels = iot[id].u.it_v2->bNrChannels;
4493 r.bmChannelConfig[0] = iot[id].u.it_v2->bmChannelConfig[0];
4494 r.bmChannelConfig[1] = iot[id].u.it_v2->bmChannelConfig[1];
4495 r.bmChannelConfig[2] = iot[id].u.it_v2->bmChannelConfig[2];
4496 r.bmChannelConfig[3] = iot[id].u.it_v2->bmChannelConfig[3];
4497 r.iChannelNames = iot[id].u.it_v2->iTerminal;
4498 goto done;
4499
4500 case UDESCSUB_AC_OUTPUT:
4501 id = iot[id].u.ot_v2->bSourceId;
4502 break;
4503
4504 case UDESCSUB_AC_MIXER:
4505 r = *(const struct usb_audio20_cluster *)
4506 &iot[id].u.mu_v2->baSourceId[
4507 iot[id].u.mu_v2->bNrInPins];
4508 goto done;
4509
4510 case UDESCSUB_AC_SELECTOR:
4511 if (iot[id].u.su_v2->bNrInPins > 0) {
4512 /* XXX This is not really right */
4513 id = iot[id].u.su_v2->baSourceId[0];
4514 }
4515 break;
4516
4517 case UDESCSUB_AC_SAMPLE_RT:
4518 id = iot[id].u.ru_v2->bSourceId;
4519 break;
4520
4521 case UDESCSUB_AC_EFFECT:
4522 id = iot[id].u.ef_v2->bSourceId;
4523 break;
4524
4525 case UDESCSUB_AC_FEATURE:
4526 id = iot[id].u.fu_v2->bSourceId;
4527 break;
4528
4529 case UDESCSUB_AC_PROCESSING_V2:
4530 r = *((const struct usb_audio20_cluster *)
4531 &iot[id].u.pu_v2->baSourceId[
4532 iot[id].u.pu_v2->bNrInPins]);
4533 goto done;
4534
4535 case UDESCSUB_AC_EXTENSION_V2:
4536 r = *((const struct usb_audio20_cluster *)
4537 &iot[id].u.eu_v2->baSourceId[
4538 iot[id].u.eu_v2->bNrInPins]);
4539 goto done;
4540
4541 default:
4542 goto error;
4543 }
4544 }
4545 error:
4546 DPRINTF("Bad data!\n");
4547 memset(&r, 0, sizeof(r));
4548 done:
4549 return (r);
4550 }
4551
4552 static bool
uaudio_mixer_foreach_input(const struct uaudio_terminal_node * iot,uint8_t * pindex)4553 uaudio_mixer_foreach_input(const struct uaudio_terminal_node *iot, uint8_t *pindex)
4554 {
4555 uint8_t n;
4556
4557 n = *pindex;
4558
4559 while (1) {
4560 if (!n--)
4561 n = iot->usr.id_max;
4562 if (n == 0)
4563 return (false);
4564 if (iot->usr.bit_input[n / 8] & (1 << (n % 8)))
4565 break;
4566 }
4567 *pindex = n;
4568 return (true);
4569 }
4570
4571 static bool
uaudio_mixer_foreach_output(const struct uaudio_terminal_node * iot,uint8_t * pindex)4572 uaudio_mixer_foreach_output(const struct uaudio_terminal_node *iot, uint8_t *pindex)
4573 {
4574 uint8_t n;
4575
4576 n = *pindex;
4577
4578 while (1) {
4579 if (!n--)
4580 n = iot->usr.id_max;
4581 if (n == 0)
4582 return (false);
4583 if (iot->usr.bit_output[n / 8] & (1 << (n % 8)))
4584 break;
4585 }
4586 *pindex = n;
4587 return (true);
4588 }
4589
4590 struct uaudio_tt_to_feature {
4591 uint16_t terminal_type;
4592 uint16_t feature;
4593 };
4594
4595 static const struct uaudio_tt_to_feature uaudio_tt_to_feature[] = {
4596 {UATI_MICROPHONE, SOUND_MIXER_MIC},
4597 {UATI_DESKMICROPHONE, SOUND_MIXER_MIC},
4598 {UATI_PERSONALMICROPHONE, SOUND_MIXER_MIC},
4599 {UATI_OMNIMICROPHONE, SOUND_MIXER_MIC},
4600 {UATI_MICROPHONEARRAY, SOUND_MIXER_MIC},
4601 {UATI_PROCMICROPHONEARR, SOUND_MIXER_MIC},
4602
4603 {UATE_ANALOGCONN, SOUND_MIXER_LINE},
4604 {UATE_LINECONN, SOUND_MIXER_LINE},
4605 {UATE_LEGACYCONN, SOUND_MIXER_LINE},
4606
4607 {UATE_DIGITALAUIFC, SOUND_MIXER_ALTPCM},
4608 {UATE_SPDIF, SOUND_MIXER_ALTPCM},
4609 {UATE_1394DA, SOUND_MIXER_ALTPCM},
4610 {UATE_1394DV, SOUND_MIXER_ALTPCM},
4611
4612 {UATF_CDPLAYER, SOUND_MIXER_CD},
4613
4614 {UATF_SYNTHESIZER, SOUND_MIXER_SYNTH},
4615
4616 {UATF_VIDEODISCAUDIO, SOUND_MIXER_VIDEO},
4617 {UATF_DVDAUDIO, SOUND_MIXER_VIDEO},
4618 {UATF_TVTUNERAUDIO, SOUND_MIXER_VIDEO},
4619
4620 {UATF_RADIORECV, SOUND_MIXER_RADIO},
4621 {UATF_RADIOXMIT, SOUND_MIXER_RADIO},
4622
4623 {} /* END */
4624 };
4625
4626 static uint16_t
uaudio_mixer_get_feature_by_tt(uint16_t terminal_type,uint16_t default_type)4627 uaudio_mixer_get_feature_by_tt(uint16_t terminal_type, uint16_t default_type)
4628 {
4629 const struct uaudio_tt_to_feature *uat = uaudio_tt_to_feature;
4630 uint16_t retval;
4631
4632 if (terminal_type == 0) {
4633 retval = default_type;
4634 } else while (1) {
4635 if (uat->terminal_type == 0) {
4636 switch (terminal_type >> 8) {
4637 case UATI_UNDEFINED >> 8:
4638 retval = SOUND_MIXER_RECLEV;
4639 goto done;
4640 case UATO_UNDEFINED >> 8:
4641 retval = SOUND_MIXER_PCM;
4642 goto done;
4643 case UATT_UNDEFINED >> 8:
4644 retval = SOUND_MIXER_PHONEIN;
4645 goto done;
4646 default:
4647 retval = default_type;
4648 goto done;
4649 }
4650 } else if (uat->terminal_type == terminal_type) {
4651 retval = uat->feature;
4652 goto done;
4653 }
4654 uat++;
4655 }
4656 done:
4657 DPRINTF("terminal_type=0x%04x RET=%d DEF=%d\n",
4658 terminal_type, retval, default_type);
4659 return (retval);
4660 }
4661
4662 static uint16_t
uaudio_mixer_determine_class(const struct uaudio_terminal_node * iot)4663 uaudio_mixer_determine_class(const struct uaudio_terminal_node *iot)
4664 {
4665 const struct uaudio_terminal_node *ptr;
4666 uint16_t terminal_type_input = 0;
4667 uint16_t terminal_type_output = 0;
4668 uint16_t temp;
4669 uint8_t match = 0;
4670 uint8_t i;
4671
4672 for (i = 0; uaudio_mixer_foreach_input(iot, &i); ) {
4673 ptr = iot->root + i;
4674 temp = UGETW(ptr->u.it_v1->wTerminalType);
4675
4676 if (temp == 0)
4677 continue;
4678 else if (temp == UAT_STREAM)
4679 match |= 1;
4680 else if ((temp & 0xFF00) != (UAT_UNDEFINED & 0xff00))
4681 terminal_type_input = temp;
4682 }
4683
4684 for (i = 0; uaudio_mixer_foreach_output(iot, &i); ) {
4685 ptr = iot->root + i;
4686 temp = UGETW(ptr->u.ot_v1->wTerminalType);
4687
4688 if (temp == 0)
4689 continue;
4690 else if (temp == UAT_STREAM)
4691 match |= 2;
4692 else if ((temp & 0xFF00) != (UAT_UNDEFINED & 0xff00))
4693 terminal_type_output = temp;
4694 }
4695
4696 DPRINTF("MATCH=%d IN=0x%04x OUT=0x%04x\n",
4697 match, terminal_type_input, terminal_type_output);
4698
4699 switch (match) {
4700 case 0: /* not connected to USB */
4701 /*
4702 * Some devices have a hardware sidetone that will show up here
4703 * as connecting the microphone to the speaker. If we look at
4704 * the output first, then we are more likely to get a PCM type
4705 * and accidentally tie it to playback when we really should
4706 * treat it as a monitor control.
4707 */
4708 if (terminal_type_input != 0 && terminal_type_output != 0) {
4709 return (SOUND_MIXER_MONITOR);
4710 } else if (terminal_type_output != 0) {
4711 return (uaudio_mixer_get_feature_by_tt(
4712 terminal_type_output, SOUND_MIXER_MONITOR));
4713 } else {
4714 return (uaudio_mixer_get_feature_by_tt(
4715 terminal_type_input, SOUND_MIXER_MONITOR));
4716 }
4717 case 3: /* connected to both USB input and USB output */
4718 return (SOUND_MIXER_IMIX);
4719 case 2: /* connected to USB output */
4720 return (uaudio_mixer_get_feature_by_tt(
4721 terminal_type_input, SOUND_MIXER_RECLEV));
4722 case 1: /* connected to USB input */
4723 return (uaudio_mixer_get_feature_by_tt(
4724 terminal_type_output, SOUND_MIXER_PCM));
4725 default:
4726 return (SOUND_MIXER_NRDEVICES);
4727 }
4728 }
4729
4730 static uint16_t
uaudio20_mixer_determine_class(const struct uaudio_terminal_node * iot)4731 uaudio20_mixer_determine_class(const struct uaudio_terminal_node *iot)
4732 {
4733 const struct uaudio_terminal_node *ptr;
4734 uint16_t terminal_type_input = 0;
4735 uint16_t terminal_type_output = 0;
4736 uint16_t temp;
4737 uint8_t match = 0;
4738 uint8_t i;
4739
4740 for (i = 0; uaudio_mixer_foreach_input(iot, &i); ) {
4741 ptr = iot->root + i;
4742 temp = UGETW(ptr->u.it_v2->wTerminalType);
4743
4744 if (temp == 0)
4745 continue;
4746 else if (temp == UAT_STREAM)
4747 match |= 1;
4748 else if ((temp & 0xFF00) != (UAT_UNDEFINED & 0xff00))
4749 terminal_type_input = temp;
4750 }
4751
4752 for (i = 0; uaudio_mixer_foreach_output(iot, &i); ) {
4753 ptr = iot->root + i;
4754 temp = UGETW(ptr->u.ot_v2->wTerminalType);
4755
4756 if (temp == 0)
4757 continue;
4758 else if (temp == UAT_STREAM)
4759 match |= 2;
4760 else if ((temp & 0xFF00) != (UAT_UNDEFINED & 0xff00))
4761 terminal_type_output = temp;
4762 }
4763
4764 DPRINTF("MATCH=%d IN=0x%04x OUT=0x%04x\n",
4765 match, terminal_type_input, terminal_type_output);
4766
4767 switch (match) {
4768 case 0: /* not connected to USB */
4769 /*
4770 * Some devices have a hardware sidetone that will show up here
4771 * as connecting the microphone to the speaker. If we look at
4772 * the output first, then we are more likely to get a PCM type
4773 * and accidentally tie it to playback when we really should
4774 * treat it as a monitor control.
4775 */
4776 if (terminal_type_input != 0 && terminal_type_output != 0) {
4777 return (SOUND_MIXER_MONITOR);
4778 } else if (terminal_type_output != 0) {
4779 return (uaudio_mixer_get_feature_by_tt(
4780 terminal_type_output, SOUND_MIXER_MONITOR));
4781 } else {
4782 return (uaudio_mixer_get_feature_by_tt(
4783 terminal_type_input, SOUND_MIXER_MONITOR));
4784 }
4785 case 3: /* connected to both USB input and USB output */
4786 return (SOUND_MIXER_IMIX);
4787 case 2: /* connected to USB output */
4788 return (uaudio_mixer_get_feature_by_tt(
4789 terminal_type_input, SOUND_MIXER_RECLEV));
4790 case 1: /* connected to USB input */
4791 return (uaudio_mixer_get_feature_by_tt(
4792 terminal_type_output, SOUND_MIXER_PCM));
4793 default:
4794 return (SOUND_MIXER_NRDEVICES);
4795 }
4796 }
4797
4798 static void
uaudio_mixer_merge_outputs(struct uaudio_search_result * dst,const struct uaudio_search_result * src)4799 uaudio_mixer_merge_outputs(struct uaudio_search_result *dst,
4800 const struct uaudio_search_result *src)
4801 {
4802 const uint8_t max = sizeof(src->bit_output) / sizeof(src->bit_output[0]);
4803 uint8_t x;
4804
4805 for (x = 0; x != max; x++)
4806 dst->bit_output[x] |= src->bit_output[x];
4807 }
4808
4809 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)4810 uaudio_mixer_find_inputs_sub(struct uaudio_terminal_node *root,
4811 const uint8_t *p_id, uint8_t n_id,
4812 struct uaudio_search_result *info)
4813 {
4814 struct uaudio_terminal_node *iot;
4815 uint8_t n;
4816 uint8_t i;
4817
4818 for (n = 0; n < n_id; n++) {
4819 i = p_id[n];
4820
4821 if (info->recurse_level == UAUDIO_RECURSE_LIMIT) {
4822 DPRINTF("avoided going into a circle at id=%d!\n", i);
4823 return;
4824 }
4825
4826 info->recurse_level++;
4827
4828 iot = (root + i);
4829
4830 if (iot->u.desc == NULL)
4831 continue;
4832
4833 switch (iot->u.desc->bDescriptorSubtype) {
4834 case UDESCSUB_AC_INPUT:
4835 uaudio_mixer_merge_outputs(&iot->usr, info);
4836 info->bit_input[i / 8] |= (1 << (i % 8));
4837 break;
4838
4839 case UDESCSUB_AC_FEATURE:
4840 uaudio_mixer_merge_outputs(&iot->usr, info);
4841 uaudio_mixer_find_inputs_sub(
4842 root, &iot->u.fu_v1->bSourceId, 1, info);
4843 break;
4844
4845 case UDESCSUB_AC_OUTPUT:
4846 info->bit_output[i / 8] |= (1 << (i % 8));
4847 uaudio_mixer_find_inputs_sub(
4848 root, &iot->u.ot_v1->bSourceId, 1, info);
4849 info->bit_output[i / 8] &= ~(1 << (i % 8));
4850 break;
4851
4852 case UDESCSUB_AC_MIXER:
4853 uaudio_mixer_merge_outputs(&iot->usr, info);
4854 uaudio_mixer_find_inputs_sub(
4855 root, iot->u.mu_v1->baSourceId,
4856 iot->u.mu_v1->bNrInPins, info);
4857 break;
4858
4859 case UDESCSUB_AC_SELECTOR:
4860 uaudio_mixer_merge_outputs(&iot->usr, info);
4861 uaudio_mixer_find_inputs_sub(
4862 root, iot->u.su_v1->baSourceId,
4863 iot->u.su_v1->bNrInPins, info);
4864 break;
4865
4866 case UDESCSUB_AC_PROCESSING:
4867 uaudio_mixer_merge_outputs(&iot->usr, info);
4868 uaudio_mixer_find_inputs_sub(
4869 root, iot->u.pu_v1->baSourceId,
4870 iot->u.pu_v1->bNrInPins, info);
4871 break;
4872
4873 case UDESCSUB_AC_EXTENSION:
4874 uaudio_mixer_merge_outputs(&iot->usr, info);
4875 uaudio_mixer_find_inputs_sub(
4876 root, iot->u.eu_v1->baSourceId,
4877 iot->u.eu_v1->bNrInPins, info);
4878 break;
4879
4880 default:
4881 break;
4882 }
4883 }
4884 }
4885
4886 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)4887 uaudio20_mixer_find_inputs_sub(struct uaudio_terminal_node *root,
4888 const uint8_t *p_id, uint8_t n_id,
4889 struct uaudio_search_result *info)
4890 {
4891 struct uaudio_terminal_node *iot;
4892 uint8_t n;
4893 uint8_t i;
4894
4895 for (n = 0; n < n_id; n++) {
4896 i = p_id[n];
4897
4898 if (info->recurse_level == UAUDIO_RECURSE_LIMIT) {
4899 DPRINTF("avoided going into a circle at id=%d!\n", i);
4900 return;
4901 }
4902
4903 info->recurse_level++;
4904
4905 iot = (root + i);
4906
4907 if (iot->u.desc == NULL)
4908 continue;
4909
4910 switch (iot->u.desc->bDescriptorSubtype) {
4911 case UDESCSUB_AC_INPUT:
4912 uaudio_mixer_merge_outputs(&iot->usr, info);
4913 info->bit_input[i / 8] |= (1 << (i % 8));
4914 break;
4915
4916 case UDESCSUB_AC_OUTPUT:
4917 info->bit_output[i / 8] |= (1 << (i % 8));
4918 uaudio20_mixer_find_inputs_sub(
4919 root, &iot->u.ot_v2->bSourceId, 1, info);
4920 info->bit_output[i / 8] &= ~(1 << (i % 8));
4921 break;
4922
4923 case UDESCSUB_AC_MIXER:
4924 uaudio_mixer_merge_outputs(&iot->usr, info);
4925 uaudio20_mixer_find_inputs_sub(
4926 root, iot->u.mu_v2->baSourceId,
4927 iot->u.mu_v2->bNrInPins, info);
4928 break;
4929
4930 case UDESCSUB_AC_SELECTOR:
4931 uaudio_mixer_merge_outputs(&iot->usr, info);
4932 uaudio20_mixer_find_inputs_sub(
4933 root, iot->u.su_v2->baSourceId,
4934 iot->u.su_v2->bNrInPins, info);
4935 break;
4936
4937 case UDESCSUB_AC_SAMPLE_RT:
4938 uaudio_mixer_merge_outputs(&iot->usr, info);
4939 uaudio20_mixer_find_inputs_sub(
4940 root, &iot->u.ru_v2->bSourceId,
4941 1, info);
4942 break;
4943
4944 case UDESCSUB_AC_EFFECT:
4945 uaudio_mixer_merge_outputs(&iot->usr, info);
4946 uaudio20_mixer_find_inputs_sub(
4947 root, &iot->u.ef_v2->bSourceId,
4948 1, info);
4949 break;
4950
4951 case UDESCSUB_AC_FEATURE:
4952 uaudio_mixer_merge_outputs(&iot->usr, info);
4953 uaudio20_mixer_find_inputs_sub(
4954 root, &iot->u.fu_v2->bSourceId, 1, info);
4955 break;
4956
4957 case UDESCSUB_AC_PROCESSING_V2:
4958 uaudio_mixer_merge_outputs(&iot->usr, info);
4959 uaudio20_mixer_find_inputs_sub(
4960 root, iot->u.pu_v2->baSourceId,
4961 iot->u.pu_v2->bNrInPins, info);
4962 break;
4963
4964 case UDESCSUB_AC_EXTENSION_V2:
4965 uaudio_mixer_merge_outputs(&iot->usr, info);
4966 uaudio20_mixer_find_inputs_sub(
4967 root, iot->u.eu_v2->baSourceId,
4968 iot->u.eu_v2->bNrInPins, info);
4969 break;
4970 default:
4971 break;
4972 }
4973 }
4974 }
4975
4976 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)4977 uaudio20_mixer_find_clocks_sub(struct uaudio_terminal_node *root,
4978 const uint8_t *p_id, uint8_t n_id,
4979 struct uaudio_search_result *info)
4980 {
4981 struct uaudio_terminal_node *iot;
4982 uint8_t n;
4983 uint8_t i;
4984 uint8_t is_last;
4985 uint8_t id;
4986
4987 top:
4988 for (n = 0; n < n_id; n++) {
4989 i = p_id[n];
4990
4991 if (info->recurse_level == UAUDIO_RECURSE_LIMIT) {
4992 DPRINTF("avoided going into a circle at id=%d!\n", i);
4993 return;
4994 }
4995
4996 info->recurse_level++;
4997
4998 iot = (root + i);
4999
5000 if (iot->u.desc == NULL)
5001 continue;
5002
5003 is_last = ((n + 1) == n_id);
5004
5005 switch (iot->u.desc->bDescriptorSubtype) {
5006 case UDESCSUB_AC_INPUT:
5007 info->is_input = 1;
5008 if (is_last) {
5009 p_id = &iot->u.it_v2->bCSourceId;
5010 n_id = 1;
5011 goto top;
5012 }
5013 uaudio20_mixer_find_clocks_sub(root,
5014 &iot->u.it_v2->bCSourceId, 1, info);
5015 break;
5016
5017 case UDESCSUB_AC_OUTPUT:
5018 info->is_input = 0;
5019 if (is_last) {
5020 p_id = &iot->u.ot_v2->bCSourceId;
5021 n_id = 1;
5022 goto top;
5023 }
5024 uaudio20_mixer_find_clocks_sub(root,
5025 &iot->u.ot_v2->bCSourceId, 1, info);
5026 break;
5027
5028 case UDESCSUB_AC_CLOCK_SEL:
5029 if (is_last) {
5030 p_id = iot->u.csel_v2->baCSourceId;
5031 n_id = iot->u.csel_v2->bNrInPins;
5032 goto top;
5033 }
5034 uaudio20_mixer_find_clocks_sub(root,
5035 iot->u.csel_v2->baCSourceId,
5036 iot->u.csel_v2->bNrInPins, info);
5037 break;
5038
5039 case UDESCSUB_AC_CLOCK_MUL:
5040 if (is_last) {
5041 p_id = &iot->u.cmul_v2->bCSourceId;
5042 n_id = 1;
5043 goto top;
5044 }
5045 uaudio20_mixer_find_clocks_sub(root,
5046 &iot->u.cmul_v2->bCSourceId,
5047 1, info);
5048 break;
5049
5050 case UDESCSUB_AC_CLOCK_SRC:
5051
5052 id = iot->u.csrc_v2->bClockId;
5053
5054 switch (info->is_input) {
5055 case 0:
5056 info->bit_output[id / 8] |= (1 << (id % 8));
5057 break;
5058 case 1:
5059 info->bit_input[id / 8] |= (1 << (id % 8));
5060 break;
5061 default:
5062 break;
5063 }
5064 break;
5065
5066 default:
5067 break;
5068 }
5069 }
5070 }
5071
5072 static void
uaudio_mixer_fill_info(struct uaudio_softc * sc,struct usb_device * udev,void * desc)5073 uaudio_mixer_fill_info(struct uaudio_softc *sc,
5074 struct usb_device *udev, void *desc)
5075 {
5076 const struct usb_audio_control_descriptor *acdp;
5077 struct usb_config_descriptor *cd = usbd_get_config_descriptor(udev);
5078 const struct usb_descriptor *dp;
5079 const struct usb_audio_unit *au;
5080 struct uaudio_terminal_node *iot = NULL;
5081 uint16_t wTotalLen;
5082 uint8_t ID_max = 0; /* inclusive */
5083 uint8_t i;
5084
5085 desc = usb_desc_foreach(cd, desc);
5086
5087 if (desc == NULL) {
5088 DPRINTF("no Audio Control header\n");
5089 goto done;
5090 }
5091 acdp = desc;
5092
5093 if ((acdp->bLength < sizeof(*acdp)) ||
5094 (acdp->bDescriptorType != UDESC_CS_INTERFACE) ||
5095 (acdp->bDescriptorSubtype != UDESCSUB_AC_HEADER)) {
5096 DPRINTF("invalid Audio Control header\n");
5097 goto done;
5098 }
5099 /* "wTotalLen" is allowed to be corrupt */
5100 wTotalLen = UGETW(acdp->wTotalLength) - acdp->bLength;
5101
5102 /* get USB audio revision */
5103 sc->sc_audio_rev = UGETW(acdp->bcdADC);
5104
5105 DPRINTFN(3, "found AC header, vers=%03x, len=%d\n",
5106 sc->sc_audio_rev, wTotalLen);
5107
5108 iot = malloc(sizeof(struct uaudio_terminal_node) * 256, M_TEMP,
5109 M_WAITOK | M_ZERO);
5110
5111 while ((desc = usb_desc_foreach(cd, desc))) {
5112 dp = desc;
5113
5114 if (dp->bLength > wTotalLen) {
5115 break;
5116 } else {
5117 wTotalLen -= dp->bLength;
5118 }
5119
5120 if (sc->sc_audio_rev >= UAUDIO_VERSION_30)
5121 au = NULL;
5122 else if (sc->sc_audio_rev >= UAUDIO_VERSION_20)
5123 au = uaudio20_mixer_verify_desc(dp, 0);
5124 else
5125 au = uaudio_mixer_verify_desc(dp, 0);
5126
5127 if (au) {
5128 iot[au->bUnitId].u.desc = (const void *)au;
5129 if (au->bUnitId > ID_max)
5130 ID_max = au->bUnitId;
5131 }
5132 }
5133
5134 DPRINTF("Maximum ID=%d\n", ID_max);
5135
5136 /*
5137 * determine sourcing inputs for
5138 * all nodes in the tree:
5139 */
5140 i = ID_max;
5141 do {
5142 if (sc->sc_audio_rev >= UAUDIO_VERSION_30) {
5143 /* FALLTHROUGH */
5144 } else if (sc->sc_audio_rev >= UAUDIO_VERSION_20) {
5145 uaudio20_mixer_find_inputs_sub(iot,
5146 &i, 1, &((iot + i)->usr));
5147
5148 sc->sc_mixer_clocks.is_input = 255;
5149 sc->sc_mixer_clocks.recurse_level = 0;
5150
5151 uaudio20_mixer_find_clocks_sub(iot,
5152 &i, 1, &sc->sc_mixer_clocks);
5153 } else {
5154 uaudio_mixer_find_inputs_sub(iot,
5155 &i, 1, &((iot + i)->usr));
5156 }
5157 } while (i--);
5158
5159 /* set "id_max" and "root" */
5160
5161 i = ID_max;
5162 do {
5163 (iot + i)->usr.id_max = ID_max;
5164 (iot + i)->root = iot;
5165 } while (i--);
5166
5167 /*
5168 * Scan the config to create a linked list of "mixer" nodes:
5169 */
5170
5171 i = ID_max;
5172 do {
5173 dp = iot[i].u.desc;
5174
5175 if (dp == NULL)
5176 continue;
5177
5178 DPRINTFN(11, "id=%d subtype=%d\n",
5179 i, dp->bDescriptorSubtype);
5180
5181 if (sc->sc_audio_rev >= UAUDIO_VERSION_30) {
5182 continue;
5183 } else if (sc->sc_audio_rev >= UAUDIO_VERSION_20) {
5184 switch (dp->bDescriptorSubtype) {
5185 case UDESCSUB_AC_HEADER:
5186 DPRINTF("unexpected AC header\n");
5187 break;
5188
5189 case UDESCSUB_AC_INPUT:
5190 case UDESCSUB_AC_OUTPUT:
5191 case UDESCSUB_AC_PROCESSING_V2:
5192 case UDESCSUB_AC_EXTENSION_V2:
5193 case UDESCSUB_AC_EFFECT:
5194 case UDESCSUB_AC_CLOCK_SRC:
5195 case UDESCSUB_AC_CLOCK_SEL:
5196 case UDESCSUB_AC_CLOCK_MUL:
5197 case UDESCSUB_AC_SAMPLE_RT:
5198 break;
5199
5200 case UDESCSUB_AC_MIXER:
5201 uaudio20_mixer_add_mixer(sc, iot, i);
5202 break;
5203
5204 case UDESCSUB_AC_SELECTOR:
5205 uaudio20_mixer_add_selector(sc, iot, i);
5206 break;
5207
5208 case UDESCSUB_AC_FEATURE:
5209 uaudio20_mixer_add_feature(sc, iot, i);
5210 break;
5211
5212 default:
5213 DPRINTF("bad AC desc subtype=0x%02x\n",
5214 dp->bDescriptorSubtype);
5215 break;
5216 }
5217 continue;
5218 }
5219
5220 switch (dp->bDescriptorSubtype) {
5221 case UDESCSUB_AC_HEADER:
5222 DPRINTF("unexpected AC header\n");
5223 break;
5224
5225 case UDESCSUB_AC_INPUT:
5226 case UDESCSUB_AC_OUTPUT:
5227 break;
5228
5229 case UDESCSUB_AC_MIXER:
5230 uaudio_mixer_add_mixer(sc, iot, i);
5231 break;
5232
5233 case UDESCSUB_AC_SELECTOR:
5234 uaudio_mixer_add_selector(sc, iot, i);
5235 break;
5236
5237 case UDESCSUB_AC_FEATURE:
5238 uaudio_mixer_add_feature(sc, iot, i);
5239 break;
5240
5241 case UDESCSUB_AC_PROCESSING:
5242 uaudio_mixer_add_processing(sc, iot, i);
5243 break;
5244
5245 case UDESCSUB_AC_EXTENSION:
5246 uaudio_mixer_add_extension(sc, iot, i);
5247 break;
5248
5249 default:
5250 DPRINTF("bad AC desc subtype=0x%02x\n",
5251 dp->bDescriptorSubtype);
5252 break;
5253 }
5254
5255 } while (i--);
5256
5257 done:
5258 free(iot, M_TEMP);
5259 }
5260
5261 static int
uaudio_mixer_get(struct usb_device * udev,uint16_t audio_rev,uint8_t what,struct uaudio_mixer_node * mc)5262 uaudio_mixer_get(struct usb_device *udev, uint16_t audio_rev,
5263 uint8_t what, struct uaudio_mixer_node *mc)
5264 {
5265 struct usb_device_request req;
5266 int val;
5267 uint8_t data[2 + (2 * 3)];
5268 usb_error_t err;
5269
5270 if (mc->wValue[0] == -1)
5271 return (0);
5272
5273 if (audio_rev >= UAUDIO_VERSION_30)
5274 return (0);
5275 else if (audio_rev >= UAUDIO_VERSION_20) {
5276 if (what == GET_CUR) {
5277 req.bRequest = UA20_CS_CUR;
5278 USETW(req.wLength, 2);
5279 } else {
5280 req.bRequest = UA20_CS_RANGE;
5281 USETW(req.wLength, 8);
5282 }
5283 } else {
5284 uint16_t len = MIX_SIZE(mc->type);
5285
5286 req.bRequest = what;
5287 USETW(req.wLength, len);
5288 }
5289
5290 req.bmRequestType = UT_READ_CLASS_INTERFACE;
5291 USETW(req.wValue, mc->wValue[0]);
5292 USETW(req.wIndex, mc->wIndex);
5293
5294 memset(data, 0, sizeof(data));
5295
5296 err = usbd_do_request(udev, NULL, &req, data);
5297 if (err) {
5298 DPRINTF("err=%s\n", usbd_errstr(err));
5299 return (0);
5300 }
5301
5302 if (audio_rev >= UAUDIO_VERSION_30) {
5303 val = 0;
5304 } else if (audio_rev >= UAUDIO_VERSION_20) {
5305 switch (what) {
5306 case GET_CUR:
5307 val = (data[0] | (data[1] << 8));
5308 break;
5309 case GET_MIN:
5310 val = (data[2] | (data[3] << 8));
5311 break;
5312 case GET_MAX:
5313 val = (data[4] | (data[5] << 8));
5314 break;
5315 case GET_RES:
5316 val = (data[6] | (data[7] << 8));
5317 break;
5318 default:
5319 val = 0;
5320 break;
5321 }
5322 } else {
5323 val = (data[0] | (data[1] << 8));
5324 }
5325
5326 if (what == GET_CUR || what == GET_MIN || what == GET_MAX)
5327 val = uaudio_mixer_signext(mc->type, val);
5328
5329 DPRINTFN(3, "val=%d\n", val);
5330
5331 return (val);
5332 }
5333
5334 static void
uaudio_mixer_write_cfg_callback(struct usb_xfer * xfer,usb_error_t error)5335 uaudio_mixer_write_cfg_callback(struct usb_xfer *xfer, usb_error_t error)
5336 {
5337 struct usb_device_request req;
5338 struct uaudio_softc *sc = usbd_xfer_softc(xfer);
5339 struct uaudio_mixer_node *mc = sc->sc_mixer_curr;
5340 struct usb_page_cache *pc;
5341 uint16_t len;
5342 uint8_t repeat = 1;
5343 uint8_t update;
5344 uint8_t chan;
5345 uint8_t buf[2];
5346
5347 DPRINTF("\n");
5348
5349 switch (USB_GET_STATE(xfer)) {
5350 case USB_ST_TRANSFERRED:
5351 tr_transferred:
5352 case USB_ST_SETUP:
5353 tr_setup:
5354
5355 if (mc == NULL) {
5356 mc = sc->sc_mixer_root;
5357 sc->sc_mixer_curr = mc;
5358 sc->sc_mixer_chan = 0;
5359 repeat = 0;
5360 }
5361 while (mc) {
5362 while (sc->sc_mixer_chan < mc->nchan) {
5363 chan = sc->sc_mixer_chan;
5364
5365 sc->sc_mixer_chan++;
5366
5367 update = ((mc->update[chan / 8] & (1 << (chan % 8))) &&
5368 (mc->wValue[chan] != -1));
5369
5370 mc->update[chan / 8] &= ~(1 << (chan % 8));
5371
5372 if (update) {
5373 req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
5374 USETW(req.wValue, mc->wValue[chan]);
5375 USETW(req.wIndex, mc->wIndex);
5376
5377 if (sc->sc_audio_rev >= UAUDIO_VERSION_30) {
5378 return;
5379 } else if (sc->sc_audio_rev >= UAUDIO_VERSION_20) {
5380 len = 2;
5381 req.bRequest = UA20_CS_CUR;
5382 USETW(req.wLength, len);
5383 } else {
5384 len = MIX_SIZE(mc->type);
5385 req.bRequest = SET_CUR;
5386 USETW(req.wLength, len);
5387 }
5388
5389 buf[0] = (mc->wData[chan] & 0xFF);
5390 buf[1] = (mc->wData[chan] >> 8) & 0xFF;
5391
5392 pc = usbd_xfer_get_frame(xfer, 0);
5393 usbd_copy_in(pc, 0, &req, sizeof(req));
5394 pc = usbd_xfer_get_frame(xfer, 1);
5395 usbd_copy_in(pc, 0, buf, len);
5396
5397 usbd_xfer_set_frame_len(xfer, 0, sizeof(req));
5398 usbd_xfer_set_frame_len(xfer, 1, len);
5399 usbd_xfer_set_frames(xfer, len ? 2 : 1);
5400 usbd_transfer_submit(xfer);
5401 return;
5402 }
5403 }
5404
5405 mc = mc->next;
5406 sc->sc_mixer_curr = mc;
5407 sc->sc_mixer_chan = 0;
5408 }
5409
5410 if (repeat) {
5411 goto tr_setup;
5412 }
5413 break;
5414
5415 default: /* Error */
5416 DPRINTF("error=%s\n", usbd_errstr(error));
5417 if (error == USB_ERR_CANCELLED) {
5418 /* do nothing - we are detaching */
5419 break;
5420 }
5421 goto tr_transferred;
5422 }
5423 }
5424
5425 static usb_error_t
uaudio_set_speed(struct usb_device * udev,uint8_t endpt,uint32_t speed)5426 uaudio_set_speed(struct usb_device *udev, uint8_t endpt, uint32_t speed)
5427 {
5428 struct usb_device_request req;
5429 uint8_t data[3];
5430
5431 DPRINTFN(6, "endpt=%d speed=%u\n", endpt, speed);
5432
5433 req.bmRequestType = UT_WRITE_CLASS_ENDPOINT;
5434 req.bRequest = SET_CUR;
5435 USETW2(req.wValue, SAMPLING_FREQ_CONTROL, 0);
5436 USETW(req.wIndex, endpt);
5437 USETW(req.wLength, 3);
5438 data[0] = speed;
5439 data[1] = speed >> 8;
5440 data[2] = speed >> 16;
5441
5442 return (usbd_do_request(udev, NULL, &req, data));
5443 }
5444
5445 static usb_error_t
uaudio20_set_speed(struct usb_device * udev,uint8_t iface_no,uint8_t clockid,uint32_t speed)5446 uaudio20_set_speed(struct usb_device *udev, uint8_t iface_no,
5447 uint8_t clockid, uint32_t speed)
5448 {
5449 struct usb_device_request req;
5450 usb_error_t err;
5451 uDWord data;
5452
5453 DPRINTFN(6, "ifaceno=%d clockid=%d speed=%u\n",
5454 iface_no, clockid, speed);
5455
5456 req.bmRequestType = UT_WRITE_CLASS_INTERFACE;
5457 req.bRequest = UA20_CS_CUR;
5458 USETW2(req.wValue, UA20_CS_SAM_FREQ_CONTROL, 0);
5459 USETW2(req.wIndex, clockid, iface_no);
5460 USETW(req.wLength, sizeof(data));
5461 USETDW(data, speed);
5462
5463 err = usbd_do_request(udev, NULL, &req, data);
5464 if (err != USB_ERR_NORMAL_COMPLETION)
5465 return (err);
5466
5467 /*
5468 * Read the rate back, because some devices only apply it once it has
5469 * been read, and produce no sound otherwise.
5470 */
5471 req.bmRequestType = UT_READ_CLASS_INTERFACE;
5472 USETDW(data, 0);
5473
5474 err = usbd_do_request(udev, NULL, &req, data);
5475 if (err != USB_ERR_NORMAL_COMPLETION) {
5476 DPRINTF("could not read sample rate back: %s\n",
5477 usbd_errstr(err));
5478 } else if (UGETDW(data) != speed) {
5479 DPRINTF("sample rate is %u Hz, expected %u Hz\n",
5480 UGETDW(data), speed);
5481 }
5482
5483 return (USB_ERR_NORMAL_COMPLETION);
5484 }
5485
5486 static int
uaudio_mixer_signext(uint8_t type,int val)5487 uaudio_mixer_signext(uint8_t type, int val)
5488 {
5489 if (!MIX_UNSIGNED(type)) {
5490 if (MIX_SIZE(type) == 2) {
5491 val = (int16_t)val;
5492 } else {
5493 val = (int8_t)val;
5494 }
5495 }
5496 return (val);
5497 }
5498
5499 static int
uaudio_mixer_bsd2value(struct uaudio_mixer_node * mc,int val)5500 uaudio_mixer_bsd2value(struct uaudio_mixer_node *mc, int val)
5501 {
5502 if (mc->type == MIX_ON_OFF) {
5503 val = (val != 0);
5504 } else if (mc->type != MIX_SELECTOR) {
5505 /* compute actual volume */
5506 val = (val * mc->mul) / 100;
5507
5508 /* add lower offset */
5509 val = val + mc->minval;
5510 }
5511 /* make sure we don't write a value out of range */
5512 if (val > mc->maxval)
5513 val = mc->maxval;
5514 else if (val < mc->minval)
5515 val = mc->minval;
5516
5517 DPRINTFN(6, "type=0x%03x val=%d min=%d max=%d val=%d\n",
5518 mc->type, val, mc->minval, mc->maxval, val);
5519 return (val);
5520 }
5521
5522 static void
uaudio_mixer_ctl_set(struct uaudio_softc * sc,unsigned index,struct uaudio_mixer_node * mc,uint8_t chan,int val)5523 uaudio_mixer_ctl_set(struct uaudio_softc *sc, unsigned index,
5524 struct uaudio_mixer_node *mc, uint8_t chan, int val)
5525 {
5526 val = uaudio_mixer_bsd2value(mc, val);
5527
5528 mc->update[chan / 8] |= (1 << (chan % 8));
5529 mc->wData[chan] = val;
5530
5531 /* start the transfer, if not already started */
5532
5533 mtx_lock(&sc->sc_child[index].mixer_lock);
5534 usbd_transfer_start(sc->sc_mixer_xfer[0]);
5535 mtx_unlock(&sc->sc_child[index].mixer_lock);
5536 }
5537
5538 static void
uaudio_mixer_init(struct uaudio_softc * sc,unsigned index)5539 uaudio_mixer_init(struct uaudio_softc *sc, unsigned index)
5540 {
5541 struct uaudio_mixer_node *mc;
5542 int32_t i;
5543
5544 if (index != 0)
5545 return;
5546 for (mc = sc->sc_mixer_root; mc; mc = mc->next) {
5547 if (mc->ctl != SOUND_MIXER_NRDEVICES) {
5548 /*
5549 * Set device mask bits. See
5550 * /usr/include/machine/soundcard.h
5551 */
5552 sc->sc_child[index].mix_info |= 1U << mc->ctl;
5553 }
5554 if ((mc->ctl == SOUND_MIXER_NRDEVICES) &&
5555 (mc->type == MIX_SELECTOR)) {
5556 for (i = mc->minval; (i > 0) && (i <= mc->maxval); i++) {
5557 if (mc->slctrtype[i - 1] == SOUND_MIXER_NRDEVICES)
5558 continue;
5559 sc->sc_child[index].recsrc_info |= 1U << mc->slctrtype[i - 1];
5560 }
5561 }
5562 }
5563 }
5564
5565 int
uaudio_mixer_init_sub(struct uaudio_softc * sc,struct snd_mixer * m)5566 uaudio_mixer_init_sub(struct uaudio_softc *sc, struct snd_mixer *m)
5567 {
5568 unsigned i = uaudio_get_child_index_by_dev(sc, mix_get_dev(m));
5569
5570 DPRINTF("child=%u\n", i);
5571
5572 /*
5573 * Initialize the mutex with MTX_RECURSE so that functions like
5574 * uaudio_mixer_ctl_set() do not panic when they recurse on the lock,
5575 * as a result of a callback function (e.g., uaudio_hid_rx_callback())
5576 * also having acquired it.
5577 */
5578 mtx_init(&sc->sc_child[i].mixer_lock, "uaudio mixer lock", NULL,
5579 MTX_RECURSE);
5580 sc->sc_child[i].mixer_dev = m;
5581
5582 if (i == 0 &&
5583 usbd_transfer_setup(sc->sc_udev, &sc->sc_mixer_iface_index,
5584 sc->sc_mixer_xfer, uaudio_mixer_config, 1, sc,
5585 &sc->sc_child[i].mixer_lock)) {
5586 DPRINTFN(0, "could not allocate USB transfer for mixer!\n");
5587 return (ENOMEM);
5588 }
5589
5590 if (sc->sc_play_chan[i].num_alt > 0 &&
5591 (sc->sc_child[i].mix_info & SOUND_MASK_VOLUME) == 0) {
5592 mix_setparentchild(m, SOUND_MIXER_VOLUME, SOUND_MASK_PCM);
5593 mix_setrealdev(m, SOUND_MIXER_VOLUME, SOUND_MIXER_NONE);
5594 }
5595 mix_setdevs(m, sc->sc_child[i].mix_info);
5596 mix_setrecdevs(m, sc->sc_child[i].recsrc_info);
5597 return (0);
5598 }
5599
5600 int
uaudio_mixer_uninit_sub(struct uaudio_softc * sc,struct snd_mixer * m)5601 uaudio_mixer_uninit_sub(struct uaudio_softc *sc, struct snd_mixer *m)
5602 {
5603 unsigned index = uaudio_get_child_index_by_dev(sc, mix_get_dev(m));
5604
5605 DPRINTF("child=%u\n", index);
5606
5607 if (index == 0)
5608 usbd_transfer_unsetup(sc->sc_mixer_xfer, 1);
5609
5610 mtx_destroy(&sc->sc_child[index].mixer_lock);
5611
5612 return (0);
5613 }
5614
5615 void
uaudio_mixer_set(struct uaudio_softc * sc,struct snd_mixer * m,unsigned type,unsigned left,unsigned right)5616 uaudio_mixer_set(struct uaudio_softc *sc, struct snd_mixer *m,
5617 unsigned type, unsigned left, unsigned right)
5618 {
5619 unsigned index = uaudio_get_child_index_by_dev(sc, mix_get_dev(m));
5620 struct uaudio_mixer_node *mc;
5621 int chan;
5622
5623 if (index != 0)
5624 return;
5625 for (mc = sc->sc_mixer_root; mc != NULL; mc = mc->next) {
5626 if (mc->ctl == type) {
5627 for (chan = 0; chan < mc->nchan; chan++) {
5628 uaudio_mixer_ctl_set(sc, index, mc, chan,
5629 chan == 0 ? left : right);
5630 }
5631 }
5632 }
5633 }
5634
5635 uint32_t
uaudio_mixer_setrecsrc(struct uaudio_softc * sc,struct snd_mixer * m,uint32_t src)5636 uaudio_mixer_setrecsrc(struct uaudio_softc *sc, struct snd_mixer *m, uint32_t src)
5637 {
5638 unsigned index = uaudio_get_child_index_by_dev(sc, mix_get_dev(m));
5639 struct uaudio_mixer_node *mc;
5640 uint32_t mask;
5641 uint32_t temp;
5642 int32_t i;
5643
5644 if (index != 0)
5645 return (0);
5646 for (mc = sc->sc_mixer_root; mc; mc = mc->next) {
5647 if ((mc->ctl == SOUND_MIXER_NRDEVICES) &&
5648 (mc->type == MIX_SELECTOR)) {
5649 /* compute selector mask */
5650
5651 mask = 0;
5652 for (i = mc->minval; (i > 0) && (i <= mc->maxval); i++)
5653 mask |= 1U << mc->slctrtype[i - 1];
5654
5655 temp = mask & src;
5656 if (temp == 0)
5657 continue;
5658
5659 /* find the first set bit */
5660 temp = (-temp) & temp;
5661
5662 /* update "src" */
5663 src &= ~mask;
5664 src |= temp;
5665
5666 for (i = mc->minval; (i > 0) && (i <= mc->maxval); i++) {
5667 if (temp != (1U << mc->slctrtype[i - 1]))
5668 continue;
5669 uaudio_mixer_ctl_set(sc, index, mc, 0, i);
5670 break;
5671 }
5672 }
5673 }
5674 return (src);
5675 }
5676
5677 /*========================================================================*
5678 * MIDI support routines
5679 *========================================================================*/
5680
5681 static void
umidi_bulk_read_callback(struct usb_xfer * xfer,usb_error_t error)5682 umidi_bulk_read_callback(struct usb_xfer *xfer, usb_error_t error)
5683 {
5684 struct umidi_chan *chan = usbd_xfer_softc(xfer);
5685 struct umidi_sub_chan *sub;
5686 struct usb_page_cache *pc;
5687 uint8_t buf[4];
5688 uint8_t cmd_len;
5689 uint8_t cn;
5690 uint16_t pos;
5691 int actlen;
5692
5693 usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
5694
5695 switch (USB_GET_STATE(xfer)) {
5696 case USB_ST_TRANSFERRED:
5697
5698 DPRINTF("actlen=%d bytes\n", actlen);
5699
5700 pos = 0;
5701 pc = usbd_xfer_get_frame(xfer, 0);
5702
5703 while (actlen >= 4) {
5704 /* copy out the MIDI data */
5705 usbd_copy_out(pc, pos, buf, 4);
5706 /* command length */
5707 cmd_len = umidi_cmd_to_len[buf[0] & 0xF];
5708 /* cable number */
5709 cn = buf[0] >> 4;
5710 /*
5711 * Lookup sub-channel. The index is range
5712 * checked below.
5713 */
5714 sub = &chan->sub[cn];
5715
5716 if ((cmd_len != 0) && (cn < chan->max_emb_jack) &&
5717 (sub->read_open != 0)) {
5718 /* Send data to the application */
5719 usb_fifo_put_data_linear(
5720 sub->fifo.fp[USB_FIFO_RX],
5721 buf + 1, cmd_len, 1);
5722 }
5723 actlen -= 4;
5724 pos += 4;
5725 }
5726
5727 case USB_ST_SETUP:
5728 DPRINTF("start\n");
5729 tr_setup:
5730 usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
5731 usbd_transfer_submit(xfer);
5732 break;
5733
5734 default:
5735 DPRINTF("error=%s\n", usbd_errstr(error));
5736
5737 if (error != USB_ERR_CANCELLED) {
5738 /* try to clear stall first */
5739 usbd_xfer_set_stall(xfer);
5740 goto tr_setup;
5741 }
5742 break;
5743 }
5744 }
5745
5746 /*
5747 * The following statemachine, that converts MIDI commands to
5748 * USB MIDI packets, derives from Linux's usbmidi.c, which
5749 * was written by "Clemens Ladisch":
5750 *
5751 * Returns:
5752 * 0: No command
5753 * Else: Command is complete
5754 */
5755 static uint8_t
umidi_convert_to_usb(struct umidi_sub_chan * sub,uint8_t cn,uint8_t b)5756 umidi_convert_to_usb(struct umidi_sub_chan *sub, uint8_t cn, uint8_t b)
5757 {
5758 uint8_t p0 = (cn << 4);
5759
5760 if (b >= 0xf8) {
5761 sub->temp_0[0] = p0 | 0x0f;
5762 sub->temp_0[1] = b;
5763 sub->temp_0[2] = 0;
5764 sub->temp_0[3] = 0;
5765 sub->temp_cmd = sub->temp_0;
5766 return (1);
5767
5768 } else if (b >= 0xf0) {
5769 switch (b) {
5770 case 0xf0: /* system exclusive begin */
5771 sub->temp_1[1] = b;
5772 sub->state = UMIDI_ST_SYSEX_1;
5773 break;
5774 case 0xf1: /* MIDI time code */
5775 case 0xf3: /* song select */
5776 sub->temp_1[1] = b;
5777 sub->state = UMIDI_ST_1PARAM;
5778 break;
5779 case 0xf2: /* song position pointer */
5780 sub->temp_1[1] = b;
5781 sub->state = UMIDI_ST_2PARAM_1;
5782 break;
5783 case 0xf4: /* unknown */
5784 case 0xf5: /* unknown */
5785 sub->state = UMIDI_ST_UNKNOWN;
5786 break;
5787 case 0xf6: /* tune request */
5788 sub->temp_1[0] = p0 | 0x05;
5789 sub->temp_1[1] = 0xf6;
5790 sub->temp_1[2] = 0;
5791 sub->temp_1[3] = 0;
5792 sub->temp_cmd = sub->temp_1;
5793 sub->state = UMIDI_ST_UNKNOWN;
5794 return (1);
5795
5796 case 0xf7: /* system exclusive end */
5797 switch (sub->state) {
5798 case UMIDI_ST_SYSEX_0:
5799 sub->temp_1[0] = p0 | 0x05;
5800 sub->temp_1[1] = 0xf7;
5801 sub->temp_1[2] = 0;
5802 sub->temp_1[3] = 0;
5803 sub->temp_cmd = sub->temp_1;
5804 sub->state = UMIDI_ST_UNKNOWN;
5805 return (1);
5806 case UMIDI_ST_SYSEX_1:
5807 sub->temp_1[0] = p0 | 0x06;
5808 sub->temp_1[2] = 0xf7;
5809 sub->temp_1[3] = 0;
5810 sub->temp_cmd = sub->temp_1;
5811 sub->state = UMIDI_ST_UNKNOWN;
5812 return (1);
5813 case UMIDI_ST_SYSEX_2:
5814 sub->temp_1[0] = p0 | 0x07;
5815 sub->temp_1[3] = 0xf7;
5816 sub->temp_cmd = sub->temp_1;
5817 sub->state = UMIDI_ST_UNKNOWN;
5818 return (1);
5819 }
5820 sub->state = UMIDI_ST_UNKNOWN;
5821 break;
5822 }
5823 } else if (b >= 0x80) {
5824 sub->temp_1[1] = b;
5825 if ((b >= 0xc0) && (b <= 0xdf)) {
5826 sub->state = UMIDI_ST_1PARAM;
5827 } else {
5828 sub->state = UMIDI_ST_2PARAM_1;
5829 }
5830 } else { /* b < 0x80 */
5831 switch (sub->state) {
5832 case UMIDI_ST_1PARAM:
5833 if (sub->temp_1[1] < 0xf0) {
5834 p0 |= sub->temp_1[1] >> 4;
5835 } else {
5836 p0 |= 0x02;
5837 sub->state = UMIDI_ST_UNKNOWN;
5838 }
5839 sub->temp_1[0] = p0;
5840 sub->temp_1[2] = b;
5841 sub->temp_1[3] = 0;
5842 sub->temp_cmd = sub->temp_1;
5843 return (1);
5844 case UMIDI_ST_2PARAM_1:
5845 sub->temp_1[2] = b;
5846 sub->state = UMIDI_ST_2PARAM_2;
5847 break;
5848 case UMIDI_ST_2PARAM_2:
5849 if (sub->temp_1[1] < 0xf0) {
5850 p0 |= sub->temp_1[1] >> 4;
5851 sub->state = UMIDI_ST_2PARAM_1;
5852 } else {
5853 p0 |= 0x03;
5854 sub->state = UMIDI_ST_UNKNOWN;
5855 }
5856 sub->temp_1[0] = p0;
5857 sub->temp_1[3] = b;
5858 sub->temp_cmd = sub->temp_1;
5859 return (1);
5860 case UMIDI_ST_SYSEX_0:
5861 sub->temp_1[1] = b;
5862 sub->state = UMIDI_ST_SYSEX_1;
5863 break;
5864 case UMIDI_ST_SYSEX_1:
5865 sub->temp_1[2] = b;
5866 sub->state = UMIDI_ST_SYSEX_2;
5867 break;
5868 case UMIDI_ST_SYSEX_2:
5869 sub->temp_1[0] = p0 | 0x04;
5870 sub->temp_1[3] = b;
5871 sub->temp_cmd = sub->temp_1;
5872 sub->state = UMIDI_ST_SYSEX_0;
5873 return (1);
5874 default:
5875 break;
5876 }
5877 }
5878 return (0);
5879 }
5880
5881 static void
umidi_bulk_write_callback(struct usb_xfer * xfer,usb_error_t error)5882 umidi_bulk_write_callback(struct usb_xfer *xfer, usb_error_t error)
5883 {
5884 struct umidi_chan *chan = usbd_xfer_softc(xfer);
5885 struct umidi_sub_chan *sub;
5886 struct usb_page_cache *pc;
5887 uint32_t actlen;
5888 uint16_t nframes;
5889 uint8_t buf;
5890 uint8_t start_cable;
5891 uint8_t tr_any;
5892 int len;
5893
5894 usbd_xfer_status(xfer, &len, NULL, NULL, NULL);
5895
5896 /*
5897 * NOTE: Some MIDI devices only accept 4 bytes of data per
5898 * short terminated USB transfer.
5899 */
5900 switch (USB_GET_STATE(xfer)) {
5901 case USB_ST_TRANSFERRED:
5902 DPRINTF("actlen=%d bytes\n", len);
5903
5904 case USB_ST_SETUP:
5905 tr_setup:
5906 DPRINTF("start\n");
5907
5908 nframes = 0; /* reset */
5909 start_cable = chan->curr_cable;
5910 tr_any = 0;
5911 pc = usbd_xfer_get_frame(xfer, 0);
5912
5913 while (1) {
5914 /* round robin de-queueing */
5915
5916 sub = &chan->sub[chan->curr_cable];
5917
5918 if (sub->write_open) {
5919 usb_fifo_get_data_linear(sub->fifo.fp[USB_FIFO_TX],
5920 &buf, 1, &actlen, 0);
5921 } else {
5922 actlen = 0;
5923 }
5924
5925 if (actlen) {
5926 tr_any = 1;
5927
5928 DPRINTF("byte=0x%02x from FIFO %u\n", buf,
5929 (unsigned int)chan->curr_cable);
5930
5931 if (umidi_convert_to_usb(sub, chan->curr_cable, buf)) {
5932 DPRINTF("sub=0x%02x 0x%02x 0x%02x 0x%02x\n",
5933 sub->temp_cmd[0], sub->temp_cmd[1],
5934 sub->temp_cmd[2], sub->temp_cmd[3]);
5935
5936 usbd_copy_in(pc, nframes * 4, sub->temp_cmd, 4);
5937
5938 nframes++;
5939
5940 if ((nframes >= UMIDI_TX_FRAMES) || (chan->single_command != 0))
5941 break;
5942 } else {
5943 continue;
5944 }
5945 }
5946
5947 chan->curr_cable %= chan->max_emb_jack;
5948
5949 if (chan->curr_cable == start_cable) {
5950 if (tr_any == 0)
5951 break;
5952 tr_any = 0;
5953 }
5954 }
5955
5956 if (nframes != 0) {
5957 DPRINTF("Transferring %d frames\n", (int)nframes);
5958 usbd_xfer_set_frame_len(xfer, 0, 4 * nframes);
5959 usbd_transfer_submit(xfer);
5960 }
5961 break;
5962
5963 default: /* Error */
5964
5965 DPRINTF("error=%s\n", usbd_errstr(error));
5966
5967 if (error != USB_ERR_CANCELLED) {
5968 /* try to clear stall first */
5969 usbd_xfer_set_stall(xfer);
5970 goto tr_setup;
5971 }
5972 break;
5973 }
5974 }
5975
5976 static struct umidi_sub_chan *
umidi_sub_by_fifo(struct usb_fifo * fifo)5977 umidi_sub_by_fifo(struct usb_fifo *fifo)
5978 {
5979 struct umidi_chan *chan = usb_fifo_softc(fifo);
5980 struct umidi_sub_chan *sub;
5981 uint32_t n;
5982
5983 for (n = 0; n < UMIDI_EMB_JACK_MAX; n++) {
5984 sub = &chan->sub[n];
5985 if ((sub->fifo.fp[USB_FIFO_RX] == fifo) ||
5986 (sub->fifo.fp[USB_FIFO_TX] == fifo)) {
5987 return (sub);
5988 }
5989 }
5990
5991 panic("%s:%d cannot find usb_fifo!\n",
5992 __FILE__, __LINE__);
5993
5994 return (NULL);
5995 }
5996
5997 static void
umidi_start_read(struct usb_fifo * fifo)5998 umidi_start_read(struct usb_fifo *fifo)
5999 {
6000 struct umidi_chan *chan = usb_fifo_softc(fifo);
6001
6002 usbd_transfer_start(chan->xfer[UMIDI_RX_TRANSFER]);
6003 }
6004
6005 static void
umidi_stop_read(struct usb_fifo * fifo)6006 umidi_stop_read(struct usb_fifo *fifo)
6007 {
6008 struct umidi_chan *chan = usb_fifo_softc(fifo);
6009 struct umidi_sub_chan *sub = umidi_sub_by_fifo(fifo);
6010
6011 DPRINTF("\n");
6012
6013 sub->read_open = 0;
6014
6015 if (--(chan->read_open_refcount) == 0) {
6016 /*
6017 * XXX don't stop the read transfer here, hence that causes
6018 * problems with some MIDI adapters
6019 */
6020 DPRINTF("(stopping read transfer)\n");
6021 }
6022 }
6023
6024 static void
umidi_start_write(struct usb_fifo * fifo)6025 umidi_start_write(struct usb_fifo *fifo)
6026 {
6027 struct umidi_chan *chan = usb_fifo_softc(fifo);
6028
6029 if (chan->xfer[UMIDI_TX_TRANSFER] == NULL) {
6030 uint8_t buf[1];
6031 int actlen;
6032 do {
6033 /* dump data */
6034 usb_fifo_get_data_linear(fifo, buf, 1, &actlen, 0);
6035 } while (actlen > 0);
6036 } else {
6037 usbd_transfer_start(chan->xfer[UMIDI_TX_TRANSFER]);
6038 }
6039 }
6040
6041 static void
umidi_stop_write(struct usb_fifo * fifo)6042 umidi_stop_write(struct usb_fifo *fifo)
6043 {
6044 struct umidi_chan *chan = usb_fifo_softc(fifo);
6045 struct umidi_sub_chan *sub = umidi_sub_by_fifo(fifo);
6046
6047 DPRINTF("\n");
6048
6049 sub->write_open = 0;
6050
6051 if (--(chan->write_open_refcount) == 0) {
6052 DPRINTF("(stopping write transfer)\n");
6053 usbd_transfer_stop(chan->xfer[UMIDI_TX_TRANSFER]);
6054 }
6055 }
6056
6057 static int
umidi_open(struct usb_fifo * fifo,int fflags)6058 umidi_open(struct usb_fifo *fifo, int fflags)
6059 {
6060 struct umidi_chan *chan = usb_fifo_softc(fifo);
6061 struct umidi_sub_chan *sub = umidi_sub_by_fifo(fifo);
6062
6063 if (fflags & FREAD) {
6064 if (usb_fifo_alloc_buffer(fifo, 4, (1024 / 4))) {
6065 return (ENOMEM);
6066 }
6067 mtx_lock(&chan->mtx);
6068 chan->read_open_refcount++;
6069 sub->read_open = 1;
6070 mtx_unlock(&chan->mtx);
6071 }
6072 if (fflags & FWRITE) {
6073 if (usb_fifo_alloc_buffer(fifo, 32, (1024 / 32))) {
6074 return (ENOMEM);
6075 }
6076 /* clear stall first */
6077 mtx_lock(&chan->mtx);
6078 chan->write_open_refcount++;
6079 sub->write_open = 1;
6080
6081 /* reset */
6082 sub->state = UMIDI_ST_UNKNOWN;
6083 mtx_unlock(&chan->mtx);
6084 }
6085 return (0); /* success */
6086 }
6087
6088 static void
umidi_close(struct usb_fifo * fifo,int fflags)6089 umidi_close(struct usb_fifo *fifo, int fflags)
6090 {
6091 if (fflags & FREAD) {
6092 usb_fifo_free_buffer(fifo);
6093 }
6094 if (fflags & FWRITE) {
6095 usb_fifo_free_buffer(fifo);
6096 }
6097 }
6098
6099 static int
umidi_ioctl(struct usb_fifo * fifo,unsigned long cmd,void * data,int fflags)6100 umidi_ioctl(struct usb_fifo *fifo, unsigned long cmd, void *data,
6101 int fflags)
6102 {
6103 return (ENODEV);
6104 }
6105
6106 static void
umidi_init(device_t dev)6107 umidi_init(device_t dev)
6108 {
6109 struct uaudio_softc *sc = device_get_softc(dev);
6110 struct umidi_chan *chan = &sc->sc_midi_chan;
6111
6112 mtx_init(&chan->mtx, "umidi lock", NULL, MTX_DEF | MTX_RECURSE);
6113 }
6114
6115 static struct usb_fifo_methods umidi_fifo_methods = {
6116 .f_start_read = &umidi_start_read,
6117 .f_start_write = &umidi_start_write,
6118 .f_stop_read = &umidi_stop_read,
6119 .f_stop_write = &umidi_stop_write,
6120 .f_open = &umidi_open,
6121 .f_close = &umidi_close,
6122 .f_ioctl = &umidi_ioctl,
6123 .basename[0] = "umidi",
6124 };
6125
6126 static int
umidi_attach(device_t dev)6127 umidi_attach(device_t dev)
6128 {
6129 struct uaudio_softc *sc = device_get_softc(dev);
6130 struct usb_attach_arg *uaa = device_get_ivars(dev);
6131 struct umidi_chan *chan = &sc->sc_midi_chan;
6132 struct umidi_sub_chan *sub;
6133 int unit = device_get_unit(dev);
6134 int error;
6135 uint32_t n;
6136
6137 if (usb_test_quirk(uaa, UQ_SINGLE_CMD_MIDI))
6138 chan->single_command = 1;
6139
6140 error = usbd_set_alt_interface_index(sc->sc_udev,
6141 chan->iface_index, chan->iface_alt_index);
6142 if (error) {
6143 DPRINTF("setting of alternate index failed: %s\n",
6144 usbd_errstr(error));
6145 goto detach;
6146 }
6147 usbd_set_parent_iface(sc->sc_udev, chan->iface_index,
6148 sc->sc_mixer_iface_index);
6149
6150 error = usbd_transfer_setup(uaa->device, &chan->iface_index,
6151 chan->xfer, umidi_config, UMIDI_N_TRANSFER,
6152 chan, &chan->mtx);
6153 if (error) {
6154 DPRINTF("error=%s\n", usbd_errstr(error));
6155 goto detach;
6156 }
6157 if (chan->xfer[UMIDI_TX_TRANSFER] == NULL &&
6158 chan->xfer[UMIDI_RX_TRANSFER] == NULL) {
6159 DPRINTF("no BULK or INTERRUPT MIDI endpoint(s) found\n");
6160 goto detach;
6161 }
6162
6163 /*
6164 * Some USB MIDI device makers couldn't resist using
6165 * wMaxPacketSize = 4 for RX and TX BULK endpoints, although
6166 * that size is an unsupported value for FULL speed BULK
6167 * endpoints. The same applies to some HIGH speed MIDI devices
6168 * which are using a wMaxPacketSize different from 512 bytes.
6169 *
6170 * Refer to section 5.8.3 in USB 2.0 PDF: Cite: "All Host
6171 * Controllers are required to have support for 8-, 16-, 32-,
6172 * and 64-byte maximum packet sizes for full-speed bulk
6173 * endpoints and 512 bytes for high-speed bulk endpoints."
6174 */
6175 if (chan->xfer[UMIDI_TX_TRANSFER] != NULL &&
6176 usbd_xfer_maxp_was_clamped(chan->xfer[UMIDI_TX_TRANSFER]))
6177 chan->single_command = 1;
6178
6179 if (chan->single_command != 0)
6180 device_printf(dev, "Single command MIDI quirk enabled\n");
6181
6182 if ((chan->max_emb_jack == 0) ||
6183 (chan->max_emb_jack > UMIDI_EMB_JACK_MAX)) {
6184 chan->max_emb_jack = UMIDI_EMB_JACK_MAX;
6185 }
6186
6187 for (n = 0; n < chan->max_emb_jack; n++) {
6188 sub = &chan->sub[n];
6189
6190 error = usb_fifo_attach(sc->sc_udev, chan, &chan->mtx,
6191 &umidi_fifo_methods, &sub->fifo, unit, n,
6192 chan->iface_index,
6193 UID_ROOT, GID_AUDIO, 0660);
6194 if (error) {
6195 goto detach;
6196 }
6197 }
6198
6199 mtx_lock(&chan->mtx);
6200
6201 /*
6202 * NOTE: At least one device will not work properly unless the
6203 * BULK IN pipe is open all the time. This might have to do
6204 * about that the internal queues of the device overflow if we
6205 * don't read them regularly.
6206 */
6207 usbd_transfer_start(chan->xfer[UMIDI_RX_TRANSFER]);
6208
6209 mtx_unlock(&chan->mtx);
6210
6211 return (0); /* success */
6212
6213 detach:
6214 return (ENXIO); /* failure */
6215 }
6216
6217 static int
umidi_detach(device_t dev)6218 umidi_detach(device_t dev)
6219 {
6220 struct uaudio_softc *sc = device_get_softc(dev);
6221 struct umidi_chan *chan = &sc->sc_midi_chan;
6222 uint32_t n;
6223
6224 for (n = 0; n < UMIDI_EMB_JACK_MAX; n++)
6225 usb_fifo_detach(&chan->sub[n].fifo);
6226
6227 mtx_lock(&chan->mtx);
6228
6229 usbd_transfer_stop(chan->xfer[UMIDI_RX_TRANSFER]);
6230
6231 mtx_unlock(&chan->mtx);
6232
6233 usbd_transfer_unsetup(chan->xfer, UMIDI_N_TRANSFER);
6234
6235 mtx_destroy(&chan->mtx);
6236
6237 return (0);
6238 }
6239
6240 static void
uaudio_hid_rx_callback(struct usb_xfer * xfer,usb_error_t error)6241 uaudio_hid_rx_callback(struct usb_xfer *xfer, usb_error_t error)
6242 {
6243 struct uaudio_softc *sc = usbd_xfer_softc(xfer);
6244 const uint8_t *buffer = usbd_xfer_get_frame_buffer(xfer, 0);
6245 struct snd_mixer *m;
6246 uint8_t id;
6247 int actlen;
6248 bool mute, volume_up, volume_down;
6249
6250 usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
6251
6252 m = NULL;
6253 mute = volume_up = volume_down = false;
6254
6255 switch (USB_GET_STATE(xfer)) {
6256 case USB_ST_TRANSFERRED:
6257 DPRINTF("actlen=%d\n", actlen);
6258
6259 if (actlen != 0 &&
6260 (sc->sc_hid.flags & UAUDIO_HID_HAS_ID)) {
6261 id = *buffer;
6262 buffer++;
6263 actlen--;
6264 } else {
6265 id = 0;
6266 }
6267
6268 m = sc->sc_child[0].mixer_dev;
6269
6270 if ((sc->sc_hid.flags & UAUDIO_HID_HAS_MUTE) &&
6271 (sc->sc_hid.mute_id == id) &&
6272 hid_get_data(buffer, actlen,
6273 &sc->sc_hid.mute_loc)) {
6274 DPRINTF("Mute toggle\n");
6275
6276 mute = true;
6277 }
6278
6279 if ((sc->sc_hid.flags & UAUDIO_HID_HAS_VOLUME_UP) &&
6280 (sc->sc_hid.volume_up_id == id) &&
6281 hid_get_data(buffer, actlen,
6282 &sc->sc_hid.volume_up_loc)) {
6283 DPRINTF("Volume Up\n");
6284
6285 volume_up = true;
6286 }
6287
6288 if ((sc->sc_hid.flags & UAUDIO_HID_HAS_VOLUME_DOWN) &&
6289 (sc->sc_hid.volume_down_id == id) &&
6290 hid_get_data(buffer, actlen,
6291 &sc->sc_hid.volume_down_loc)) {
6292 DPRINTF("Volume Down\n");
6293
6294 volume_down = true;
6295 }
6296
6297 case USB_ST_SETUP:
6298 tr_setup:
6299 /* check if we can put more data into the FIFO */
6300 usbd_xfer_set_frame_len(xfer, 0, usbd_xfer_max_len(xfer));
6301 usbd_transfer_submit(xfer);
6302 break;
6303
6304 default: /* Error */
6305
6306 DPRINTF("error=%s\n", usbd_errstr(error));
6307
6308 if (error != USB_ERR_CANCELLED) {
6309 /* try to clear stall first */
6310 usbd_xfer_set_stall(xfer);
6311 goto tr_setup;
6312 }
6313 break;
6314 }
6315
6316 if (!mute && !volume_up && !volume_down)
6317 return;
6318
6319 /*
6320 * The mixer_hwvol_*() functions take the mixer lock, which is the PCM
6321 * lock, and end up in uaudio_mixer_ctl_set(), which takes the
6322 * mixer_lock this callback is entered with. Acquiring the two in that
6323 * order here would reverse the order taken by the mixer ioctl path
6324 * (PCM lock first, then mixer_lock), so drop mixer_lock for the
6325 * duration. The USB stack explicitly allows a callback to drop its
6326 * transfer mutex, and usbd_transfer_drain() accounts for it.
6327 */
6328 mtx_unlock(&sc->sc_child[0].mixer_lock);
6329 if (mute)
6330 mixer_hwvol_mute(m->dev);
6331 if (volume_up)
6332 mixer_hwvol_step(m->dev, 1, 1);
6333 if (volume_down)
6334 mixer_hwvol_step(m->dev, -1, -1);
6335 mtx_lock(&sc->sc_child[0].mixer_lock);
6336 }
6337
6338 static int
uaudio_hid_attach(struct uaudio_softc * sc,struct usb_attach_arg * uaa)6339 uaudio_hid_attach(struct uaudio_softc *sc,
6340 struct usb_attach_arg *uaa)
6341 {
6342 void *d_ptr;
6343 uint32_t flags;
6344 uint16_t d_len;
6345 uint8_t id;
6346 int error;
6347
6348 if (!(sc->sc_hid.flags & UAUDIO_HID_VALID))
6349 return (-1);
6350
6351 /* Get HID descriptor */
6352 error = usbd_req_get_hid_desc(uaa->device, NULL, &d_ptr,
6353 &d_len, M_TEMP, sc->sc_hid.iface_index);
6354
6355 if (error) {
6356 DPRINTF("error reading report description\n");
6357 return (-1);
6358 }
6359
6360 /* check if there is an ID byte */
6361 hid_report_size_max(d_ptr, d_len, hid_input, &id);
6362
6363 if (id != 0)
6364 sc->sc_hid.flags |= UAUDIO_HID_HAS_ID;
6365
6366 if (hid_locate(d_ptr, d_len,
6367 HID_USAGE2(HUP_CONSUMER, 0xE9 /* Volume Increment */),
6368 hid_input, 0, &sc->sc_hid.volume_up_loc, &flags,
6369 &sc->sc_hid.volume_up_id)) {
6370 if (flags & HIO_VARIABLE)
6371 sc->sc_hid.flags |= UAUDIO_HID_HAS_VOLUME_UP;
6372 DPRINTFN(1, "Found Volume Up key\n");
6373 }
6374
6375 if (hid_locate(d_ptr, d_len,
6376 HID_USAGE2(HUP_CONSUMER, 0xEA /* Volume Decrement */),
6377 hid_input, 0, &sc->sc_hid.volume_down_loc, &flags,
6378 &sc->sc_hid.volume_down_id)) {
6379 if (flags & HIO_VARIABLE)
6380 sc->sc_hid.flags |= UAUDIO_HID_HAS_VOLUME_DOWN;
6381 DPRINTFN(1, "Found Volume Down key\n");
6382 }
6383
6384 if (hid_locate(d_ptr, d_len,
6385 HID_USAGE2(HUP_CONSUMER, 0xE2 /* Mute */),
6386 hid_input, 0, &sc->sc_hid.mute_loc, &flags,
6387 &sc->sc_hid.mute_id)) {
6388 if (flags & HIO_VARIABLE)
6389 sc->sc_hid.flags |= UAUDIO_HID_HAS_MUTE;
6390 DPRINTFN(1, "Found Mute key\n");
6391 }
6392
6393 free(d_ptr, M_TEMP);
6394
6395 if (!(sc->sc_hid.flags & (UAUDIO_HID_HAS_VOLUME_UP |
6396 UAUDIO_HID_HAS_VOLUME_DOWN |
6397 UAUDIO_HID_HAS_MUTE))) {
6398 DPRINTFN(1, "Did not find any volume related keys\n");
6399 return (-1);
6400 }
6401
6402 /* prevent the uhid driver from attaching */
6403 usbd_set_parent_iface(uaa->device, sc->sc_hid.iface_index,
6404 sc->sc_mixer_iface_index);
6405
6406 /* allocate USB transfers */
6407 error = usbd_transfer_setup(uaa->device, &sc->sc_hid.iface_index,
6408 sc->sc_hid.xfer, uaudio_hid_config, UAUDIO_HID_N_TRANSFER,
6409 sc, &sc->sc_child[0].mixer_lock);
6410 if (error) {
6411 DPRINTF("error=%s\n", usbd_errstr(error));
6412 return (-1);
6413 }
6414 return (0);
6415 }
6416
6417 static void
uaudio_hid_detach(struct uaudio_softc * sc)6418 uaudio_hid_detach(struct uaudio_softc *sc)
6419 {
6420 usbd_transfer_unsetup(sc->sc_hid.xfer, UAUDIO_HID_N_TRANSFER);
6421 }
6422
6423 DRIVER_MODULE_ORDERED(snd_uaudio, uhub, uaudio_driver, NULL, NULL, SI_ORDER_ANY);
6424 MODULE_DEPEND(snd_uaudio, usb, 1, 1, 1);
6425 MODULE_DEPEND(snd_uaudio, sound, 1, 1, 1);
6426 MODULE_DEPEND(snd_uaudio, hid, 1, 1, 1);
6427 MODULE_VERSION(snd_uaudio, 1);
6428 USB_PNP_HOST_INFO(uaudio_devs);
6429 USB_PNP_HOST_INFO(uaudio_vendor_audio);
6430 USB_PNP_HOST_INFO(uaudio_vendor_midi);
6431