1
2
3
4
5
6
7
8
9
10#include <linux/usb/audio.h>
11#include <linux/usb/audio-v2.h>
12#include <linux/module.h>
13
14#include "u_audio.h"
15#include "u_uac2.h"
16
17
18
19
20
21
22
23
24
25#define USB_OUT_CLK_ID (out_clk_src_desc.bClockID)
26#define USB_IN_CLK_ID (in_clk_src_desc.bClockID)
27
28#define CONTROL_ABSENT 0
29#define CONTROL_RDONLY 1
30#define CONTROL_RDWR 3
31
32#define CLK_FREQ_CTRL 0
33#define CLK_VLD_CTRL 2
34
35#define COPY_CTRL 0
36#define CONN_CTRL 2
37#define OVRLD_CTRL 4
38#define CLSTR_CTRL 6
39#define UNFLW_CTRL 8
40#define OVFLW_CTRL 10
41
42#define EPIN_EN(_opts) ((_opts)->p_chmask != 0)
43#define EPOUT_EN(_opts) ((_opts)->c_chmask != 0)
44
45struct f_uac2 {
46 struct g_audio g_audio;
47 u8 ac_intf, as_in_intf, as_out_intf;
48 u8 ac_alt, as_in_alt, as_out_alt;
49};
50
51static inline struct f_uac2 *func_to_uac2(struct usb_function *f)
52{
53 return container_of(f, struct f_uac2, g_audio.func);
54}
55
56static inline
57struct f_uac2_opts *g_audio_to_uac2_opts(struct g_audio *agdev)
58{
59 return container_of(agdev->func.fi, struct f_uac2_opts, func_inst);
60}
61
62
63
64enum {
65 STR_ASSOC,
66 STR_IF_CTRL,
67 STR_CLKSRC_IN,
68 STR_CLKSRC_OUT,
69 STR_USB_IT,
70 STR_IO_IT,
71 STR_USB_OT,
72 STR_IO_OT,
73 STR_AS_OUT_ALT0,
74 STR_AS_OUT_ALT1,
75 STR_AS_IN_ALT0,
76 STR_AS_IN_ALT1,
77};
78
79static char clksrc_in[8];
80static char clksrc_out[8];
81
82static struct usb_string strings_fn[] = {
83 [STR_ASSOC].s = "Source/Sink",
84 [STR_IF_CTRL].s = "Topology Control",
85 [STR_CLKSRC_IN].s = clksrc_in,
86 [STR_CLKSRC_OUT].s = clksrc_out,
87 [STR_USB_IT].s = "USBH Out",
88 [STR_IO_IT].s = "USBD Out",
89 [STR_USB_OT].s = "USBH In",
90 [STR_IO_OT].s = "USBD In",
91 [STR_AS_OUT_ALT0].s = "Playback Inactive",
92 [STR_AS_OUT_ALT1].s = "Playback Active",
93 [STR_AS_IN_ALT0].s = "Capture Inactive",
94 [STR_AS_IN_ALT1].s = "Capture Active",
95 { },
96};
97
98static struct usb_gadget_strings str_fn = {
99 .language = 0x0409,
100 .strings = strings_fn,
101};
102
103static struct usb_gadget_strings *fn_strings[] = {
104 &str_fn,
105 NULL,
106};
107
108static struct usb_interface_assoc_descriptor iad_desc = {
109 .bLength = sizeof iad_desc,
110 .bDescriptorType = USB_DT_INTERFACE_ASSOCIATION,
111
112 .bFirstInterface = 0,
113 .bInterfaceCount = 3,
114 .bFunctionClass = USB_CLASS_AUDIO,
115 .bFunctionSubClass = UAC2_FUNCTION_SUBCLASS_UNDEFINED,
116 .bFunctionProtocol = UAC_VERSION_2,
117};
118
119
120static struct usb_interface_descriptor std_ac_if_desc = {
121 .bLength = sizeof std_ac_if_desc,
122 .bDescriptorType = USB_DT_INTERFACE,
123
124 .bAlternateSetting = 0,
125 .bNumEndpoints = 0,
126 .bInterfaceClass = USB_CLASS_AUDIO,
127 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
128 .bInterfaceProtocol = UAC_VERSION_2,
129};
130
131
132static struct uac_clock_source_descriptor in_clk_src_desc = {
133 .bLength = sizeof in_clk_src_desc,
134 .bDescriptorType = USB_DT_CS_INTERFACE,
135
136 .bDescriptorSubtype = UAC2_CLOCK_SOURCE,
137
138 .bmAttributes = UAC_CLOCK_SOURCE_TYPE_INT_FIXED,
139 .bmControls = (CONTROL_RDONLY << CLK_FREQ_CTRL),
140 .bAssocTerminal = 0,
141};
142
143
144static struct uac_clock_source_descriptor out_clk_src_desc = {
145 .bLength = sizeof out_clk_src_desc,
146 .bDescriptorType = USB_DT_CS_INTERFACE,
147
148 .bDescriptorSubtype = UAC2_CLOCK_SOURCE,
149
150 .bmAttributes = UAC_CLOCK_SOURCE_TYPE_INT_FIXED,
151 .bmControls = (CONTROL_RDONLY << CLK_FREQ_CTRL),
152 .bAssocTerminal = 0,
153};
154
155
156static struct uac2_input_terminal_descriptor usb_out_it_desc = {
157 .bLength = sizeof usb_out_it_desc,
158 .bDescriptorType = USB_DT_CS_INTERFACE,
159
160 .bDescriptorSubtype = UAC_INPUT_TERMINAL,
161
162 .wTerminalType = cpu_to_le16(UAC_TERMINAL_STREAMING),
163 .bAssocTerminal = 0,
164
165 .iChannelNames = 0,
166 .bmControls = cpu_to_le16(CONTROL_RDWR << COPY_CTRL),
167};
168
169
170static struct uac2_input_terminal_descriptor io_in_it_desc = {
171 .bLength = sizeof io_in_it_desc,
172 .bDescriptorType = USB_DT_CS_INTERFACE,
173
174 .bDescriptorSubtype = UAC_INPUT_TERMINAL,
175
176 .wTerminalType = cpu_to_le16(UAC_INPUT_TERMINAL_UNDEFINED),
177 .bAssocTerminal = 0,
178
179 .iChannelNames = 0,
180 .bmControls = cpu_to_le16(CONTROL_RDWR << COPY_CTRL),
181};
182
183
184static struct uac2_output_terminal_descriptor usb_in_ot_desc = {
185 .bLength = sizeof usb_in_ot_desc,
186 .bDescriptorType = USB_DT_CS_INTERFACE,
187
188 .bDescriptorSubtype = UAC_OUTPUT_TERMINAL,
189
190 .wTerminalType = cpu_to_le16(UAC_TERMINAL_STREAMING),
191 .bAssocTerminal = 0,
192
193
194 .bmControls = cpu_to_le16(CONTROL_RDWR << COPY_CTRL),
195};
196
197
198static struct uac2_output_terminal_descriptor io_out_ot_desc = {
199 .bLength = sizeof io_out_ot_desc,
200 .bDescriptorType = USB_DT_CS_INTERFACE,
201
202 .bDescriptorSubtype = UAC_OUTPUT_TERMINAL,
203
204 .wTerminalType = cpu_to_le16(UAC_OUTPUT_TERMINAL_UNDEFINED),
205 .bAssocTerminal = 0,
206
207
208 .bmControls = cpu_to_le16(CONTROL_RDWR << COPY_CTRL),
209};
210
211static struct uac2_ac_header_descriptor ac_hdr_desc = {
212 .bLength = sizeof ac_hdr_desc,
213 .bDescriptorType = USB_DT_CS_INTERFACE,
214
215 .bDescriptorSubtype = UAC_MS_HEADER,
216 .bcdADC = cpu_to_le16(0x200),
217 .bCategory = UAC2_FUNCTION_IO_BOX,
218
219 .bmControls = 0,
220};
221
222
223static struct usb_interface_descriptor std_as_out_if0_desc = {
224 .bLength = sizeof std_as_out_if0_desc,
225 .bDescriptorType = USB_DT_INTERFACE,
226
227 .bAlternateSetting = 0,
228 .bNumEndpoints = 0,
229 .bInterfaceClass = USB_CLASS_AUDIO,
230 .bInterfaceSubClass = USB_SUBCLASS_AUDIOSTREAMING,
231 .bInterfaceProtocol = UAC_VERSION_2,
232};
233
234
235static struct usb_interface_descriptor std_as_out_if1_desc = {
236 .bLength = sizeof std_as_out_if1_desc,
237 .bDescriptorType = USB_DT_INTERFACE,
238
239 .bAlternateSetting = 1,
240 .bNumEndpoints = 1,
241 .bInterfaceClass = USB_CLASS_AUDIO,
242 .bInterfaceSubClass = USB_SUBCLASS_AUDIOSTREAMING,
243 .bInterfaceProtocol = UAC_VERSION_2,
244};
245
246
247static struct uac2_as_header_descriptor as_out_hdr_desc = {
248 .bLength = sizeof as_out_hdr_desc,
249 .bDescriptorType = USB_DT_CS_INTERFACE,
250
251 .bDescriptorSubtype = UAC_AS_GENERAL,
252
253 .bmControls = 0,
254 .bFormatType = UAC_FORMAT_TYPE_I,
255 .bmFormats = cpu_to_le32(UAC_FORMAT_TYPE_I_PCM),
256 .iChannelNames = 0,
257};
258
259
260static struct uac2_format_type_i_descriptor as_out_fmt1_desc = {
261 .bLength = sizeof as_out_fmt1_desc,
262 .bDescriptorType = USB_DT_CS_INTERFACE,
263 .bDescriptorSubtype = UAC_FORMAT_TYPE,
264 .bFormatType = UAC_FORMAT_TYPE_I,
265};
266
267
268static struct usb_endpoint_descriptor fs_epout_desc = {
269 .bLength = USB_DT_ENDPOINT_SIZE,
270 .bDescriptorType = USB_DT_ENDPOINT,
271
272 .bEndpointAddress = USB_DIR_OUT,
273 .bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC,
274 .wMaxPacketSize = cpu_to_le16(1023),
275 .bInterval = 1,
276};
277
278static struct usb_endpoint_descriptor hs_epout_desc = {
279 .bLength = USB_DT_ENDPOINT_SIZE,
280 .bDescriptorType = USB_DT_ENDPOINT,
281
282 .bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC,
283 .wMaxPacketSize = cpu_to_le16(1024),
284 .bInterval = 4,
285};
286
287
288static struct uac2_iso_endpoint_descriptor as_iso_out_desc = {
289 .bLength = sizeof as_iso_out_desc,
290 .bDescriptorType = USB_DT_CS_ENDPOINT,
291
292 .bDescriptorSubtype = UAC_EP_GENERAL,
293 .bmAttributes = 0,
294 .bmControls = 0,
295 .bLockDelayUnits = 0,
296 .wLockDelay = 0,
297};
298
299
300static struct usb_interface_descriptor std_as_in_if0_desc = {
301 .bLength = sizeof std_as_in_if0_desc,
302 .bDescriptorType = USB_DT_INTERFACE,
303
304 .bAlternateSetting = 0,
305 .bNumEndpoints = 0,
306 .bInterfaceClass = USB_CLASS_AUDIO,
307 .bInterfaceSubClass = USB_SUBCLASS_AUDIOSTREAMING,
308 .bInterfaceProtocol = UAC_VERSION_2,
309};
310
311
312static struct usb_interface_descriptor std_as_in_if1_desc = {
313 .bLength = sizeof std_as_in_if1_desc,
314 .bDescriptorType = USB_DT_INTERFACE,
315
316 .bAlternateSetting = 1,
317 .bNumEndpoints = 1,
318 .bInterfaceClass = USB_CLASS_AUDIO,
319 .bInterfaceSubClass = USB_SUBCLASS_AUDIOSTREAMING,
320 .bInterfaceProtocol = UAC_VERSION_2,
321};
322
323
324static struct uac2_as_header_descriptor as_in_hdr_desc = {
325 .bLength = sizeof as_in_hdr_desc,
326 .bDescriptorType = USB_DT_CS_INTERFACE,
327
328 .bDescriptorSubtype = UAC_AS_GENERAL,
329
330 .bmControls = 0,
331 .bFormatType = UAC_FORMAT_TYPE_I,
332 .bmFormats = cpu_to_le32(UAC_FORMAT_TYPE_I_PCM),
333 .iChannelNames = 0,
334};
335
336
337static struct uac2_format_type_i_descriptor as_in_fmt1_desc = {
338 .bLength = sizeof as_in_fmt1_desc,
339 .bDescriptorType = USB_DT_CS_INTERFACE,
340 .bDescriptorSubtype = UAC_FORMAT_TYPE,
341 .bFormatType = UAC_FORMAT_TYPE_I,
342};
343
344
345static struct usb_endpoint_descriptor fs_epin_desc = {
346 .bLength = USB_DT_ENDPOINT_SIZE,
347 .bDescriptorType = USB_DT_ENDPOINT,
348
349 .bEndpointAddress = USB_DIR_IN,
350 .bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC,
351 .wMaxPacketSize = cpu_to_le16(1023),
352 .bInterval = 1,
353};
354
355static struct usb_endpoint_descriptor hs_epin_desc = {
356 .bLength = USB_DT_ENDPOINT_SIZE,
357 .bDescriptorType = USB_DT_ENDPOINT,
358
359 .bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC,
360 .wMaxPacketSize = cpu_to_le16(1024),
361 .bInterval = 4,
362};
363
364
365static struct uac2_iso_endpoint_descriptor as_iso_in_desc = {
366 .bLength = sizeof as_iso_in_desc,
367 .bDescriptorType = USB_DT_CS_ENDPOINT,
368
369 .bDescriptorSubtype = UAC_EP_GENERAL,
370 .bmAttributes = 0,
371 .bmControls = 0,
372 .bLockDelayUnits = 0,
373 .wLockDelay = 0,
374};
375
376static struct usb_descriptor_header *fs_audio_desc[] = {
377 (struct usb_descriptor_header *)&iad_desc,
378 (struct usb_descriptor_header *)&std_ac_if_desc,
379
380 (struct usb_descriptor_header *)&ac_hdr_desc,
381 (struct usb_descriptor_header *)&in_clk_src_desc,
382 (struct usb_descriptor_header *)&out_clk_src_desc,
383 (struct usb_descriptor_header *)&usb_out_it_desc,
384 (struct usb_descriptor_header *)&io_in_it_desc,
385 (struct usb_descriptor_header *)&usb_in_ot_desc,
386 (struct usb_descriptor_header *)&io_out_ot_desc,
387
388 (struct usb_descriptor_header *)&std_as_out_if0_desc,
389 (struct usb_descriptor_header *)&std_as_out_if1_desc,
390
391 (struct usb_descriptor_header *)&as_out_hdr_desc,
392 (struct usb_descriptor_header *)&as_out_fmt1_desc,
393 (struct usb_descriptor_header *)&fs_epout_desc,
394 (struct usb_descriptor_header *)&as_iso_out_desc,
395
396 (struct usb_descriptor_header *)&std_as_in_if0_desc,
397 (struct usb_descriptor_header *)&std_as_in_if1_desc,
398
399 (struct usb_descriptor_header *)&as_in_hdr_desc,
400 (struct usb_descriptor_header *)&as_in_fmt1_desc,
401 (struct usb_descriptor_header *)&fs_epin_desc,
402 (struct usb_descriptor_header *)&as_iso_in_desc,
403 NULL,
404};
405
406static struct usb_descriptor_header *hs_audio_desc[] = {
407 (struct usb_descriptor_header *)&iad_desc,
408 (struct usb_descriptor_header *)&std_ac_if_desc,
409
410 (struct usb_descriptor_header *)&ac_hdr_desc,
411 (struct usb_descriptor_header *)&in_clk_src_desc,
412 (struct usb_descriptor_header *)&out_clk_src_desc,
413 (struct usb_descriptor_header *)&usb_out_it_desc,
414 (struct usb_descriptor_header *)&io_in_it_desc,
415 (struct usb_descriptor_header *)&usb_in_ot_desc,
416 (struct usb_descriptor_header *)&io_out_ot_desc,
417
418 (struct usb_descriptor_header *)&std_as_out_if0_desc,
419 (struct usb_descriptor_header *)&std_as_out_if1_desc,
420
421 (struct usb_descriptor_header *)&as_out_hdr_desc,
422 (struct usb_descriptor_header *)&as_out_fmt1_desc,
423 (struct usb_descriptor_header *)&hs_epout_desc,
424 (struct usb_descriptor_header *)&as_iso_out_desc,
425
426 (struct usb_descriptor_header *)&std_as_in_if0_desc,
427 (struct usb_descriptor_header *)&std_as_in_if1_desc,
428
429 (struct usb_descriptor_header *)&as_in_hdr_desc,
430 (struct usb_descriptor_header *)&as_in_fmt1_desc,
431 (struct usb_descriptor_header *)&hs_epin_desc,
432 (struct usb_descriptor_header *)&as_iso_in_desc,
433 NULL,
434};
435
436struct cntrl_cur_lay3 {
437 __le32 dCUR;
438};
439
440struct cntrl_range_lay3 {
441 __le16 wNumSubRanges;
442 __le32 dMIN;
443 __le32 dMAX;
444 __le32 dRES;
445} __packed;
446
447static void set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
448 struct usb_endpoint_descriptor *ep_desc,
449 unsigned int factor, bool is_playback)
450{
451 int chmask, srate, ssize;
452 u16 max_packet_size;
453
454 if (is_playback) {
455 chmask = uac2_opts->p_chmask;
456 srate = uac2_opts->p_srate;
457 ssize = uac2_opts->p_ssize;
458 } else {
459 chmask = uac2_opts->c_chmask;
460 srate = uac2_opts->c_srate;
461 ssize = uac2_opts->c_ssize;
462 }
463
464 max_packet_size = num_channels(chmask) * ssize *
465 DIV_ROUND_UP(srate, factor / (1 << (ep_desc->bInterval - 1)));
466 ep_desc->wMaxPacketSize = cpu_to_le16(min_t(u16, max_packet_size,
467 le16_to_cpu(ep_desc->wMaxPacketSize)));
468}
469
470
471#define USBDHDR(p) (struct usb_descriptor_header *)(p)
472
473static void setup_descriptor(struct f_uac2_opts *opts)
474{
475
476 int i = 1;
477
478 if (EPOUT_EN(opts))
479 usb_out_it_desc.bTerminalID = i++;
480 if (EPIN_EN(opts))
481 io_in_it_desc.bTerminalID = i++;
482 if (EPOUT_EN(opts))
483 io_out_ot_desc.bTerminalID = i++;
484 if (EPIN_EN(opts))
485 usb_in_ot_desc.bTerminalID = i++;
486 if (EPOUT_EN(opts))
487 out_clk_src_desc.bClockID = i++;
488 if (EPIN_EN(opts))
489 in_clk_src_desc.bClockID = i++;
490
491 usb_out_it_desc.bCSourceID = out_clk_src_desc.bClockID;
492 usb_in_ot_desc.bSourceID = io_in_it_desc.bTerminalID;
493 usb_in_ot_desc.bCSourceID = in_clk_src_desc.bClockID;
494 io_in_it_desc.bCSourceID = in_clk_src_desc.bClockID;
495 io_out_ot_desc.bCSourceID = out_clk_src_desc.bClockID;
496 io_out_ot_desc.bSourceID = usb_out_it_desc.bTerminalID;
497 as_out_hdr_desc.bTerminalLink = usb_out_it_desc.bTerminalID;
498 as_in_hdr_desc.bTerminalLink = usb_in_ot_desc.bTerminalID;
499
500 iad_desc.bInterfaceCount = 1;
501 ac_hdr_desc.wTotalLength = cpu_to_le16(sizeof(ac_hdr_desc));
502
503 if (EPIN_EN(opts)) {
504 u16 len = le16_to_cpu(ac_hdr_desc.wTotalLength);
505
506 len += sizeof(in_clk_src_desc);
507 len += sizeof(usb_in_ot_desc);
508 len += sizeof(io_in_it_desc);
509 ac_hdr_desc.wTotalLength = cpu_to_le16(len);
510 iad_desc.bInterfaceCount++;
511 }
512 if (EPOUT_EN(opts)) {
513 u16 len = le16_to_cpu(ac_hdr_desc.wTotalLength);
514
515 len += sizeof(out_clk_src_desc);
516 len += sizeof(usb_out_it_desc);
517 len += sizeof(io_out_ot_desc);
518 ac_hdr_desc.wTotalLength = cpu_to_le16(len);
519 iad_desc.bInterfaceCount++;
520 }
521
522 i = 0;
523 fs_audio_desc[i++] = USBDHDR(&iad_desc);
524 fs_audio_desc[i++] = USBDHDR(&std_ac_if_desc);
525 fs_audio_desc[i++] = USBDHDR(&ac_hdr_desc);
526 if (EPIN_EN(opts))
527 fs_audio_desc[i++] = USBDHDR(&in_clk_src_desc);
528 if (EPOUT_EN(opts)) {
529 fs_audio_desc[i++] = USBDHDR(&out_clk_src_desc);
530 fs_audio_desc[i++] = USBDHDR(&usb_out_it_desc);
531 }
532 if (EPIN_EN(opts)) {
533 fs_audio_desc[i++] = USBDHDR(&io_in_it_desc);
534 fs_audio_desc[i++] = USBDHDR(&usb_in_ot_desc);
535 }
536 if (EPOUT_EN(opts)) {
537 fs_audio_desc[i++] = USBDHDR(&io_out_ot_desc);
538 fs_audio_desc[i++] = USBDHDR(&std_as_out_if0_desc);
539 fs_audio_desc[i++] = USBDHDR(&std_as_out_if1_desc);
540 fs_audio_desc[i++] = USBDHDR(&as_out_hdr_desc);
541 fs_audio_desc[i++] = USBDHDR(&as_out_fmt1_desc);
542 fs_audio_desc[i++] = USBDHDR(&fs_epout_desc);
543 fs_audio_desc[i++] = USBDHDR(&as_iso_out_desc);
544 }
545 if (EPIN_EN(opts)) {
546 fs_audio_desc[i++] = USBDHDR(&std_as_in_if0_desc);
547 fs_audio_desc[i++] = USBDHDR(&std_as_in_if1_desc);
548 fs_audio_desc[i++] = USBDHDR(&as_in_hdr_desc);
549 fs_audio_desc[i++] = USBDHDR(&as_in_fmt1_desc);
550 fs_audio_desc[i++] = USBDHDR(&fs_epin_desc);
551 fs_audio_desc[i++] = USBDHDR(&as_iso_in_desc);
552 }
553 fs_audio_desc[i] = NULL;
554
555 i = 0;
556 hs_audio_desc[i++] = USBDHDR(&iad_desc);
557 hs_audio_desc[i++] = USBDHDR(&std_ac_if_desc);
558 hs_audio_desc[i++] = USBDHDR(&ac_hdr_desc);
559 if (EPIN_EN(opts))
560 hs_audio_desc[i++] = USBDHDR(&in_clk_src_desc);
561 if (EPOUT_EN(opts)) {
562 hs_audio_desc[i++] = USBDHDR(&out_clk_src_desc);
563 hs_audio_desc[i++] = USBDHDR(&usb_out_it_desc);
564 }
565 if (EPIN_EN(opts)) {
566 hs_audio_desc[i++] = USBDHDR(&io_in_it_desc);
567 hs_audio_desc[i++] = USBDHDR(&usb_in_ot_desc);
568 }
569 if (EPOUT_EN(opts)) {
570 hs_audio_desc[i++] = USBDHDR(&io_out_ot_desc);
571 hs_audio_desc[i++] = USBDHDR(&std_as_out_if0_desc);
572 hs_audio_desc[i++] = USBDHDR(&std_as_out_if1_desc);
573 hs_audio_desc[i++] = USBDHDR(&as_out_hdr_desc);
574 hs_audio_desc[i++] = USBDHDR(&as_out_fmt1_desc);
575 hs_audio_desc[i++] = USBDHDR(&hs_epout_desc);
576 hs_audio_desc[i++] = USBDHDR(&as_iso_out_desc);
577 }
578 if (EPIN_EN(opts)) {
579 hs_audio_desc[i++] = USBDHDR(&std_as_in_if0_desc);
580 hs_audio_desc[i++] = USBDHDR(&std_as_in_if1_desc);
581 hs_audio_desc[i++] = USBDHDR(&as_in_hdr_desc);
582 hs_audio_desc[i++] = USBDHDR(&as_in_fmt1_desc);
583 hs_audio_desc[i++] = USBDHDR(&hs_epin_desc);
584 hs_audio_desc[i++] = USBDHDR(&as_iso_in_desc);
585 }
586 hs_audio_desc[i] = NULL;
587}
588
589static int
590afunc_bind(struct usb_configuration *cfg, struct usb_function *fn)
591{
592 struct f_uac2 *uac2 = func_to_uac2(fn);
593 struct g_audio *agdev = func_to_g_audio(fn);
594 struct usb_composite_dev *cdev = cfg->cdev;
595 struct usb_gadget *gadget = cdev->gadget;
596 struct device *dev = &gadget->dev;
597 struct f_uac2_opts *uac2_opts;
598 struct usb_string *us;
599 int ret;
600
601 uac2_opts = container_of(fn->fi, struct f_uac2_opts, func_inst);
602
603 us = usb_gstrings_attach(cdev, fn_strings, ARRAY_SIZE(strings_fn));
604 if (IS_ERR(us))
605 return PTR_ERR(us);
606 iad_desc.iFunction = us[STR_ASSOC].id;
607 std_ac_if_desc.iInterface = us[STR_IF_CTRL].id;
608 in_clk_src_desc.iClockSource = us[STR_CLKSRC_IN].id;
609 out_clk_src_desc.iClockSource = us[STR_CLKSRC_OUT].id;
610 usb_out_it_desc.iTerminal = us[STR_USB_IT].id;
611 io_in_it_desc.iTerminal = us[STR_IO_IT].id;
612 usb_in_ot_desc.iTerminal = us[STR_USB_OT].id;
613 io_out_ot_desc.iTerminal = us[STR_IO_OT].id;
614 std_as_out_if0_desc.iInterface = us[STR_AS_OUT_ALT0].id;
615 std_as_out_if1_desc.iInterface = us[STR_AS_OUT_ALT1].id;
616 std_as_in_if0_desc.iInterface = us[STR_AS_IN_ALT0].id;
617 std_as_in_if1_desc.iInterface = us[STR_AS_IN_ALT1].id;
618
619
620
621 usb_out_it_desc.bNrChannels = num_channels(uac2_opts->c_chmask);
622 usb_out_it_desc.bmChannelConfig = cpu_to_le32(uac2_opts->c_chmask);
623 io_in_it_desc.bNrChannels = num_channels(uac2_opts->p_chmask);
624 io_in_it_desc.bmChannelConfig = cpu_to_le32(uac2_opts->p_chmask);
625 as_out_hdr_desc.bNrChannels = num_channels(uac2_opts->c_chmask);
626 as_out_hdr_desc.bmChannelConfig = cpu_to_le32(uac2_opts->c_chmask);
627 as_in_hdr_desc.bNrChannels = num_channels(uac2_opts->p_chmask);
628 as_in_hdr_desc.bmChannelConfig = cpu_to_le32(uac2_opts->p_chmask);
629 as_out_fmt1_desc.bSubslotSize = uac2_opts->c_ssize;
630 as_out_fmt1_desc.bBitResolution = uac2_opts->c_ssize * 8;
631 as_in_fmt1_desc.bSubslotSize = uac2_opts->p_ssize;
632 as_in_fmt1_desc.bBitResolution = uac2_opts->p_ssize * 8;
633
634 snprintf(clksrc_in, sizeof(clksrc_in), "%uHz", uac2_opts->p_srate);
635 snprintf(clksrc_out, sizeof(clksrc_out), "%uHz", uac2_opts->c_srate);
636
637 ret = usb_interface_id(cfg, fn);
638 if (ret < 0) {
639 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
640 return ret;
641 }
642 iad_desc.bFirstInterface = ret;
643
644 std_ac_if_desc.bInterfaceNumber = ret;
645 uac2->ac_intf = ret;
646 uac2->ac_alt = 0;
647
648 if (EPOUT_EN(uac2_opts)) {
649 ret = usb_interface_id(cfg, fn);
650 if (ret < 0) {
651 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
652 return ret;
653 }
654 std_as_out_if0_desc.bInterfaceNumber = ret;
655 std_as_out_if1_desc.bInterfaceNumber = ret;
656 uac2->as_out_intf = ret;
657 uac2->as_out_alt = 0;
658 }
659
660 if (EPIN_EN(uac2_opts)) {
661 ret = usb_interface_id(cfg, fn);
662 if (ret < 0) {
663 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
664 return ret;
665 }
666 std_as_in_if0_desc.bInterfaceNumber = ret;
667 std_as_in_if1_desc.bInterfaceNumber = ret;
668 uac2->as_in_intf = ret;
669 uac2->as_in_alt = 0;
670 }
671
672
673 set_ep_max_packet_size(uac2_opts, &fs_epin_desc, 1000, true);
674 set_ep_max_packet_size(uac2_opts, &fs_epout_desc, 1000, false);
675 set_ep_max_packet_size(uac2_opts, &hs_epin_desc, 8000, true);
676 set_ep_max_packet_size(uac2_opts, &hs_epout_desc, 8000, false);
677
678 if (EPOUT_EN(uac2_opts)) {
679 agdev->out_ep = usb_ep_autoconfig(gadget, &fs_epout_desc);
680 if (!agdev->out_ep) {
681 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
682 return -ENODEV;
683 }
684 }
685
686 if (EPIN_EN(uac2_opts)) {
687 agdev->in_ep = usb_ep_autoconfig(gadget, &fs_epin_desc);
688 if (!agdev->in_ep) {
689 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
690 return -ENODEV;
691 }
692 }
693
694 agdev->in_ep_maxpsize = max_t(u16,
695 le16_to_cpu(fs_epin_desc.wMaxPacketSize),
696 le16_to_cpu(hs_epin_desc.wMaxPacketSize));
697 agdev->out_ep_maxpsize = max_t(u16,
698 le16_to_cpu(fs_epout_desc.wMaxPacketSize),
699 le16_to_cpu(hs_epout_desc.wMaxPacketSize));
700
701 hs_epout_desc.bEndpointAddress = fs_epout_desc.bEndpointAddress;
702 hs_epin_desc.bEndpointAddress = fs_epin_desc.bEndpointAddress;
703
704 setup_descriptor(uac2_opts);
705
706 ret = usb_assign_descriptors(fn, fs_audio_desc, hs_audio_desc, NULL,
707 NULL);
708 if (ret)
709 return ret;
710
711 agdev->gadget = gadget;
712
713 agdev->params.p_chmask = uac2_opts->p_chmask;
714 agdev->params.p_srate = uac2_opts->p_srate;
715 agdev->params.p_ssize = uac2_opts->p_ssize;
716 agdev->params.c_chmask = uac2_opts->c_chmask;
717 agdev->params.c_srate = uac2_opts->c_srate;
718 agdev->params.c_ssize = uac2_opts->c_ssize;
719 agdev->params.req_number = uac2_opts->req_number;
720 ret = g_audio_setup(agdev, "UAC2 PCM", "UAC2_Gadget");
721 if (ret)
722 goto err_free_descs;
723 return 0;
724
725err_free_descs:
726 usb_free_all_descriptors(fn);
727 agdev->gadget = NULL;
728 return ret;
729}
730
731static int
732afunc_set_alt(struct usb_function *fn, unsigned intf, unsigned alt)
733{
734 struct usb_composite_dev *cdev = fn->config->cdev;
735 struct f_uac2 *uac2 = func_to_uac2(fn);
736 struct usb_gadget *gadget = cdev->gadget;
737 struct device *dev = &gadget->dev;
738 int ret = 0;
739
740
741 if (alt > 1) {
742 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
743 return -EINVAL;
744 }
745
746 if (intf == uac2->ac_intf) {
747
748 if (alt) {
749 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
750 return -EINVAL;
751 }
752 return 0;
753 }
754
755 if (intf == uac2->as_out_intf) {
756 uac2->as_out_alt = alt;
757
758 if (alt)
759 ret = u_audio_start_capture(&uac2->g_audio);
760 else
761 u_audio_stop_capture(&uac2->g_audio);
762 } else if (intf == uac2->as_in_intf) {
763 uac2->as_in_alt = alt;
764
765 if (alt)
766 ret = u_audio_start_playback(&uac2->g_audio);
767 else
768 u_audio_stop_playback(&uac2->g_audio);
769 } else {
770 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
771 return -EINVAL;
772 }
773
774 return ret;
775}
776
777static int
778afunc_get_alt(struct usb_function *fn, unsigned intf)
779{
780 struct f_uac2 *uac2 = func_to_uac2(fn);
781 struct g_audio *agdev = func_to_g_audio(fn);
782
783 if (intf == uac2->ac_intf)
784 return uac2->ac_alt;
785 else if (intf == uac2->as_out_intf)
786 return uac2->as_out_alt;
787 else if (intf == uac2->as_in_intf)
788 return uac2->as_in_alt;
789 else
790 dev_err(&agdev->gadget->dev,
791 "%s:%d Invalid Interface %d!\n",
792 __func__, __LINE__, intf);
793
794 return -EINVAL;
795}
796
797static void
798afunc_disable(struct usb_function *fn)
799{
800 struct f_uac2 *uac2 = func_to_uac2(fn);
801
802 uac2->as_in_alt = 0;
803 uac2->as_out_alt = 0;
804 u_audio_stop_capture(&uac2->g_audio);
805 u_audio_stop_playback(&uac2->g_audio);
806}
807
808static int
809in_rq_cur(struct usb_function *fn, const struct usb_ctrlrequest *cr)
810{
811 struct usb_request *req = fn->config->cdev->req;
812 struct g_audio *agdev = func_to_g_audio(fn);
813 struct f_uac2_opts *opts;
814 u16 w_length = le16_to_cpu(cr->wLength);
815 u16 w_index = le16_to_cpu(cr->wIndex);
816 u16 w_value = le16_to_cpu(cr->wValue);
817 u8 entity_id = (w_index >> 8) & 0xff;
818 u8 control_selector = w_value >> 8;
819 int value = -EOPNOTSUPP;
820 int p_srate, c_srate;
821
822 opts = g_audio_to_uac2_opts(agdev);
823 p_srate = opts->p_srate;
824 c_srate = opts->c_srate;
825
826 if (control_selector == UAC2_CS_CONTROL_SAM_FREQ) {
827 struct cntrl_cur_lay3 c;
828 memset(&c, 0, sizeof(struct cntrl_cur_lay3));
829
830 if (entity_id == USB_IN_CLK_ID)
831 c.dCUR = cpu_to_le32(p_srate);
832 else if (entity_id == USB_OUT_CLK_ID)
833 c.dCUR = cpu_to_le32(c_srate);
834
835 value = min_t(unsigned, w_length, sizeof c);
836 memcpy(req->buf, &c, value);
837 } else if (control_selector == UAC2_CS_CONTROL_CLOCK_VALID) {
838 *(u8 *)req->buf = 1;
839 value = min_t(unsigned, w_length, 1);
840 } else {
841 dev_err(&agdev->gadget->dev,
842 "%s:%d control_selector=%d TODO!\n",
843 __func__, __LINE__, control_selector);
844 }
845
846 return value;
847}
848
849static int
850in_rq_range(struct usb_function *fn, const struct usb_ctrlrequest *cr)
851{
852 struct usb_request *req = fn->config->cdev->req;
853 struct g_audio *agdev = func_to_g_audio(fn);
854 struct f_uac2_opts *opts;
855 u16 w_length = le16_to_cpu(cr->wLength);
856 u16 w_index = le16_to_cpu(cr->wIndex);
857 u16 w_value = le16_to_cpu(cr->wValue);
858 u8 entity_id = (w_index >> 8) & 0xff;
859 u8 control_selector = w_value >> 8;
860 struct cntrl_range_lay3 r;
861 int value = -EOPNOTSUPP;
862 int p_srate, c_srate;
863
864 opts = g_audio_to_uac2_opts(agdev);
865 p_srate = opts->p_srate;
866 c_srate = opts->c_srate;
867
868 if (control_selector == UAC2_CS_CONTROL_SAM_FREQ) {
869 if (entity_id == USB_IN_CLK_ID)
870 r.dMIN = cpu_to_le32(p_srate);
871 else if (entity_id == USB_OUT_CLK_ID)
872 r.dMIN = cpu_to_le32(c_srate);
873 else
874 return -EOPNOTSUPP;
875
876 r.dMAX = r.dMIN;
877 r.dRES = 0;
878 r.wNumSubRanges = cpu_to_le16(1);
879
880 value = min_t(unsigned, w_length, sizeof r);
881 memcpy(req->buf, &r, value);
882 } else {
883 dev_err(&agdev->gadget->dev,
884 "%s:%d control_selector=%d TODO!\n",
885 __func__, __LINE__, control_selector);
886 }
887
888 return value;
889}
890
891static int
892ac_rq_in(struct usb_function *fn, const struct usb_ctrlrequest *cr)
893{
894 if (cr->bRequest == UAC2_CS_CUR)
895 return in_rq_cur(fn, cr);
896 else if (cr->bRequest == UAC2_CS_RANGE)
897 return in_rq_range(fn, cr);
898 else
899 return -EOPNOTSUPP;
900}
901
902static int
903out_rq_cur(struct usb_function *fn, const struct usb_ctrlrequest *cr)
904{
905 u16 w_length = le16_to_cpu(cr->wLength);
906 u16 w_value = le16_to_cpu(cr->wValue);
907 u8 control_selector = w_value >> 8;
908
909 if (control_selector == UAC2_CS_CONTROL_SAM_FREQ)
910 return w_length;
911
912 return -EOPNOTSUPP;
913}
914
915static int
916setup_rq_inf(struct usb_function *fn, const struct usb_ctrlrequest *cr)
917{
918 struct f_uac2 *uac2 = func_to_uac2(fn);
919 struct g_audio *agdev = func_to_g_audio(fn);
920 u16 w_index = le16_to_cpu(cr->wIndex);
921 u8 intf = w_index & 0xff;
922
923 if (intf != uac2->ac_intf) {
924 dev_err(&agdev->gadget->dev,
925 "%s:%d Error!\n", __func__, __LINE__);
926 return -EOPNOTSUPP;
927 }
928
929 if (cr->bRequestType & USB_DIR_IN)
930 return ac_rq_in(fn, cr);
931 else if (cr->bRequest == UAC2_CS_CUR)
932 return out_rq_cur(fn, cr);
933
934 return -EOPNOTSUPP;
935}
936
937static int
938afunc_setup(struct usb_function *fn, const struct usb_ctrlrequest *cr)
939{
940 struct usb_composite_dev *cdev = fn->config->cdev;
941 struct g_audio *agdev = func_to_g_audio(fn);
942 struct usb_request *req = cdev->req;
943 u16 w_length = le16_to_cpu(cr->wLength);
944 int value = -EOPNOTSUPP;
945
946
947 if ((cr->bRequestType & USB_TYPE_MASK) != USB_TYPE_CLASS)
948 return -EOPNOTSUPP;
949
950 if ((cr->bRequestType & USB_RECIP_MASK) == USB_RECIP_INTERFACE)
951 value = setup_rq_inf(fn, cr);
952 else
953 dev_err(&agdev->gadget->dev, "%s:%d Error!\n",
954 __func__, __LINE__);
955
956 if (value >= 0) {
957 req->length = value;
958 req->zero = value < w_length;
959 value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
960 if (value < 0) {
961 dev_err(&agdev->gadget->dev,
962 "%s:%d Error!\n", __func__, __LINE__);
963 req->status = 0;
964 }
965 }
966
967 return value;
968}
969
970static inline struct f_uac2_opts *to_f_uac2_opts(struct config_item *item)
971{
972 return container_of(to_config_group(item), struct f_uac2_opts,
973 func_inst.group);
974}
975
976static void f_uac2_attr_release(struct config_item *item)
977{
978 struct f_uac2_opts *opts = to_f_uac2_opts(item);
979
980 usb_put_function_instance(&opts->func_inst);
981}
982
983static struct configfs_item_operations f_uac2_item_ops = {
984 .release = f_uac2_attr_release,
985};
986
987#define UAC2_ATTRIBUTE(name) \
988static ssize_t f_uac2_opts_##name##_show(struct config_item *item, \
989 char *page) \
990{ \
991 struct f_uac2_opts *opts = to_f_uac2_opts(item); \
992 int result; \
993 \
994 mutex_lock(&opts->lock); \
995 result = sprintf(page, "%u\n", opts->name); \
996 mutex_unlock(&opts->lock); \
997 \
998 return result; \
999} \
1000 \
1001static ssize_t f_uac2_opts_##name##_store(struct config_item *item, \
1002 const char *page, size_t len) \
1003{ \
1004 struct f_uac2_opts *opts = to_f_uac2_opts(item); \
1005 int ret; \
1006 u32 num; \
1007 \
1008 mutex_lock(&opts->lock); \
1009 if (opts->refcnt) { \
1010 ret = -EBUSY; \
1011 goto end; \
1012 } \
1013 \
1014 ret = kstrtou32(page, 0, &num); \
1015 if (ret) \
1016 goto end; \
1017 \
1018 opts->name = num; \
1019 ret = len; \
1020 \
1021end: \
1022 mutex_unlock(&opts->lock); \
1023 return ret; \
1024} \
1025 \
1026CONFIGFS_ATTR(f_uac2_opts_, name)
1027
1028UAC2_ATTRIBUTE(p_chmask);
1029UAC2_ATTRIBUTE(p_srate);
1030UAC2_ATTRIBUTE(p_ssize);
1031UAC2_ATTRIBUTE(c_chmask);
1032UAC2_ATTRIBUTE(c_srate);
1033UAC2_ATTRIBUTE(c_ssize);
1034UAC2_ATTRIBUTE(req_number);
1035
1036static struct configfs_attribute *f_uac2_attrs[] = {
1037 &f_uac2_opts_attr_p_chmask,
1038 &f_uac2_opts_attr_p_srate,
1039 &f_uac2_opts_attr_p_ssize,
1040 &f_uac2_opts_attr_c_chmask,
1041 &f_uac2_opts_attr_c_srate,
1042 &f_uac2_opts_attr_c_ssize,
1043 &f_uac2_opts_attr_req_number,
1044 NULL,
1045};
1046
1047static const struct config_item_type f_uac2_func_type = {
1048 .ct_item_ops = &f_uac2_item_ops,
1049 .ct_attrs = f_uac2_attrs,
1050 .ct_owner = THIS_MODULE,
1051};
1052
1053static void afunc_free_inst(struct usb_function_instance *f)
1054{
1055 struct f_uac2_opts *opts;
1056
1057 opts = container_of(f, struct f_uac2_opts, func_inst);
1058 kfree(opts);
1059}
1060
1061static struct usb_function_instance *afunc_alloc_inst(void)
1062{
1063 struct f_uac2_opts *opts;
1064
1065 opts = kzalloc(sizeof(*opts), GFP_KERNEL);
1066 if (!opts)
1067 return ERR_PTR(-ENOMEM);
1068
1069 mutex_init(&opts->lock);
1070 opts->func_inst.free_func_inst = afunc_free_inst;
1071
1072 config_group_init_type_name(&opts->func_inst.group, "",
1073 &f_uac2_func_type);
1074
1075 opts->p_chmask = UAC2_DEF_PCHMASK;
1076 opts->p_srate = UAC2_DEF_PSRATE;
1077 opts->p_ssize = UAC2_DEF_PSSIZE;
1078 opts->c_chmask = UAC2_DEF_CCHMASK;
1079 opts->c_srate = UAC2_DEF_CSRATE;
1080 opts->c_ssize = UAC2_DEF_CSSIZE;
1081 opts->req_number = UAC2_DEF_REQ_NUM;
1082 return &opts->func_inst;
1083}
1084
1085static void afunc_free(struct usb_function *f)
1086{
1087 struct g_audio *agdev;
1088 struct f_uac2_opts *opts;
1089
1090 agdev = func_to_g_audio(f);
1091 opts = container_of(f->fi, struct f_uac2_opts, func_inst);
1092 kfree(agdev);
1093 mutex_lock(&opts->lock);
1094 --opts->refcnt;
1095 mutex_unlock(&opts->lock);
1096}
1097
1098static void afunc_unbind(struct usb_configuration *c, struct usb_function *f)
1099{
1100 struct g_audio *agdev = func_to_g_audio(f);
1101
1102 g_audio_cleanup(agdev);
1103 usb_free_all_descriptors(f);
1104
1105 agdev->gadget = NULL;
1106}
1107
1108static struct usb_function *afunc_alloc(struct usb_function_instance *fi)
1109{
1110 struct f_uac2 *uac2;
1111 struct f_uac2_opts *opts;
1112
1113 uac2 = kzalloc(sizeof(*uac2), GFP_KERNEL);
1114 if (uac2 == NULL)
1115 return ERR_PTR(-ENOMEM);
1116
1117 opts = container_of(fi, struct f_uac2_opts, func_inst);
1118 mutex_lock(&opts->lock);
1119 ++opts->refcnt;
1120 mutex_unlock(&opts->lock);
1121
1122 uac2->g_audio.func.name = "uac2_func";
1123 uac2->g_audio.func.bind = afunc_bind;
1124 uac2->g_audio.func.unbind = afunc_unbind;
1125 uac2->g_audio.func.set_alt = afunc_set_alt;
1126 uac2->g_audio.func.get_alt = afunc_get_alt;
1127 uac2->g_audio.func.disable = afunc_disable;
1128 uac2->g_audio.func.setup = afunc_setup;
1129 uac2->g_audio.func.free_func = afunc_free;
1130
1131 return &uac2->g_audio.func;
1132}
1133
1134DECLARE_USB_FUNCTION_INIT(uac2, afunc_alloc_inst, afunc_alloc);
1135MODULE_LICENSE("GPL");
1136MODULE_AUTHOR("Yadwinder Singh");
1137MODULE_AUTHOR("Jaswinder Singh");
1138
