Commit | Line | Data |
---|---|---|
79f920fb DM |
1 | /* |
2 | * Clock domain and sample rate management functions | |
3 | * | |
4 | * This program is free software; you can redistribute it and/or modify | |
5 | * it under the terms of the GNU General Public License as published by | |
6 | * the Free Software Foundation; either version 2 of the License, or | |
7 | * (at your option) any later version. | |
8 | * | |
9 | * This program is distributed in the hope that it will be useful, | |
10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | |
11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
12 | * GNU General Public License for more details. | |
13 | * | |
14 | * You should have received a copy of the GNU General Public License | |
15 | * along with this program; if not, write to the Free Software | |
16 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | |
17 | * | |
18 | */ | |
19 | ||
20 | #include <linux/bitops.h> | |
21 | #include <linux/init.h> | |
79f920fb DM |
22 | #include <linux/string.h> |
23 | #include <linux/usb.h> | |
79f920fb DM |
24 | #include <linux/usb/audio.h> |
25 | #include <linux/usb/audio-v2.h> | |
9a2fe9b8 | 26 | #include <linux/usb/audio-v3.h> |
79f920fb DM |
27 | |
28 | #include <sound/core.h> | |
29 | #include <sound/info.h> | |
30 | #include <sound/pcm.h> | |
79f920fb DM |
31 | |
32 | #include "usbaudio.h" | |
33 | #include "card.h" | |
79f920fb | 34 | #include "helper.h" |
f22aa949 | 35 | #include "clock.h" |
21bb5aaf | 36 | #include "quirks.h" |
79f920fb | 37 | |
f7645bd6 TI |
38 | static void *find_uac_clock_desc(struct usb_host_interface *iface, int id, |
39 | bool (*validator)(void *, int), u8 type) | |
79f920fb | 40 | { |
f7645bd6 | 41 | void *cs = NULL; |
79f920fb | 42 | |
f7645bd6 TI |
43 | while ((cs = snd_usb_find_csint_desc(iface->extra, iface->extralen, |
44 | cs, type))) { | |
45 | if (validator(cs, id)) | |
79f920fb DM |
46 | return cs; |
47 | } | |
48 | ||
49 | return NULL; | |
50 | } | |
51 | ||
f7645bd6 | 52 | static bool validate_clock_source_v2(void *p, int id) |
9a2fe9b8 | 53 | { |
f7645bd6 | 54 | struct uac_clock_source_descriptor *cs = p; |
f5d76e9c | 55 | return cs->bLength == sizeof(*cs) && cs->bClockID == id; |
9a2fe9b8 RB |
56 | } |
57 | ||
f7645bd6 | 58 | static bool validate_clock_source_v3(void *p, int id) |
79f920fb | 59 | { |
f7645bd6 | 60 | struct uac3_clock_source_descriptor *cs = p; |
b580fbff | 61 | return cs->bLength == sizeof(*cs) && cs->bClockID == id; |
79f920fb DM |
62 | } |
63 | ||
f7645bd6 | 64 | static bool validate_clock_selector_v2(void *p, int id) |
9a2fe9b8 | 65 | { |
f7645bd6 TI |
66 | struct uac_clock_selector_descriptor *cs = p; |
67 | return cs->bLength >= sizeof(*cs) && cs->bClockID == id && | |
f5d76e9c | 68 | cs->bLength == 7 + cs->bNrInPins; |
9a2fe9b8 RB |
69 | } |
70 | ||
f7645bd6 | 71 | static bool validate_clock_selector_v3(void *p, int id) |
79f920fb | 72 | { |
f7645bd6 | 73 | struct uac3_clock_selector_descriptor *cs = p; |
b580fbff TI |
74 | return cs->bLength >= sizeof(*cs) && cs->bClockID == id && |
75 | cs->bLength == 11 + cs->bNrInPins; | |
79f920fb DM |
76 | } |
77 | ||
f7645bd6 | 78 | static bool validate_clock_multiplier_v2(void *p, int id) |
9a2fe9b8 | 79 | { |
f7645bd6 | 80 | struct uac_clock_multiplier_descriptor *cs = p; |
f5d76e9c | 81 | return cs->bLength == sizeof(*cs) && cs->bClockID == id; |
f7645bd6 | 82 | } |
9a2fe9b8 | 83 | |
f7645bd6 TI |
84 | static bool validate_clock_multiplier_v3(void *p, int id) |
85 | { | |
86 | struct uac3_clock_multiplier_descriptor *cs = p; | |
b580fbff | 87 | return cs->bLength == sizeof(*cs) && cs->bClockID == id; |
f7645bd6 | 88 | } |
9a2fe9b8 | 89 | |
f7645bd6 TI |
90 | #define DEFINE_FIND_HELPER(name, obj, validator, type) \ |
91 | static obj *name(struct usb_host_interface *iface, int id) \ | |
92 | { \ | |
93 | return find_uac_clock_desc(iface, id, validator, type); \ | |
9a2fe9b8 RB |
94 | } |
95 | ||
f7645bd6 TI |
96 | DEFINE_FIND_HELPER(snd_usb_find_clock_source, |
97 | struct uac_clock_source_descriptor, | |
98 | validate_clock_source_v2, UAC2_CLOCK_SOURCE); | |
99 | DEFINE_FIND_HELPER(snd_usb_find_clock_source_v3, | |
100 | struct uac3_clock_source_descriptor, | |
101 | validate_clock_source_v3, UAC3_CLOCK_SOURCE); | |
102 | ||
103 | DEFINE_FIND_HELPER(snd_usb_find_clock_selector, | |
104 | struct uac_clock_selector_descriptor, | |
105 | validate_clock_selector_v2, UAC2_CLOCK_SELECTOR); | |
106 | DEFINE_FIND_HELPER(snd_usb_find_clock_selector_v3, | |
107 | struct uac3_clock_selector_descriptor, | |
108 | validate_clock_selector_v3, UAC3_CLOCK_SELECTOR); | |
109 | ||
110 | DEFINE_FIND_HELPER(snd_usb_find_clock_multiplier, | |
111 | struct uac_clock_multiplier_descriptor, | |
112 | validate_clock_multiplier_v2, UAC2_CLOCK_MULTIPLIER); | |
113 | DEFINE_FIND_HELPER(snd_usb_find_clock_multiplier_v3, | |
114 | struct uac3_clock_multiplier_descriptor, | |
115 | validate_clock_multiplier_v3, UAC3_CLOCK_MULTIPLIER); | |
116 | ||
79f920fb DM |
117 | static int uac_clock_selector_get_val(struct snd_usb_audio *chip, int selector_id) |
118 | { | |
119 | unsigned char buf; | |
120 | int ret; | |
121 | ||
122 | ret = snd_usb_ctl_msg(chip->dev, usb_rcvctrlpipe(chip->dev, 0), | |
123 | UAC2_CS_CUR, | |
124 | USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_IN, | |
11bcbc44 DM |
125 | UAC2_CX_CLOCK_SELECTOR << 8, |
126 | snd_usb_ctrl_intf(chip) | (selector_id << 8), | |
17d900c4 | 127 | &buf, sizeof(buf)); |
79f920fb DM |
128 | |
129 | if (ret < 0) | |
130 | return ret; | |
131 | ||
132 | return buf; | |
133 | } | |
134 | ||
8c55af3f EZ |
135 | static int uac_clock_selector_set_val(struct snd_usb_audio *chip, int selector_id, |
136 | unsigned char pin) | |
137 | { | |
138 | int ret; | |
139 | ||
140 | ret = snd_usb_ctl_msg(chip->dev, usb_sndctrlpipe(chip->dev, 0), | |
141 | UAC2_CS_CUR, | |
142 | USB_RECIP_INTERFACE | USB_TYPE_CLASS | USB_DIR_OUT, | |
143 | UAC2_CX_CLOCK_SELECTOR << 8, | |
144 | snd_usb_ctrl_intf(chip) | (selector_id << 8), | |
145 | &pin, sizeof(pin)); | |
146 | if (ret < 0) | |
147 | return ret; | |
148 | ||
149 | if (ret != sizeof(pin)) { | |
0ba41d91 TI |
150 | usb_audio_err(chip, |
151 | "setting selector (id %d) unexpected length %d\n", | |
152 | selector_id, ret); | |
8c55af3f EZ |
153 | return -EINVAL; |
154 | } | |
155 | ||
156 | ret = uac_clock_selector_get_val(chip, selector_id); | |
157 | if (ret < 0) | |
158 | return ret; | |
159 | ||
160 | if (ret != pin) { | |
0ba41d91 TI |
161 | usb_audio_err(chip, |
162 | "setting selector (id %d) to %x failed (current: %d)\n", | |
163 | selector_id, pin, ret); | |
8c55af3f EZ |
164 | return -EINVAL; |
165 | } | |
166 | ||
167 | return ret; | |
168 | } | |
169 | ||
9a2fe9b8 RB |
170 | static bool uac_clock_source_is_valid(struct snd_usb_audio *chip, |
171 | int protocol, | |
172 | int source_id) | |
79f920fb DM |
173 | { |
174 | int err; | |
175 | unsigned char data; | |
176 | struct usb_device *dev = chip->dev; | |
9a2fe9b8 RB |
177 | u32 bmControls; |
178 | ||
179 | if (protocol == UAC_VERSION_3) { | |
180 | struct uac3_clock_source_descriptor *cs_desc = | |
181 | snd_usb_find_clock_source_v3(chip->ctrl_intf, source_id); | |
182 | ||
183 | if (!cs_desc) | |
184 | return 0; | |
185 | bmControls = le32_to_cpu(cs_desc->bmControls); | |
186 | } else { /* UAC_VERSION_1/2 */ | |
187 | struct uac_clock_source_descriptor *cs_desc = | |
188 | snd_usb_find_clock_source(chip->ctrl_intf, source_id); | |
189 | ||
190 | if (!cs_desc) | |
191 | return 0; | |
192 | bmControls = cs_desc->bmControls; | |
193 | } | |
3bc6fbc7 DM |
194 | |
195 | /* If a clock source can't tell us whether it's valid, we assume it is */ | |
9a2fe9b8 | 196 | if (!uac_v2v3_control_is_readable(bmControls, |
21e9b3e9 | 197 | UAC2_CS_CONTROL_CLOCK_VALID)) |
3bc6fbc7 | 198 | return 1; |
79f920fb DM |
199 | |
200 | err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC2_CS_CUR, | |
201 | USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN, | |
11bcbc44 DM |
202 | UAC2_CS_CONTROL_CLOCK_VALID << 8, |
203 | snd_usb_ctrl_intf(chip) | (source_id << 8), | |
17d900c4 | 204 | &data, sizeof(data)); |
79f920fb DM |
205 | |
206 | if (err < 0) { | |
0ba41d91 TI |
207 | dev_warn(&dev->dev, |
208 | "%s(): cannot get clock validity for id %d\n", | |
79f920fb | 209 | __func__, source_id); |
3bc6fbc7 | 210 | return 0; |
79f920fb DM |
211 | } |
212 | ||
213 | return !!data; | |
214 | } | |
215 | ||
9a2fe9b8 RB |
216 | static int __uac_clock_find_source(struct snd_usb_audio *chip, int entity_id, |
217 | unsigned long *visited, bool validate) | |
79f920fb DM |
218 | { |
219 | struct uac_clock_source_descriptor *source; | |
220 | struct uac_clock_selector_descriptor *selector; | |
221 | struct uac_clock_multiplier_descriptor *multiplier; | |
222 | ||
223 | entity_id &= 0xff; | |
224 | ||
225 | if (test_and_set_bit(entity_id, visited)) { | |
0ba41d91 TI |
226 | usb_audio_warn(chip, |
227 | "%s(): recursive clock topology detected, id %d.\n", | |
228 | __func__, entity_id); | |
79f920fb DM |
229 | return -EINVAL; |
230 | } | |
231 | ||
232 | /* first, see if the ID we're looking for is a clock source already */ | |
3d8d4dcf | 233 | source = snd_usb_find_clock_source(chip->ctrl_intf, entity_id); |
06ffc1eb EZ |
234 | if (source) { |
235 | entity_id = source->bClockID; | |
9a2fe9b8 RB |
236 | if (validate && !uac_clock_source_is_valid(chip, UAC_VERSION_2, |
237 | entity_id)) { | |
0ba41d91 TI |
238 | usb_audio_err(chip, |
239 | "clock source %d is not valid, cannot use\n", | |
240 | entity_id); | |
06ffc1eb EZ |
241 | return -ENXIO; |
242 | } | |
243 | return entity_id; | |
244 | } | |
79f920fb | 245 | |
3d8d4dcf | 246 | selector = snd_usb_find_clock_selector(chip->ctrl_intf, entity_id); |
79f920fb | 247 | if (selector) { |
8c55af3f | 248 | int ret, i, cur; |
79f920fb DM |
249 | |
250 | /* the entity ID we are looking for is a selector. | |
251 | * find out what it currently selects */ | |
252 | ret = uac_clock_selector_get_val(chip, selector->bClockID); | |
253 | if (ret < 0) | |
254 | return ret; | |
255 | ||
157a57b6 DM |
256 | /* Selector values are one-based */ |
257 | ||
79f920fb | 258 | if (ret > selector->bNrInPins || ret < 1) { |
0ba41d91 | 259 | usb_audio_err(chip, |
79f920fb DM |
260 | "%s(): selector reported illegal value, id %d, ret %d\n", |
261 | __func__, selector->bClockID, ret); | |
262 | ||
263 | return -EINVAL; | |
264 | } | |
265 | ||
8c55af3f EZ |
266 | cur = ret; |
267 | ret = __uac_clock_find_source(chip, selector->baCSourceID[ret - 1], | |
06ffc1eb | 268 | visited, validate); |
ef02e29b | 269 | if (!validate || ret > 0 || !chip->autoclock) |
8c55af3f EZ |
270 | return ret; |
271 | ||
272 | /* The current clock source is invalid, try others. */ | |
273 | for (i = 1; i <= selector->bNrInPins; i++) { | |
274 | int err; | |
275 | ||
276 | if (i == cur) | |
277 | continue; | |
278 | ||
279 | ret = __uac_clock_find_source(chip, selector->baCSourceID[i - 1], | |
280 | visited, true); | |
281 | if (ret < 0) | |
282 | continue; | |
283 | ||
284 | err = uac_clock_selector_set_val(chip, entity_id, i); | |
285 | if (err < 0) | |
286 | continue; | |
287 | ||
0ba41d91 TI |
288 | usb_audio_info(chip, |
289 | "found and selected valid clock source %d\n", | |
290 | ret); | |
8c55af3f EZ |
291 | return ret; |
292 | } | |
293 | ||
294 | return -ENXIO; | |
79f920fb DM |
295 | } |
296 | ||
297 | /* FIXME: multipliers only act as pass-thru element for now */ | |
3d8d4dcf | 298 | multiplier = snd_usb_find_clock_multiplier(chip->ctrl_intf, entity_id); |
79f920fb | 299 | if (multiplier) |
3d8d4dcf | 300 | return __uac_clock_find_source(chip, multiplier->bCSourceID, |
06ffc1eb | 301 | visited, validate); |
79f920fb DM |
302 | |
303 | return -EINVAL; | |
304 | } | |
305 | ||
9a2fe9b8 RB |
306 | static int __uac3_clock_find_source(struct snd_usb_audio *chip, int entity_id, |
307 | unsigned long *visited, bool validate) | |
308 | { | |
309 | struct uac3_clock_source_descriptor *source; | |
310 | struct uac3_clock_selector_descriptor *selector; | |
311 | struct uac3_clock_multiplier_descriptor *multiplier; | |
312 | ||
313 | entity_id &= 0xff; | |
314 | ||
315 | if (test_and_set_bit(entity_id, visited)) { | |
316 | usb_audio_warn(chip, | |
317 | "%s(): recursive clock topology detected, id %d.\n", | |
318 | __func__, entity_id); | |
319 | return -EINVAL; | |
320 | } | |
321 | ||
322 | /* first, see if the ID we're looking for is a clock source already */ | |
323 | source = snd_usb_find_clock_source_v3(chip->ctrl_intf, entity_id); | |
324 | if (source) { | |
325 | entity_id = source->bClockID; | |
326 | if (validate && !uac_clock_source_is_valid(chip, UAC_VERSION_3, | |
327 | entity_id)) { | |
328 | usb_audio_err(chip, | |
329 | "clock source %d is not valid, cannot use\n", | |
330 | entity_id); | |
331 | return -ENXIO; | |
332 | } | |
333 | return entity_id; | |
334 | } | |
335 | ||
336 | selector = snd_usb_find_clock_selector_v3(chip->ctrl_intf, entity_id); | |
337 | if (selector) { | |
338 | int ret, i, cur; | |
339 | ||
340 | /* the entity ID we are looking for is a selector. | |
341 | * find out what it currently selects */ | |
342 | ret = uac_clock_selector_get_val(chip, selector->bClockID); | |
343 | if (ret < 0) | |
344 | return ret; | |
345 | ||
346 | /* Selector values are one-based */ | |
347 | ||
348 | if (ret > selector->bNrInPins || ret < 1) { | |
349 | usb_audio_err(chip, | |
350 | "%s(): selector reported illegal value, id %d, ret %d\n", | |
351 | __func__, selector->bClockID, ret); | |
352 | ||
353 | return -EINVAL; | |
354 | } | |
355 | ||
356 | cur = ret; | |
357 | ret = __uac3_clock_find_source(chip, selector->baCSourceID[ret - 1], | |
358 | visited, validate); | |
359 | if (!validate || ret > 0 || !chip->autoclock) | |
360 | return ret; | |
361 | ||
362 | /* The current clock source is invalid, try others. */ | |
363 | for (i = 1; i <= selector->bNrInPins; i++) { | |
364 | int err; | |
365 | ||
366 | if (i == cur) | |
367 | continue; | |
368 | ||
369 | ret = __uac3_clock_find_source(chip, selector->baCSourceID[i - 1], | |
370 | visited, true); | |
371 | if (ret < 0) | |
372 | continue; | |
373 | ||
374 | err = uac_clock_selector_set_val(chip, entity_id, i); | |
375 | if (err < 0) | |
376 | continue; | |
377 | ||
378 | usb_audio_info(chip, | |
379 | "found and selected valid clock source %d\n", | |
380 | ret); | |
381 | return ret; | |
382 | } | |
383 | ||
384 | return -ENXIO; | |
385 | } | |
386 | ||
387 | /* FIXME: multipliers only act as pass-thru element for now */ | |
388 | multiplier = snd_usb_find_clock_multiplier_v3(chip->ctrl_intf, | |
389 | entity_id); | |
390 | if (multiplier) | |
391 | return __uac3_clock_find_source(chip, multiplier->bCSourceID, | |
392 | visited, validate); | |
393 | ||
394 | return -EINVAL; | |
395 | } | |
396 | ||
157a57b6 DM |
397 | /* |
398 | * For all kinds of sample rate settings and other device queries, | |
399 | * the clock source (end-leaf) must be used. However, clock selectors, | |
400 | * clock multipliers and sample rate converters may be specified as | |
401 | * clock source input to terminal. This functions walks the clock path | |
402 | * to its end and tries to find the source. | |
403 | * | |
404 | * The 'visited' bitfield is used internally to detect recursive loops. | |
405 | * | |
406 | * Returns the clock source UnitID (>=0) on success, or an error. | |
407 | */ | |
9a2fe9b8 RB |
408 | int snd_usb_clock_find_source(struct snd_usb_audio *chip, int protocol, |
409 | int entity_id, bool validate) | |
79f920fb DM |
410 | { |
411 | DECLARE_BITMAP(visited, 256); | |
412 | memset(visited, 0, sizeof(visited)); | |
9a2fe9b8 RB |
413 | |
414 | switch (protocol) { | |
415 | case UAC_VERSION_2: | |
416 | return __uac_clock_find_source(chip, entity_id, visited, | |
417 | validate); | |
418 | case UAC_VERSION_3: | |
419 | return __uac3_clock_find_source(chip, entity_id, visited, | |
420 | validate); | |
421 | default: | |
422 | return -EINVAL; | |
423 | } | |
79f920fb DM |
424 | } |
425 | ||
426 | static int set_sample_rate_v1(struct snd_usb_audio *chip, int iface, | |
427 | struct usb_host_interface *alts, | |
428 | struct audioformat *fmt, int rate) | |
429 | { | |
430 | struct usb_device *dev = chip->dev; | |
431 | unsigned int ep; | |
432 | unsigned char data[3]; | |
433 | int err, crate; | |
434 | ||
447d6275 TI |
435 | if (get_iface_desc(alts)->bNumEndpoints < 1) |
436 | return -EINVAL; | |
79f920fb DM |
437 | ep = get_endpoint(alts, 0)->bEndpointAddress; |
438 | ||
439 | /* if endpoint doesn't have sampling rate control, bail out */ | |
d32d552e | 440 | if (!(fmt->attributes & UAC_EP_CS_ATTR_SAMPLE_RATE)) |
79f920fb | 441 | return 0; |
79f920fb DM |
442 | |
443 | data[0] = rate; | |
444 | data[1] = rate >> 8; | |
445 | data[2] = rate >> 16; | |
f25ecf8f TI |
446 | err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), UAC_SET_CUR, |
447 | USB_TYPE_CLASS | USB_RECIP_ENDPOINT | USB_DIR_OUT, | |
448 | UAC_EP_CS_ATTR_SAMPLE_RATE << 8, ep, | |
449 | data, sizeof(data)); | |
450 | if (err < 0) { | |
0ba41d91 TI |
451 | dev_err(&dev->dev, "%d:%d: cannot set freq %d to ep %#x\n", |
452 | iface, fmt->altsetting, rate, ep); | |
79f920fb DM |
453 | return err; |
454 | } | |
455 | ||
b62b9980 JT |
456 | /* Don't check the sample rate for devices which we know don't |
457 | * support reading */ | |
458 | if (snd_usb_get_sample_rate_quirk(chip)) | |
459 | return 0; | |
57dd5414 TI |
460 | /* the firmware is likely buggy, don't repeat to fail too many times */ |
461 | if (chip->sample_rate_read_error > 2) | |
462 | return 0; | |
b62b9980 | 463 | |
f25ecf8f TI |
464 | err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC_GET_CUR, |
465 | USB_TYPE_CLASS | USB_RECIP_ENDPOINT | USB_DIR_IN, | |
466 | UAC_EP_CS_ATTR_SAMPLE_RATE << 8, ep, | |
467 | data, sizeof(data)); | |
468 | if (err < 0) { | |
0ba41d91 TI |
469 | dev_err(&dev->dev, "%d:%d: cannot get freq at ep %#x\n", |
470 | iface, fmt->altsetting, ep); | |
57dd5414 | 471 | chip->sample_rate_read_error++; |
79f920fb DM |
472 | return 0; /* some devices don't support reading */ |
473 | } | |
474 | ||
475 | crate = data[0] | (data[1] << 8) | (data[2] << 16); | |
476 | if (crate != rate) { | |
0ba41d91 | 477 | dev_warn(&dev->dev, "current rate %d is different from the runtime rate %d\n", crate, rate); |
79f920fb DM |
478 | // runtime->rate = crate; |
479 | } | |
480 | ||
481 | return 0; | |
482 | } | |
483 | ||
9a2fe9b8 | 484 | static int get_sample_rate_v2v3(struct snd_usb_audio *chip, int iface, |
7c517465 TI |
485 | int altsetting, int clock) |
486 | { | |
487 | struct usb_device *dev = chip->dev; | |
f6a8bc70 | 488 | __le32 data; |
7c517465 TI |
489 | int err; |
490 | ||
491 | err = snd_usb_ctl_msg(dev, usb_rcvctrlpipe(dev, 0), UAC2_CS_CUR, | |
492 | USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN, | |
493 | UAC2_CS_CONTROL_SAM_FREQ << 8, | |
494 | snd_usb_ctrl_intf(chip) | (clock << 8), | |
f6a8bc70 | 495 | &data, sizeof(data)); |
7c517465 | 496 | if (err < 0) { |
9a2fe9b8 | 497 | dev_warn(&dev->dev, "%d:%d: cannot get freq (v2/v3): err %d\n", |
0ba41d91 | 498 | iface, altsetting, err); |
7c517465 TI |
499 | return 0; |
500 | } | |
501 | ||
f6a8bc70 | 502 | return le32_to_cpu(data); |
7c517465 TI |
503 | } |
504 | ||
9a2fe9b8 | 505 | static int set_sample_rate_v2v3(struct snd_usb_audio *chip, int iface, |
79f920fb DM |
506 | struct usb_host_interface *alts, |
507 | struct audioformat *fmt, int rate) | |
508 | { | |
509 | struct usb_device *dev = chip->dev; | |
f6a8bc70 | 510 | __le32 data; |
690a863f | 511 | int err, cur_rate, prev_rate; |
8c55af3f | 512 | int clock; |
1dc669fe | 513 | bool writeable; |
9a2fe9b8 | 514 | u32 bmControls; |
79f920fb | 515 | |
9a2fe9b8 RB |
516 | clock = snd_usb_clock_find_source(chip, fmt->protocol, |
517 | fmt->clock, true); | |
79f920fb DM |
518 | if (clock < 0) |
519 | return clock; | |
520 | ||
9a2fe9b8 | 521 | prev_rate = get_sample_rate_v2v3(chip, iface, fmt->altsetting, clock); |
fa92dd77 DH |
522 | if (prev_rate == rate) |
523 | return 0; | |
690a863f | 524 | |
9a2fe9b8 RB |
525 | if (fmt->protocol == UAC_VERSION_3) { |
526 | struct uac3_clock_source_descriptor *cs_desc; | |
527 | ||
528 | cs_desc = snd_usb_find_clock_source_v3(chip->ctrl_intf, clock); | |
529 | bmControls = le32_to_cpu(cs_desc->bmControls); | |
530 | } else { | |
531 | struct uac_clock_source_descriptor *cs_desc; | |
532 | ||
533 | cs_desc = snd_usb_find_clock_source(chip->ctrl_intf, clock); | |
534 | bmControls = cs_desc->bmControls; | |
535 | } | |
536 | ||
21e9b3e9 AC |
537 | writeable = uac_v2v3_control_is_writeable(bmControls, |
538 | UAC2_CS_CONTROL_SAM_FREQ); | |
1dc669fe EZ |
539 | if (writeable) { |
540 | data = cpu_to_le32(rate); | |
541 | err = snd_usb_ctl_msg(dev, usb_sndctrlpipe(dev, 0), UAC2_CS_CUR, | |
542 | USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_OUT, | |
543 | UAC2_CS_CONTROL_SAM_FREQ << 8, | |
544 | snd_usb_ctrl_intf(chip) | (clock << 8), | |
545 | &data, sizeof(data)); | |
546 | if (err < 0) { | |
0ba41d91 | 547 | usb_audio_err(chip, |
9a2fe9b8 | 548 | "%d:%d: cannot set freq %d (v2/v3): err %d\n", |
0ba41d91 | 549 | iface, fmt->altsetting, rate, err); |
1dc669fe EZ |
550 | return err; |
551 | } | |
79f920fb | 552 | |
9a2fe9b8 RB |
553 | cur_rate = get_sample_rate_v2v3(chip, iface, |
554 | fmt->altsetting, clock); | |
1dc669fe EZ |
555 | } else { |
556 | cur_rate = prev_rate; | |
557 | } | |
79f920fb | 558 | |
690a863f | 559 | if (cur_rate != rate) { |
1dc669fe | 560 | if (!writeable) { |
0ba41d91 TI |
561 | usb_audio_warn(chip, |
562 | "%d:%d: freq mismatch (RO clock): req %d, clock runs @%d\n", | |
563 | iface, fmt->altsetting, rate, cur_rate); | |
1dc669fe EZ |
564 | return -ENXIO; |
565 | } | |
0ba41d91 TI |
566 | usb_audio_dbg(chip, |
567 | "current rate %d is different from the runtime rate %d\n", | |
568 | cur_rate, rate); | |
690a863f TH |
569 | } |
570 | ||
571 | /* Some devices doesn't respond to sample rate changes while the | |
572 | * interface is active. */ | |
573 | if (rate != prev_rate) { | |
574 | usb_set_interface(dev, iface, 0); | |
21bb5aaf | 575 | snd_usb_set_interface_quirk(dev); |
690a863f | 576 | usb_set_interface(dev, iface, fmt->altsetting); |
21bb5aaf | 577 | snd_usb_set_interface_quirk(dev); |
690a863f | 578 | } |
79f920fb DM |
579 | |
580 | return 0; | |
581 | } | |
582 | ||
583 | int snd_usb_init_sample_rate(struct snd_usb_audio *chip, int iface, | |
584 | struct usb_host_interface *alts, | |
585 | struct audioformat *fmt, int rate) | |
586 | { | |
8f898e92 | 587 | switch (fmt->protocol) { |
79f920fb | 588 | case UAC_VERSION_1: |
a2acad82 | 589 | default: |
79f920fb DM |
590 | return set_sample_rate_v1(chip, iface, alts, fmt, rate); |
591 | ||
9a2fe9b8 | 592 | case UAC_VERSION_3: |
17156f23 RB |
593 | if (chip->badd_profile >= UAC3_FUNCTION_SUBCLASS_GENERIC_IO) { |
594 | if (rate != UAC3_BADD_SAMPLING_RATE) | |
595 | return -ENXIO; | |
596 | else | |
597 | return 0; | |
598 | } | |
599 | /* fall through */ | |
600 | case UAC_VERSION_2: | |
9a2fe9b8 | 601 | return set_sample_rate_v2v3(chip, iface, alts, fmt, rate); |
79f920fb | 602 | } |
79f920fb DM |
603 | } |
604 |