1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | */ |
4 | |
5 | #include <linux/init.h> |
6 | #include <linux/slab.h> |
7 | #include <linux/usb.h> |
8 | #include <linux/usb/audio.h> |
9 | #include <linux/usb/audio-v2.h> |
10 | #include <linux/usb/audio-v3.h> |
11 | |
12 | #include <sound/core.h> |
13 | #include <sound/pcm.h> |
14 | |
15 | #include "usbaudio.h" |
16 | #include "card.h" |
17 | #include "quirks.h" |
18 | #include "helper.h" |
19 | #include "clock.h" |
20 | #include "format.h" |
21 | |
22 | /* |
23 | * parse the audio format type I descriptor |
24 | * and returns the corresponding pcm format |
25 | * |
26 | * @dev: usb device |
27 | * @fp: audioformat record |
28 | * @format: the format tag (wFormatTag) |
29 | * @fmt: the format type descriptor (v1/v2) or AudioStreaming descriptor (v3) |
30 | */ |
31 | static u64 parse_audio_format_i_type(struct snd_usb_audio *chip, |
32 | struct audioformat *fp, |
33 | u64 format, void *_fmt) |
34 | { |
35 | int sample_width, sample_bytes; |
36 | u64 pcm_formats = 0; |
37 | |
38 | switch (fp->protocol) { |
39 | case UAC_VERSION_1: |
40 | default: { |
41 | struct uac_format_type_i_discrete_descriptor *fmt = _fmt; |
42 | if (format >= 64) { |
43 | usb_audio_info(chip, |
44 | "%u:%d: invalid format type 0x%llx is detected, processed as PCM\n" , |
45 | fp->iface, fp->altsetting, format); |
46 | format = UAC_FORMAT_TYPE_I_PCM; |
47 | } |
48 | sample_width = fmt->bBitResolution; |
49 | sample_bytes = fmt->bSubframeSize; |
50 | format = 1ULL << format; |
51 | break; |
52 | } |
53 | |
54 | case UAC_VERSION_2: { |
55 | struct uac_format_type_i_ext_descriptor *fmt = _fmt; |
56 | sample_width = fmt->bBitResolution; |
57 | sample_bytes = fmt->bSubslotSize; |
58 | |
59 | if (format & UAC2_FORMAT_TYPE_I_RAW_DATA) { |
60 | pcm_formats |= SNDRV_PCM_FMTBIT_SPECIAL; |
61 | /* flag potentially raw DSD capable altsettings */ |
62 | fp->dsd_raw = true; |
63 | } |
64 | |
65 | format <<= 1; |
66 | break; |
67 | } |
68 | case UAC_VERSION_3: { |
69 | struct uac3_as_header_descriptor *as = _fmt; |
70 | |
71 | sample_width = as->bBitResolution; |
72 | sample_bytes = as->bSubslotSize; |
73 | |
74 | if (format & UAC3_FORMAT_TYPE_I_RAW_DATA) |
75 | pcm_formats |= SNDRV_PCM_FMTBIT_SPECIAL; |
76 | |
77 | format <<= 1; |
78 | break; |
79 | } |
80 | } |
81 | |
82 | fp->fmt_bits = sample_width; |
83 | |
84 | if ((pcm_formats == 0) && |
85 | (format == 0 || format == (1 << UAC_FORMAT_TYPE_I_UNDEFINED))) { |
86 | /* some devices don't define this correctly... */ |
87 | usb_audio_info(chip, "%u:%d : format type 0 is detected, processed as PCM\n" , |
88 | fp->iface, fp->altsetting); |
89 | format = 1 << UAC_FORMAT_TYPE_I_PCM; |
90 | } |
91 | if (format & (1 << UAC_FORMAT_TYPE_I_PCM)) { |
92 | if (((chip->usb_id == USB_ID(0x0582, 0x0016)) || |
93 | /* Edirol SD-90 */ |
94 | (chip->usb_id == USB_ID(0x0582, 0x000c))) && |
95 | /* Roland SC-D70 */ |
96 | sample_width == 24 && sample_bytes == 2) |
97 | sample_bytes = 3; |
98 | else if (sample_width > sample_bytes * 8) { |
99 | usb_audio_info(chip, "%u:%d : sample bitwidth %d in over sample bytes %d\n" , |
100 | fp->iface, fp->altsetting, |
101 | sample_width, sample_bytes); |
102 | } |
103 | /* check the format byte size */ |
104 | switch (sample_bytes) { |
105 | case 1: |
106 | pcm_formats |= SNDRV_PCM_FMTBIT_S8; |
107 | break; |
108 | case 2: |
109 | if (snd_usb_is_big_endian_format(chip, fp)) |
110 | pcm_formats |= SNDRV_PCM_FMTBIT_S16_BE; /* grrr, big endian!! */ |
111 | else |
112 | pcm_formats |= SNDRV_PCM_FMTBIT_S16_LE; |
113 | break; |
114 | case 3: |
115 | if (snd_usb_is_big_endian_format(chip, fp)) |
116 | pcm_formats |= SNDRV_PCM_FMTBIT_S24_3BE; /* grrr, big endian!! */ |
117 | else |
118 | pcm_formats |= SNDRV_PCM_FMTBIT_S24_3LE; |
119 | break; |
120 | case 4: |
121 | pcm_formats |= SNDRV_PCM_FMTBIT_S32_LE; |
122 | break; |
123 | default: |
124 | usb_audio_info(chip, |
125 | "%u:%d : unsupported sample bitwidth %d in %d bytes\n" , |
126 | fp->iface, fp->altsetting, |
127 | sample_width, sample_bytes); |
128 | break; |
129 | } |
130 | } |
131 | if (format & (1 << UAC_FORMAT_TYPE_I_PCM8)) { |
132 | /* Dallas DS4201 workaround: it advertises U8 format, but really |
133 | supports S8. */ |
134 | if (chip->usb_id == USB_ID(0x04fa, 0x4201)) |
135 | pcm_formats |= SNDRV_PCM_FMTBIT_S8; |
136 | else |
137 | pcm_formats |= SNDRV_PCM_FMTBIT_U8; |
138 | } |
139 | if (format & (1 << UAC_FORMAT_TYPE_I_IEEE_FLOAT)) { |
140 | pcm_formats |= SNDRV_PCM_FMTBIT_FLOAT_LE; |
141 | } |
142 | if (format & (1 << UAC_FORMAT_TYPE_I_ALAW)) { |
143 | pcm_formats |= SNDRV_PCM_FMTBIT_A_LAW; |
144 | } |
145 | if (format & (1 << UAC_FORMAT_TYPE_I_MULAW)) { |
146 | pcm_formats |= SNDRV_PCM_FMTBIT_MU_LAW; |
147 | } |
148 | if (format & ~0x3f) { |
149 | usb_audio_info(chip, |
150 | "%u:%d : unsupported format bits %#llx\n" , |
151 | fp->iface, fp->altsetting, format); |
152 | } |
153 | |
154 | pcm_formats |= snd_usb_interface_dsd_format_quirks(chip, fp, sample_bytes); |
155 | |
156 | return pcm_formats; |
157 | } |
158 | |
159 | static int set_fixed_rate(struct audioformat *fp, int rate, int rate_bits) |
160 | { |
161 | kfree(objp: fp->rate_table); |
162 | fp->rate_table = kmalloc(size: sizeof(int), GFP_KERNEL); |
163 | if (!fp->rate_table) |
164 | return -ENOMEM; |
165 | fp->nr_rates = 1; |
166 | fp->rate_min = rate; |
167 | fp->rate_max = rate; |
168 | fp->rates = rate_bits; |
169 | fp->rate_table[0] = rate; |
170 | return 0; |
171 | } |
172 | |
173 | /* set up rate_min, rate_max and rates from the rate table */ |
174 | static void set_rate_table_min_max(struct audioformat *fp) |
175 | { |
176 | unsigned int rate; |
177 | int i; |
178 | |
179 | fp->rate_min = INT_MAX; |
180 | fp->rate_max = 0; |
181 | fp->rates = 0; |
182 | for (i = 0; i < fp->nr_rates; i++) { |
183 | rate = fp->rate_table[i]; |
184 | fp->rate_min = min(fp->rate_min, rate); |
185 | fp->rate_max = max(fp->rate_max, rate); |
186 | fp->rates |= snd_pcm_rate_to_rate_bit(rate); |
187 | } |
188 | } |
189 | |
190 | /* |
191 | * parse the format descriptor and stores the possible sample rates |
192 | * on the audioformat table (audio class v1). |
193 | * |
194 | * @dev: usb device |
195 | * @fp: audioformat record |
196 | * @fmt: the format descriptor |
197 | * @offset: the start offset of descriptor pointing the rate type |
198 | * (7 for type I and II, 8 for type II) |
199 | */ |
200 | static int parse_audio_format_rates_v1(struct snd_usb_audio *chip, struct audioformat *fp, |
201 | unsigned char *fmt, int offset) |
202 | { |
203 | int nr_rates = fmt[offset]; |
204 | |
205 | if (fmt[0] < offset + 1 + 3 * (nr_rates ? nr_rates : 2)) { |
206 | usb_audio_err(chip, |
207 | "%u:%d : invalid UAC_FORMAT_TYPE desc\n" , |
208 | fp->iface, fp->altsetting); |
209 | return -EINVAL; |
210 | } |
211 | |
212 | if (nr_rates) { |
213 | /* |
214 | * build the rate table and bitmap flags |
215 | */ |
216 | int r, idx; |
217 | |
218 | fp->rate_table = kmalloc_array(n: nr_rates, size: sizeof(int), |
219 | GFP_KERNEL); |
220 | if (fp->rate_table == NULL) |
221 | return -ENOMEM; |
222 | |
223 | fp->nr_rates = 0; |
224 | for (r = 0, idx = offset + 1; r < nr_rates; r++, idx += 3) { |
225 | unsigned int rate = combine_triple(&fmt[idx]); |
226 | if (!rate) |
227 | continue; |
228 | /* C-Media CM6501 mislabels its 96 kHz altsetting */ |
229 | /* Terratec Aureon 7.1 USB C-Media 6206, too */ |
230 | /* Ozone Z90 USB C-Media, too */ |
231 | if (rate == 48000 && nr_rates == 1 && |
232 | (chip->usb_id == USB_ID(0x0d8c, 0x0201) || |
233 | chip->usb_id == USB_ID(0x0d8c, 0x0102) || |
234 | chip->usb_id == USB_ID(0x0d8c, 0x0078) || |
235 | chip->usb_id == USB_ID(0x0ccd, 0x00b1)) && |
236 | fp->altsetting == 5 && fp->maxpacksize == 392) |
237 | rate = 96000; |
238 | /* Creative VF0420/VF0470 Live Cams report 16 kHz instead of 8kHz */ |
239 | if (rate == 16000 && |
240 | (chip->usb_id == USB_ID(0x041e, 0x4064) || |
241 | chip->usb_id == USB_ID(0x041e, 0x4068))) |
242 | rate = 8000; |
243 | |
244 | fp->rate_table[fp->nr_rates++] = rate; |
245 | } |
246 | if (!fp->nr_rates) { |
247 | usb_audio_info(chip, |
248 | "%u:%d: All rates were zero\n" , |
249 | fp->iface, fp->altsetting); |
250 | return -EINVAL; |
251 | } |
252 | set_rate_table_min_max(fp); |
253 | } else { |
254 | /* continuous rates */ |
255 | fp->rates = SNDRV_PCM_RATE_CONTINUOUS; |
256 | fp->rate_min = combine_triple(&fmt[offset + 1]); |
257 | fp->rate_max = combine_triple(&fmt[offset + 4]); |
258 | } |
259 | |
260 | /* Jabra Evolve 65 headset */ |
261 | if (chip->usb_id == USB_ID(0x0b0e, 0x030b)) { |
262 | /* only 48kHz for playback while keeping 16kHz for capture */ |
263 | if (fp->nr_rates != 1) |
264 | return set_fixed_rate(fp, rate: 48000, SNDRV_PCM_RATE_48000); |
265 | } |
266 | |
267 | return 0; |
268 | } |
269 | |
270 | |
271 | /* |
272 | * Presonus Studio 1810c supports a limited set of sampling |
273 | * rates per altsetting but reports the full set each time. |
274 | * If we don't filter out the unsupported rates and attempt |
275 | * to configure the card, it will hang refusing to do any |
276 | * further audio I/O until a hard reset is performed. |
277 | * |
278 | * The list of supported rates per altsetting (set of available |
279 | * I/O channels) is described in the owner's manual, section 2.2. |
280 | */ |
281 | static bool s1810c_valid_sample_rate(struct audioformat *fp, |
282 | unsigned int rate) |
283 | { |
284 | switch (fp->altsetting) { |
285 | case 1: |
286 | /* All ADAT ports available */ |
287 | return rate <= 48000; |
288 | case 2: |
289 | /* Half of ADAT ports available */ |
290 | return (rate == 88200 || rate == 96000); |
291 | case 3: |
292 | /* Analog I/O only (no S/PDIF nor ADAT) */ |
293 | return rate >= 176400; |
294 | default: |
295 | return false; |
296 | } |
297 | return false; |
298 | } |
299 | |
300 | /* |
301 | * Many Focusrite devices supports a limited set of sampling rates per |
302 | * altsetting. Maximum rate is exposed in the last 4 bytes of Format Type |
303 | * descriptor which has a non-standard bLength = 10. |
304 | */ |
305 | static bool focusrite_valid_sample_rate(struct snd_usb_audio *chip, |
306 | struct audioformat *fp, |
307 | unsigned int rate) |
308 | { |
309 | struct usb_interface *iface; |
310 | struct usb_host_interface *alts; |
311 | unsigned char *fmt; |
312 | unsigned int max_rate; |
313 | |
314 | iface = usb_ifnum_to_if(dev: chip->dev, ifnum: fp->iface); |
315 | if (!iface) |
316 | return true; |
317 | |
318 | alts = &iface->altsetting[fp->altset_idx]; |
319 | fmt = snd_usb_find_csint_desc(descstart: alts->extra, desclen: alts->extralen, |
320 | NULL, UAC_FORMAT_TYPE); |
321 | if (!fmt) |
322 | return true; |
323 | |
324 | if (fmt[0] == 10) { /* bLength */ |
325 | max_rate = combine_quad(&fmt[6]); |
326 | |
327 | /* Validate max rate */ |
328 | if (max_rate != 48000 && |
329 | max_rate != 96000 && |
330 | max_rate != 192000 && |
331 | max_rate != 384000) { |
332 | |
333 | usb_audio_info(chip, |
334 | "%u:%d : unexpected max rate: %u\n" , |
335 | fp->iface, fp->altsetting, max_rate); |
336 | |
337 | return true; |
338 | } |
339 | |
340 | return rate <= max_rate; |
341 | } |
342 | |
343 | return true; |
344 | } |
345 | |
346 | /* |
347 | * Helper function to walk the array of sample rate triplets reported by |
348 | * the device. The problem is that we need to parse whole array first to |
349 | * get to know how many sample rates we have to expect. |
350 | * Then fp->rate_table can be allocated and filled. |
351 | */ |
352 | static int parse_uac2_sample_rate_range(struct snd_usb_audio *chip, |
353 | struct audioformat *fp, int nr_triplets, |
354 | const unsigned char *data) |
355 | { |
356 | int i, nr_rates = 0; |
357 | |
358 | for (i = 0; i < nr_triplets; i++) { |
359 | int min = combine_quad(&data[2 + 12 * i]); |
360 | int max = combine_quad(&data[6 + 12 * i]); |
361 | int res = combine_quad(&data[10 + 12 * i]); |
362 | unsigned int rate; |
363 | |
364 | if ((max < 0) || (min < 0) || (res < 0) || (max < min)) |
365 | continue; |
366 | |
367 | /* |
368 | * for ranges with res == 1, we announce a continuous sample |
369 | * rate range, and this function should return 0 for no further |
370 | * parsing. |
371 | */ |
372 | if (res == 1) { |
373 | fp->rate_min = min; |
374 | fp->rate_max = max; |
375 | fp->rates = SNDRV_PCM_RATE_CONTINUOUS; |
376 | return 0; |
377 | } |
378 | |
379 | for (rate = min; rate <= max; rate += res) { |
380 | |
381 | /* Filter out invalid rates on Presonus Studio 1810c */ |
382 | if (chip->usb_id == USB_ID(0x194f, 0x010c) && |
383 | !s1810c_valid_sample_rate(fp, rate)) |
384 | goto skip_rate; |
385 | |
386 | /* Filter out invalid rates on Focusrite devices */ |
387 | if (USB_ID_VENDOR(chip->usb_id) == 0x1235 && |
388 | !focusrite_valid_sample_rate(chip, fp, rate)) |
389 | goto skip_rate; |
390 | |
391 | if (fp->rate_table) |
392 | fp->rate_table[nr_rates] = rate; |
393 | nr_rates++; |
394 | if (nr_rates >= MAX_NR_RATES) { |
395 | usb_audio_err(chip, "invalid uac2 rates\n" ); |
396 | break; |
397 | } |
398 | |
399 | skip_rate: |
400 | /* avoid endless loop */ |
401 | if (res == 0) |
402 | break; |
403 | } |
404 | } |
405 | |
406 | return nr_rates; |
407 | } |
408 | |
409 | /* Line6 Helix series and the Rode Rodecaster Pro don't support the |
410 | * UAC2_CS_RANGE usb function call. Return a static table of known |
411 | * clock rates. |
412 | */ |
413 | static int line6_parse_audio_format_rates_quirk(struct snd_usb_audio *chip, |
414 | struct audioformat *fp) |
415 | { |
416 | switch (chip->usb_id) { |
417 | case USB_ID(0x0e41, 0x4241): /* Line6 Helix */ |
418 | case USB_ID(0x0e41, 0x4242): /* Line6 Helix Rack */ |
419 | case USB_ID(0x0e41, 0x4244): /* Line6 Helix LT */ |
420 | case USB_ID(0x0e41, 0x4246): /* Line6 HX-Stomp */ |
421 | case USB_ID(0x0e41, 0x4253): /* Line6 HX-Stomp XL */ |
422 | case USB_ID(0x0e41, 0x4247): /* Line6 Pod Go */ |
423 | case USB_ID(0x0e41, 0x4248): /* Line6 Helix >= fw 2.82 */ |
424 | case USB_ID(0x0e41, 0x4249): /* Line6 Helix Rack >= fw 2.82 */ |
425 | case USB_ID(0x0e41, 0x424a): /* Line6 Helix LT >= fw 2.82 */ |
426 | case USB_ID(0x0e41, 0x424b): /* Line6 Pod Go */ |
427 | case USB_ID(0x19f7, 0x0011): /* Rode Rodecaster Pro */ |
428 | return set_fixed_rate(fp, rate: 48000, SNDRV_PCM_RATE_48000); |
429 | } |
430 | |
431 | return -ENODEV; |
432 | } |
433 | |
434 | /* check whether the given altsetting is supported for the already set rate */ |
435 | static bool check_valid_altsetting_v2v3(struct snd_usb_audio *chip, int iface, |
436 | int altsetting) |
437 | { |
438 | struct usb_device *dev = chip->dev; |
439 | __le64 raw_data = 0; |
440 | u64 data; |
441 | int err; |
442 | |
443 | /* we assume 64bit is enough for any altsettings */ |
444 | if (snd_BUG_ON(altsetting >= 64 - 8)) |
445 | return false; |
446 | |
447 | err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC2_CS_CUR, |
448 | USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN, |
449 | UAC2_AS_VAL_ALT_SETTINGS << 8, |
450 | index: iface, data: &raw_data, size: sizeof(raw_data)); |
451 | if (err < 0) |
452 | return false; |
453 | |
454 | data = le64_to_cpu(raw_data); |
455 | /* first byte contains the bitmap size */ |
456 | if ((data & 0xff) * 8 < altsetting) |
457 | return false; |
458 | if (data & (1ULL << (altsetting + 8))) |
459 | return true; |
460 | |
461 | return false; |
462 | } |
463 | |
464 | /* |
465 | * Validate each sample rate with the altsetting |
466 | * Rebuild the rate table if only partial values are valid |
467 | */ |
468 | static int validate_sample_rate_table_v2v3(struct snd_usb_audio *chip, |
469 | struct audioformat *fp, |
470 | int clock) |
471 | { |
472 | struct usb_device *dev = chip->dev; |
473 | unsigned int *table; |
474 | unsigned int nr_rates; |
475 | int i, err; |
476 | |
477 | /* performing the rate verification may lead to unexpected USB bus |
478 | * behavior afterwards by some unknown reason. Do this only for the |
479 | * known devices. |
480 | */ |
481 | if (!(chip->quirk_flags & QUIRK_FLAG_VALIDATE_RATES)) |
482 | return 0; /* don't perform the validation as default */ |
483 | |
484 | table = kcalloc(n: fp->nr_rates, size: sizeof(*table), GFP_KERNEL); |
485 | if (!table) |
486 | return -ENOMEM; |
487 | |
488 | /* clear the interface altsetting at first */ |
489 | usb_set_interface(dev, ifnum: fp->iface, alternate: 0); |
490 | |
491 | nr_rates = 0; |
492 | for (i = 0; i < fp->nr_rates; i++) { |
493 | err = snd_usb_set_sample_rate_v2v3(chip, fmt: fp, clock, |
494 | rate: fp->rate_table[i]); |
495 | if (err < 0) |
496 | continue; |
497 | |
498 | if (check_valid_altsetting_v2v3(chip, iface: fp->iface, altsetting: fp->altsetting)) |
499 | table[nr_rates++] = fp->rate_table[i]; |
500 | } |
501 | |
502 | if (!nr_rates) { |
503 | usb_audio_dbg(chip, |
504 | "No valid sample rate available for %d:%d, assuming a firmware bug\n" , |
505 | fp->iface, fp->altsetting); |
506 | nr_rates = fp->nr_rates; /* continue as is */ |
507 | } |
508 | |
509 | if (fp->nr_rates == nr_rates) { |
510 | kfree(objp: table); |
511 | return 0; |
512 | } |
513 | |
514 | kfree(objp: fp->rate_table); |
515 | fp->rate_table = table; |
516 | fp->nr_rates = nr_rates; |
517 | return 0; |
518 | } |
519 | |
520 | /* |
521 | * parse the format descriptor and stores the possible sample rates |
522 | * on the audioformat table (audio class v2 and v3). |
523 | */ |
524 | static int parse_audio_format_rates_v2v3(struct snd_usb_audio *chip, |
525 | struct audioformat *fp) |
526 | { |
527 | struct usb_device *dev = chip->dev; |
528 | unsigned char tmp[2], *data; |
529 | int nr_triplets, data_size, ret = 0, ret_l6; |
530 | int clock = snd_usb_clock_find_source(chip, fmt: fp, validate: false); |
531 | |
532 | if (clock < 0) { |
533 | dev_err(&dev->dev, |
534 | "%s(): unable to find clock source (clock %d)\n" , |
535 | __func__, clock); |
536 | goto err; |
537 | } |
538 | |
539 | /* get the number of sample rates first by only fetching 2 bytes */ |
540 | ret = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC2_CS_RANGE, |
541 | USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN, |
542 | UAC2_CS_CONTROL_SAM_FREQ << 8, |
543 | index: snd_usb_ctrl_intf(chip) | (clock << 8), |
544 | data: tmp, size: sizeof(tmp)); |
545 | |
546 | if (ret < 0) { |
547 | /* line6 helix devices don't support UAC2_CS_CONTROL_SAM_FREQ call */ |
548 | ret_l6 = line6_parse_audio_format_rates_quirk(chip, fp); |
549 | if (ret_l6 == -ENODEV) { |
550 | /* no line6 device found continue showing the error */ |
551 | dev_err(&dev->dev, |
552 | "%s(): unable to retrieve number of sample rates (clock %d)\n" , |
553 | __func__, clock); |
554 | goto err; |
555 | } |
556 | if (ret_l6 == 0) { |
557 | dev_info(&dev->dev, |
558 | "%s(): unable to retrieve number of sample rates: set it to a predefined value (clock %d).\n" , |
559 | __func__, clock); |
560 | return 0; |
561 | } |
562 | ret = ret_l6; |
563 | goto err; |
564 | } |
565 | |
566 | nr_triplets = (tmp[1] << 8) | tmp[0]; |
567 | data_size = 2 + 12 * nr_triplets; |
568 | data = kzalloc(size: data_size, GFP_KERNEL); |
569 | if (!data) { |
570 | ret = -ENOMEM; |
571 | goto err; |
572 | } |
573 | |
574 | /* now get the full information */ |
575 | ret = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC2_CS_RANGE, |
576 | USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN, |
577 | UAC2_CS_CONTROL_SAM_FREQ << 8, |
578 | index: snd_usb_ctrl_intf(chip) | (clock << 8), |
579 | data, size: data_size); |
580 | |
581 | if (ret < 0) { |
582 | dev_err(&dev->dev, |
583 | "%s(): unable to retrieve sample rate range (clock %d)\n" , |
584 | __func__, clock); |
585 | ret = -EINVAL; |
586 | goto err_free; |
587 | } |
588 | |
589 | /* Call the triplet parser, and make sure fp->rate_table is NULL. |
590 | * We just use the return value to know how many sample rates we |
591 | * will have to deal with. */ |
592 | kfree(objp: fp->rate_table); |
593 | fp->rate_table = NULL; |
594 | fp->nr_rates = parse_uac2_sample_rate_range(chip, fp, nr_triplets, data); |
595 | |
596 | if (fp->nr_rates == 0) { |
597 | /* SNDRV_PCM_RATE_CONTINUOUS */ |
598 | ret = 0; |
599 | goto err_free; |
600 | } |
601 | |
602 | fp->rate_table = kmalloc_array(n: fp->nr_rates, size: sizeof(int), GFP_KERNEL); |
603 | if (!fp->rate_table) { |
604 | ret = -ENOMEM; |
605 | goto err_free; |
606 | } |
607 | |
608 | /* Call the triplet parser again, but this time, fp->rate_table is |
609 | * allocated, so the rates will be stored */ |
610 | parse_uac2_sample_rate_range(chip, fp, nr_triplets, data); |
611 | |
612 | ret = validate_sample_rate_table_v2v3(chip, fp, clock); |
613 | if (ret < 0) |
614 | goto err_free; |
615 | |
616 | set_rate_table_min_max(fp); |
617 | |
618 | err_free: |
619 | kfree(objp: data); |
620 | err: |
621 | return ret; |
622 | } |
623 | |
624 | /* |
625 | * parse the format type I and III descriptors |
626 | */ |
627 | static int parse_audio_format_i(struct snd_usb_audio *chip, |
628 | struct audioformat *fp, u64 format, |
629 | void *_fmt) |
630 | { |
631 | snd_pcm_format_t pcm_format; |
632 | unsigned int fmt_type; |
633 | int ret; |
634 | |
635 | switch (fp->protocol) { |
636 | default: |
637 | case UAC_VERSION_1: |
638 | case UAC_VERSION_2: { |
639 | struct uac_format_type_i_continuous_descriptor *fmt = _fmt; |
640 | |
641 | fmt_type = fmt->bFormatType; |
642 | break; |
643 | } |
644 | case UAC_VERSION_3: { |
645 | /* fp->fmt_type is already set in this case */ |
646 | fmt_type = fp->fmt_type; |
647 | break; |
648 | } |
649 | } |
650 | |
651 | if (fmt_type == UAC_FORMAT_TYPE_III) { |
652 | /* FIXME: the format type is really IECxxx |
653 | * but we give normal PCM format to get the existing |
654 | * apps working... |
655 | */ |
656 | switch (chip->usb_id) { |
657 | |
658 | case USB_ID(0x0763, 0x2003): /* M-Audio Audiophile USB */ |
659 | if (chip->setup == 0x00 && |
660 | fp->altsetting == 6) |
661 | pcm_format = SNDRV_PCM_FORMAT_S16_BE; |
662 | else |
663 | pcm_format = SNDRV_PCM_FORMAT_S16_LE; |
664 | break; |
665 | default: |
666 | pcm_format = SNDRV_PCM_FORMAT_S16_LE; |
667 | } |
668 | fp->formats = pcm_format_to_bits(pcm_format); |
669 | } else { |
670 | fp->formats = parse_audio_format_i_type(chip, fp, format, _fmt); |
671 | if (!fp->formats) |
672 | return -EINVAL; |
673 | } |
674 | |
675 | /* gather possible sample rates */ |
676 | /* audio class v1 reports possible sample rates as part of the |
677 | * proprietary class specific descriptor. |
678 | * audio class v2 uses class specific EP0 range requests for that. |
679 | */ |
680 | switch (fp->protocol) { |
681 | default: |
682 | case UAC_VERSION_1: { |
683 | struct uac_format_type_i_continuous_descriptor *fmt = _fmt; |
684 | |
685 | fp->channels = fmt->bNrChannels; |
686 | ret = parse_audio_format_rates_v1(chip, fp, fmt: (unsigned char *) fmt, offset: 7); |
687 | break; |
688 | } |
689 | case UAC_VERSION_2: |
690 | case UAC_VERSION_3: { |
691 | /* fp->channels is already set in this case */ |
692 | ret = parse_audio_format_rates_v2v3(chip, fp); |
693 | break; |
694 | } |
695 | } |
696 | |
697 | if (fp->channels < 1) { |
698 | usb_audio_err(chip, |
699 | "%u:%d : invalid channels %d\n" , |
700 | fp->iface, fp->altsetting, fp->channels); |
701 | return -EINVAL; |
702 | } |
703 | |
704 | return ret; |
705 | } |
706 | |
707 | /* |
708 | * parse the format type II descriptor |
709 | */ |
710 | static int parse_audio_format_ii(struct snd_usb_audio *chip, |
711 | struct audioformat *fp, |
712 | u64 format, void *_fmt) |
713 | { |
714 | int brate, framesize, ret; |
715 | |
716 | switch (format) { |
717 | case UAC_FORMAT_TYPE_II_AC3: |
718 | /* FIXME: there is no AC3 format defined yet */ |
719 | // fp->formats = SNDRV_PCM_FMTBIT_AC3; |
720 | fp->formats = SNDRV_PCM_FMTBIT_U8; /* temporary hack to receive byte streams */ |
721 | break; |
722 | case UAC_FORMAT_TYPE_II_MPEG: |
723 | fp->formats = SNDRV_PCM_FMTBIT_MPEG; |
724 | break; |
725 | default: |
726 | usb_audio_info(chip, |
727 | "%u:%d : unknown format tag %#llx is detected. processed as MPEG.\n" , |
728 | fp->iface, fp->altsetting, format); |
729 | fp->formats = SNDRV_PCM_FMTBIT_MPEG; |
730 | break; |
731 | } |
732 | |
733 | fp->channels = 1; |
734 | |
735 | switch (fp->protocol) { |
736 | default: |
737 | case UAC_VERSION_1: { |
738 | struct uac_format_type_ii_discrete_descriptor *fmt = _fmt; |
739 | brate = le16_to_cpu(fmt->wMaxBitRate); |
740 | framesize = le16_to_cpu(fmt->wSamplesPerFrame); |
741 | usb_audio_info(chip, "found format II with max.bitrate = %d, frame size=%d\n" , brate, framesize); |
742 | fp->frame_size = framesize; |
743 | ret = parse_audio_format_rates_v1(chip, fp, fmt: _fmt, offset: 8); /* fmt[8..] sample rates */ |
744 | break; |
745 | } |
746 | case UAC_VERSION_2: { |
747 | struct uac_format_type_ii_ext_descriptor *fmt = _fmt; |
748 | brate = le16_to_cpu(fmt->wMaxBitRate); |
749 | framesize = le16_to_cpu(fmt->wSamplesPerFrame); |
750 | usb_audio_info(chip, "found format II with max.bitrate = %d, frame size=%d\n" , brate, framesize); |
751 | fp->frame_size = framesize; |
752 | ret = parse_audio_format_rates_v2v3(chip, fp); |
753 | break; |
754 | } |
755 | } |
756 | |
757 | return ret; |
758 | } |
759 | |
760 | int snd_usb_parse_audio_format(struct snd_usb_audio *chip, |
761 | struct audioformat *fp, u64 format, |
762 | struct uac_format_type_i_continuous_descriptor *fmt, |
763 | int stream) |
764 | { |
765 | int err; |
766 | |
767 | switch (fmt->bFormatType) { |
768 | case UAC_FORMAT_TYPE_I: |
769 | case UAC_FORMAT_TYPE_III: |
770 | err = parse_audio_format_i(chip, fp, format, fmt: fmt); |
771 | break; |
772 | case UAC_FORMAT_TYPE_II: |
773 | err = parse_audio_format_ii(chip, fp, format, fmt: fmt); |
774 | break; |
775 | default: |
776 | usb_audio_info(chip, |
777 | "%u:%d : format type %d is not supported yet\n" , |
778 | fp->iface, fp->altsetting, |
779 | fmt->bFormatType); |
780 | return -ENOTSUPP; |
781 | } |
782 | fp->fmt_type = fmt->bFormatType; |
783 | if (err < 0) |
784 | return err; |
785 | #if 1 |
786 | /* FIXME: temporary hack for extigy/audigy 2 nx/zs */ |
787 | /* extigy apparently supports sample rates other than 48k |
788 | * but not in ordinary way. so we enable only 48k atm. |
789 | */ |
790 | if (chip->usb_id == USB_ID(0x041e, 0x3000) || |
791 | chip->usb_id == USB_ID(0x041e, 0x3020) || |
792 | chip->usb_id == USB_ID(0x041e, 0x3061)) { |
793 | if (fmt->bFormatType == UAC_FORMAT_TYPE_I && |
794 | fp->rates != SNDRV_PCM_RATE_48000 && |
795 | fp->rates != SNDRV_PCM_RATE_96000) |
796 | return -ENOTSUPP; |
797 | } |
798 | #endif |
799 | return 0; |
800 | } |
801 | |
802 | int snd_usb_parse_audio_format_v3(struct snd_usb_audio *chip, |
803 | struct audioformat *fp, |
804 | struct uac3_as_header_descriptor *as, |
805 | int stream) |
806 | { |
807 | u64 format = le64_to_cpu(as->bmFormats); |
808 | int err; |
809 | |
810 | /* |
811 | * Type I format bits are D0..D6 |
812 | * This test works because type IV is not supported |
813 | */ |
814 | if (format & 0x7f) |
815 | fp->fmt_type = UAC_FORMAT_TYPE_I; |
816 | else |
817 | fp->fmt_type = UAC_FORMAT_TYPE_III; |
818 | |
819 | err = parse_audio_format_i(chip, fp, format, fmt: as); |
820 | if (err < 0) |
821 | return err; |
822 | |
823 | return 0; |
824 | } |
825 | |