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