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