GNU Linux-libre 4.19.207-gnu1
[releases.git] / drivers / usb / gadget / function / f_uac1.c
1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * f_uac1.c -- USB Audio Class 1.0 Function (using u_audio API)
4  *
5  * Copyright (C) 2016 Ruslan Bilovol <ruslan.bilovol@gmail.com>
6  *
7  * This driver doesn't expect any real Audio codec to be present
8  * on the device - the audio streams are simply sinked to and
9  * sourced from a virtual ALSA sound card created.
10  *
11  * This file is based on f_uac1.c which is
12  *   Copyright (C) 2008 Bryan Wu <cooloney@kernel.org>
13  *   Copyright (C) 2008 Analog Devices, Inc
14  */
15
16 #include <linux/usb/audio.h>
17 #include <linux/module.h>
18
19 #include "u_audio.h"
20 #include "u_uac1.h"
21
22 /* UAC1 spec: 3.7.2.3 Audio Channel Cluster Format */
23 #define UAC1_CHANNEL_MASK 0x0FFF
24
25 struct f_uac1 {
26         struct g_audio g_audio;
27         u8 ac_intf, as_in_intf, as_out_intf;
28         u8 ac_alt, as_in_alt, as_out_alt;       /* needed for get_alt() */
29 };
30
31 static inline struct f_uac1 *func_to_uac1(struct usb_function *f)
32 {
33         return container_of(f, struct f_uac1, g_audio.func);
34 }
35
36 static inline struct f_uac1_opts *g_audio_to_uac1_opts(struct g_audio *audio)
37 {
38         return container_of(audio->func.fi, struct f_uac1_opts, func_inst);
39 }
40
41 /*
42  * DESCRIPTORS ... most are static, but strings and full
43  * configuration descriptors are built on demand.
44  */
45
46 /*
47  * We have three interfaces - one AudioControl and two AudioStreaming
48  *
49  * The driver implements a simple UAC_1 topology.
50  * USB-OUT -> IT_1 -> OT_2 -> ALSA_Capture
51  * ALSA_Playback -> IT_3 -> OT_4 -> USB-IN
52  */
53 #define F_AUDIO_AC_INTERFACE            0
54 #define F_AUDIO_AS_OUT_INTERFACE        1
55 #define F_AUDIO_AS_IN_INTERFACE         2
56 /* Number of streaming interfaces */
57 #define F_AUDIO_NUM_INTERFACES          2
58
59 /* B.3.1  Standard AC Interface Descriptor */
60 static struct usb_interface_descriptor ac_interface_desc = {
61         .bLength =              USB_DT_INTERFACE_SIZE,
62         .bDescriptorType =      USB_DT_INTERFACE,
63         .bNumEndpoints =        0,
64         .bInterfaceClass =      USB_CLASS_AUDIO,
65         .bInterfaceSubClass =   USB_SUBCLASS_AUDIOCONTROL,
66 };
67
68 /*
69  * The number of AudioStreaming and MIDIStreaming interfaces
70  * in the Audio Interface Collection
71  */
72 DECLARE_UAC_AC_HEADER_DESCRIPTOR(2);
73
74 #define UAC_DT_AC_HEADER_LENGTH UAC_DT_AC_HEADER_SIZE(F_AUDIO_NUM_INTERFACES)
75 /* 2 input terminals and 2 output terminals */
76 #define UAC_DT_TOTAL_LENGTH (UAC_DT_AC_HEADER_LENGTH \
77         + 2*UAC_DT_INPUT_TERMINAL_SIZE + 2*UAC_DT_OUTPUT_TERMINAL_SIZE)
78 /* B.3.2  Class-Specific AC Interface Descriptor */
79 static struct uac1_ac_header_descriptor_2 ac_header_desc = {
80         .bLength =              UAC_DT_AC_HEADER_LENGTH,
81         .bDescriptorType =      USB_DT_CS_INTERFACE,
82         .bDescriptorSubtype =   UAC_HEADER,
83         .bcdADC =               cpu_to_le16(0x0100),
84         .wTotalLength =         cpu_to_le16(UAC_DT_TOTAL_LENGTH),
85         .bInCollection =        F_AUDIO_NUM_INTERFACES,
86         .baInterfaceNr = {
87         /* Interface number of the AudioStream interfaces */
88                 [0] =           1,
89                 [1] =           2,
90         }
91 };
92
93 #define USB_OUT_IT_ID   1
94 static struct uac_input_terminal_descriptor usb_out_it_desc = {
95         .bLength =              UAC_DT_INPUT_TERMINAL_SIZE,
96         .bDescriptorType =      USB_DT_CS_INTERFACE,
97         .bDescriptorSubtype =   UAC_INPUT_TERMINAL,
98         .bTerminalID =          USB_OUT_IT_ID,
99         .wTerminalType =        cpu_to_le16(UAC_TERMINAL_STREAMING),
100         .bAssocTerminal =       0,
101         .wChannelConfig =       cpu_to_le16(0x3),
102 };
103
104 #define IO_OUT_OT_ID    2
105 static struct uac1_output_terminal_descriptor io_out_ot_desc = {
106         .bLength                = UAC_DT_OUTPUT_TERMINAL_SIZE,
107         .bDescriptorType        = USB_DT_CS_INTERFACE,
108         .bDescriptorSubtype     = UAC_OUTPUT_TERMINAL,
109         .bTerminalID            = IO_OUT_OT_ID,
110         .wTerminalType          = cpu_to_le16(UAC_OUTPUT_TERMINAL_SPEAKER),
111         .bAssocTerminal         = 0,
112         .bSourceID              = USB_OUT_IT_ID,
113 };
114
115 #define IO_IN_IT_ID     3
116 static struct uac_input_terminal_descriptor io_in_it_desc = {
117         .bLength                = UAC_DT_INPUT_TERMINAL_SIZE,
118         .bDescriptorType        = USB_DT_CS_INTERFACE,
119         .bDescriptorSubtype     = UAC_INPUT_TERMINAL,
120         .bTerminalID            = IO_IN_IT_ID,
121         .wTerminalType          = cpu_to_le16(UAC_INPUT_TERMINAL_MICROPHONE),
122         .bAssocTerminal         = 0,
123         .wChannelConfig         = cpu_to_le16(0x3),
124 };
125
126 #define USB_IN_OT_ID    4
127 static struct uac1_output_terminal_descriptor usb_in_ot_desc = {
128         .bLength =              UAC_DT_OUTPUT_TERMINAL_SIZE,
129         .bDescriptorType =      USB_DT_CS_INTERFACE,
130         .bDescriptorSubtype =   UAC_OUTPUT_TERMINAL,
131         .bTerminalID =          USB_IN_OT_ID,
132         .wTerminalType =        cpu_to_le16(UAC_TERMINAL_STREAMING),
133         .bAssocTerminal =       0,
134         .bSourceID =            IO_IN_IT_ID,
135 };
136
137 /* B.4.1  Standard AS Interface Descriptor */
138 static struct usb_interface_descriptor as_out_interface_alt_0_desc = {
139         .bLength =              USB_DT_INTERFACE_SIZE,
140         .bDescriptorType =      USB_DT_INTERFACE,
141         .bAlternateSetting =    0,
142         .bNumEndpoints =        0,
143         .bInterfaceClass =      USB_CLASS_AUDIO,
144         .bInterfaceSubClass =   USB_SUBCLASS_AUDIOSTREAMING,
145 };
146
147 static struct usb_interface_descriptor as_out_interface_alt_1_desc = {
148         .bLength =              USB_DT_INTERFACE_SIZE,
149         .bDescriptorType =      USB_DT_INTERFACE,
150         .bAlternateSetting =    1,
151         .bNumEndpoints =        1,
152         .bInterfaceClass =      USB_CLASS_AUDIO,
153         .bInterfaceSubClass =   USB_SUBCLASS_AUDIOSTREAMING,
154 };
155
156 static struct usb_interface_descriptor as_in_interface_alt_0_desc = {
157         .bLength =              USB_DT_INTERFACE_SIZE,
158         .bDescriptorType =      USB_DT_INTERFACE,
159         .bAlternateSetting =    0,
160         .bNumEndpoints =        0,
161         .bInterfaceClass =      USB_CLASS_AUDIO,
162         .bInterfaceSubClass =   USB_SUBCLASS_AUDIOSTREAMING,
163 };
164
165 static struct usb_interface_descriptor as_in_interface_alt_1_desc = {
166         .bLength =              USB_DT_INTERFACE_SIZE,
167         .bDescriptorType =      USB_DT_INTERFACE,
168         .bAlternateSetting =    1,
169         .bNumEndpoints =        1,
170         .bInterfaceClass =      USB_CLASS_AUDIO,
171         .bInterfaceSubClass =   USB_SUBCLASS_AUDIOSTREAMING,
172 };
173
174 /* B.4.2  Class-Specific AS Interface Descriptor */
175 static struct uac1_as_header_descriptor as_out_header_desc = {
176         .bLength =              UAC_DT_AS_HEADER_SIZE,
177         .bDescriptorType =      USB_DT_CS_INTERFACE,
178         .bDescriptorSubtype =   UAC_AS_GENERAL,
179         .bTerminalLink =        USB_OUT_IT_ID,
180         .bDelay =               1,
181         .wFormatTag =           cpu_to_le16(UAC_FORMAT_TYPE_I_PCM),
182 };
183
184 static struct uac1_as_header_descriptor as_in_header_desc = {
185         .bLength =              UAC_DT_AS_HEADER_SIZE,
186         .bDescriptorType =      USB_DT_CS_INTERFACE,
187         .bDescriptorSubtype =   UAC_AS_GENERAL,
188         .bTerminalLink =        USB_IN_OT_ID,
189         .bDelay =               1,
190         .wFormatTag =           cpu_to_le16(UAC_FORMAT_TYPE_I_PCM),
191 };
192
193 DECLARE_UAC_FORMAT_TYPE_I_DISCRETE_DESC(1);
194
195 static struct uac_format_type_i_discrete_descriptor_1 as_out_type_i_desc = {
196         .bLength =              UAC_FORMAT_TYPE_I_DISCRETE_DESC_SIZE(1),
197         .bDescriptorType =      USB_DT_CS_INTERFACE,
198         .bDescriptorSubtype =   UAC_FORMAT_TYPE,
199         .bFormatType =          UAC_FORMAT_TYPE_I,
200         .bSubframeSize =        2,
201         .bBitResolution =       16,
202         .bSamFreqType =         1,
203 };
204
205 /* Standard ISO OUT Endpoint Descriptor */
206 static struct usb_endpoint_descriptor as_out_ep_desc  = {
207         .bLength =              USB_DT_ENDPOINT_AUDIO_SIZE,
208         .bDescriptorType =      USB_DT_ENDPOINT,
209         .bEndpointAddress =     USB_DIR_OUT,
210         .bmAttributes =         USB_ENDPOINT_SYNC_ADAPTIVE
211                                 | USB_ENDPOINT_XFER_ISOC,
212         .wMaxPacketSize =       cpu_to_le16(UAC1_OUT_EP_MAX_PACKET_SIZE),
213         .bInterval =            4,
214 };
215
216 /* Class-specific AS ISO OUT Endpoint Descriptor */
217 static struct uac_iso_endpoint_descriptor as_iso_out_desc = {
218         .bLength =              UAC_ISO_ENDPOINT_DESC_SIZE,
219         .bDescriptorType =      USB_DT_CS_ENDPOINT,
220         .bDescriptorSubtype =   UAC_EP_GENERAL,
221         .bmAttributes =         1,
222         .bLockDelayUnits =      1,
223         .wLockDelay =           cpu_to_le16(1),
224 };
225
226 static struct uac_format_type_i_discrete_descriptor_1 as_in_type_i_desc = {
227         .bLength =              UAC_FORMAT_TYPE_I_DISCRETE_DESC_SIZE(1),
228         .bDescriptorType =      USB_DT_CS_INTERFACE,
229         .bDescriptorSubtype =   UAC_FORMAT_TYPE,
230         .bFormatType =          UAC_FORMAT_TYPE_I,
231         .bSubframeSize =        2,
232         .bBitResolution =       16,
233         .bSamFreqType =         1,
234 };
235
236 /* Standard ISO OUT Endpoint Descriptor */
237 static struct usb_endpoint_descriptor as_in_ep_desc  = {
238         .bLength =              USB_DT_ENDPOINT_AUDIO_SIZE,
239         .bDescriptorType =      USB_DT_ENDPOINT,
240         .bEndpointAddress =     USB_DIR_IN,
241         .bmAttributes =         USB_ENDPOINT_SYNC_ASYNC
242                                 | USB_ENDPOINT_XFER_ISOC,
243         .wMaxPacketSize =       cpu_to_le16(UAC1_OUT_EP_MAX_PACKET_SIZE),
244         .bInterval =            4,
245 };
246
247 /* Class-specific AS ISO OUT Endpoint Descriptor */
248 static struct uac_iso_endpoint_descriptor as_iso_in_desc = {
249         .bLength =              UAC_ISO_ENDPOINT_DESC_SIZE,
250         .bDescriptorType =      USB_DT_CS_ENDPOINT,
251         .bDescriptorSubtype =   UAC_EP_GENERAL,
252         .bmAttributes =         1,
253         .bLockDelayUnits =      0,
254         .wLockDelay =           0,
255 };
256
257 static struct usb_descriptor_header *f_audio_desc[] = {
258         (struct usb_descriptor_header *)&ac_interface_desc,
259         (struct usb_descriptor_header *)&ac_header_desc,
260
261         (struct usb_descriptor_header *)&usb_out_it_desc,
262         (struct usb_descriptor_header *)&io_out_ot_desc,
263         (struct usb_descriptor_header *)&io_in_it_desc,
264         (struct usb_descriptor_header *)&usb_in_ot_desc,
265
266         (struct usb_descriptor_header *)&as_out_interface_alt_0_desc,
267         (struct usb_descriptor_header *)&as_out_interface_alt_1_desc,
268         (struct usb_descriptor_header *)&as_out_header_desc,
269
270         (struct usb_descriptor_header *)&as_out_type_i_desc,
271
272         (struct usb_descriptor_header *)&as_out_ep_desc,
273         (struct usb_descriptor_header *)&as_iso_out_desc,
274
275         (struct usb_descriptor_header *)&as_in_interface_alt_0_desc,
276         (struct usb_descriptor_header *)&as_in_interface_alt_1_desc,
277         (struct usb_descriptor_header *)&as_in_header_desc,
278
279         (struct usb_descriptor_header *)&as_in_type_i_desc,
280
281         (struct usb_descriptor_header *)&as_in_ep_desc,
282         (struct usb_descriptor_header *)&as_iso_in_desc,
283         NULL,
284 };
285
286 enum {
287         STR_AC_IF,
288         STR_USB_OUT_IT,
289         STR_USB_OUT_IT_CH_NAMES,
290         STR_IO_OUT_OT,
291         STR_IO_IN_IT,
292         STR_IO_IN_IT_CH_NAMES,
293         STR_USB_IN_OT,
294         STR_AS_OUT_IF_ALT0,
295         STR_AS_OUT_IF_ALT1,
296         STR_AS_IN_IF_ALT0,
297         STR_AS_IN_IF_ALT1,
298 };
299
300 static struct usb_string strings_uac1[] = {
301         [STR_AC_IF].s = "AC Interface",
302         [STR_USB_OUT_IT].s = "Playback Input terminal",
303         [STR_USB_OUT_IT_CH_NAMES].s = "Playback Channels",
304         [STR_IO_OUT_OT].s = "Playback Output terminal",
305         [STR_IO_IN_IT].s = "Capture Input terminal",
306         [STR_IO_IN_IT_CH_NAMES].s = "Capture Channels",
307         [STR_USB_IN_OT].s = "Capture Output terminal",
308         [STR_AS_OUT_IF_ALT0].s = "Playback Inactive",
309         [STR_AS_OUT_IF_ALT1].s = "Playback Active",
310         [STR_AS_IN_IF_ALT0].s = "Capture Inactive",
311         [STR_AS_IN_IF_ALT1].s = "Capture Active",
312         { },
313 };
314
315 static struct usb_gadget_strings str_uac1 = {
316         .language = 0x0409,     /* en-us */
317         .strings = strings_uac1,
318 };
319
320 static struct usb_gadget_strings *uac1_strings[] = {
321         &str_uac1,
322         NULL,
323 };
324
325 /*
326  * This function is an ALSA sound card following USB Audio Class Spec 1.0.
327  */
328
329 static int audio_set_endpoint_req(struct usb_function *f,
330                 const struct usb_ctrlrequest *ctrl)
331 {
332         struct usb_composite_dev *cdev = f->config->cdev;
333         int                     value = -EOPNOTSUPP;
334         u16                     ep = le16_to_cpu(ctrl->wIndex);
335         u16                     len = le16_to_cpu(ctrl->wLength);
336         u16                     w_value = le16_to_cpu(ctrl->wValue);
337
338         DBG(cdev, "bRequest 0x%x, w_value 0x%04x, len %d, endpoint %d\n",
339                         ctrl->bRequest, w_value, len, ep);
340
341         switch (ctrl->bRequest) {
342         case UAC_SET_CUR:
343                 value = len;
344                 break;
345
346         case UAC_SET_MIN:
347                 break;
348
349         case UAC_SET_MAX:
350                 break;
351
352         case UAC_SET_RES:
353                 break;
354
355         case UAC_SET_MEM:
356                 break;
357
358         default:
359                 break;
360         }
361
362         return value;
363 }
364
365 static int audio_get_endpoint_req(struct usb_function *f,
366                 const struct usb_ctrlrequest *ctrl)
367 {
368         struct usb_composite_dev *cdev = f->config->cdev;
369         int value = -EOPNOTSUPP;
370         u8 ep = ((le16_to_cpu(ctrl->wIndex) >> 8) & 0xFF);
371         u16 len = le16_to_cpu(ctrl->wLength);
372         u16 w_value = le16_to_cpu(ctrl->wValue);
373
374         DBG(cdev, "bRequest 0x%x, w_value 0x%04x, len %d, endpoint %d\n",
375                         ctrl->bRequest, w_value, len, ep);
376
377         switch (ctrl->bRequest) {
378         case UAC_GET_CUR:
379         case UAC_GET_MIN:
380         case UAC_GET_MAX:
381         case UAC_GET_RES:
382                 value = len;
383                 break;
384         case UAC_GET_MEM:
385                 break;
386         default:
387                 break;
388         }
389
390         return value;
391 }
392
393 static int
394 f_audio_setup(struct usb_function *f, const struct usb_ctrlrequest *ctrl)
395 {
396         struct usb_composite_dev *cdev = f->config->cdev;
397         struct usb_request      *req = cdev->req;
398         int                     value = -EOPNOTSUPP;
399         u16                     w_index = le16_to_cpu(ctrl->wIndex);
400         u16                     w_value = le16_to_cpu(ctrl->wValue);
401         u16                     w_length = le16_to_cpu(ctrl->wLength);
402
403         /* composite driver infrastructure handles everything; interface
404          * activation uses set_alt().
405          */
406         switch (ctrl->bRequestType) {
407         case USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_ENDPOINT:
408                 value = audio_set_endpoint_req(f, ctrl);
409                 break;
410
411         case USB_DIR_IN | USB_TYPE_CLASS | USB_RECIP_ENDPOINT:
412                 value = audio_get_endpoint_req(f, ctrl);
413                 break;
414
415         default:
416                 ERROR(cdev, "invalid control req%02x.%02x v%04x i%04x l%d\n",
417                         ctrl->bRequestType, ctrl->bRequest,
418                         w_value, w_index, w_length);
419         }
420
421         /* respond with data transfer or status phase? */
422         if (value >= 0) {
423                 DBG(cdev, "audio req%02x.%02x v%04x i%04x l%d\n",
424                         ctrl->bRequestType, ctrl->bRequest,
425                         w_value, w_index, w_length);
426                 req->zero = 0;
427                 req->length = value;
428                 value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
429                 if (value < 0)
430                         ERROR(cdev, "audio response on err %d\n", value);
431         }
432
433         /* device either stalls (value < 0) or reports success */
434         return value;
435 }
436
437 static int f_audio_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
438 {
439         struct usb_composite_dev *cdev = f->config->cdev;
440         struct usb_gadget *gadget = cdev->gadget;
441         struct device *dev = &gadget->dev;
442         struct f_uac1 *uac1 = func_to_uac1(f);
443         int ret = 0;
444
445         /* No i/f has more than 2 alt settings */
446         if (alt > 1) {
447                 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
448                 return -EINVAL;
449         }
450
451         if (intf == uac1->ac_intf) {
452                 /* Control I/f has only 1 AltSetting - 0 */
453                 if (alt) {
454                         dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
455                         return -EINVAL;
456                 }
457                 return 0;
458         }
459
460         if (intf == uac1->as_out_intf) {
461                 uac1->as_out_alt = alt;
462
463                 if (alt)
464                         ret = u_audio_start_capture(&uac1->g_audio);
465                 else
466                         u_audio_stop_capture(&uac1->g_audio);
467         } else if (intf == uac1->as_in_intf) {
468                 uac1->as_in_alt = alt;
469
470                         if (alt)
471                                 ret = u_audio_start_playback(&uac1->g_audio);
472                         else
473                                 u_audio_stop_playback(&uac1->g_audio);
474         } else {
475                 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
476                 return -EINVAL;
477         }
478
479         return ret;
480 }
481
482 static int f_audio_get_alt(struct usb_function *f, unsigned intf)
483 {
484         struct usb_composite_dev *cdev = f->config->cdev;
485         struct usb_gadget *gadget = cdev->gadget;
486         struct device *dev = &gadget->dev;
487         struct f_uac1 *uac1 = func_to_uac1(f);
488
489         if (intf == uac1->ac_intf)
490                 return uac1->ac_alt;
491         else if (intf == uac1->as_out_intf)
492                 return uac1->as_out_alt;
493         else if (intf == uac1->as_in_intf)
494                 return uac1->as_in_alt;
495         else
496                 dev_err(dev, "%s:%d Invalid Interface %d!\n",
497                         __func__, __LINE__, intf);
498
499         return -EINVAL;
500 }
501
502
503 static void f_audio_disable(struct usb_function *f)
504 {
505         struct f_uac1 *uac1 = func_to_uac1(f);
506
507         uac1->as_out_alt = 0;
508         uac1->as_in_alt = 0;
509
510         u_audio_stop_playback(&uac1->g_audio);
511         u_audio_stop_capture(&uac1->g_audio);
512 }
513
514 /*-------------------------------------------------------------------------*/
515
516 static int f_audio_validate_opts(struct g_audio *audio, struct device *dev)
517 {
518         struct f_uac1_opts *opts = g_audio_to_uac1_opts(audio);
519
520         if (!opts->p_chmask && !opts->c_chmask) {
521                 dev_err(dev, "Error: no playback and capture channels\n");
522                 return -EINVAL;
523         } else if (opts->p_chmask & ~UAC1_CHANNEL_MASK) {
524                 dev_err(dev, "Error: unsupported playback channels mask\n");
525                 return -EINVAL;
526         } else if (opts->c_chmask & ~UAC1_CHANNEL_MASK) {
527                 dev_err(dev, "Error: unsupported capture channels mask\n");
528                 return -EINVAL;
529         } else if ((opts->p_ssize < 1) || (opts->p_ssize > 4)) {
530                 dev_err(dev, "Error: incorrect playback sample size\n");
531                 return -EINVAL;
532         } else if ((opts->c_ssize < 1) || (opts->c_ssize > 4)) {
533                 dev_err(dev, "Error: incorrect capture sample size\n");
534                 return -EINVAL;
535         } else if (!opts->p_srate) {
536                 dev_err(dev, "Error: incorrect playback sampling rate\n");
537                 return -EINVAL;
538         } else if (!opts->c_srate) {
539                 dev_err(dev, "Error: incorrect capture sampling rate\n");
540                 return -EINVAL;
541         }
542
543         return 0;
544 }
545
546 /* audio function driver setup/binding */
547 static int f_audio_bind(struct usb_configuration *c, struct usb_function *f)
548 {
549         struct usb_composite_dev        *cdev = c->cdev;
550         struct usb_gadget               *gadget = cdev->gadget;
551         struct device                   *dev = &gadget->dev;
552         struct f_uac1                   *uac1 = func_to_uac1(f);
553         struct g_audio                  *audio = func_to_g_audio(f);
554         struct f_uac1_opts              *audio_opts;
555         struct usb_ep                   *ep = NULL;
556         struct usb_string               *us;
557         u8                              *sam_freq;
558         int                             rate;
559         int                             status;
560
561         status = f_audio_validate_opts(audio, dev);
562         if (status)
563                 return status;
564
565         audio_opts = container_of(f->fi, struct f_uac1_opts, func_inst);
566
567         us = usb_gstrings_attach(cdev, uac1_strings, ARRAY_SIZE(strings_uac1));
568         if (IS_ERR(us))
569                 return PTR_ERR(us);
570         ac_interface_desc.iInterface = us[STR_AC_IF].id;
571         usb_out_it_desc.iTerminal = us[STR_USB_OUT_IT].id;
572         usb_out_it_desc.iChannelNames = us[STR_USB_OUT_IT_CH_NAMES].id;
573         io_out_ot_desc.iTerminal = us[STR_IO_OUT_OT].id;
574         as_out_interface_alt_0_desc.iInterface = us[STR_AS_OUT_IF_ALT0].id;
575         as_out_interface_alt_1_desc.iInterface = us[STR_AS_OUT_IF_ALT1].id;
576         io_in_it_desc.iTerminal = us[STR_IO_IN_IT].id;
577         io_in_it_desc.iChannelNames = us[STR_IO_IN_IT_CH_NAMES].id;
578         usb_in_ot_desc.iTerminal = us[STR_USB_IN_OT].id;
579         as_in_interface_alt_0_desc.iInterface = us[STR_AS_IN_IF_ALT0].id;
580         as_in_interface_alt_1_desc.iInterface = us[STR_AS_IN_IF_ALT1].id;
581
582         /* Set channel numbers */
583         usb_out_it_desc.bNrChannels = num_channels(audio_opts->c_chmask);
584         usb_out_it_desc.wChannelConfig = cpu_to_le16(audio_opts->c_chmask);
585         as_out_type_i_desc.bNrChannels = num_channels(audio_opts->c_chmask);
586         as_out_type_i_desc.bSubframeSize = audio_opts->c_ssize;
587         as_out_type_i_desc.bBitResolution = audio_opts->c_ssize * 8;
588         io_in_it_desc.bNrChannels = num_channels(audio_opts->p_chmask);
589         io_in_it_desc.wChannelConfig = cpu_to_le16(audio_opts->p_chmask);
590         as_in_type_i_desc.bNrChannels = num_channels(audio_opts->p_chmask);
591         as_in_type_i_desc.bSubframeSize = audio_opts->p_ssize;
592         as_in_type_i_desc.bBitResolution = audio_opts->p_ssize * 8;
593
594         /* Set sample rates */
595         rate = audio_opts->c_srate;
596         sam_freq = as_out_type_i_desc.tSamFreq[0];
597         memcpy(sam_freq, &rate, 3);
598         rate = audio_opts->p_srate;
599         sam_freq = as_in_type_i_desc.tSamFreq[0];
600         memcpy(sam_freq, &rate, 3);
601
602         /* allocate instance-specific interface IDs, and patch descriptors */
603         status = usb_interface_id(c, f);
604         if (status < 0)
605                 goto fail;
606         ac_interface_desc.bInterfaceNumber = status;
607         uac1->ac_intf = status;
608         uac1->ac_alt = 0;
609
610         status = usb_interface_id(c, f);
611         if (status < 0)
612                 goto fail;
613         as_out_interface_alt_0_desc.bInterfaceNumber = status;
614         as_out_interface_alt_1_desc.bInterfaceNumber = status;
615         uac1->as_out_intf = status;
616         uac1->as_out_alt = 0;
617
618         status = usb_interface_id(c, f);
619         if (status < 0)
620                 goto fail;
621         as_in_interface_alt_0_desc.bInterfaceNumber = status;
622         as_in_interface_alt_1_desc.bInterfaceNumber = status;
623         uac1->as_in_intf = status;
624         uac1->as_in_alt = 0;
625
626         audio->gadget = gadget;
627
628         status = -ENODEV;
629
630         /* allocate instance-specific endpoints */
631         ep = usb_ep_autoconfig(cdev->gadget, &as_out_ep_desc);
632         if (!ep)
633                 goto fail;
634         audio->out_ep = ep;
635         audio->out_ep->desc = &as_out_ep_desc;
636
637         ep = usb_ep_autoconfig(cdev->gadget, &as_in_ep_desc);
638         if (!ep)
639                 goto fail;
640         audio->in_ep = ep;
641         audio->in_ep->desc = &as_in_ep_desc;
642
643         /* copy descriptors, and track endpoint copies */
644         status = usb_assign_descriptors(f, f_audio_desc, f_audio_desc, NULL,
645                                         NULL);
646         if (status)
647                 goto fail;
648
649         audio->out_ep_maxpsize = le16_to_cpu(as_out_ep_desc.wMaxPacketSize);
650         audio->in_ep_maxpsize = le16_to_cpu(as_in_ep_desc.wMaxPacketSize);
651         audio->params.c_chmask = audio_opts->c_chmask;
652         audio->params.c_srate = audio_opts->c_srate;
653         audio->params.c_ssize = audio_opts->c_ssize;
654         audio->params.p_chmask = audio_opts->p_chmask;
655         audio->params.p_srate = audio_opts->p_srate;
656         audio->params.p_ssize = audio_opts->p_ssize;
657         audio->params.req_number = audio_opts->req_number;
658
659         status = g_audio_setup(audio, "UAC1_PCM", "UAC1_Gadget");
660         if (status)
661                 goto err_card_register;
662
663         return 0;
664
665 err_card_register:
666         usb_free_all_descriptors(f);
667 fail:
668         return status;
669 }
670
671 /*-------------------------------------------------------------------------*/
672
673 static inline struct f_uac1_opts *to_f_uac1_opts(struct config_item *item)
674 {
675         return container_of(to_config_group(item), struct f_uac1_opts,
676                             func_inst.group);
677 }
678
679 static void f_uac1_attr_release(struct config_item *item)
680 {
681         struct f_uac1_opts *opts = to_f_uac1_opts(item);
682
683         usb_put_function_instance(&opts->func_inst);
684 }
685
686 static struct configfs_item_operations f_uac1_item_ops = {
687         .release        = f_uac1_attr_release,
688 };
689
690 #define UAC1_ATTRIBUTE(name)                                            \
691 static ssize_t f_uac1_opts_##name##_show(                               \
692                                           struct config_item *item,     \
693                                           char *page)                   \
694 {                                                                       \
695         struct f_uac1_opts *opts = to_f_uac1_opts(item);                \
696         int result;                                                     \
697                                                                         \
698         mutex_lock(&opts->lock);                                        \
699         result = sprintf(page, "%u\n", opts->name);                     \
700         mutex_unlock(&opts->lock);                                      \
701                                                                         \
702         return result;                                                  \
703 }                                                                       \
704                                                                         \
705 static ssize_t f_uac1_opts_##name##_store(                              \
706                                           struct config_item *item,     \
707                                           const char *page, size_t len) \
708 {                                                                       \
709         struct f_uac1_opts *opts = to_f_uac1_opts(item);                \
710         int ret;                                                        \
711         u32 num;                                                        \
712                                                                         \
713         mutex_lock(&opts->lock);                                        \
714         if (opts->refcnt) {                                             \
715                 ret = -EBUSY;                                           \
716                 goto end;                                               \
717         }                                                               \
718                                                                         \
719         ret = kstrtou32(page, 0, &num);                                 \
720         if (ret)                                                        \
721                 goto end;                                               \
722                                                                         \
723         opts->name = num;                                               \
724         ret = len;                                                      \
725                                                                         \
726 end:                                                                    \
727         mutex_unlock(&opts->lock);                                      \
728         return ret;                                                     \
729 }                                                                       \
730                                                                         \
731 CONFIGFS_ATTR(f_uac1_opts_, name)
732
733 UAC1_ATTRIBUTE(c_chmask);
734 UAC1_ATTRIBUTE(c_srate);
735 UAC1_ATTRIBUTE(c_ssize);
736 UAC1_ATTRIBUTE(p_chmask);
737 UAC1_ATTRIBUTE(p_srate);
738 UAC1_ATTRIBUTE(p_ssize);
739 UAC1_ATTRIBUTE(req_number);
740
741 static struct configfs_attribute *f_uac1_attrs[] = {
742         &f_uac1_opts_attr_c_chmask,
743         &f_uac1_opts_attr_c_srate,
744         &f_uac1_opts_attr_c_ssize,
745         &f_uac1_opts_attr_p_chmask,
746         &f_uac1_opts_attr_p_srate,
747         &f_uac1_opts_attr_p_ssize,
748         &f_uac1_opts_attr_req_number,
749         NULL,
750 };
751
752 static const struct config_item_type f_uac1_func_type = {
753         .ct_item_ops    = &f_uac1_item_ops,
754         .ct_attrs       = f_uac1_attrs,
755         .ct_owner       = THIS_MODULE,
756 };
757
758 static void f_audio_free_inst(struct usb_function_instance *f)
759 {
760         struct f_uac1_opts *opts;
761
762         opts = container_of(f, struct f_uac1_opts, func_inst);
763         kfree(opts);
764 }
765
766 static struct usb_function_instance *f_audio_alloc_inst(void)
767 {
768         struct f_uac1_opts *opts;
769
770         opts = kzalloc(sizeof(*opts), GFP_KERNEL);
771         if (!opts)
772                 return ERR_PTR(-ENOMEM);
773
774         mutex_init(&opts->lock);
775         opts->func_inst.free_func_inst = f_audio_free_inst;
776
777         config_group_init_type_name(&opts->func_inst.group, "",
778                                     &f_uac1_func_type);
779
780         opts->c_chmask = UAC1_DEF_CCHMASK;
781         opts->c_srate = UAC1_DEF_CSRATE;
782         opts->c_ssize = UAC1_DEF_CSSIZE;
783         opts->p_chmask = UAC1_DEF_PCHMASK;
784         opts->p_srate = UAC1_DEF_PSRATE;
785         opts->p_ssize = UAC1_DEF_PSSIZE;
786         opts->req_number = UAC1_DEF_REQ_NUM;
787         return &opts->func_inst;
788 }
789
790 static void f_audio_free(struct usb_function *f)
791 {
792         struct g_audio *audio;
793         struct f_uac1_opts *opts;
794
795         audio = func_to_g_audio(f);
796         opts = container_of(f->fi, struct f_uac1_opts, func_inst);
797         kfree(audio);
798         mutex_lock(&opts->lock);
799         --opts->refcnt;
800         mutex_unlock(&opts->lock);
801 }
802
803 static void f_audio_unbind(struct usb_configuration *c, struct usb_function *f)
804 {
805         struct g_audio *audio = func_to_g_audio(f);
806
807         g_audio_cleanup(audio);
808         usb_free_all_descriptors(f);
809
810         audio->gadget = NULL;
811 }
812
813 static struct usb_function *f_audio_alloc(struct usb_function_instance *fi)
814 {
815         struct f_uac1 *uac1;
816         struct f_uac1_opts *opts;
817
818         /* allocate and initialize one new instance */
819         uac1 = kzalloc(sizeof(*uac1), GFP_KERNEL);
820         if (!uac1)
821                 return ERR_PTR(-ENOMEM);
822
823         opts = container_of(fi, struct f_uac1_opts, func_inst);
824         mutex_lock(&opts->lock);
825         ++opts->refcnt;
826         mutex_unlock(&opts->lock);
827
828         uac1->g_audio.func.name = "uac1_func";
829         uac1->g_audio.func.bind = f_audio_bind;
830         uac1->g_audio.func.unbind = f_audio_unbind;
831         uac1->g_audio.func.set_alt = f_audio_set_alt;
832         uac1->g_audio.func.get_alt = f_audio_get_alt;
833         uac1->g_audio.func.setup = f_audio_setup;
834         uac1->g_audio.func.disable = f_audio_disable;
835         uac1->g_audio.func.free_func = f_audio_free;
836
837         return &uac1->g_audio.func;
838 }
839
840 DECLARE_USB_FUNCTION_INIT(uac1, f_audio_alloc_inst, f_audio_alloc);
841 MODULE_LICENSE("GPL");
842 MODULE_AUTHOR("Ruslan Bilovol");