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