1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * f_uac2.c -- USB Audio Class 2.0 Function
4 *
5 * Copyright (C) 2011
6 * Yadwinder Singh (yadi.brar01@gmail.com)
7 * Jaswinder Singh (jaswinder.singh@linaro.org)
8 *
9 * Copyright (C) 2020
10 * Ruslan Bilovol (ruslan.bilovol@gmail.com)
11 */
12
13 #include <linux/usb/audio.h>
14 #include <linux/usb/audio-v2.h>
15 #include <linux/module.h>
16
17 #include "u_audio.h"
18
19 #include "u_uac2.h"
20
21 /* UAC2 spec: 4.1 Audio Channel Cluster Descriptor */
22 #define UAC2_CHANNEL_MASK 0x07FFFFFF
23
24 /*
25 * The driver implements a simple UAC_2 topology.
26 * USB-OUT -> IT_1 -> FU -> OT_3 -> ALSA_Capture
27 * ALSA_Playback -> IT_2 -> FU -> OT_4 -> USB-IN
28 * Capture and Playback sampling rates are independently
29 * controlled by two clock sources :
30 * CLK_5 := c_srate, and CLK_6 := p_srate
31 */
32 #define USB_OUT_CLK_ID (out_clk_src_desc.bClockID)
33 #define USB_IN_CLK_ID (in_clk_src_desc.bClockID)
34 #define USB_OUT_FU_ID (out_feature_unit_desc->bUnitID)
35 #define USB_IN_FU_ID (in_feature_unit_desc->bUnitID)
36
37 #define CONTROL_ABSENT 0
38 #define CONTROL_RDONLY 1
39 #define CONTROL_RDWR 3
40
41 #define CLK_FREQ_CTRL 0
42 #define CLK_VLD_CTRL 2
43 #define FU_MUTE_CTRL 0
44 #define FU_VOL_CTRL 2
45
46 #define COPY_CTRL 0
47 #define CONN_CTRL 2
48 #define OVRLD_CTRL 4
49 #define CLSTR_CTRL 6
50 #define UNFLW_CTRL 8
51 #define OVFLW_CTRL 10
52
53 #define EPIN_EN(_opts) ((_opts)->p_chmask != 0)
54 #define EPOUT_EN(_opts) ((_opts)->c_chmask != 0)
55 #define FUIN_EN(_opts) (EPIN_EN(_opts) \
56 && ((_opts)->p_mute_present \
57 || (_opts)->p_volume_present))
58 #define FUOUT_EN(_opts) (EPOUT_EN(_opts) \
59 && ((_opts)->c_mute_present \
60 || (_opts)->c_volume_present))
61 #define EPOUT_FBACK_IN_EN(_opts) ((_opts)->c_sync == USB_ENDPOINT_SYNC_ASYNC)
62
63 struct f_uac2 {
64 struct g_audio g_audio;
65 u8 ac_intf, as_in_intf, as_out_intf;
66 u8 ac_alt, as_in_alt, as_out_alt; /* needed for get_alt() */
67
68 struct usb_ctrlrequest setup_cr; /* will be used in data stage */
69
70 /* Interrupt IN endpoint of AC interface */
71 struct usb_ep *int_ep;
72 atomic_t int_count;
73 /* transient state, only valid during handling of a single control request */
74 int clock_id;
75 };
76
func_to_uac2(struct usb_function * f)77 static inline struct f_uac2 *func_to_uac2(struct usb_function *f)
78 {
79 return container_of(f, struct f_uac2, g_audio.func);
80 }
81
82 static inline
g_audio_to_uac2_opts(struct g_audio * agdev)83 struct f_uac2_opts *g_audio_to_uac2_opts(struct g_audio *agdev)
84 {
85 return container_of(agdev->func.fi, struct f_uac2_opts, func_inst);
86 }
87
88 static int afunc_notify(struct g_audio *agdev, int unit_id, int cs);
89
90 /* --------- USB Function Interface ------------- */
91
92 enum {
93 STR_ASSOC,
94 STR_IF_CTRL,
95 STR_CLKSRC_IN,
96 STR_CLKSRC_OUT,
97 STR_USB_IT,
98 STR_USB_IT_CH,
99 STR_IO_IT,
100 STR_IO_IT_CH,
101 STR_USB_OT,
102 STR_IO_OT,
103 STR_FU_IN,
104 STR_FU_OUT,
105 STR_AS_OUT_ALT0,
106 STR_AS_OUT_ALT1,
107 STR_AS_IN_ALT0,
108 STR_AS_IN_ALT1,
109 NUM_STR_DESCRIPTORS,
110 };
111
112 static struct usb_string strings_fn[NUM_STR_DESCRIPTORS + 1] = {};
113
114 static const char *const speed_names[] = {
115 [USB_SPEED_UNKNOWN] = "UNKNOWN",
116 [USB_SPEED_LOW] = "LS",
117 [USB_SPEED_FULL] = "FS",
118 [USB_SPEED_HIGH] = "HS",
119 [USB_SPEED_WIRELESS] = "W",
120 [USB_SPEED_SUPER] = "SS",
121 [USB_SPEED_SUPER_PLUS] = "SS+",
122 };
123
124 static struct usb_gadget_strings str_fn = {
125 .language = 0x0409, /* en-us */
126 .strings = strings_fn,
127 };
128
129 static struct usb_gadget_strings *fn_strings[] = {
130 &str_fn,
131 NULL,
132 };
133
134 static struct usb_interface_assoc_descriptor iad_desc = {
135 .bLength = sizeof iad_desc,
136 .bDescriptorType = USB_DT_INTERFACE_ASSOCIATION,
137
138 .bFirstInterface = 0,
139 .bInterfaceCount = 3,
140 .bFunctionClass = USB_CLASS_AUDIO,
141 .bFunctionSubClass = UAC2_FUNCTION_SUBCLASS_UNDEFINED,
142 .bFunctionProtocol = UAC_VERSION_2,
143 };
144
145 /* Audio Control Interface */
146 static struct usb_interface_descriptor std_ac_if_desc = {
147 .bLength = sizeof std_ac_if_desc,
148 .bDescriptorType = USB_DT_INTERFACE,
149
150 .bAlternateSetting = 0,
151 /* .bNumEndpoints = DYNAMIC */
152 .bInterfaceClass = USB_CLASS_AUDIO,
153 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
154 .bInterfaceProtocol = UAC_VERSION_2,
155 };
156
157 /* Clock source for IN traffic */
158 static struct uac_clock_source_descriptor in_clk_src_desc = {
159 .bLength = sizeof in_clk_src_desc,
160 .bDescriptorType = USB_DT_CS_INTERFACE,
161
162 .bDescriptorSubtype = UAC2_CLOCK_SOURCE,
163 /* .bClockID = DYNAMIC */
164 .bmAttributes = UAC_CLOCK_SOURCE_TYPE_INT_FIXED,
165 .bmControls = (CONTROL_RDWR << CLK_FREQ_CTRL),
166 .bAssocTerminal = 0,
167 };
168
169 /* Clock source for OUT traffic */
170 static struct uac_clock_source_descriptor out_clk_src_desc = {
171 .bLength = sizeof out_clk_src_desc,
172 .bDescriptorType = USB_DT_CS_INTERFACE,
173
174 .bDescriptorSubtype = UAC2_CLOCK_SOURCE,
175 /* .bClockID = DYNAMIC */
176 .bmAttributes = UAC_CLOCK_SOURCE_TYPE_INT_FIXED,
177 .bmControls = (CONTROL_RDWR << CLK_FREQ_CTRL),
178 .bAssocTerminal = 0,
179 };
180
181 /* Input Terminal for USB_OUT */
182 static struct uac2_input_terminal_descriptor usb_out_it_desc = {
183 .bLength = sizeof usb_out_it_desc,
184 .bDescriptorType = USB_DT_CS_INTERFACE,
185
186 .bDescriptorSubtype = UAC_INPUT_TERMINAL,
187 /* .bTerminalID = DYNAMIC */
188 .wTerminalType = cpu_to_le16(UAC_TERMINAL_STREAMING),
189 .bAssocTerminal = 0,
190 /* .bCSourceID = DYNAMIC */
191 .iChannelNames = 0,
192 .bmControls = cpu_to_le16(CONTROL_RDWR << COPY_CTRL),
193 };
194
195 /* Input Terminal for I/O-In */
196 static struct uac2_input_terminal_descriptor io_in_it_desc = {
197 .bLength = sizeof io_in_it_desc,
198 .bDescriptorType = USB_DT_CS_INTERFACE,
199
200 .bDescriptorSubtype = UAC_INPUT_TERMINAL,
201 /* .bTerminalID = DYNAMIC */
202 /* .wTerminalType = DYNAMIC */
203 .bAssocTerminal = 0,
204 /* .bCSourceID = DYNAMIC */
205 .iChannelNames = 0,
206 .bmControls = cpu_to_le16(CONTROL_RDWR << COPY_CTRL),
207 };
208
209 /* Ouput Terminal for USB_IN */
210 static struct uac2_output_terminal_descriptor usb_in_ot_desc = {
211 .bLength = sizeof usb_in_ot_desc,
212 .bDescriptorType = USB_DT_CS_INTERFACE,
213
214 .bDescriptorSubtype = UAC_OUTPUT_TERMINAL,
215 /* .bTerminalID = DYNAMIC */
216 .wTerminalType = cpu_to_le16(UAC_TERMINAL_STREAMING),
217 .bAssocTerminal = 0,
218 /* .bSourceID = DYNAMIC */
219 /* .bCSourceID = DYNAMIC */
220 .bmControls = cpu_to_le16(CONTROL_RDWR << COPY_CTRL),
221 };
222
223 /* Ouput Terminal for I/O-Out */
224 static struct uac2_output_terminal_descriptor io_out_ot_desc = {
225 .bLength = sizeof io_out_ot_desc,
226 .bDescriptorType = USB_DT_CS_INTERFACE,
227
228 .bDescriptorSubtype = UAC_OUTPUT_TERMINAL,
229 /* .bTerminalID = DYNAMIC */
230 /* .wTerminalType = DYNAMIC */
231 .bAssocTerminal = 0,
232 /* .bSourceID = DYNAMIC */
233 /* .bCSourceID = DYNAMIC */
234 .bmControls = cpu_to_le16(CONTROL_RDWR << COPY_CTRL),
235 };
236
237 static struct uac2_feature_unit_descriptor *in_feature_unit_desc;
238 static struct uac2_feature_unit_descriptor *out_feature_unit_desc;
239
240 static struct uac2_ac_header_descriptor ac_hdr_desc = {
241 .bLength = sizeof ac_hdr_desc,
242 .bDescriptorType = USB_DT_CS_INTERFACE,
243
244 .bDescriptorSubtype = UAC_MS_HEADER,
245 .bcdADC = cpu_to_le16(0x200),
246 .bCategory = UAC2_FUNCTION_IO_BOX,
247 /* .wTotalLength = DYNAMIC */
248 .bmControls = 0,
249 };
250
251 /* AC IN Interrupt Endpoint */
252 static struct usb_endpoint_descriptor fs_ep_int_desc = {
253 .bLength = USB_DT_ENDPOINT_SIZE,
254 .bDescriptorType = USB_DT_ENDPOINT,
255
256 .bEndpointAddress = USB_DIR_IN,
257 .bmAttributes = USB_ENDPOINT_XFER_INT,
258 .wMaxPacketSize = cpu_to_le16(6),
259 .bInterval = 1,
260 };
261
262 static struct usb_endpoint_descriptor hs_ep_int_desc = {
263 .bLength = USB_DT_ENDPOINT_SIZE,
264 .bDescriptorType = USB_DT_ENDPOINT,
265
266 .bmAttributes = USB_ENDPOINT_XFER_INT,
267 .wMaxPacketSize = cpu_to_le16(6),
268 .bInterval = 4,
269 };
270
271 static struct usb_endpoint_descriptor ss_ep_int_desc = {
272 .bLength = USB_DT_ENDPOINT_SIZE,
273 .bDescriptorType = USB_DT_ENDPOINT,
274
275 .bEndpointAddress = USB_DIR_IN,
276 .bmAttributes = USB_ENDPOINT_XFER_INT,
277 .wMaxPacketSize = cpu_to_le16(6),
278 .bInterval = 4,
279 };
280
281 static struct usb_ss_ep_comp_descriptor ss_ep_int_desc_comp = {
282 .bLength = sizeof(ss_ep_int_desc_comp),
283 .bDescriptorType = USB_DT_SS_ENDPOINT_COMP,
284 .wBytesPerInterval = cpu_to_le16(6),
285 };
286
287 /* Audio Streaming OUT Interface - Alt0 */
288 static struct usb_interface_descriptor std_as_out_if0_desc = {
289 .bLength = sizeof std_as_out_if0_desc,
290 .bDescriptorType = USB_DT_INTERFACE,
291
292 .bAlternateSetting = 0,
293 .bNumEndpoints = 0,
294 .bInterfaceClass = USB_CLASS_AUDIO,
295 .bInterfaceSubClass = USB_SUBCLASS_AUDIOSTREAMING,
296 .bInterfaceProtocol = UAC_VERSION_2,
297 };
298
299 /* Audio Streaming OUT Interface - Alt1 */
300 static struct usb_interface_descriptor std_as_out_if1_desc = {
301 .bLength = sizeof std_as_out_if1_desc,
302 .bDescriptorType = USB_DT_INTERFACE,
303
304 .bAlternateSetting = 1,
305 .bNumEndpoints = 1,
306 .bInterfaceClass = USB_CLASS_AUDIO,
307 .bInterfaceSubClass = USB_SUBCLASS_AUDIOSTREAMING,
308 .bInterfaceProtocol = UAC_VERSION_2,
309 };
310
311 /* Audio Stream OUT Intface Desc */
312 static struct uac2_as_header_descriptor as_out_hdr_desc = {
313 .bLength = sizeof as_out_hdr_desc,
314 .bDescriptorType = USB_DT_CS_INTERFACE,
315
316 .bDescriptorSubtype = UAC_AS_GENERAL,
317 /* .bTerminalLink = DYNAMIC */
318 .bmControls = 0,
319 .bFormatType = UAC_FORMAT_TYPE_I,
320 .bmFormats = cpu_to_le32(UAC_FORMAT_TYPE_I_PCM),
321 .iChannelNames = 0,
322 };
323
324 /* Audio USB_OUT Format */
325 static struct uac2_format_type_i_descriptor as_out_fmt1_desc = {
326 .bLength = sizeof as_out_fmt1_desc,
327 .bDescriptorType = USB_DT_CS_INTERFACE,
328 .bDescriptorSubtype = UAC_FORMAT_TYPE,
329 .bFormatType = UAC_FORMAT_TYPE_I,
330 };
331
332 /* STD AS ISO OUT Endpoint */
333 static struct usb_endpoint_descriptor fs_epout_desc = {
334 .bLength = USB_DT_ENDPOINT_SIZE,
335 .bDescriptorType = USB_DT_ENDPOINT,
336
337 .bEndpointAddress = USB_DIR_OUT,
338 /* .bmAttributes = DYNAMIC */
339 /* .wMaxPacketSize = DYNAMIC */
340 .bInterval = 1,
341 };
342
343 static struct usb_endpoint_descriptor hs_epout_desc = {
344 .bLength = USB_DT_ENDPOINT_SIZE,
345 .bDescriptorType = USB_DT_ENDPOINT,
346
347 /* .bmAttributes = DYNAMIC */
348 /* .wMaxPacketSize = DYNAMIC */
349 /* .bInterval = DYNAMIC */
350 };
351
352 static struct usb_endpoint_descriptor ss_epout_desc = {
353 .bLength = USB_DT_ENDPOINT_SIZE,
354 .bDescriptorType = USB_DT_ENDPOINT,
355
356 .bEndpointAddress = USB_DIR_OUT,
357 /* .bmAttributes = DYNAMIC */
358 /* .wMaxPacketSize = DYNAMIC */
359 /* .bInterval = DYNAMIC */
360 };
361
362 static struct usb_ss_ep_comp_descriptor ss_epout_desc_comp = {
363 .bLength = sizeof(ss_epout_desc_comp),
364 .bDescriptorType = USB_DT_SS_ENDPOINT_COMP,
365 .bMaxBurst = 0,
366 .bmAttributes = 0,
367 /* wBytesPerInterval = DYNAMIC */
368 };
369
370 /* CS AS ISO OUT Endpoint */
371 static struct uac2_iso_endpoint_descriptor as_iso_out_desc = {
372 .bLength = sizeof as_iso_out_desc,
373 .bDescriptorType = USB_DT_CS_ENDPOINT,
374
375 .bDescriptorSubtype = UAC_EP_GENERAL,
376 .bmAttributes = 0,
377 .bmControls = 0,
378 .bLockDelayUnits = 0,
379 .wLockDelay = 0,
380 };
381
382 /* STD AS ISO IN Feedback Endpoint */
383 static struct usb_endpoint_descriptor fs_epin_fback_desc = {
384 .bLength = USB_DT_ENDPOINT_SIZE,
385 .bDescriptorType = USB_DT_ENDPOINT,
386
387 .bEndpointAddress = USB_DIR_IN,
388 .bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_USAGE_FEEDBACK,
389 .wMaxPacketSize = cpu_to_le16(3),
390 .bInterval = 1,
391 };
392
393 static struct usb_endpoint_descriptor hs_epin_fback_desc = {
394 .bLength = USB_DT_ENDPOINT_SIZE,
395 .bDescriptorType = USB_DT_ENDPOINT,
396
397 .bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_USAGE_FEEDBACK,
398 .wMaxPacketSize = cpu_to_le16(4),
399 .bInterval = 4,
400 };
401
402 static struct usb_endpoint_descriptor ss_epin_fback_desc = {
403 .bLength = USB_DT_ENDPOINT_SIZE,
404 .bDescriptorType = USB_DT_ENDPOINT,
405
406 .bEndpointAddress = USB_DIR_IN,
407 .bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_USAGE_FEEDBACK,
408 .wMaxPacketSize = cpu_to_le16(4),
409 .bInterval = 4,
410 };
411
412 static struct usb_ss_ep_comp_descriptor ss_epin_fback_desc_comp = {
413 .bLength = sizeof(ss_epin_fback_desc_comp),
414 .bDescriptorType = USB_DT_SS_ENDPOINT_COMP,
415 .bMaxBurst = 0,
416 .bmAttributes = 0,
417 .wBytesPerInterval = cpu_to_le16(4),
418 };
419
420
421 /* Audio Streaming IN Interface - Alt0 */
422 static struct usb_interface_descriptor std_as_in_if0_desc = {
423 .bLength = sizeof std_as_in_if0_desc,
424 .bDescriptorType = USB_DT_INTERFACE,
425
426 .bAlternateSetting = 0,
427 .bNumEndpoints = 0,
428 .bInterfaceClass = USB_CLASS_AUDIO,
429 .bInterfaceSubClass = USB_SUBCLASS_AUDIOSTREAMING,
430 .bInterfaceProtocol = UAC_VERSION_2,
431 };
432
433 /* Audio Streaming IN Interface - Alt1 */
434 static struct usb_interface_descriptor std_as_in_if1_desc = {
435 .bLength = sizeof std_as_in_if1_desc,
436 .bDescriptorType = USB_DT_INTERFACE,
437
438 .bAlternateSetting = 1,
439 .bNumEndpoints = 1,
440 .bInterfaceClass = USB_CLASS_AUDIO,
441 .bInterfaceSubClass = USB_SUBCLASS_AUDIOSTREAMING,
442 .bInterfaceProtocol = UAC_VERSION_2,
443 };
444
445 /* Audio Stream IN Intface Desc */
446 static struct uac2_as_header_descriptor as_in_hdr_desc = {
447 .bLength = sizeof as_in_hdr_desc,
448 .bDescriptorType = USB_DT_CS_INTERFACE,
449
450 .bDescriptorSubtype = UAC_AS_GENERAL,
451 /* .bTerminalLink = DYNAMIC */
452 .bmControls = 0,
453 .bFormatType = UAC_FORMAT_TYPE_I,
454 .bmFormats = cpu_to_le32(UAC_FORMAT_TYPE_I_PCM),
455 .iChannelNames = 0,
456 };
457
458 /* Audio USB_IN Format */
459 static struct uac2_format_type_i_descriptor as_in_fmt1_desc = {
460 .bLength = sizeof as_in_fmt1_desc,
461 .bDescriptorType = USB_DT_CS_INTERFACE,
462 .bDescriptorSubtype = UAC_FORMAT_TYPE,
463 .bFormatType = UAC_FORMAT_TYPE_I,
464 };
465
466 /* STD AS ISO IN Endpoint */
467 static struct usb_endpoint_descriptor fs_epin_desc = {
468 .bLength = USB_DT_ENDPOINT_SIZE,
469 .bDescriptorType = USB_DT_ENDPOINT,
470
471 .bEndpointAddress = USB_DIR_IN,
472 .bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC,
473 /* .wMaxPacketSize = DYNAMIC */
474 .bInterval = 1,
475 };
476
477 static struct usb_endpoint_descriptor hs_epin_desc = {
478 .bLength = USB_DT_ENDPOINT_SIZE,
479 .bDescriptorType = USB_DT_ENDPOINT,
480
481 .bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC,
482 /* .wMaxPacketSize = DYNAMIC */
483 /* .bInterval = DYNAMIC */
484 };
485
486 static struct usb_endpoint_descriptor ss_epin_desc = {
487 .bLength = USB_DT_ENDPOINT_SIZE,
488 .bDescriptorType = USB_DT_ENDPOINT,
489
490 .bEndpointAddress = USB_DIR_IN,
491 .bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC,
492 /* .wMaxPacketSize = DYNAMIC */
493 /* .bInterval = DYNAMIC */
494 };
495
496 static struct usb_ss_ep_comp_descriptor ss_epin_desc_comp = {
497 .bLength = sizeof(ss_epin_desc_comp),
498 .bDescriptorType = USB_DT_SS_ENDPOINT_COMP,
499 .bMaxBurst = 0,
500 .bmAttributes = 0,
501 /* wBytesPerInterval = DYNAMIC */
502 };
503
504 /* CS AS ISO IN Endpoint */
505 static struct uac2_iso_endpoint_descriptor as_iso_in_desc = {
506 .bLength = sizeof as_iso_in_desc,
507 .bDescriptorType = USB_DT_CS_ENDPOINT,
508
509 .bDescriptorSubtype = UAC_EP_GENERAL,
510 .bmAttributes = 0,
511 .bmControls = 0,
512 .bLockDelayUnits = 0,
513 .wLockDelay = 0,
514 };
515
516 static struct usb_descriptor_header *fs_audio_desc[] = {
517 (struct usb_descriptor_header *)&iad_desc,
518 (struct usb_descriptor_header *)&std_ac_if_desc,
519
520 (struct usb_descriptor_header *)&ac_hdr_desc,
521 (struct usb_descriptor_header *)&in_clk_src_desc,
522 (struct usb_descriptor_header *)&out_clk_src_desc,
523 (struct usb_descriptor_header *)&usb_out_it_desc,
524 (struct usb_descriptor_header *)&out_feature_unit_desc,
525 (struct usb_descriptor_header *)&io_in_it_desc,
526 (struct usb_descriptor_header *)&usb_in_ot_desc,
527 (struct usb_descriptor_header *)&in_feature_unit_desc,
528 (struct usb_descriptor_header *)&io_out_ot_desc,
529
530 (struct usb_descriptor_header *)&fs_ep_int_desc,
531
532 (struct usb_descriptor_header *)&std_as_out_if0_desc,
533 (struct usb_descriptor_header *)&std_as_out_if1_desc,
534
535 (struct usb_descriptor_header *)&as_out_hdr_desc,
536 (struct usb_descriptor_header *)&as_out_fmt1_desc,
537 (struct usb_descriptor_header *)&fs_epout_desc,
538 (struct usb_descriptor_header *)&as_iso_out_desc,
539 (struct usb_descriptor_header *)&fs_epin_fback_desc,
540
541 (struct usb_descriptor_header *)&std_as_in_if0_desc,
542 (struct usb_descriptor_header *)&std_as_in_if1_desc,
543
544 (struct usb_descriptor_header *)&as_in_hdr_desc,
545 (struct usb_descriptor_header *)&as_in_fmt1_desc,
546 (struct usb_descriptor_header *)&fs_epin_desc,
547 (struct usb_descriptor_header *)&as_iso_in_desc,
548 NULL,
549 };
550
551 static struct usb_descriptor_header *hs_audio_desc[] = {
552 (struct usb_descriptor_header *)&iad_desc,
553 (struct usb_descriptor_header *)&std_ac_if_desc,
554
555 (struct usb_descriptor_header *)&ac_hdr_desc,
556 (struct usb_descriptor_header *)&in_clk_src_desc,
557 (struct usb_descriptor_header *)&out_clk_src_desc,
558 (struct usb_descriptor_header *)&usb_out_it_desc,
559 (struct usb_descriptor_header *)&out_feature_unit_desc,
560 (struct usb_descriptor_header *)&io_in_it_desc,
561 (struct usb_descriptor_header *)&usb_in_ot_desc,
562 (struct usb_descriptor_header *)&in_feature_unit_desc,
563 (struct usb_descriptor_header *)&io_out_ot_desc,
564
565 (struct usb_descriptor_header *)&hs_ep_int_desc,
566
567 (struct usb_descriptor_header *)&std_as_out_if0_desc,
568 (struct usb_descriptor_header *)&std_as_out_if1_desc,
569
570 (struct usb_descriptor_header *)&as_out_hdr_desc,
571 (struct usb_descriptor_header *)&as_out_fmt1_desc,
572 (struct usb_descriptor_header *)&hs_epout_desc,
573 (struct usb_descriptor_header *)&as_iso_out_desc,
574 (struct usb_descriptor_header *)&hs_epin_fback_desc,
575
576 (struct usb_descriptor_header *)&std_as_in_if0_desc,
577 (struct usb_descriptor_header *)&std_as_in_if1_desc,
578
579 (struct usb_descriptor_header *)&as_in_hdr_desc,
580 (struct usb_descriptor_header *)&as_in_fmt1_desc,
581 (struct usb_descriptor_header *)&hs_epin_desc,
582 (struct usb_descriptor_header *)&as_iso_in_desc,
583 NULL,
584 };
585
586 static struct usb_descriptor_header *ss_audio_desc[] = {
587 (struct usb_descriptor_header *)&iad_desc,
588 (struct usb_descriptor_header *)&std_ac_if_desc,
589
590 (struct usb_descriptor_header *)&ac_hdr_desc,
591 (struct usb_descriptor_header *)&in_clk_src_desc,
592 (struct usb_descriptor_header *)&out_clk_src_desc,
593 (struct usb_descriptor_header *)&usb_out_it_desc,
594 (struct usb_descriptor_header *)&out_feature_unit_desc,
595 (struct usb_descriptor_header *)&io_in_it_desc,
596 (struct usb_descriptor_header *)&usb_in_ot_desc,
597 (struct usb_descriptor_header *)&in_feature_unit_desc,
598 (struct usb_descriptor_header *)&io_out_ot_desc,
599
600 (struct usb_descriptor_header *)&ss_ep_int_desc,
601 (struct usb_descriptor_header *)&ss_ep_int_desc_comp,
602
603 (struct usb_descriptor_header *)&std_as_out_if0_desc,
604 (struct usb_descriptor_header *)&std_as_out_if1_desc,
605
606 (struct usb_descriptor_header *)&as_out_hdr_desc,
607 (struct usb_descriptor_header *)&as_out_fmt1_desc,
608 (struct usb_descriptor_header *)&ss_epout_desc,
609 (struct usb_descriptor_header *)&ss_epout_desc_comp,
610 (struct usb_descriptor_header *)&as_iso_out_desc,
611 (struct usb_descriptor_header *)&ss_epin_fback_desc,
612 (struct usb_descriptor_header *)&ss_epin_fback_desc_comp,
613
614 (struct usb_descriptor_header *)&std_as_in_if0_desc,
615 (struct usb_descriptor_header *)&std_as_in_if1_desc,
616
617 (struct usb_descriptor_header *)&as_in_hdr_desc,
618 (struct usb_descriptor_header *)&as_in_fmt1_desc,
619 (struct usb_descriptor_header *)&ss_epin_desc,
620 (struct usb_descriptor_header *)&ss_epin_desc_comp,
621 (struct usb_descriptor_header *)&as_iso_in_desc,
622 NULL,
623 };
624
625 struct cntrl_cur_lay2 {
626 __le16 wCUR;
627 };
628
629 struct cntrl_range_lay2 {
630 __le16 wNumSubRanges;
631 __le16 wMIN;
632 __le16 wMAX;
633 __le16 wRES;
634 } __packed;
635
636 struct cntrl_cur_lay3 {
637 __le32 dCUR;
638 };
639
640 struct cntrl_subrange_lay3 {
641 __le32 dMIN;
642 __le32 dMAX;
643 __le32 dRES;
644 } __packed;
645
646 #define ranges_lay3_size(c) (sizeof(c.wNumSubRanges) \
647 + le16_to_cpu(c.wNumSubRanges) \
648 * sizeof(struct cntrl_subrange_lay3))
649
650 #define DECLARE_UAC2_CNTRL_RANGES_LAY3(k, n) \
651 struct cntrl_ranges_lay3_##k { \
652 __le16 wNumSubRanges; \
653 struct cntrl_subrange_lay3 r[n]; \
654 } __packed
655
656 DECLARE_UAC2_CNTRL_RANGES_LAY3(srates, UAC_MAX_RATES);
657
get_max_srate(const int * srates)658 static int get_max_srate(const int *srates)
659 {
660 int i, max_srate = 0;
661
662 for (i = 0; i < UAC_MAX_RATES; i++) {
663 if (srates[i] == 0)
664 break;
665 if (srates[i] > max_srate)
666 max_srate = srates[i];
667 }
668 return max_srate;
669 }
670
get_max_bw_for_bint(const struct f_uac2_opts * uac2_opts,u8 bint,unsigned int factor,bool is_playback)671 static int get_max_bw_for_bint(const struct f_uac2_opts *uac2_opts,
672 u8 bint, unsigned int factor, bool is_playback)
673 {
674 int chmask, srate, ssize;
675 u16 max_size_bw;
676
677 if (is_playback) {
678 chmask = uac2_opts->p_chmask;
679 srate = get_max_srate(uac2_opts->p_srates);
680 ssize = uac2_opts->p_ssize;
681 } else {
682 chmask = uac2_opts->c_chmask;
683 srate = get_max_srate(uac2_opts->c_srates);
684 ssize = uac2_opts->c_ssize;
685 }
686
687 if (is_playback || (uac2_opts->c_sync == USB_ENDPOINT_SYNC_ASYNC)) {
688 // playback is always async, capture only when configured
689 // Win10 requires max packet size + 1 frame
690 srate = srate * (1000 + uac2_opts->fb_max) / 1000;
691 // updated srate is always bigger, therefore DIV_ROUND_UP always yields +1
692 max_size_bw = num_channels(chmask) * ssize *
693 (DIV_ROUND_UP(srate, factor / (1 << (bint - 1))));
694 } else {
695 // adding 1 frame provision for Win10
696 max_size_bw = num_channels(chmask) * ssize *
697 (DIV_ROUND_UP(srate, factor / (1 << (bint - 1))) + 1);
698 }
699 return max_size_bw;
700 }
701
set_ep_max_packet_size_bint(struct device * dev,const struct f_uac2_opts * uac2_opts,struct usb_endpoint_descriptor * ep_desc,enum usb_device_speed speed,bool is_playback)702 static int set_ep_max_packet_size_bint(struct device *dev, const struct f_uac2_opts *uac2_opts,
703 struct usb_endpoint_descriptor *ep_desc,
704 enum usb_device_speed speed, bool is_playback)
705 {
706 u16 max_size_bw, max_size_ep;
707 u8 bint, opts_bint;
708 char *dir;
709
710 switch (speed) {
711 case USB_SPEED_FULL:
712 max_size_ep = 1023;
713 // fixed
714 bint = ep_desc->bInterval;
715 max_size_bw = get_max_bw_for_bint(uac2_opts, bint, 1000, is_playback);
716 break;
717
718 case USB_SPEED_HIGH:
719 case USB_SPEED_SUPER:
720 max_size_ep = 1024;
721 if (is_playback)
722 opts_bint = uac2_opts->p_hs_bint;
723 else
724 opts_bint = uac2_opts->c_hs_bint;
725
726 if (opts_bint > 0) {
727 /* fixed bint */
728 bint = opts_bint;
729 max_size_bw = get_max_bw_for_bint(uac2_opts, bint, 8000, is_playback);
730 } else {
731 /* checking bInterval from 4 to 1 whether the required bandwidth fits */
732 for (bint = 4; bint > 0; --bint) {
733 max_size_bw = get_max_bw_for_bint(
734 uac2_opts, bint, 8000, is_playback);
735 if (max_size_bw <= max_size_ep)
736 break;
737 }
738 }
739 break;
740
741 default:
742 return -EINVAL;
743 }
744
745 if (is_playback)
746 dir = "Playback";
747 else
748 dir = "Capture";
749
750 if (max_size_bw <= max_size_ep)
751 dev_dbg(dev,
752 "%s %s: Would use wMaxPacketSize %d and bInterval %d\n",
753 speed_names[speed], dir, max_size_bw, bint);
754 else {
755 dev_warn(dev,
756 "%s %s: Req. wMaxPacketSize %d at bInterval %d > max ISOC %d, may drop data!\n",
757 speed_names[speed], dir, max_size_bw, bint, max_size_ep);
758 max_size_bw = max_size_ep;
759 }
760
761 ep_desc->wMaxPacketSize = cpu_to_le16(max_size_bw);
762 ep_desc->bInterval = bint;
763
764 return 0;
765 }
766
build_fu_desc(int chmask)767 static struct uac2_feature_unit_descriptor *build_fu_desc(int chmask)
768 {
769 struct uac2_feature_unit_descriptor *fu_desc;
770 int channels = num_channels(chmask);
771 int fu_desc_size = UAC2_DT_FEATURE_UNIT_SIZE(channels);
772
773 fu_desc = kzalloc(fu_desc_size, GFP_KERNEL);
774 if (!fu_desc)
775 return NULL;
776
777 fu_desc->bLength = fu_desc_size;
778 fu_desc->bDescriptorType = USB_DT_CS_INTERFACE;
779
780 fu_desc->bDescriptorSubtype = UAC_FEATURE_UNIT;
781
782 /* bUnitID, bSourceID and bmaControls will be defined later */
783
784 return fu_desc;
785 }
786
787 /* Use macro to overcome line length limitation */
788 #define USBDHDR(p) (struct usb_descriptor_header *)(p)
789
setup_headers(struct f_uac2_opts * opts,struct usb_descriptor_header ** headers,enum usb_device_speed speed)790 static void setup_headers(struct f_uac2_opts *opts,
791 struct usb_descriptor_header **headers,
792 enum usb_device_speed speed)
793 {
794 struct usb_ss_ep_comp_descriptor *epout_desc_comp = NULL;
795 struct usb_ss_ep_comp_descriptor *epin_desc_comp = NULL;
796 struct usb_ss_ep_comp_descriptor *epin_fback_desc_comp = NULL;
797 struct usb_ss_ep_comp_descriptor *ep_int_desc_comp = NULL;
798 struct usb_endpoint_descriptor *epout_desc;
799 struct usb_endpoint_descriptor *epin_desc;
800 struct usb_endpoint_descriptor *epin_fback_desc;
801 struct usb_endpoint_descriptor *ep_int_desc;
802 int i;
803
804 switch (speed) {
805 case USB_SPEED_FULL:
806 epout_desc = &fs_epout_desc;
807 epin_desc = &fs_epin_desc;
808 epin_fback_desc = &fs_epin_fback_desc;
809 ep_int_desc = &fs_ep_int_desc;
810 break;
811 case USB_SPEED_HIGH:
812 epout_desc = &hs_epout_desc;
813 epin_desc = &hs_epin_desc;
814 epin_fback_desc = &hs_epin_fback_desc;
815 ep_int_desc = &hs_ep_int_desc;
816 break;
817 default:
818 epout_desc = &ss_epout_desc;
819 epin_desc = &ss_epin_desc;
820 epout_desc_comp = &ss_epout_desc_comp;
821 epin_desc_comp = &ss_epin_desc_comp;
822 epin_fback_desc = &ss_epin_fback_desc;
823 epin_fback_desc_comp = &ss_epin_fback_desc_comp;
824 ep_int_desc = &ss_ep_int_desc;
825 ep_int_desc_comp = &ss_ep_int_desc_comp;
826 }
827
828 i = 0;
829 headers[i++] = USBDHDR(&iad_desc);
830 headers[i++] = USBDHDR(&std_ac_if_desc);
831 headers[i++] = USBDHDR(&ac_hdr_desc);
832 if (EPIN_EN(opts))
833 headers[i++] = USBDHDR(&in_clk_src_desc);
834 if (EPOUT_EN(opts)) {
835 headers[i++] = USBDHDR(&out_clk_src_desc);
836 headers[i++] = USBDHDR(&usb_out_it_desc);
837
838 if (FUOUT_EN(opts))
839 headers[i++] = USBDHDR(out_feature_unit_desc);
840 }
841
842 if (EPIN_EN(opts)) {
843 headers[i++] = USBDHDR(&io_in_it_desc);
844
845 if (FUIN_EN(opts))
846 headers[i++] = USBDHDR(in_feature_unit_desc);
847
848 headers[i++] = USBDHDR(&usb_in_ot_desc);
849 }
850
851 if (EPOUT_EN(opts))
852 headers[i++] = USBDHDR(&io_out_ot_desc);
853
854 if (FUOUT_EN(opts) || FUIN_EN(opts)) {
855 headers[i++] = USBDHDR(ep_int_desc);
856 if (ep_int_desc_comp)
857 headers[i++] = USBDHDR(ep_int_desc_comp);
858 }
859
860 if (EPOUT_EN(opts)) {
861 headers[i++] = USBDHDR(&std_as_out_if0_desc);
862 headers[i++] = USBDHDR(&std_as_out_if1_desc);
863 headers[i++] = USBDHDR(&as_out_hdr_desc);
864 headers[i++] = USBDHDR(&as_out_fmt1_desc);
865 headers[i++] = USBDHDR(epout_desc);
866 if (epout_desc_comp)
867 headers[i++] = USBDHDR(epout_desc_comp);
868
869 headers[i++] = USBDHDR(&as_iso_out_desc);
870
871 if (EPOUT_FBACK_IN_EN(opts)) {
872 headers[i++] = USBDHDR(epin_fback_desc);
873 if (epin_fback_desc_comp)
874 headers[i++] = USBDHDR(epin_fback_desc_comp);
875 }
876 }
877
878 if (EPIN_EN(opts)) {
879 headers[i++] = USBDHDR(&std_as_in_if0_desc);
880 headers[i++] = USBDHDR(&std_as_in_if1_desc);
881 headers[i++] = USBDHDR(&as_in_hdr_desc);
882 headers[i++] = USBDHDR(&as_in_fmt1_desc);
883 headers[i++] = USBDHDR(epin_desc);
884 if (epin_desc_comp)
885 headers[i++] = USBDHDR(epin_desc_comp);
886
887 headers[i++] = USBDHDR(&as_iso_in_desc);
888 }
889 headers[i] = NULL;
890 }
891
setup_descriptor(struct f_uac2_opts * opts)892 static void setup_descriptor(struct f_uac2_opts *opts)
893 {
894 /* patch descriptors */
895 int i = 1; /* ID's start with 1 */
896
897 if (EPOUT_EN(opts))
898 usb_out_it_desc.bTerminalID = i++;
899 if (EPIN_EN(opts))
900 io_in_it_desc.bTerminalID = i++;
901 if (EPOUT_EN(opts))
902 io_out_ot_desc.bTerminalID = i++;
903 if (EPIN_EN(opts))
904 usb_in_ot_desc.bTerminalID = i++;
905 if (FUOUT_EN(opts))
906 out_feature_unit_desc->bUnitID = i++;
907 if (FUIN_EN(opts))
908 in_feature_unit_desc->bUnitID = i++;
909 if (EPOUT_EN(opts))
910 out_clk_src_desc.bClockID = i++;
911 if (EPIN_EN(opts))
912 in_clk_src_desc.bClockID = i++;
913
914 usb_out_it_desc.bCSourceID = out_clk_src_desc.bClockID;
915
916 if (FUIN_EN(opts)) {
917 usb_in_ot_desc.bSourceID = in_feature_unit_desc->bUnitID;
918 in_feature_unit_desc->bSourceID = io_in_it_desc.bTerminalID;
919 } else {
920 usb_in_ot_desc.bSourceID = io_in_it_desc.bTerminalID;
921 }
922
923 usb_in_ot_desc.bCSourceID = in_clk_src_desc.bClockID;
924 io_in_it_desc.bCSourceID = in_clk_src_desc.bClockID;
925 io_out_ot_desc.bCSourceID = out_clk_src_desc.bClockID;
926
927 if (FUOUT_EN(opts)) {
928 io_out_ot_desc.bSourceID = out_feature_unit_desc->bUnitID;
929 out_feature_unit_desc->bSourceID = usb_out_it_desc.bTerminalID;
930 } else {
931 io_out_ot_desc.bSourceID = usb_out_it_desc.bTerminalID;
932 }
933
934 as_out_hdr_desc.bTerminalLink = usb_out_it_desc.bTerminalID;
935 as_in_hdr_desc.bTerminalLink = usb_in_ot_desc.bTerminalID;
936
937 iad_desc.bInterfaceCount = 1;
938 ac_hdr_desc.wTotalLength = cpu_to_le16(sizeof(ac_hdr_desc));
939
940 if (EPIN_EN(opts)) {
941 u16 len = le16_to_cpu(ac_hdr_desc.wTotalLength);
942
943 len += sizeof(in_clk_src_desc);
944 len += sizeof(usb_in_ot_desc);
945
946 if (FUIN_EN(opts))
947 len += in_feature_unit_desc->bLength;
948
949 len += sizeof(io_in_it_desc);
950 ac_hdr_desc.wTotalLength = cpu_to_le16(len);
951 iad_desc.bInterfaceCount++;
952 }
953 if (EPOUT_EN(opts)) {
954 u16 len = le16_to_cpu(ac_hdr_desc.wTotalLength);
955
956 len += sizeof(out_clk_src_desc);
957 len += sizeof(usb_out_it_desc);
958
959 if (FUOUT_EN(opts))
960 len += out_feature_unit_desc->bLength;
961
962 len += sizeof(io_out_ot_desc);
963 ac_hdr_desc.wTotalLength = cpu_to_le16(len);
964 iad_desc.bInterfaceCount++;
965 }
966
967 io_in_it_desc.wTerminalType = cpu_to_le16(opts->c_terminal_type);
968 io_out_ot_desc.wTerminalType = cpu_to_le16(opts->p_terminal_type);
969
970 setup_headers(opts, fs_audio_desc, USB_SPEED_FULL);
971 setup_headers(opts, hs_audio_desc, USB_SPEED_HIGH);
972 setup_headers(opts, ss_audio_desc, USB_SPEED_SUPER);
973 }
974
afunc_validate_opts(struct g_audio * agdev,struct device * dev)975 static int afunc_validate_opts(struct g_audio *agdev, struct device *dev)
976 {
977 struct f_uac2_opts *opts = g_audio_to_uac2_opts(agdev);
978 const char *msg = NULL;
979
980 if (!opts->p_chmask && !opts->c_chmask)
981 msg = "no playback and capture channels";
982 else if (opts->p_chmask & ~UAC2_CHANNEL_MASK)
983 msg = "unsupported playback channels mask";
984 else if (opts->c_chmask & ~UAC2_CHANNEL_MASK)
985 msg = "unsupported capture channels mask";
986 else if ((opts->p_ssize < 1) || (opts->p_ssize > 4))
987 msg = "incorrect playback sample size";
988 else if ((opts->c_ssize < 1) || (opts->c_ssize > 4))
989 msg = "incorrect capture sample size";
990 else if (!opts->p_srates[0])
991 msg = "incorrect playback sampling rate";
992 else if (!opts->c_srates[0])
993 msg = "incorrect capture sampling rate";
994
995 else if (opts->p_volume_max <= opts->p_volume_min)
996 msg = "incorrect playback volume max/min";
997 else if (opts->c_volume_max <= opts->c_volume_min)
998 msg = "incorrect capture volume max/min";
999 else if (opts->p_volume_res <= 0)
1000 msg = "negative/zero playback volume resolution";
1001 else if (opts->c_volume_res <= 0)
1002 msg = "negative/zero capture volume resolution";
1003
1004 else if ((opts->p_volume_max - opts->p_volume_min) % opts->p_volume_res)
1005 msg = "incorrect playback volume resolution";
1006 else if ((opts->c_volume_max - opts->c_volume_min) % opts->c_volume_res)
1007 msg = "incorrect capture volume resolution";
1008
1009 else if ((opts->p_hs_bint < 0) || (opts->p_hs_bint > 4))
1010 msg = "incorrect playback HS/SS bInterval (1-4: fixed, 0: auto)";
1011 else if ((opts->c_hs_bint < 0) || (opts->c_hs_bint > 4))
1012 msg = "incorrect capture HS/SS bInterval (1-4: fixed, 0: auto)";
1013
1014 if (msg) {
1015 dev_err(dev, "Error: %s\n", msg);
1016 return -EINVAL;
1017 }
1018
1019 return 0;
1020 }
1021
1022 static int
afunc_bind(struct usb_configuration * cfg,struct usb_function * fn)1023 afunc_bind(struct usb_configuration *cfg, struct usb_function *fn)
1024 {
1025 struct f_uac2 *uac2 = func_to_uac2(fn);
1026 struct g_audio *agdev = func_to_g_audio(fn);
1027 struct usb_composite_dev *cdev = cfg->cdev;
1028 struct usb_gadget *gadget = cdev->gadget;
1029 struct device *dev = &gadget->dev;
1030 struct f_uac2_opts *uac2_opts = g_audio_to_uac2_opts(agdev);
1031 struct usb_string *us;
1032 int ret;
1033
1034 ret = afunc_validate_opts(agdev, dev);
1035 if (ret)
1036 return ret;
1037
1038 strings_fn[STR_ASSOC].s = uac2_opts->function_name;
1039 strings_fn[STR_IF_CTRL].s = uac2_opts->if_ctrl_name;
1040 strings_fn[STR_CLKSRC_IN].s = uac2_opts->clksrc_in_name;
1041 strings_fn[STR_CLKSRC_OUT].s = uac2_opts->clksrc_out_name;
1042
1043 strings_fn[STR_USB_IT].s = uac2_opts->c_it_name;
1044 strings_fn[STR_USB_IT_CH].s = uac2_opts->c_it_ch_name;
1045 strings_fn[STR_IO_OT].s = uac2_opts->c_ot_name;
1046 strings_fn[STR_FU_OUT].s = uac2_opts->c_fu_vol_name;
1047 strings_fn[STR_AS_OUT_ALT0].s = "Playback Inactive";
1048 strings_fn[STR_AS_OUT_ALT1].s = "Playback Active";
1049
1050 strings_fn[STR_IO_IT].s = uac2_opts->p_it_name;
1051 strings_fn[STR_IO_IT_CH].s = uac2_opts->p_it_ch_name;
1052 strings_fn[STR_USB_OT].s = uac2_opts->p_ot_name;
1053 strings_fn[STR_FU_IN].s = uac2_opts->p_fu_vol_name;
1054 strings_fn[STR_AS_IN_ALT0].s = "Capture Inactive";
1055 strings_fn[STR_AS_IN_ALT1].s = "Capture Active";
1056
1057 us = usb_gstrings_attach(cdev, fn_strings, ARRAY_SIZE(strings_fn));
1058 if (IS_ERR(us))
1059 return PTR_ERR(us);
1060
1061 if (FUOUT_EN(uac2_opts)) {
1062 out_feature_unit_desc = build_fu_desc(uac2_opts->c_chmask);
1063 if (!out_feature_unit_desc)
1064 return -ENOMEM;
1065 }
1066 if (FUIN_EN(uac2_opts)) {
1067 in_feature_unit_desc = build_fu_desc(uac2_opts->p_chmask);
1068 if (!in_feature_unit_desc) {
1069 ret = -ENOMEM;
1070 goto err_free_fu;
1071 }
1072 }
1073
1074 iad_desc.iFunction = us[STR_ASSOC].id;
1075 std_ac_if_desc.iInterface = us[STR_IF_CTRL].id;
1076 in_clk_src_desc.iClockSource = us[STR_CLKSRC_IN].id;
1077 out_clk_src_desc.iClockSource = us[STR_CLKSRC_OUT].id;
1078 usb_out_it_desc.iTerminal = us[STR_USB_IT].id;
1079 usb_out_it_desc.iChannelNames = us[STR_USB_IT_CH].id;
1080 io_in_it_desc.iTerminal = us[STR_IO_IT].id;
1081 io_in_it_desc.iChannelNames = us[STR_IO_IT_CH].id;
1082 usb_in_ot_desc.iTerminal = us[STR_USB_OT].id;
1083 io_out_ot_desc.iTerminal = us[STR_IO_OT].id;
1084 std_as_out_if0_desc.iInterface = us[STR_AS_OUT_ALT0].id;
1085 std_as_out_if1_desc.iInterface = us[STR_AS_OUT_ALT1].id;
1086 std_as_in_if0_desc.iInterface = us[STR_AS_IN_ALT0].id;
1087 std_as_in_if1_desc.iInterface = us[STR_AS_IN_ALT1].id;
1088
1089 if (FUOUT_EN(uac2_opts)) {
1090 u8 *i_feature = (u8 *)out_feature_unit_desc +
1091 out_feature_unit_desc->bLength - 1;
1092 *i_feature = us[STR_FU_OUT].id;
1093 }
1094 if (FUIN_EN(uac2_opts)) {
1095 u8 *i_feature = (u8 *)in_feature_unit_desc +
1096 in_feature_unit_desc->bLength - 1;
1097 *i_feature = us[STR_FU_IN].id;
1098 }
1099
1100
1101 /* Initialize the configurable parameters */
1102 usb_out_it_desc.bNrChannels = num_channels(uac2_opts->c_chmask);
1103 usb_out_it_desc.bmChannelConfig = cpu_to_le32(uac2_opts->c_chmask);
1104 io_in_it_desc.bNrChannels = num_channels(uac2_opts->p_chmask);
1105 io_in_it_desc.bmChannelConfig = cpu_to_le32(uac2_opts->p_chmask);
1106 as_out_hdr_desc.bNrChannels = num_channels(uac2_opts->c_chmask);
1107 as_out_hdr_desc.bmChannelConfig = cpu_to_le32(uac2_opts->c_chmask);
1108 as_in_hdr_desc.bNrChannels = num_channels(uac2_opts->p_chmask);
1109 as_in_hdr_desc.bmChannelConfig = cpu_to_le32(uac2_opts->p_chmask);
1110 as_out_fmt1_desc.bSubslotSize = uac2_opts->c_ssize;
1111 as_out_fmt1_desc.bBitResolution = uac2_opts->c_ssize * 8;
1112 as_in_fmt1_desc.bSubslotSize = uac2_opts->p_ssize;
1113 as_in_fmt1_desc.bBitResolution = uac2_opts->p_ssize * 8;
1114 if (FUOUT_EN(uac2_opts)) {
1115 __le32 *bma = (__le32 *)&out_feature_unit_desc->bmaControls[0];
1116 u32 control = 0;
1117
1118 if (uac2_opts->c_mute_present)
1119 control |= CONTROL_RDWR << FU_MUTE_CTRL;
1120 if (uac2_opts->c_volume_present)
1121 control |= CONTROL_RDWR << FU_VOL_CTRL;
1122 *bma = cpu_to_le32(control);
1123 }
1124 if (FUIN_EN(uac2_opts)) {
1125 __le32 *bma = (__le32 *)&in_feature_unit_desc->bmaControls[0];
1126 u32 control = 0;
1127
1128 if (uac2_opts->p_mute_present)
1129 control |= CONTROL_RDWR << FU_MUTE_CTRL;
1130 if (uac2_opts->p_volume_present)
1131 control |= CONTROL_RDWR << FU_VOL_CTRL;
1132 *bma = cpu_to_le32(control);
1133 }
1134
1135 ret = usb_interface_id(cfg, fn);
1136 if (ret < 0) {
1137 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
1138 goto err_free_fu;
1139 }
1140 iad_desc.bFirstInterface = ret;
1141
1142 std_ac_if_desc.bInterfaceNumber = ret;
1143 uac2->ac_intf = ret;
1144 uac2->ac_alt = 0;
1145
1146 if (EPOUT_EN(uac2_opts)) {
1147 ret = usb_interface_id(cfg, fn);
1148 if (ret < 0) {
1149 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
1150 goto err_free_fu;
1151 }
1152 std_as_out_if0_desc.bInterfaceNumber = ret;
1153 std_as_out_if1_desc.bInterfaceNumber = ret;
1154 std_as_out_if1_desc.bNumEndpoints = 1;
1155 uac2->as_out_intf = ret;
1156 uac2->as_out_alt = 0;
1157
1158 if (EPOUT_FBACK_IN_EN(uac2_opts)) {
1159 fs_epout_desc.bmAttributes =
1160 USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC;
1161 hs_epout_desc.bmAttributes =
1162 USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC;
1163 ss_epout_desc.bmAttributes =
1164 USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC;
1165 std_as_out_if1_desc.bNumEndpoints++;
1166 } else {
1167 fs_epout_desc.bmAttributes =
1168 USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ADAPTIVE;
1169 hs_epout_desc.bmAttributes =
1170 USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ADAPTIVE;
1171 ss_epout_desc.bmAttributes =
1172 USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ADAPTIVE;
1173 }
1174 }
1175
1176 if (EPIN_EN(uac2_opts)) {
1177 ret = usb_interface_id(cfg, fn);
1178 if (ret < 0) {
1179 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
1180 goto err_free_fu;
1181 }
1182 std_as_in_if0_desc.bInterfaceNumber = ret;
1183 std_as_in_if1_desc.bInterfaceNumber = ret;
1184 uac2->as_in_intf = ret;
1185 uac2->as_in_alt = 0;
1186 }
1187
1188 if (FUOUT_EN(uac2_opts) || FUIN_EN(uac2_opts)) {
1189 uac2->int_ep = usb_ep_autoconfig(gadget, &fs_ep_int_desc);
1190 if (!uac2->int_ep) {
1191 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
1192 ret = -ENODEV;
1193 goto err_free_fu;
1194 }
1195
1196 std_ac_if_desc.bNumEndpoints = 1;
1197 }
1198
1199 hs_epin_desc.bInterval = uac2_opts->p_hs_bint;
1200 ss_epin_desc.bInterval = uac2_opts->p_hs_bint;
1201 hs_epout_desc.bInterval = uac2_opts->c_hs_bint;
1202 ss_epout_desc.bInterval = uac2_opts->c_hs_bint;
1203
1204 /* Calculate wMaxPacketSize according to audio bandwidth */
1205 ret = set_ep_max_packet_size_bint(dev, uac2_opts, &fs_epin_desc,
1206 USB_SPEED_FULL, true);
1207 if (ret < 0) {
1208 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
1209 return ret;
1210 }
1211
1212 ret = set_ep_max_packet_size_bint(dev, uac2_opts, &fs_epout_desc,
1213 USB_SPEED_FULL, false);
1214 if (ret < 0) {
1215 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
1216 return ret;
1217 }
1218
1219 ret = set_ep_max_packet_size_bint(dev, uac2_opts, &hs_epin_desc,
1220 USB_SPEED_HIGH, true);
1221 if (ret < 0) {
1222 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
1223 return ret;
1224 }
1225
1226 ret = set_ep_max_packet_size_bint(dev, uac2_opts, &hs_epout_desc,
1227 USB_SPEED_HIGH, false);
1228 if (ret < 0) {
1229 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
1230 return ret;
1231 }
1232
1233 ret = set_ep_max_packet_size_bint(dev, uac2_opts, &ss_epin_desc,
1234 USB_SPEED_SUPER, true);
1235 if (ret < 0) {
1236 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
1237 return ret;
1238 }
1239
1240 ret = set_ep_max_packet_size_bint(dev, uac2_opts, &ss_epout_desc,
1241 USB_SPEED_SUPER, false);
1242 if (ret < 0) {
1243 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
1244 return ret;
1245 }
1246
1247 if (EPOUT_EN(uac2_opts)) {
1248 agdev->out_ep = usb_ep_autoconfig(gadget, &fs_epout_desc);
1249 if (!agdev->out_ep) {
1250 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
1251 ret = -ENODEV;
1252 goto err_free_fu;
1253 }
1254 if (EPOUT_FBACK_IN_EN(uac2_opts)) {
1255 agdev->in_ep_fback = usb_ep_autoconfig(gadget,
1256 &fs_epin_fback_desc);
1257 if (!agdev->in_ep_fback) {
1258 dev_err(dev, "%s:%d Error!\n",
1259 __func__, __LINE__);
1260 ret = -ENODEV;
1261 goto err_free_fu;
1262 }
1263 }
1264 }
1265
1266 if (EPIN_EN(uac2_opts)) {
1267 agdev->in_ep = usb_ep_autoconfig(gadget, &fs_epin_desc);
1268 if (!agdev->in_ep) {
1269 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
1270 ret = -ENODEV;
1271 goto err_free_fu;
1272 }
1273 }
1274
1275 agdev->in_ep_maxpsize = max_t(u16,
1276 le16_to_cpu(fs_epin_desc.wMaxPacketSize),
1277 le16_to_cpu(hs_epin_desc.wMaxPacketSize));
1278 agdev->out_ep_maxpsize = max_t(u16,
1279 le16_to_cpu(fs_epout_desc.wMaxPacketSize),
1280 le16_to_cpu(hs_epout_desc.wMaxPacketSize));
1281
1282 agdev->in_ep_maxpsize = max_t(u16, agdev->in_ep_maxpsize,
1283 le16_to_cpu(ss_epin_desc.wMaxPacketSize));
1284 agdev->out_ep_maxpsize = max_t(u16, agdev->out_ep_maxpsize,
1285 le16_to_cpu(ss_epout_desc.wMaxPacketSize));
1286
1287 ss_epin_desc_comp.wBytesPerInterval = ss_epin_desc.wMaxPacketSize;
1288 ss_epout_desc_comp.wBytesPerInterval = ss_epout_desc.wMaxPacketSize;
1289
1290 // HS and SS endpoint addresses are copied from autoconfigured FS descriptors
1291 hs_ep_int_desc.bEndpointAddress = fs_ep_int_desc.bEndpointAddress;
1292 hs_epout_desc.bEndpointAddress = fs_epout_desc.bEndpointAddress;
1293 hs_epin_fback_desc.bEndpointAddress = fs_epin_fback_desc.bEndpointAddress;
1294 hs_epin_desc.bEndpointAddress = fs_epin_desc.bEndpointAddress;
1295 ss_epout_desc.bEndpointAddress = fs_epout_desc.bEndpointAddress;
1296 ss_epin_fback_desc.bEndpointAddress = fs_epin_fback_desc.bEndpointAddress;
1297 ss_epin_desc.bEndpointAddress = fs_epin_desc.bEndpointAddress;
1298 ss_ep_int_desc.bEndpointAddress = fs_ep_int_desc.bEndpointAddress;
1299
1300 setup_descriptor(uac2_opts);
1301
1302 ret = usb_assign_descriptors(fn, fs_audio_desc, hs_audio_desc, ss_audio_desc,
1303 ss_audio_desc);
1304 if (ret)
1305 goto err_free_fu;
1306
1307 agdev->gadget = gadget;
1308
1309 agdev->params.p_chmask = uac2_opts->p_chmask;
1310 memcpy(agdev->params.p_srates, uac2_opts->p_srates,
1311 sizeof(agdev->params.p_srates));
1312 agdev->params.p_ssize = uac2_opts->p_ssize;
1313 if (FUIN_EN(uac2_opts)) {
1314 agdev->params.p_fu.id = USB_IN_FU_ID;
1315 agdev->params.p_fu.mute_present = uac2_opts->p_mute_present;
1316 agdev->params.p_fu.volume_present = uac2_opts->p_volume_present;
1317 agdev->params.p_fu.volume_min = uac2_opts->p_volume_min;
1318 agdev->params.p_fu.volume_max = uac2_opts->p_volume_max;
1319 agdev->params.p_fu.volume_res = uac2_opts->p_volume_res;
1320 }
1321 agdev->params.c_chmask = uac2_opts->c_chmask;
1322 memcpy(agdev->params.c_srates, uac2_opts->c_srates,
1323 sizeof(agdev->params.c_srates));
1324 agdev->params.c_ssize = uac2_opts->c_ssize;
1325 if (FUOUT_EN(uac2_opts)) {
1326 agdev->params.c_fu.id = USB_OUT_FU_ID;
1327 agdev->params.c_fu.mute_present = uac2_opts->c_mute_present;
1328 agdev->params.c_fu.volume_present = uac2_opts->c_volume_present;
1329 agdev->params.c_fu.volume_min = uac2_opts->c_volume_min;
1330 agdev->params.c_fu.volume_max = uac2_opts->c_volume_max;
1331 agdev->params.c_fu.volume_res = uac2_opts->c_volume_res;
1332 }
1333 agdev->params.req_number = uac2_opts->req_number;
1334 agdev->params.fb_max = uac2_opts->fb_max;
1335
1336 if (FUOUT_EN(uac2_opts) || FUIN_EN(uac2_opts))
1337 agdev->notify = afunc_notify;
1338
1339 ret = g_audio_setup(agdev, "UAC2 PCM", "UAC2_Gadget");
1340 if (ret)
1341 goto err_free_descs;
1342
1343 return 0;
1344
1345 err_free_descs:
1346 usb_free_all_descriptors(fn);
1347 agdev->gadget = NULL;
1348 err_free_fu:
1349 kfree(out_feature_unit_desc);
1350 out_feature_unit_desc = NULL;
1351 kfree(in_feature_unit_desc);
1352 in_feature_unit_desc = NULL;
1353 return ret;
1354 }
1355
1356 static void
afunc_notify_complete(struct usb_ep * _ep,struct usb_request * req)1357 afunc_notify_complete(struct usb_ep *_ep, struct usb_request *req)
1358 {
1359 struct g_audio *agdev = req->context;
1360 struct f_uac2 *uac2 = func_to_uac2(&agdev->func);
1361
1362 atomic_dec(&uac2->int_count);
1363 kfree(req->buf);
1364 usb_ep_free_request(_ep, req);
1365 }
1366
1367 static int
afunc_notify(struct g_audio * agdev,int unit_id,int cs)1368 afunc_notify(struct g_audio *agdev, int unit_id, int cs)
1369 {
1370 struct f_uac2 *uac2 = func_to_uac2(&agdev->func);
1371 struct usb_request *req;
1372 struct uac2_interrupt_data_msg *msg;
1373 u16 w_index, w_value;
1374 int ret;
1375
1376 if (!uac2->int_ep->enabled)
1377 return 0;
1378
1379 if (atomic_inc_return(&uac2->int_count) > UAC2_DEF_INT_REQ_NUM) {
1380 atomic_dec(&uac2->int_count);
1381 return 0;
1382 }
1383
1384 req = usb_ep_alloc_request(uac2->int_ep, GFP_ATOMIC);
1385 if (req == NULL) {
1386 ret = -ENOMEM;
1387 goto err_dec_int_count;
1388 }
1389
1390 msg = kzalloc(sizeof(*msg), GFP_ATOMIC);
1391 if (msg == NULL) {
1392 ret = -ENOMEM;
1393 goto err_free_request;
1394 }
1395
1396 w_index = unit_id << 8 | uac2->ac_intf;
1397 w_value = cs << 8;
1398
1399 msg->bInfo = 0; /* Non-vendor, interface interrupt */
1400 msg->bAttribute = UAC2_CS_CUR;
1401 msg->wIndex = cpu_to_le16(w_index);
1402 msg->wValue = cpu_to_le16(w_value);
1403
1404 req->length = sizeof(*msg);
1405 req->buf = msg;
1406 req->context = agdev;
1407 req->complete = afunc_notify_complete;
1408
1409 ret = usb_ep_queue(uac2->int_ep, req, GFP_ATOMIC);
1410
1411 if (ret)
1412 goto err_free_msg;
1413
1414 return 0;
1415
1416 err_free_msg:
1417 kfree(msg);
1418 err_free_request:
1419 usb_ep_free_request(uac2->int_ep, req);
1420 err_dec_int_count:
1421 atomic_dec(&uac2->int_count);
1422
1423 return ret;
1424 }
1425
1426 static int
afunc_set_alt(struct usb_function * fn,unsigned intf,unsigned alt)1427 afunc_set_alt(struct usb_function *fn, unsigned intf, unsigned alt)
1428 {
1429 struct usb_composite_dev *cdev = fn->config->cdev;
1430 struct f_uac2 *uac2 = func_to_uac2(fn);
1431 struct g_audio *agdev = func_to_g_audio(fn);
1432 struct usb_gadget *gadget = cdev->gadget;
1433 struct device *dev = &gadget->dev;
1434 int ret = 0;
1435
1436 /* No i/f has more than 2 alt settings */
1437 if (alt > 1) {
1438 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
1439 return -EINVAL;
1440 }
1441
1442 if (intf == uac2->ac_intf) {
1443 /* Control I/f has only 1 AltSetting - 0 */
1444 if (alt) {
1445 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
1446 return -EINVAL;
1447 }
1448
1449 /* restart interrupt endpoint */
1450 if (uac2->int_ep) {
1451 usb_ep_disable(uac2->int_ep);
1452 config_ep_by_speed(gadget, &agdev->func, uac2->int_ep);
1453 usb_ep_enable(uac2->int_ep);
1454 }
1455
1456 return 0;
1457 }
1458
1459 if (intf == uac2->as_out_intf) {
1460 uac2->as_out_alt = alt;
1461
1462 if (alt)
1463 ret = u_audio_start_capture(&uac2->g_audio);
1464 else
1465 u_audio_stop_capture(&uac2->g_audio);
1466 } else if (intf == uac2->as_in_intf) {
1467 uac2->as_in_alt = alt;
1468
1469 if (alt)
1470 ret = u_audio_start_playback(&uac2->g_audio);
1471 else
1472 u_audio_stop_playback(&uac2->g_audio);
1473 } else {
1474 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
1475 return -EINVAL;
1476 }
1477
1478 return ret;
1479 }
1480
1481 static int
afunc_get_alt(struct usb_function * fn,unsigned intf)1482 afunc_get_alt(struct usb_function *fn, unsigned intf)
1483 {
1484 struct f_uac2 *uac2 = func_to_uac2(fn);
1485 struct g_audio *agdev = func_to_g_audio(fn);
1486
1487 if (intf == uac2->ac_intf)
1488 return uac2->ac_alt;
1489 else if (intf == uac2->as_out_intf)
1490 return uac2->as_out_alt;
1491 else if (intf == uac2->as_in_intf)
1492 return uac2->as_in_alt;
1493 else
1494 dev_err(&agdev->gadget->dev,
1495 "%s:%d Invalid Interface %d!\n",
1496 __func__, __LINE__, intf);
1497
1498 return -EINVAL;
1499 }
1500
1501 static void
afunc_disable(struct usb_function * fn)1502 afunc_disable(struct usb_function *fn)
1503 {
1504 struct f_uac2 *uac2 = func_to_uac2(fn);
1505
1506 uac2->as_in_alt = 0;
1507 uac2->as_out_alt = 0;
1508 u_audio_stop_capture(&uac2->g_audio);
1509 u_audio_stop_playback(&uac2->g_audio);
1510 if (uac2->int_ep)
1511 usb_ep_disable(uac2->int_ep);
1512 }
1513
1514 static void
afunc_suspend(struct usb_function * fn)1515 afunc_suspend(struct usb_function *fn)
1516 {
1517 struct f_uac2 *uac2 = func_to_uac2(fn);
1518
1519 u_audio_suspend(&uac2->g_audio);
1520 }
1521
1522 static int
in_rq_cur(struct usb_function * fn,const struct usb_ctrlrequest * cr)1523 in_rq_cur(struct usb_function *fn, const struct usb_ctrlrequest *cr)
1524 {
1525 struct usb_request *req = fn->config->cdev->req;
1526 struct g_audio *agdev = func_to_g_audio(fn);
1527 struct f_uac2_opts *opts = g_audio_to_uac2_opts(agdev);
1528 u16 w_length = le16_to_cpu(cr->wLength);
1529 u16 w_index = le16_to_cpu(cr->wIndex);
1530 u16 w_value = le16_to_cpu(cr->wValue);
1531 u8 entity_id = (w_index >> 8) & 0xff;
1532 u8 control_selector = w_value >> 8;
1533 int value = -EOPNOTSUPP;
1534 u32 p_srate, c_srate;
1535
1536 u_audio_get_playback_srate(agdev, &p_srate);
1537 u_audio_get_capture_srate(agdev, &c_srate);
1538
1539 if ((entity_id == USB_IN_CLK_ID) || (entity_id == USB_OUT_CLK_ID)) {
1540 if (control_selector == UAC2_CS_CONTROL_SAM_FREQ) {
1541 struct cntrl_cur_lay3 c;
1542
1543 memset(&c, 0, sizeof(struct cntrl_cur_lay3));
1544
1545 if (entity_id == USB_IN_CLK_ID)
1546 c.dCUR = cpu_to_le32(p_srate);
1547 else if (entity_id == USB_OUT_CLK_ID)
1548 c.dCUR = cpu_to_le32(c_srate);
1549
1550 value = min_t(unsigned int, w_length, sizeof(c));
1551 memcpy(req->buf, &c, value);
1552 } else if (control_selector == UAC2_CS_CONTROL_CLOCK_VALID) {
1553 *(u8 *)req->buf = 1;
1554 value = min_t(unsigned int, w_length, 1);
1555 } else {
1556 dev_err(&agdev->gadget->dev,
1557 "%s:%d control_selector=%d TODO!\n",
1558 __func__, __LINE__, control_selector);
1559 }
1560 } else if ((FUIN_EN(opts) && (entity_id == USB_IN_FU_ID)) ||
1561 (FUOUT_EN(opts) && (entity_id == USB_OUT_FU_ID))) {
1562 unsigned int is_playback = 0;
1563
1564 if (FUIN_EN(opts) && (entity_id == USB_IN_FU_ID))
1565 is_playback = 1;
1566
1567 if (control_selector == UAC_FU_MUTE) {
1568 unsigned int mute;
1569
1570 u_audio_get_mute(agdev, is_playback, &mute);
1571
1572 *(u8 *)req->buf = mute;
1573 value = min_t(unsigned int, w_length, 1);
1574 } else if (control_selector == UAC_FU_VOLUME) {
1575 struct cntrl_cur_lay2 c;
1576 s16 volume;
1577
1578 memset(&c, 0, sizeof(struct cntrl_cur_lay2));
1579
1580 u_audio_get_volume(agdev, is_playback, &volume);
1581 c.wCUR = cpu_to_le16(volume);
1582
1583 value = min_t(unsigned int, w_length, sizeof(c));
1584 memcpy(req->buf, &c, value);
1585 } else {
1586 dev_err(&agdev->gadget->dev,
1587 "%s:%d control_selector=%d TODO!\n",
1588 __func__, __LINE__, control_selector);
1589 }
1590 } else {
1591 dev_err(&agdev->gadget->dev,
1592 "%s:%d entity_id=%d control_selector=%d TODO!\n",
1593 __func__, __LINE__, entity_id, control_selector);
1594 }
1595
1596 return value;
1597 }
1598
1599 static int
in_rq_range(struct usb_function * fn,const struct usb_ctrlrequest * cr)1600 in_rq_range(struct usb_function *fn, const struct usb_ctrlrequest *cr)
1601 {
1602 struct usb_request *req = fn->config->cdev->req;
1603 struct g_audio *agdev = func_to_g_audio(fn);
1604 struct f_uac2_opts *opts = g_audio_to_uac2_opts(agdev);
1605 u16 w_length = le16_to_cpu(cr->wLength);
1606 u16 w_index = le16_to_cpu(cr->wIndex);
1607 u16 w_value = le16_to_cpu(cr->wValue);
1608 u8 entity_id = (w_index >> 8) & 0xff;
1609 u8 control_selector = w_value >> 8;
1610 int value = -EOPNOTSUPP;
1611
1612 if ((entity_id == USB_IN_CLK_ID) || (entity_id == USB_OUT_CLK_ID)) {
1613 if (control_selector == UAC2_CS_CONTROL_SAM_FREQ) {
1614 struct cntrl_ranges_lay3_srates rs;
1615 int i;
1616 int wNumSubRanges = 0;
1617 int srate;
1618 int *srates;
1619
1620 if (entity_id == USB_IN_CLK_ID)
1621 srates = opts->p_srates;
1622 else if (entity_id == USB_OUT_CLK_ID)
1623 srates = opts->c_srates;
1624 else
1625 return -EOPNOTSUPP;
1626 for (i = 0; i < UAC_MAX_RATES; i++) {
1627 srate = srates[i];
1628 if (srate == 0)
1629 break;
1630
1631 rs.r[wNumSubRanges].dMIN = cpu_to_le32(srate);
1632 rs.r[wNumSubRanges].dMAX = cpu_to_le32(srate);
1633 rs.r[wNumSubRanges].dRES = 0;
1634 wNumSubRanges++;
1635 dev_dbg(&agdev->gadget->dev,
1636 "%s(): clk %d: rate ID %d: %d\n",
1637 __func__, entity_id, wNumSubRanges, srate);
1638 }
1639 rs.wNumSubRanges = cpu_to_le16(wNumSubRanges);
1640 value = min_t(unsigned int, w_length, ranges_lay3_size(rs));
1641 dev_dbg(&agdev->gadget->dev, "%s(): sending %d rates, size %d\n",
1642 __func__, rs.wNumSubRanges, value);
1643 memcpy(req->buf, &rs, value);
1644 } else {
1645 dev_err(&agdev->gadget->dev,
1646 "%s:%d control_selector=%d TODO!\n",
1647 __func__, __LINE__, control_selector);
1648 }
1649 } else if ((FUIN_EN(opts) && (entity_id == USB_IN_FU_ID)) ||
1650 (FUOUT_EN(opts) && (entity_id == USB_OUT_FU_ID))) {
1651 unsigned int is_playback = 0;
1652
1653 if (FUIN_EN(opts) && (entity_id == USB_IN_FU_ID))
1654 is_playback = 1;
1655
1656 if (control_selector == UAC_FU_VOLUME) {
1657 struct cntrl_range_lay2 r;
1658 s16 max_db, min_db, res_db;
1659
1660 if (is_playback) {
1661 max_db = opts->p_volume_max;
1662 min_db = opts->p_volume_min;
1663 res_db = opts->p_volume_res;
1664 } else {
1665 max_db = opts->c_volume_max;
1666 min_db = opts->c_volume_min;
1667 res_db = opts->c_volume_res;
1668 }
1669
1670 r.wMAX = cpu_to_le16(max_db);
1671 r.wMIN = cpu_to_le16(min_db);
1672 r.wRES = cpu_to_le16(res_db);
1673 r.wNumSubRanges = cpu_to_le16(1);
1674
1675 value = min_t(unsigned int, w_length, sizeof(r));
1676 memcpy(req->buf, &r, value);
1677 } else {
1678 dev_err(&agdev->gadget->dev,
1679 "%s:%d control_selector=%d TODO!\n",
1680 __func__, __LINE__, control_selector);
1681 }
1682 } else {
1683 dev_err(&agdev->gadget->dev,
1684 "%s:%d entity_id=%d control_selector=%d TODO!\n",
1685 __func__, __LINE__, entity_id, control_selector);
1686 }
1687
1688 return value;
1689 }
1690
1691 static int
ac_rq_in(struct usb_function * fn,const struct usb_ctrlrequest * cr)1692 ac_rq_in(struct usb_function *fn, const struct usb_ctrlrequest *cr)
1693 {
1694 if (cr->bRequest == UAC2_CS_CUR)
1695 return in_rq_cur(fn, cr);
1696 else if (cr->bRequest == UAC2_CS_RANGE)
1697 return in_rq_range(fn, cr);
1698 else
1699 return -EOPNOTSUPP;
1700 }
1701
uac2_cs_control_sam_freq(struct usb_ep * ep,struct usb_request * req)1702 static void uac2_cs_control_sam_freq(struct usb_ep *ep, struct usb_request *req)
1703 {
1704 struct usb_function *fn = ep->driver_data;
1705 struct g_audio *agdev = func_to_g_audio(fn);
1706 struct f_uac2 *uac2 = func_to_uac2(fn);
1707 u32 val;
1708
1709 if (req->actual != 4)
1710 return;
1711
1712 val = le32_to_cpu(*((__le32 *)req->buf));
1713 dev_dbg(&agdev->gadget->dev, "%s val: %d.\n", __func__, val);
1714 if (uac2->clock_id == USB_IN_CLK_ID) {
1715 u_audio_set_playback_srate(agdev, val);
1716 } else if (uac2->clock_id == USB_OUT_CLK_ID) {
1717 u_audio_set_capture_srate(agdev, val);
1718 }
1719 }
1720
1721 static void
out_rq_cur_complete(struct usb_ep * ep,struct usb_request * req)1722 out_rq_cur_complete(struct usb_ep *ep, struct usb_request *req)
1723 {
1724 struct g_audio *agdev = req->context;
1725 struct usb_composite_dev *cdev = agdev->func.config->cdev;
1726 struct f_uac2_opts *opts = g_audio_to_uac2_opts(agdev);
1727 struct f_uac2 *uac2 = func_to_uac2(&agdev->func);
1728 struct usb_ctrlrequest *cr = &uac2->setup_cr;
1729 u16 w_index = le16_to_cpu(cr->wIndex);
1730 u16 w_value = le16_to_cpu(cr->wValue);
1731 u8 entity_id = (w_index >> 8) & 0xff;
1732 u8 control_selector = w_value >> 8;
1733
1734 if (req->status != 0) {
1735 dev_dbg(&cdev->gadget->dev, "completion err %d\n", req->status);
1736 return;
1737 }
1738
1739 if ((FUIN_EN(opts) && (entity_id == USB_IN_FU_ID)) ||
1740 (FUOUT_EN(opts) && (entity_id == USB_OUT_FU_ID))) {
1741 unsigned int is_playback = 0;
1742
1743 if (FUIN_EN(opts) && (entity_id == USB_IN_FU_ID))
1744 is_playback = 1;
1745
1746 if (control_selector == UAC_FU_MUTE) {
1747 u8 mute = *(u8 *)req->buf;
1748
1749 u_audio_set_mute(agdev, is_playback, mute);
1750
1751 return;
1752 } else if (control_selector == UAC_FU_VOLUME) {
1753 struct cntrl_cur_lay2 *c = req->buf;
1754 s16 volume;
1755
1756 volume = le16_to_cpu(c->wCUR);
1757 u_audio_set_volume(agdev, is_playback, volume);
1758
1759 return;
1760 } else {
1761 dev_err(&agdev->gadget->dev,
1762 "%s:%d control_selector=%d TODO!\n",
1763 __func__, __LINE__, control_selector);
1764 usb_ep_set_halt(ep);
1765 }
1766 }
1767 }
1768
1769 static int
out_rq_cur(struct usb_function * fn,const struct usb_ctrlrequest * cr)1770 out_rq_cur(struct usb_function *fn, const struct usb_ctrlrequest *cr)
1771 {
1772 struct usb_composite_dev *cdev = fn->config->cdev;
1773 struct usb_request *req = fn->config->cdev->req;
1774 struct g_audio *agdev = func_to_g_audio(fn);
1775 struct f_uac2_opts *opts = g_audio_to_uac2_opts(agdev);
1776 struct f_uac2 *uac2 = func_to_uac2(fn);
1777 u16 w_length = le16_to_cpu(cr->wLength);
1778 u16 w_index = le16_to_cpu(cr->wIndex);
1779 u16 w_value = le16_to_cpu(cr->wValue);
1780 u8 entity_id = (w_index >> 8) & 0xff;
1781 u8 control_selector = w_value >> 8;
1782 u8 clock_id = w_index >> 8;
1783
1784 if ((entity_id == USB_IN_CLK_ID) || (entity_id == USB_OUT_CLK_ID)) {
1785 if (control_selector == UAC2_CS_CONTROL_SAM_FREQ) {
1786 dev_dbg(&agdev->gadget->dev,
1787 "control_selector UAC2_CS_CONTROL_SAM_FREQ, clock: %d\n", clock_id);
1788 cdev->gadget->ep0->driver_data = fn;
1789 uac2->clock_id = clock_id;
1790 req->complete = uac2_cs_control_sam_freq;
1791 return w_length;
1792 }
1793 } else if ((FUIN_EN(opts) && (entity_id == USB_IN_FU_ID)) ||
1794 (FUOUT_EN(opts) && (entity_id == USB_OUT_FU_ID))) {
1795 memcpy(&uac2->setup_cr, cr, sizeof(*cr));
1796 req->context = agdev;
1797 req->complete = out_rq_cur_complete;
1798
1799 return w_length;
1800 } else {
1801 dev_err(&agdev->gadget->dev,
1802 "%s:%d entity_id=%d control_selector=%d TODO!\n",
1803 __func__, __LINE__, entity_id, control_selector);
1804 }
1805 return -EOPNOTSUPP;
1806 }
1807
1808 static int
setup_rq_inf(struct usb_function * fn,const struct usb_ctrlrequest * cr)1809 setup_rq_inf(struct usb_function *fn, const struct usb_ctrlrequest *cr)
1810 {
1811 struct f_uac2 *uac2 = func_to_uac2(fn);
1812 struct g_audio *agdev = func_to_g_audio(fn);
1813 u16 w_index = le16_to_cpu(cr->wIndex);
1814 u8 intf = w_index & 0xff;
1815
1816 if (intf != uac2->ac_intf) {
1817 dev_err(&agdev->gadget->dev,
1818 "%s:%d Error!\n", __func__, __LINE__);
1819 return -EOPNOTSUPP;
1820 }
1821
1822 if (cr->bRequestType & USB_DIR_IN)
1823 return ac_rq_in(fn, cr);
1824 else if (cr->bRequest == UAC2_CS_CUR)
1825 return out_rq_cur(fn, cr);
1826
1827 return -EOPNOTSUPP;
1828 }
1829
1830 static int
afunc_setup(struct usb_function * fn,const struct usb_ctrlrequest * cr)1831 afunc_setup(struct usb_function *fn, const struct usb_ctrlrequest *cr)
1832 {
1833 struct usb_composite_dev *cdev = fn->config->cdev;
1834 struct g_audio *agdev = func_to_g_audio(fn);
1835 struct usb_request *req = cdev->req;
1836 u16 w_length = le16_to_cpu(cr->wLength);
1837 int value = -EOPNOTSUPP;
1838
1839 /* Only Class specific requests are supposed to reach here */
1840 if ((cr->bRequestType & USB_TYPE_MASK) != USB_TYPE_CLASS)
1841 return -EOPNOTSUPP;
1842
1843 if ((cr->bRequestType & USB_RECIP_MASK) == USB_RECIP_INTERFACE)
1844 value = setup_rq_inf(fn, cr);
1845 else
1846 dev_err(&agdev->gadget->dev, "%s:%d Error!\n",
1847 __func__, __LINE__);
1848
1849 if (value >= 0) {
1850 req->length = value;
1851 req->zero = value < w_length;
1852 value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
1853 if (value < 0) {
1854 dev_err(&agdev->gadget->dev,
1855 "%s:%d Error!\n", __func__, __LINE__);
1856 req->status = 0;
1857 }
1858 }
1859
1860 return value;
1861 }
1862
to_f_uac2_opts(struct config_item * item)1863 static inline struct f_uac2_opts *to_f_uac2_opts(struct config_item *item)
1864 {
1865 return container_of(to_config_group(item), struct f_uac2_opts,
1866 func_inst.group);
1867 }
1868
f_uac2_attr_release(struct config_item * item)1869 static void f_uac2_attr_release(struct config_item *item)
1870 {
1871 struct f_uac2_opts *opts = to_f_uac2_opts(item);
1872
1873 usb_put_function_instance(&opts->func_inst);
1874 }
1875
1876 static struct configfs_item_operations f_uac2_item_ops = {
1877 .release = f_uac2_attr_release,
1878 };
1879
1880 #define uac2_kstrtou8 kstrtou8
1881 #define uac2_kstrtou32 kstrtou32
1882 #define uac2_kstrtos16 kstrtos16
1883 #define uac2_kstrtobool(s, base, res) kstrtobool((s), (res))
1884
1885 static const char *u8_fmt = "%u\n";
1886 static const char *u32_fmt = "%u\n";
1887 static const char *s16_fmt = "%hd\n";
1888 static const char *bool_fmt = "%u\n";
1889
1890 #define UAC2_ATTRIBUTE(type, name) \
1891 static ssize_t f_uac2_opts_##name##_show(struct config_item *item, \
1892 char *page) \
1893 { \
1894 struct f_uac2_opts *opts = to_f_uac2_opts(item); \
1895 int result; \
1896 \
1897 mutex_lock(&opts->lock); \
1898 result = sprintf(page, type##_fmt, opts->name); \
1899 mutex_unlock(&opts->lock); \
1900 \
1901 return result; \
1902 } \
1903 \
1904 static ssize_t f_uac2_opts_##name##_store(struct config_item *item, \
1905 const char *page, size_t len) \
1906 { \
1907 struct f_uac2_opts *opts = to_f_uac2_opts(item); \
1908 int ret; \
1909 type num; \
1910 \
1911 mutex_lock(&opts->lock); \
1912 if (opts->refcnt) { \
1913 ret = -EBUSY; \
1914 goto end; \
1915 } \
1916 \
1917 ret = uac2_kstrto##type(page, 0, &num); \
1918 if (ret) \
1919 goto end; \
1920 \
1921 opts->name = num; \
1922 ret = len; \
1923 \
1924 end: \
1925 mutex_unlock(&opts->lock); \
1926 return ret; \
1927 } \
1928 \
1929 CONFIGFS_ATTR(f_uac2_opts_, name)
1930
1931 #define UAC2_ATTRIBUTE_SYNC(name) \
1932 static ssize_t f_uac2_opts_##name##_show(struct config_item *item, \
1933 char *page) \
1934 { \
1935 struct f_uac2_opts *opts = to_f_uac2_opts(item); \
1936 int result; \
1937 char *str; \
1938 \
1939 mutex_lock(&opts->lock); \
1940 switch (opts->name) { \
1941 case USB_ENDPOINT_SYNC_ASYNC: \
1942 str = "async"; \
1943 break; \
1944 case USB_ENDPOINT_SYNC_ADAPTIVE: \
1945 str = "adaptive"; \
1946 break; \
1947 default: \
1948 str = "unknown"; \
1949 break; \
1950 } \
1951 result = sprintf(page, "%s\n", str); \
1952 mutex_unlock(&opts->lock); \
1953 \
1954 return result; \
1955 } \
1956 \
1957 static ssize_t f_uac2_opts_##name##_store(struct config_item *item, \
1958 const char *page, size_t len) \
1959 { \
1960 struct f_uac2_opts *opts = to_f_uac2_opts(item); \
1961 int ret = 0; \
1962 \
1963 mutex_lock(&opts->lock); \
1964 if (opts->refcnt) { \
1965 ret = -EBUSY; \
1966 goto end; \
1967 } \
1968 \
1969 if (!strncmp(page, "async", 5)) \
1970 opts->name = USB_ENDPOINT_SYNC_ASYNC; \
1971 else if (!strncmp(page, "adaptive", 8)) \
1972 opts->name = USB_ENDPOINT_SYNC_ADAPTIVE; \
1973 else { \
1974 ret = -EINVAL; \
1975 goto end; \
1976 } \
1977 \
1978 ret = len; \
1979 \
1980 end: \
1981 mutex_unlock(&opts->lock); \
1982 return ret; \
1983 } \
1984 \
1985 CONFIGFS_ATTR(f_uac2_opts_, name)
1986
1987 #define UAC2_RATE_ATTRIBUTE(name) \
1988 static ssize_t f_uac2_opts_##name##_show(struct config_item *item, \
1989 char *page) \
1990 { \
1991 struct f_uac2_opts *opts = to_f_uac2_opts(item); \
1992 int result = 0; \
1993 int i; \
1994 \
1995 mutex_lock(&opts->lock); \
1996 page[0] = '\0'; \
1997 for (i = 0; i < UAC_MAX_RATES; i++) { \
1998 if (opts->name##s[i] == 0) \
1999 break; \
2000 result += sprintf(page + strlen(page), "%u,", \
2001 opts->name##s[i]); \
2002 } \
2003 if (strlen(page) > 0) \
2004 page[strlen(page) - 1] = '\n'; \
2005 mutex_unlock(&opts->lock); \
2006 \
2007 return result; \
2008 } \
2009 \
2010 static ssize_t f_uac2_opts_##name##_store(struct config_item *item, \
2011 const char *page, size_t len) \
2012 { \
2013 struct f_uac2_opts *opts = to_f_uac2_opts(item); \
2014 char *split_page = NULL; \
2015 int ret = -EINVAL; \
2016 char *token; \
2017 u32 num; \
2018 int i; \
2019 \
2020 mutex_lock(&opts->lock); \
2021 if (opts->refcnt) { \
2022 ret = -EBUSY; \
2023 goto end; \
2024 } \
2025 \
2026 i = 0; \
2027 memset(opts->name##s, 0x00, sizeof(opts->name##s)); \
2028 split_page = kstrdup(page, GFP_KERNEL); \
2029 while ((token = strsep(&split_page, ",")) != NULL) { \
2030 ret = kstrtou32(token, 0, &num); \
2031 if (ret) \
2032 goto end; \
2033 \
2034 opts->name##s[i++] = num; \
2035 ret = len; \
2036 }; \
2037 \
2038 end: \
2039 kfree(split_page); \
2040 mutex_unlock(&opts->lock); \
2041 return ret; \
2042 } \
2043 \
2044 CONFIGFS_ATTR(f_uac2_opts_, name)
2045
2046 #define UAC2_ATTRIBUTE_STRING(name) \
2047 static ssize_t f_uac2_opts_##name##_show(struct config_item *item, \
2048 char *page) \
2049 { \
2050 struct f_uac2_opts *opts = to_f_uac2_opts(item); \
2051 int result; \
2052 \
2053 mutex_lock(&opts->lock); \
2054 result = scnprintf(page, sizeof(opts->name), "%s", opts->name); \
2055 mutex_unlock(&opts->lock); \
2056 \
2057 return result; \
2058 } \
2059 \
2060 static ssize_t f_uac2_opts_##name##_store(struct config_item *item, \
2061 const char *page, size_t len) \
2062 { \
2063 struct f_uac2_opts *opts = to_f_uac2_opts(item); \
2064 int ret = len; \
2065 \
2066 mutex_lock(&opts->lock); \
2067 if (opts->refcnt) { \
2068 ret = -EBUSY; \
2069 goto end; \
2070 } \
2071 \
2072 if (len && page[len - 1] == '\n') \
2073 len--; \
2074 \
2075 scnprintf(opts->name, min(sizeof(opts->name), len + 1), \
2076 "%s", page); \
2077 \
2078 end: \
2079 mutex_unlock(&opts->lock); \
2080 return ret; \
2081 } \
2082 \
2083 CONFIGFS_ATTR(f_uac2_opts_, name)
2084
2085 UAC2_ATTRIBUTE(u32, p_chmask);
2086 UAC2_RATE_ATTRIBUTE(p_srate);
2087 UAC2_ATTRIBUTE(u32, p_ssize);
2088 UAC2_ATTRIBUTE(u8, p_hs_bint);
2089 UAC2_ATTRIBUTE(u32, c_chmask);
2090 UAC2_RATE_ATTRIBUTE(c_srate);
2091 UAC2_ATTRIBUTE_SYNC(c_sync);
2092 UAC2_ATTRIBUTE(u32, c_ssize);
2093 UAC2_ATTRIBUTE(u8, c_hs_bint);
2094 UAC2_ATTRIBUTE(u32, req_number);
2095
2096 UAC2_ATTRIBUTE(bool, p_mute_present);
2097 UAC2_ATTRIBUTE(bool, p_volume_present);
2098 UAC2_ATTRIBUTE(s16, p_volume_min);
2099 UAC2_ATTRIBUTE(s16, p_volume_max);
2100 UAC2_ATTRIBUTE(s16, p_volume_res);
2101
2102 UAC2_ATTRIBUTE(bool, c_mute_present);
2103 UAC2_ATTRIBUTE(bool, c_volume_present);
2104 UAC2_ATTRIBUTE(s16, c_volume_min);
2105 UAC2_ATTRIBUTE(s16, c_volume_max);
2106 UAC2_ATTRIBUTE(s16, c_volume_res);
2107 UAC2_ATTRIBUTE(u32, fb_max);
2108 UAC2_ATTRIBUTE_STRING(function_name);
2109 UAC2_ATTRIBUTE_STRING(if_ctrl_name);
2110 UAC2_ATTRIBUTE_STRING(clksrc_in_name);
2111 UAC2_ATTRIBUTE_STRING(clksrc_out_name);
2112
2113 UAC2_ATTRIBUTE_STRING(p_it_name);
2114 UAC2_ATTRIBUTE_STRING(p_it_ch_name);
2115 UAC2_ATTRIBUTE_STRING(p_ot_name);
2116 UAC2_ATTRIBUTE_STRING(p_fu_vol_name);
2117
2118 UAC2_ATTRIBUTE_STRING(c_it_name);
2119 UAC2_ATTRIBUTE_STRING(c_it_ch_name);
2120 UAC2_ATTRIBUTE_STRING(c_ot_name);
2121 UAC2_ATTRIBUTE_STRING(c_fu_vol_name);
2122
2123 UAC2_ATTRIBUTE(s16, p_terminal_type);
2124 UAC2_ATTRIBUTE(s16, c_terminal_type);
2125
2126
2127 static struct configfs_attribute *f_uac2_attrs[] = {
2128 &f_uac2_opts_attr_p_chmask,
2129 &f_uac2_opts_attr_p_srate,
2130 &f_uac2_opts_attr_p_ssize,
2131 &f_uac2_opts_attr_p_hs_bint,
2132 &f_uac2_opts_attr_c_chmask,
2133 &f_uac2_opts_attr_c_srate,
2134 &f_uac2_opts_attr_c_ssize,
2135 &f_uac2_opts_attr_c_hs_bint,
2136 &f_uac2_opts_attr_c_sync,
2137 &f_uac2_opts_attr_req_number,
2138 &f_uac2_opts_attr_fb_max,
2139
2140 &f_uac2_opts_attr_p_mute_present,
2141 &f_uac2_opts_attr_p_volume_present,
2142 &f_uac2_opts_attr_p_volume_min,
2143 &f_uac2_opts_attr_p_volume_max,
2144 &f_uac2_opts_attr_p_volume_res,
2145
2146 &f_uac2_opts_attr_c_mute_present,
2147 &f_uac2_opts_attr_c_volume_present,
2148 &f_uac2_opts_attr_c_volume_min,
2149 &f_uac2_opts_attr_c_volume_max,
2150 &f_uac2_opts_attr_c_volume_res,
2151
2152 &f_uac2_opts_attr_function_name,
2153 &f_uac2_opts_attr_if_ctrl_name,
2154 &f_uac2_opts_attr_clksrc_in_name,
2155 &f_uac2_opts_attr_clksrc_out_name,
2156
2157 &f_uac2_opts_attr_p_it_name,
2158 &f_uac2_opts_attr_p_it_ch_name,
2159 &f_uac2_opts_attr_p_ot_name,
2160 &f_uac2_opts_attr_p_fu_vol_name,
2161
2162 &f_uac2_opts_attr_c_it_name,
2163 &f_uac2_opts_attr_c_it_ch_name,
2164 &f_uac2_opts_attr_c_ot_name,
2165 &f_uac2_opts_attr_c_fu_vol_name,
2166
2167 &f_uac2_opts_attr_p_terminal_type,
2168 &f_uac2_opts_attr_c_terminal_type,
2169
2170 NULL,
2171 };
2172
2173 static const struct config_item_type f_uac2_func_type = {
2174 .ct_item_ops = &f_uac2_item_ops,
2175 .ct_attrs = f_uac2_attrs,
2176 .ct_owner = THIS_MODULE,
2177 };
2178
afunc_free_inst(struct usb_function_instance * f)2179 static void afunc_free_inst(struct usb_function_instance *f)
2180 {
2181 struct f_uac2_opts *opts;
2182
2183 opts = container_of(f, struct f_uac2_opts, func_inst);
2184 kfree(opts);
2185 }
2186
afunc_alloc_inst(void)2187 static struct usb_function_instance *afunc_alloc_inst(void)
2188 {
2189 struct f_uac2_opts *opts;
2190
2191 opts = kzalloc(sizeof(*opts), GFP_KERNEL);
2192 if (!opts)
2193 return ERR_PTR(-ENOMEM);
2194
2195 mutex_init(&opts->lock);
2196 opts->func_inst.free_func_inst = afunc_free_inst;
2197
2198 config_group_init_type_name(&opts->func_inst.group, "",
2199 &f_uac2_func_type);
2200
2201 opts->p_chmask = UAC2_DEF_PCHMASK;
2202 opts->p_srates[0] = UAC2_DEF_PSRATE;
2203 opts->p_ssize = UAC2_DEF_PSSIZE;
2204 opts->p_hs_bint = UAC2_DEF_PHSBINT;
2205 opts->c_chmask = UAC2_DEF_CCHMASK;
2206 opts->c_srates[0] = UAC2_DEF_CSRATE;
2207 opts->c_ssize = UAC2_DEF_CSSIZE;
2208 opts->c_hs_bint = UAC2_DEF_CHSBINT;
2209 opts->c_sync = UAC2_DEF_CSYNC;
2210
2211 opts->p_mute_present = UAC2_DEF_MUTE_PRESENT;
2212 opts->p_volume_present = UAC2_DEF_VOLUME_PRESENT;
2213 opts->p_volume_min = UAC2_DEF_MIN_DB;
2214 opts->p_volume_max = UAC2_DEF_MAX_DB;
2215 opts->p_volume_res = UAC2_DEF_RES_DB;
2216
2217 opts->c_mute_present = UAC2_DEF_MUTE_PRESENT;
2218 opts->c_volume_present = UAC2_DEF_VOLUME_PRESENT;
2219 opts->c_volume_min = UAC2_DEF_MIN_DB;
2220 opts->c_volume_max = UAC2_DEF_MAX_DB;
2221 opts->c_volume_res = UAC2_DEF_RES_DB;
2222
2223 opts->req_number = UAC2_DEF_REQ_NUM;
2224 opts->fb_max = FBACK_FAST_MAX;
2225
2226 scnprintf(opts->function_name, sizeof(opts->function_name), "Source/Sink");
2227 scnprintf(opts->if_ctrl_name, sizeof(opts->if_ctrl_name), "Topology Control");
2228 scnprintf(opts->clksrc_in_name, sizeof(opts->clksrc_in_name), "Input Clock");
2229 scnprintf(opts->clksrc_out_name, sizeof(opts->clksrc_out_name), "Output Clock");
2230
2231 scnprintf(opts->p_it_name, sizeof(opts->p_it_name), "USBD Out");
2232 scnprintf(opts->p_it_ch_name, sizeof(opts->p_it_ch_name), "Capture Channels");
2233 scnprintf(opts->p_ot_name, sizeof(opts->p_ot_name), "USBH In");
2234 scnprintf(opts->p_fu_vol_name, sizeof(opts->p_fu_vol_name), "Capture Volume");
2235
2236 scnprintf(opts->c_it_name, sizeof(opts->c_it_name), "USBH Out");
2237 scnprintf(opts->c_it_ch_name, sizeof(opts->c_it_ch_name), "Playback Channels");
2238 scnprintf(opts->c_ot_name, sizeof(opts->c_ot_name), "USBD In");
2239 scnprintf(opts->c_fu_vol_name, sizeof(opts->c_fu_vol_name), "Playback Volume");
2240
2241 opts->p_terminal_type = UAC2_DEF_P_TERM_TYPE;
2242 opts->c_terminal_type = UAC2_DEF_C_TERM_TYPE;
2243
2244 return &opts->func_inst;
2245 }
2246
afunc_free(struct usb_function * f)2247 static void afunc_free(struct usb_function *f)
2248 {
2249 struct g_audio *agdev;
2250 struct f_uac2_opts *opts;
2251
2252 agdev = func_to_g_audio(f);
2253 opts = container_of(f->fi, struct f_uac2_opts, func_inst);
2254 kfree(agdev);
2255 mutex_lock(&opts->lock);
2256 --opts->refcnt;
2257 mutex_unlock(&opts->lock);
2258 }
2259
afunc_unbind(struct usb_configuration * c,struct usb_function * f)2260 static void afunc_unbind(struct usb_configuration *c, struct usb_function *f)
2261 {
2262 struct g_audio *agdev = func_to_g_audio(f);
2263
2264 g_audio_cleanup(agdev);
2265 usb_free_all_descriptors(f);
2266
2267 agdev->gadget = NULL;
2268
2269 kfree(out_feature_unit_desc);
2270 out_feature_unit_desc = NULL;
2271 kfree(in_feature_unit_desc);
2272 in_feature_unit_desc = NULL;
2273 }
2274
afunc_alloc(struct usb_function_instance * fi)2275 static struct usb_function *afunc_alloc(struct usb_function_instance *fi)
2276 {
2277 struct f_uac2 *uac2;
2278 struct f_uac2_opts *opts;
2279
2280 uac2 = kzalloc(sizeof(*uac2), GFP_KERNEL);
2281 if (uac2 == NULL)
2282 return ERR_PTR(-ENOMEM);
2283
2284 opts = container_of(fi, struct f_uac2_opts, func_inst);
2285 mutex_lock(&opts->lock);
2286 ++opts->refcnt;
2287 mutex_unlock(&opts->lock);
2288
2289 uac2->g_audio.func.name = "uac2_func";
2290 uac2->g_audio.func.bind = afunc_bind;
2291 uac2->g_audio.func.unbind = afunc_unbind;
2292 uac2->g_audio.func.set_alt = afunc_set_alt;
2293 uac2->g_audio.func.get_alt = afunc_get_alt;
2294 uac2->g_audio.func.disable = afunc_disable;
2295 uac2->g_audio.func.suspend = afunc_suspend;
2296 uac2->g_audio.func.setup = afunc_setup;
2297 uac2->g_audio.func.free_func = afunc_free;
2298
2299 return &uac2->g_audio.func;
2300 }
2301
2302 DECLARE_USB_FUNCTION_INIT(uac2, afunc_alloc_inst, afunc_alloc);
2303 MODULE_DESCRIPTION("USB Audio Class 2.0 Function");
2304 MODULE_LICENSE("GPL");
2305 MODULE_AUTHOR("Yadwinder Singh");
2306 MODULE_AUTHOR("Jaswinder Singh");
2307 MODULE_AUTHOR("Ruslan Bilovol");
2308