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