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