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