1 /* 2 * f_uac2.c -- USB Audio Class 2.0 Function 3 * 4 * Copyright (C) 2011 5 * Yadwinder Singh (yadi.brar01@gmail.com) 6 * Jaswinder Singh (jaswinder.singh@linaro.org) 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or 11 * (at your option) any later version. 12 */ 13 14 #include <linux/usb/audio.h> 15 #include <linux/usb/audio-v2.h> 16 #include <linux/platform_device.h> 17 #include <linux/module.h> 18 19 #include <sound/core.h> 20 #include <sound/pcm.h> 21 #include <sound/pcm_params.h> 22 23 /* Playback(USB-IN) Default Stereo - Fl/Fr */ 24 static int p_chmask = 0x3; 25 module_param(p_chmask, uint, S_IRUGO); 26 MODULE_PARM_DESC(p_chmask, "Playback Channel Mask"); 27 28 /* Playback Default 48 KHz */ 29 static int p_srate = 48000; 30 module_param(p_srate, uint, S_IRUGO); 31 MODULE_PARM_DESC(p_srate, "Playback Sampling Rate"); 32 33 /* Playback Default 16bits/sample */ 34 static int p_ssize = 2; 35 module_param(p_ssize, uint, S_IRUGO); 36 MODULE_PARM_DESC(p_ssize, "Playback Sample Size(bytes)"); 37 38 /* Capture(USB-OUT) Default Stereo - Fl/Fr */ 39 static int c_chmask = 0x3; 40 module_param(c_chmask, uint, S_IRUGO); 41 MODULE_PARM_DESC(c_chmask, "Capture Channel Mask"); 42 43 /* Capture Default 64 KHz */ 44 static int c_srate = 64000; 45 module_param(c_srate, uint, S_IRUGO); 46 MODULE_PARM_DESC(c_srate, "Capture Sampling Rate"); 47 48 /* Capture Default 16bits/sample */ 49 static int c_ssize = 2; 50 module_param(c_ssize, uint, S_IRUGO); 51 MODULE_PARM_DESC(c_ssize, "Capture Sample Size(bytes)"); 52 53 /* Keep everyone on toes */ 54 #define USB_XFERS 2 55 56 /* 57 * The driver implements a simple UAC_2 topology. 58 * USB-OUT -> IT_1 -> OT_3 -> ALSA_Capture 59 * ALSA_Playback -> IT_2 -> OT_4 -> USB-IN 60 * Capture and Playback sampling rates are independently 61 * controlled by two clock sources : 62 * CLK_5 := c_srate, and CLK_6 := p_srate 63 */ 64 #define USB_OUT_IT_ID 1 65 #define IO_IN_IT_ID 2 66 #define IO_OUT_OT_ID 3 67 #define USB_IN_OT_ID 4 68 #define USB_OUT_CLK_ID 5 69 #define USB_IN_CLK_ID 6 70 71 #define CONTROL_ABSENT 0 72 #define CONTROL_RDONLY 1 73 #define CONTROL_RDWR 3 74 75 #define CLK_FREQ_CTRL 0 76 #define CLK_VLD_CTRL 2 77 78 #define COPY_CTRL 0 79 #define CONN_CTRL 2 80 #define OVRLD_CTRL 4 81 #define CLSTR_CTRL 6 82 #define UNFLW_CTRL 8 83 #define OVFLW_CTRL 10 84 85 const char *uac2_name = "snd_uac2"; 86 87 struct uac2_req { 88 struct uac2_rtd_params *pp; /* parent param */ 89 struct usb_request *req; 90 }; 91 92 struct uac2_rtd_params { 93 struct snd_uac2_chip *uac2; /* parent chip */ 94 bool ep_enabled; /* if the ep is enabled */ 95 /* Size of the ring buffer */ 96 size_t dma_bytes; 97 unsigned char *dma_area; 98 99 struct snd_pcm_substream *ss; 100 101 /* Ring buffer */ 102 ssize_t hw_ptr; 103 104 void *rbuf; 105 106 size_t period_size; 107 108 unsigned max_psize; 109 struct uac2_req ureq[USB_XFERS]; 110 111 spinlock_t lock; 112 }; 113 114 struct snd_uac2_chip { 115 struct platform_device pdev; 116 struct platform_driver pdrv; 117 118 struct uac2_rtd_params p_prm; 119 struct uac2_rtd_params c_prm; 120 121 struct snd_card *card; 122 struct snd_pcm *pcm; 123 }; 124 125 #define BUFF_SIZE_MAX (PAGE_SIZE * 16) 126 #define PRD_SIZE_MAX PAGE_SIZE 127 #define MIN_PERIODS 4 128 129 static struct snd_pcm_hardware uac2_pcm_hardware = { 130 .info = SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER 131 | SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID 132 | SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_RESUME, 133 .rates = SNDRV_PCM_RATE_CONTINUOUS, 134 .periods_max = BUFF_SIZE_MAX / PRD_SIZE_MAX, 135 .buffer_bytes_max = BUFF_SIZE_MAX, 136 .period_bytes_max = PRD_SIZE_MAX, 137 .periods_min = MIN_PERIODS, 138 }; 139 140 struct audio_dev { 141 u8 ac_intf, ac_alt; 142 u8 as_out_intf, as_out_alt; 143 u8 as_in_intf, as_in_alt; 144 145 struct usb_ep *in_ep, *out_ep; 146 struct usb_function func; 147 148 /* The ALSA Sound Card it represents on the USB-Client side */ 149 struct snd_uac2_chip uac2; 150 }; 151 152 static struct audio_dev *agdev_g; 153 154 static inline 155 struct audio_dev *func_to_agdev(struct usb_function *f) 156 { 157 return container_of(f, struct audio_dev, func); 158 } 159 160 static inline 161 struct audio_dev *uac2_to_agdev(struct snd_uac2_chip *u) 162 { 163 return container_of(u, struct audio_dev, uac2); 164 } 165 166 static inline 167 struct snd_uac2_chip *pdev_to_uac2(struct platform_device *p) 168 { 169 return container_of(p, struct snd_uac2_chip, pdev); 170 } 171 172 static inline 173 uint num_channels(uint chanmask) 174 { 175 uint num = 0; 176 177 while (chanmask) { 178 num += (chanmask & 1); 179 chanmask >>= 1; 180 } 181 182 return num; 183 } 184 185 static void 186 agdev_iso_complete(struct usb_ep *ep, struct usb_request *req) 187 { 188 unsigned pending; 189 unsigned long flags; 190 bool update_alsa = false; 191 unsigned char *src, *dst; 192 int status = req->status; 193 struct uac2_req *ur = req->context; 194 struct snd_pcm_substream *substream; 195 struct uac2_rtd_params *prm = ur->pp; 196 struct snd_uac2_chip *uac2 = prm->uac2; 197 198 /* i/f shutting down */ 199 if (!prm->ep_enabled || req->status == -ESHUTDOWN) 200 return; 201 202 /* 203 * We can't really do much about bad xfers. 204 * Afterall, the ISOCH xfers could fail legitimately. 205 */ 206 if (status) 207 pr_debug("%s: iso_complete status(%d) %d/%d\n", 208 __func__, status, req->actual, req->length); 209 210 substream = prm->ss; 211 212 /* Do nothing if ALSA isn't active */ 213 if (!substream) 214 goto exit; 215 216 spin_lock_irqsave(&prm->lock, flags); 217 218 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { 219 src = prm->dma_area + prm->hw_ptr; 220 req->actual = req->length; 221 dst = req->buf; 222 } else { 223 dst = prm->dma_area + prm->hw_ptr; 224 src = req->buf; 225 } 226 227 pending = prm->hw_ptr % prm->period_size; 228 pending += req->actual; 229 if (pending >= prm->period_size) 230 update_alsa = true; 231 232 prm->hw_ptr = (prm->hw_ptr + req->actual) % prm->dma_bytes; 233 234 spin_unlock_irqrestore(&prm->lock, flags); 235 236 /* Pack USB load in ALSA ring buffer */ 237 memcpy(dst, src, req->actual); 238 exit: 239 if (usb_ep_queue(ep, req, GFP_ATOMIC)) 240 dev_err(&uac2->pdev.dev, "%d Error!\n", __LINE__); 241 242 if (update_alsa) 243 snd_pcm_period_elapsed(substream); 244 245 return; 246 } 247 248 static int 249 uac2_pcm_trigger(struct snd_pcm_substream *substream, int cmd) 250 { 251 struct snd_uac2_chip *uac2 = snd_pcm_substream_chip(substream); 252 struct uac2_rtd_params *prm; 253 unsigned long flags; 254 int err = 0; 255 256 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) 257 prm = &uac2->p_prm; 258 else 259 prm = &uac2->c_prm; 260 261 spin_lock_irqsave(&prm->lock, flags); 262 263 /* Reset */ 264 prm->hw_ptr = 0; 265 266 switch (cmd) { 267 case SNDRV_PCM_TRIGGER_START: 268 case SNDRV_PCM_TRIGGER_RESUME: 269 prm->ss = substream; 270 break; 271 case SNDRV_PCM_TRIGGER_STOP: 272 case SNDRV_PCM_TRIGGER_SUSPEND: 273 prm->ss = NULL; 274 break; 275 default: 276 err = -EINVAL; 277 } 278 279 spin_unlock_irqrestore(&prm->lock, flags); 280 281 /* Clear buffer after Play stops */ 282 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK && !prm->ss) 283 memset(prm->rbuf, 0, prm->max_psize * USB_XFERS); 284 285 return err; 286 } 287 288 static snd_pcm_uframes_t uac2_pcm_pointer(struct snd_pcm_substream *substream) 289 { 290 struct snd_uac2_chip *uac2 = snd_pcm_substream_chip(substream); 291 struct uac2_rtd_params *prm; 292 293 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) 294 prm = &uac2->p_prm; 295 else 296 prm = &uac2->c_prm; 297 298 return bytes_to_frames(substream->runtime, prm->hw_ptr); 299 } 300 301 static int uac2_pcm_hw_params(struct snd_pcm_substream *substream, 302 struct snd_pcm_hw_params *hw_params) 303 { 304 struct snd_uac2_chip *uac2 = snd_pcm_substream_chip(substream); 305 struct uac2_rtd_params *prm; 306 int err; 307 308 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) 309 prm = &uac2->p_prm; 310 else 311 prm = &uac2->c_prm; 312 313 err = snd_pcm_lib_malloc_pages(substream, 314 params_buffer_bytes(hw_params)); 315 if (err >= 0) { 316 prm->dma_bytes = substream->runtime->dma_bytes; 317 prm->dma_area = substream->runtime->dma_area; 318 prm->period_size = params_period_bytes(hw_params); 319 } 320 321 return err; 322 } 323 324 static int uac2_pcm_hw_free(struct snd_pcm_substream *substream) 325 { 326 struct snd_uac2_chip *uac2 = snd_pcm_substream_chip(substream); 327 struct uac2_rtd_params *prm; 328 329 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) 330 prm = &uac2->p_prm; 331 else 332 prm = &uac2->c_prm; 333 334 prm->dma_area = NULL; 335 prm->dma_bytes = 0; 336 prm->period_size = 0; 337 338 return snd_pcm_lib_free_pages(substream); 339 } 340 341 static int uac2_pcm_open(struct snd_pcm_substream *substream) 342 { 343 struct snd_uac2_chip *uac2 = snd_pcm_substream_chip(substream); 344 struct snd_pcm_runtime *runtime = substream->runtime; 345 346 runtime->hw = uac2_pcm_hardware; 347 348 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { 349 spin_lock_init(&uac2->p_prm.lock); 350 runtime->hw.rate_min = p_srate; 351 switch (p_ssize) { 352 case 3: 353 runtime->hw.formats = SNDRV_PCM_FMTBIT_S24_3LE; 354 break; 355 case 4: 356 runtime->hw.formats = SNDRV_PCM_FMTBIT_S32_LE; 357 break; 358 default: 359 runtime->hw.formats = SNDRV_PCM_FMTBIT_S16_LE; 360 break; 361 } 362 runtime->hw.channels_min = num_channels(p_chmask); 363 runtime->hw.period_bytes_min = 2 * uac2->p_prm.max_psize 364 / runtime->hw.periods_min; 365 } else { 366 spin_lock_init(&uac2->c_prm.lock); 367 runtime->hw.rate_min = c_srate; 368 switch (c_ssize) { 369 case 3: 370 runtime->hw.formats = SNDRV_PCM_FMTBIT_S24_3LE; 371 break; 372 case 4: 373 runtime->hw.formats = SNDRV_PCM_FMTBIT_S32_LE; 374 break; 375 default: 376 runtime->hw.formats = SNDRV_PCM_FMTBIT_S16_LE; 377 break; 378 } 379 runtime->hw.channels_min = num_channels(c_chmask); 380 runtime->hw.period_bytes_min = 2 * uac2->c_prm.max_psize 381 / runtime->hw.periods_min; 382 } 383 384 runtime->hw.rate_max = runtime->hw.rate_min; 385 runtime->hw.channels_max = runtime->hw.channels_min; 386 387 snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS); 388 389 return 0; 390 } 391 392 /* ALSA cries without these function pointers */ 393 static int uac2_pcm_null(struct snd_pcm_substream *substream) 394 { 395 return 0; 396 } 397 398 static struct snd_pcm_ops uac2_pcm_ops = { 399 .open = uac2_pcm_open, 400 .close = uac2_pcm_null, 401 .ioctl = snd_pcm_lib_ioctl, 402 .hw_params = uac2_pcm_hw_params, 403 .hw_free = uac2_pcm_hw_free, 404 .trigger = uac2_pcm_trigger, 405 .pointer = uac2_pcm_pointer, 406 .prepare = uac2_pcm_null, 407 }; 408 409 static int snd_uac2_probe(struct platform_device *pdev) 410 { 411 struct snd_uac2_chip *uac2 = pdev_to_uac2(pdev); 412 struct snd_card *card; 413 struct snd_pcm *pcm; 414 int err; 415 416 /* Choose any slot, with no id */ 417 err = snd_card_new(&pdev->dev, -1, NULL, THIS_MODULE, 0, &card); 418 if (err < 0) 419 return err; 420 421 uac2->card = card; 422 423 /* 424 * Create first PCM device 425 * Create a substream only for non-zero channel streams 426 */ 427 err = snd_pcm_new(uac2->card, "UAC2 PCM", 0, 428 p_chmask ? 1 : 0, c_chmask ? 1 : 0, &pcm); 429 if (err < 0) 430 goto snd_fail; 431 432 strcpy(pcm->name, "UAC2 PCM"); 433 pcm->private_data = uac2; 434 435 uac2->pcm = pcm; 436 437 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &uac2_pcm_ops); 438 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &uac2_pcm_ops); 439 440 strcpy(card->driver, "UAC2_Gadget"); 441 strcpy(card->shortname, "UAC2_Gadget"); 442 sprintf(card->longname, "UAC2_Gadget %i", pdev->id); 443 444 snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_CONTINUOUS, 445 snd_dma_continuous_data(GFP_KERNEL), 0, BUFF_SIZE_MAX); 446 447 err = snd_card_register(card); 448 if (!err) { 449 platform_set_drvdata(pdev, card); 450 return 0; 451 } 452 453 snd_fail: 454 snd_card_free(card); 455 456 uac2->pcm = NULL; 457 uac2->card = NULL; 458 459 return err; 460 } 461 462 static int snd_uac2_remove(struct platform_device *pdev) 463 { 464 struct snd_card *card = platform_get_drvdata(pdev); 465 466 if (card) 467 return snd_card_free(card); 468 469 return 0; 470 } 471 472 static int alsa_uac2_init(struct audio_dev *agdev) 473 { 474 struct snd_uac2_chip *uac2 = &agdev->uac2; 475 int err; 476 477 uac2->pdrv.probe = snd_uac2_probe; 478 uac2->pdrv.remove = snd_uac2_remove; 479 uac2->pdrv.driver.name = uac2_name; 480 481 uac2->pdev.id = 0; 482 uac2->pdev.name = uac2_name; 483 484 /* Register snd_uac2 driver */ 485 err = platform_driver_register(&uac2->pdrv); 486 if (err) 487 return err; 488 489 /* Register snd_uac2 device */ 490 err = platform_device_register(&uac2->pdev); 491 if (err) 492 platform_driver_unregister(&uac2->pdrv); 493 494 return err; 495 } 496 497 static void alsa_uac2_exit(struct audio_dev *agdev) 498 { 499 struct snd_uac2_chip *uac2 = &agdev->uac2; 500 501 platform_driver_unregister(&uac2->pdrv); 502 platform_device_unregister(&uac2->pdev); 503 } 504 505 506 /* --------- USB Function Interface ------------- */ 507 508 enum { 509 STR_ASSOC, 510 STR_IF_CTRL, 511 STR_CLKSRC_IN, 512 STR_CLKSRC_OUT, 513 STR_USB_IT, 514 STR_IO_IT, 515 STR_USB_OT, 516 STR_IO_OT, 517 STR_AS_OUT_ALT0, 518 STR_AS_OUT_ALT1, 519 STR_AS_IN_ALT0, 520 STR_AS_IN_ALT1, 521 }; 522 523 static char clksrc_in[8]; 524 static char clksrc_out[8]; 525 526 static struct usb_string strings_fn[] = { 527 [STR_ASSOC].s = "Source/Sink", 528 [STR_IF_CTRL].s = "Topology Control", 529 [STR_CLKSRC_IN].s = clksrc_in, 530 [STR_CLKSRC_OUT].s = clksrc_out, 531 [STR_USB_IT].s = "USBH Out", 532 [STR_IO_IT].s = "USBD Out", 533 [STR_USB_OT].s = "USBH In", 534 [STR_IO_OT].s = "USBD In", 535 [STR_AS_OUT_ALT0].s = "Playback Inactive", 536 [STR_AS_OUT_ALT1].s = "Playback Active", 537 [STR_AS_IN_ALT0].s = "Capture Inactive", 538 [STR_AS_IN_ALT1].s = "Capture Active", 539 { }, 540 }; 541 542 static struct usb_gadget_strings str_fn = { 543 .language = 0x0409, /* en-us */ 544 .strings = strings_fn, 545 }; 546 547 static struct usb_gadget_strings *fn_strings[] = { 548 &str_fn, 549 NULL, 550 }; 551 552 static struct usb_qualifier_descriptor devqual_desc = { 553 .bLength = sizeof devqual_desc, 554 .bDescriptorType = USB_DT_DEVICE_QUALIFIER, 555 556 .bcdUSB = cpu_to_le16(0x200), 557 .bDeviceClass = USB_CLASS_MISC, 558 .bDeviceSubClass = 0x02, 559 .bDeviceProtocol = 0x01, 560 .bNumConfigurations = 1, 561 .bRESERVED = 0, 562 }; 563 564 static struct usb_interface_assoc_descriptor iad_desc = { 565 .bLength = sizeof iad_desc, 566 .bDescriptorType = USB_DT_INTERFACE_ASSOCIATION, 567 568 .bFirstInterface = 0, 569 .bInterfaceCount = 3, 570 .bFunctionClass = USB_CLASS_AUDIO, 571 .bFunctionSubClass = UAC2_FUNCTION_SUBCLASS_UNDEFINED, 572 .bFunctionProtocol = UAC_VERSION_2, 573 }; 574 575 /* Audio Control Interface */ 576 static struct usb_interface_descriptor std_ac_if_desc = { 577 .bLength = sizeof std_ac_if_desc, 578 .bDescriptorType = USB_DT_INTERFACE, 579 580 .bAlternateSetting = 0, 581 .bNumEndpoints = 0, 582 .bInterfaceClass = USB_CLASS_AUDIO, 583 .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL, 584 .bInterfaceProtocol = UAC_VERSION_2, 585 }; 586 587 /* Clock source for IN traffic */ 588 struct uac_clock_source_descriptor in_clk_src_desc = { 589 .bLength = sizeof in_clk_src_desc, 590 .bDescriptorType = USB_DT_CS_INTERFACE, 591 592 .bDescriptorSubtype = UAC2_CLOCK_SOURCE, 593 .bClockID = USB_IN_CLK_ID, 594 .bmAttributes = UAC_CLOCK_SOURCE_TYPE_INT_FIXED, 595 .bmControls = (CONTROL_RDONLY << CLK_FREQ_CTRL), 596 .bAssocTerminal = 0, 597 }; 598 599 /* Clock source for OUT traffic */ 600 struct uac_clock_source_descriptor out_clk_src_desc = { 601 .bLength = sizeof out_clk_src_desc, 602 .bDescriptorType = USB_DT_CS_INTERFACE, 603 604 .bDescriptorSubtype = UAC2_CLOCK_SOURCE, 605 .bClockID = USB_OUT_CLK_ID, 606 .bmAttributes = UAC_CLOCK_SOURCE_TYPE_INT_FIXED, 607 .bmControls = (CONTROL_RDONLY << CLK_FREQ_CTRL), 608 .bAssocTerminal = 0, 609 }; 610 611 /* Input Terminal for USB_OUT */ 612 struct uac2_input_terminal_descriptor usb_out_it_desc = { 613 .bLength = sizeof usb_out_it_desc, 614 .bDescriptorType = USB_DT_CS_INTERFACE, 615 616 .bDescriptorSubtype = UAC_INPUT_TERMINAL, 617 .bTerminalID = USB_OUT_IT_ID, 618 .wTerminalType = cpu_to_le16(UAC_TERMINAL_STREAMING), 619 .bAssocTerminal = 0, 620 .bCSourceID = USB_OUT_CLK_ID, 621 .iChannelNames = 0, 622 .bmControls = (CONTROL_RDWR << COPY_CTRL), 623 }; 624 625 /* Input Terminal for I/O-In */ 626 struct uac2_input_terminal_descriptor io_in_it_desc = { 627 .bLength = sizeof io_in_it_desc, 628 .bDescriptorType = USB_DT_CS_INTERFACE, 629 630 .bDescriptorSubtype = UAC_INPUT_TERMINAL, 631 .bTerminalID = IO_IN_IT_ID, 632 .wTerminalType = cpu_to_le16(UAC_INPUT_TERMINAL_UNDEFINED), 633 .bAssocTerminal = 0, 634 .bCSourceID = USB_IN_CLK_ID, 635 .iChannelNames = 0, 636 .bmControls = (CONTROL_RDWR << COPY_CTRL), 637 }; 638 639 /* Ouput Terminal for USB_IN */ 640 struct uac2_output_terminal_descriptor usb_in_ot_desc = { 641 .bLength = sizeof usb_in_ot_desc, 642 .bDescriptorType = USB_DT_CS_INTERFACE, 643 644 .bDescriptorSubtype = UAC_OUTPUT_TERMINAL, 645 .bTerminalID = USB_IN_OT_ID, 646 .wTerminalType = cpu_to_le16(UAC_TERMINAL_STREAMING), 647 .bAssocTerminal = 0, 648 .bSourceID = IO_IN_IT_ID, 649 .bCSourceID = USB_IN_CLK_ID, 650 .bmControls = (CONTROL_RDWR << COPY_CTRL), 651 }; 652 653 /* Ouput Terminal for I/O-Out */ 654 struct uac2_output_terminal_descriptor io_out_ot_desc = { 655 .bLength = sizeof io_out_ot_desc, 656 .bDescriptorType = USB_DT_CS_INTERFACE, 657 658 .bDescriptorSubtype = UAC_OUTPUT_TERMINAL, 659 .bTerminalID = IO_OUT_OT_ID, 660 .wTerminalType = cpu_to_le16(UAC_OUTPUT_TERMINAL_UNDEFINED), 661 .bAssocTerminal = 0, 662 .bSourceID = USB_OUT_IT_ID, 663 .bCSourceID = USB_OUT_CLK_ID, 664 .bmControls = (CONTROL_RDWR << COPY_CTRL), 665 }; 666 667 struct uac2_ac_header_descriptor ac_hdr_desc = { 668 .bLength = sizeof ac_hdr_desc, 669 .bDescriptorType = USB_DT_CS_INTERFACE, 670 671 .bDescriptorSubtype = UAC_MS_HEADER, 672 .bcdADC = cpu_to_le16(0x200), 673 .bCategory = UAC2_FUNCTION_IO_BOX, 674 .wTotalLength = sizeof in_clk_src_desc + sizeof out_clk_src_desc 675 + sizeof usb_out_it_desc + sizeof io_in_it_desc 676 + sizeof usb_in_ot_desc + sizeof io_out_ot_desc, 677 .bmControls = 0, 678 }; 679 680 /* Audio Streaming OUT Interface - Alt0 */ 681 static struct usb_interface_descriptor std_as_out_if0_desc = { 682 .bLength = sizeof std_as_out_if0_desc, 683 .bDescriptorType = USB_DT_INTERFACE, 684 685 .bAlternateSetting = 0, 686 .bNumEndpoints = 0, 687 .bInterfaceClass = USB_CLASS_AUDIO, 688 .bInterfaceSubClass = USB_SUBCLASS_AUDIOSTREAMING, 689 .bInterfaceProtocol = UAC_VERSION_2, 690 }; 691 692 /* Audio Streaming OUT Interface - Alt1 */ 693 static struct usb_interface_descriptor std_as_out_if1_desc = { 694 .bLength = sizeof std_as_out_if1_desc, 695 .bDescriptorType = USB_DT_INTERFACE, 696 697 .bAlternateSetting = 1, 698 .bNumEndpoints = 1, 699 .bInterfaceClass = USB_CLASS_AUDIO, 700 .bInterfaceSubClass = USB_SUBCLASS_AUDIOSTREAMING, 701 .bInterfaceProtocol = UAC_VERSION_2, 702 }; 703 704 /* Audio Stream OUT Intface Desc */ 705 struct uac2_as_header_descriptor as_out_hdr_desc = { 706 .bLength = sizeof as_out_hdr_desc, 707 .bDescriptorType = USB_DT_CS_INTERFACE, 708 709 .bDescriptorSubtype = UAC_AS_GENERAL, 710 .bTerminalLink = USB_OUT_IT_ID, 711 .bmControls = 0, 712 .bFormatType = UAC_FORMAT_TYPE_I, 713 .bmFormats = cpu_to_le32(UAC_FORMAT_TYPE_I_PCM), 714 .iChannelNames = 0, 715 }; 716 717 /* Audio USB_OUT Format */ 718 struct uac2_format_type_i_descriptor as_out_fmt1_desc = { 719 .bLength = sizeof as_out_fmt1_desc, 720 .bDescriptorType = USB_DT_CS_INTERFACE, 721 .bDescriptorSubtype = UAC_FORMAT_TYPE, 722 .bFormatType = UAC_FORMAT_TYPE_I, 723 }; 724 725 /* STD AS ISO OUT Endpoint */ 726 struct usb_endpoint_descriptor fs_epout_desc = { 727 .bLength = USB_DT_ENDPOINT_SIZE, 728 .bDescriptorType = USB_DT_ENDPOINT, 729 730 .bEndpointAddress = USB_DIR_OUT, 731 .bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC, 732 .bInterval = 1, 733 }; 734 735 struct usb_endpoint_descriptor hs_epout_desc = { 736 .bLength = USB_DT_ENDPOINT_SIZE, 737 .bDescriptorType = USB_DT_ENDPOINT, 738 739 .bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC, 740 .bInterval = 4, 741 }; 742 743 /* CS AS ISO OUT Endpoint */ 744 static struct uac2_iso_endpoint_descriptor as_iso_out_desc = { 745 .bLength = sizeof as_iso_out_desc, 746 .bDescriptorType = USB_DT_CS_ENDPOINT, 747 748 .bDescriptorSubtype = UAC_EP_GENERAL, 749 .bmAttributes = 0, 750 .bmControls = 0, 751 .bLockDelayUnits = 0, 752 .wLockDelay = 0, 753 }; 754 755 /* Audio Streaming IN Interface - Alt0 */ 756 static struct usb_interface_descriptor std_as_in_if0_desc = { 757 .bLength = sizeof std_as_in_if0_desc, 758 .bDescriptorType = USB_DT_INTERFACE, 759 760 .bAlternateSetting = 0, 761 .bNumEndpoints = 0, 762 .bInterfaceClass = USB_CLASS_AUDIO, 763 .bInterfaceSubClass = USB_SUBCLASS_AUDIOSTREAMING, 764 .bInterfaceProtocol = UAC_VERSION_2, 765 }; 766 767 /* Audio Streaming IN Interface - Alt1 */ 768 static struct usb_interface_descriptor std_as_in_if1_desc = { 769 .bLength = sizeof std_as_in_if1_desc, 770 .bDescriptorType = USB_DT_INTERFACE, 771 772 .bAlternateSetting = 1, 773 .bNumEndpoints = 1, 774 .bInterfaceClass = USB_CLASS_AUDIO, 775 .bInterfaceSubClass = USB_SUBCLASS_AUDIOSTREAMING, 776 .bInterfaceProtocol = UAC_VERSION_2, 777 }; 778 779 /* Audio Stream IN Intface Desc */ 780 struct uac2_as_header_descriptor as_in_hdr_desc = { 781 .bLength = sizeof as_in_hdr_desc, 782 .bDescriptorType = USB_DT_CS_INTERFACE, 783 784 .bDescriptorSubtype = UAC_AS_GENERAL, 785 .bTerminalLink = USB_IN_OT_ID, 786 .bmControls = 0, 787 .bFormatType = UAC_FORMAT_TYPE_I, 788 .bmFormats = cpu_to_le32(UAC_FORMAT_TYPE_I_PCM), 789 .iChannelNames = 0, 790 }; 791 792 /* Audio USB_IN Format */ 793 struct uac2_format_type_i_descriptor as_in_fmt1_desc = { 794 .bLength = sizeof as_in_fmt1_desc, 795 .bDescriptorType = USB_DT_CS_INTERFACE, 796 .bDescriptorSubtype = UAC_FORMAT_TYPE, 797 .bFormatType = UAC_FORMAT_TYPE_I, 798 }; 799 800 /* STD AS ISO IN Endpoint */ 801 struct usb_endpoint_descriptor fs_epin_desc = { 802 .bLength = USB_DT_ENDPOINT_SIZE, 803 .bDescriptorType = USB_DT_ENDPOINT, 804 805 .bEndpointAddress = USB_DIR_IN, 806 .bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC, 807 .bInterval = 1, 808 }; 809 810 struct usb_endpoint_descriptor hs_epin_desc = { 811 .bLength = USB_DT_ENDPOINT_SIZE, 812 .bDescriptorType = USB_DT_ENDPOINT, 813 814 .bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC, 815 .bInterval = 4, 816 }; 817 818 /* CS AS ISO IN Endpoint */ 819 static struct uac2_iso_endpoint_descriptor as_iso_in_desc = { 820 .bLength = sizeof as_iso_in_desc, 821 .bDescriptorType = USB_DT_CS_ENDPOINT, 822 823 .bDescriptorSubtype = UAC_EP_GENERAL, 824 .bmAttributes = 0, 825 .bmControls = 0, 826 .bLockDelayUnits = 0, 827 .wLockDelay = 0, 828 }; 829 830 static struct usb_descriptor_header *fs_audio_desc[] = { 831 (struct usb_descriptor_header *)&iad_desc, 832 (struct usb_descriptor_header *)&std_ac_if_desc, 833 834 (struct usb_descriptor_header *)&ac_hdr_desc, 835 (struct usb_descriptor_header *)&in_clk_src_desc, 836 (struct usb_descriptor_header *)&out_clk_src_desc, 837 (struct usb_descriptor_header *)&usb_out_it_desc, 838 (struct usb_descriptor_header *)&io_in_it_desc, 839 (struct usb_descriptor_header *)&usb_in_ot_desc, 840 (struct usb_descriptor_header *)&io_out_ot_desc, 841 842 (struct usb_descriptor_header *)&std_as_out_if0_desc, 843 (struct usb_descriptor_header *)&std_as_out_if1_desc, 844 845 (struct usb_descriptor_header *)&as_out_hdr_desc, 846 (struct usb_descriptor_header *)&as_out_fmt1_desc, 847 (struct usb_descriptor_header *)&fs_epout_desc, 848 (struct usb_descriptor_header *)&as_iso_out_desc, 849 850 (struct usb_descriptor_header *)&std_as_in_if0_desc, 851 (struct usb_descriptor_header *)&std_as_in_if1_desc, 852 853 (struct usb_descriptor_header *)&as_in_hdr_desc, 854 (struct usb_descriptor_header *)&as_in_fmt1_desc, 855 (struct usb_descriptor_header *)&fs_epin_desc, 856 (struct usb_descriptor_header *)&as_iso_in_desc, 857 NULL, 858 }; 859 860 static struct usb_descriptor_header *hs_audio_desc[] = { 861 (struct usb_descriptor_header *)&iad_desc, 862 (struct usb_descriptor_header *)&std_ac_if_desc, 863 864 (struct usb_descriptor_header *)&ac_hdr_desc, 865 (struct usb_descriptor_header *)&in_clk_src_desc, 866 (struct usb_descriptor_header *)&out_clk_src_desc, 867 (struct usb_descriptor_header *)&usb_out_it_desc, 868 (struct usb_descriptor_header *)&io_in_it_desc, 869 (struct usb_descriptor_header *)&usb_in_ot_desc, 870 (struct usb_descriptor_header *)&io_out_ot_desc, 871 872 (struct usb_descriptor_header *)&std_as_out_if0_desc, 873 (struct usb_descriptor_header *)&std_as_out_if1_desc, 874 875 (struct usb_descriptor_header *)&as_out_hdr_desc, 876 (struct usb_descriptor_header *)&as_out_fmt1_desc, 877 (struct usb_descriptor_header *)&hs_epout_desc, 878 (struct usb_descriptor_header *)&as_iso_out_desc, 879 880 (struct usb_descriptor_header *)&std_as_in_if0_desc, 881 (struct usb_descriptor_header *)&std_as_in_if1_desc, 882 883 (struct usb_descriptor_header *)&as_in_hdr_desc, 884 (struct usb_descriptor_header *)&as_in_fmt1_desc, 885 (struct usb_descriptor_header *)&hs_epin_desc, 886 (struct usb_descriptor_header *)&as_iso_in_desc, 887 NULL, 888 }; 889 890 struct cntrl_cur_lay3 { 891 __u32 dCUR; 892 }; 893 894 struct cntrl_range_lay3 { 895 __u16 wNumSubRanges; 896 __u32 dMIN; 897 __u32 dMAX; 898 __u32 dRES; 899 } __packed; 900 901 static inline void 902 free_ep(struct uac2_rtd_params *prm, struct usb_ep *ep) 903 { 904 struct snd_uac2_chip *uac2 = prm->uac2; 905 int i; 906 907 prm->ep_enabled = false; 908 909 for (i = 0; i < USB_XFERS; i++) { 910 if (prm->ureq[i].req) { 911 usb_ep_dequeue(ep, prm->ureq[i].req); 912 usb_ep_free_request(ep, prm->ureq[i].req); 913 prm->ureq[i].req = NULL; 914 } 915 } 916 917 if (usb_ep_disable(ep)) 918 dev_err(&uac2->pdev.dev, 919 "%s:%d Error!\n", __func__, __LINE__); 920 } 921 922 static int __init 923 afunc_bind(struct usb_configuration *cfg, struct usb_function *fn) 924 { 925 struct audio_dev *agdev = func_to_agdev(fn); 926 struct snd_uac2_chip *uac2 = &agdev->uac2; 927 struct usb_composite_dev *cdev = cfg->cdev; 928 struct usb_gadget *gadget = cdev->gadget; 929 struct uac2_rtd_params *prm; 930 int ret; 931 932 ret = usb_interface_id(cfg, fn); 933 if (ret < 0) { 934 dev_err(&uac2->pdev.dev, 935 "%s:%d Error!\n", __func__, __LINE__); 936 return ret; 937 } 938 std_ac_if_desc.bInterfaceNumber = ret; 939 agdev->ac_intf = ret; 940 agdev->ac_alt = 0; 941 942 ret = usb_interface_id(cfg, fn); 943 if (ret < 0) { 944 dev_err(&uac2->pdev.dev, 945 "%s:%d Error!\n", __func__, __LINE__); 946 return ret; 947 } 948 std_as_out_if0_desc.bInterfaceNumber = ret; 949 std_as_out_if1_desc.bInterfaceNumber = ret; 950 agdev->as_out_intf = ret; 951 agdev->as_out_alt = 0; 952 953 ret = usb_interface_id(cfg, fn); 954 if (ret < 0) { 955 dev_err(&uac2->pdev.dev, 956 "%s:%d Error!\n", __func__, __LINE__); 957 return ret; 958 } 959 std_as_in_if0_desc.bInterfaceNumber = ret; 960 std_as_in_if1_desc.bInterfaceNumber = ret; 961 agdev->as_in_intf = ret; 962 agdev->as_in_alt = 0; 963 964 agdev->out_ep = usb_ep_autoconfig(gadget, &fs_epout_desc); 965 if (!agdev->out_ep) { 966 dev_err(&uac2->pdev.dev, 967 "%s:%d Error!\n", __func__, __LINE__); 968 goto err; 969 } 970 agdev->out_ep->driver_data = agdev; 971 972 agdev->in_ep = usb_ep_autoconfig(gadget, &fs_epin_desc); 973 if (!agdev->in_ep) { 974 dev_err(&uac2->pdev.dev, 975 "%s:%d Error!\n", __func__, __LINE__); 976 goto err; 977 } 978 agdev->in_ep->driver_data = agdev; 979 980 uac2->p_prm.uac2 = uac2; 981 uac2->c_prm.uac2 = uac2; 982 983 hs_epout_desc.bEndpointAddress = fs_epout_desc.bEndpointAddress; 984 hs_epout_desc.wMaxPacketSize = fs_epout_desc.wMaxPacketSize; 985 hs_epin_desc.bEndpointAddress = fs_epin_desc.bEndpointAddress; 986 hs_epin_desc.wMaxPacketSize = fs_epin_desc.wMaxPacketSize; 987 988 ret = usb_assign_descriptors(fn, fs_audio_desc, hs_audio_desc, NULL); 989 if (ret) 990 goto err; 991 992 prm = &agdev->uac2.c_prm; 993 prm->max_psize = hs_epout_desc.wMaxPacketSize; 994 prm->rbuf = kzalloc(prm->max_psize * USB_XFERS, GFP_KERNEL); 995 if (!prm->rbuf) { 996 prm->max_psize = 0; 997 goto err; 998 } 999 1000 prm = &agdev->uac2.p_prm; 1001 prm->max_psize = hs_epin_desc.wMaxPacketSize; 1002 prm->rbuf = kzalloc(prm->max_psize * USB_XFERS, GFP_KERNEL); 1003 if (!prm->rbuf) { 1004 prm->max_psize = 0; 1005 goto err; 1006 } 1007 1008 ret = alsa_uac2_init(agdev); 1009 if (ret) 1010 goto err; 1011 return 0; 1012 err: 1013 kfree(agdev->uac2.p_prm.rbuf); 1014 kfree(agdev->uac2.c_prm.rbuf); 1015 usb_free_all_descriptors(fn); 1016 if (agdev->in_ep) 1017 agdev->in_ep->driver_data = NULL; 1018 if (agdev->out_ep) 1019 agdev->out_ep->driver_data = NULL; 1020 return -EINVAL; 1021 } 1022 1023 static void 1024 afunc_unbind(struct usb_configuration *cfg, struct usb_function *fn) 1025 { 1026 struct audio_dev *agdev = func_to_agdev(fn); 1027 struct uac2_rtd_params *prm; 1028 1029 alsa_uac2_exit(agdev); 1030 1031 prm = &agdev->uac2.p_prm; 1032 kfree(prm->rbuf); 1033 1034 prm = &agdev->uac2.c_prm; 1035 kfree(prm->rbuf); 1036 usb_free_all_descriptors(fn); 1037 1038 if (agdev->in_ep) 1039 agdev->in_ep->driver_data = NULL; 1040 if (agdev->out_ep) 1041 agdev->out_ep->driver_data = NULL; 1042 } 1043 1044 static int 1045 afunc_set_alt(struct usb_function *fn, unsigned intf, unsigned alt) 1046 { 1047 struct usb_composite_dev *cdev = fn->config->cdev; 1048 struct audio_dev *agdev = func_to_agdev(fn); 1049 struct snd_uac2_chip *uac2 = &agdev->uac2; 1050 struct usb_gadget *gadget = cdev->gadget; 1051 struct usb_request *req; 1052 struct usb_ep *ep; 1053 struct uac2_rtd_params *prm; 1054 int i; 1055 1056 /* No i/f has more than 2 alt settings */ 1057 if (alt > 1) { 1058 dev_err(&uac2->pdev.dev, 1059 "%s:%d Error!\n", __func__, __LINE__); 1060 return -EINVAL; 1061 } 1062 1063 if (intf == agdev->ac_intf) { 1064 /* Control I/f has only 1 AltSetting - 0 */ 1065 if (alt) { 1066 dev_err(&uac2->pdev.dev, 1067 "%s:%d Error!\n", __func__, __LINE__); 1068 return -EINVAL; 1069 } 1070 return 0; 1071 } 1072 1073 if (intf == agdev->as_out_intf) { 1074 ep = agdev->out_ep; 1075 prm = &uac2->c_prm; 1076 config_ep_by_speed(gadget, fn, ep); 1077 agdev->as_out_alt = alt; 1078 } else if (intf == agdev->as_in_intf) { 1079 ep = agdev->in_ep; 1080 prm = &uac2->p_prm; 1081 config_ep_by_speed(gadget, fn, ep); 1082 agdev->as_in_alt = alt; 1083 } else { 1084 dev_err(&uac2->pdev.dev, 1085 "%s:%d Error!\n", __func__, __LINE__); 1086 return -EINVAL; 1087 } 1088 1089 if (alt == 0) { 1090 free_ep(prm, ep); 1091 return 0; 1092 } 1093 1094 prm->ep_enabled = true; 1095 usb_ep_enable(ep); 1096 1097 for (i = 0; i < USB_XFERS; i++) { 1098 if (prm->ureq[i].req) { 1099 if (usb_ep_queue(ep, prm->ureq[i].req, GFP_ATOMIC)) 1100 dev_err(&uac2->pdev.dev, "%d Error!\n", 1101 __LINE__); 1102 continue; 1103 } 1104 1105 req = usb_ep_alloc_request(ep, GFP_ATOMIC); 1106 if (req == NULL) { 1107 dev_err(&uac2->pdev.dev, 1108 "%s:%d Error!\n", __func__, __LINE__); 1109 return -EINVAL; 1110 } 1111 1112 prm->ureq[i].req = req; 1113 prm->ureq[i].pp = prm; 1114 1115 req->zero = 0; 1116 req->context = &prm->ureq[i]; 1117 req->length = prm->max_psize; 1118 req->complete = agdev_iso_complete; 1119 req->buf = prm->rbuf + i * req->length; 1120 1121 if (usb_ep_queue(ep, req, GFP_ATOMIC)) 1122 dev_err(&uac2->pdev.dev, "%d Error!\n", __LINE__); 1123 } 1124 1125 return 0; 1126 } 1127 1128 static int 1129 afunc_get_alt(struct usb_function *fn, unsigned intf) 1130 { 1131 struct audio_dev *agdev = func_to_agdev(fn); 1132 struct snd_uac2_chip *uac2 = &agdev->uac2; 1133 1134 if (intf == agdev->ac_intf) 1135 return agdev->ac_alt; 1136 else if (intf == agdev->as_out_intf) 1137 return agdev->as_out_alt; 1138 else if (intf == agdev->as_in_intf) 1139 return agdev->as_in_alt; 1140 else 1141 dev_err(&uac2->pdev.dev, 1142 "%s:%d Invalid Interface %d!\n", 1143 __func__, __LINE__, intf); 1144 1145 return -EINVAL; 1146 } 1147 1148 static void 1149 afunc_disable(struct usb_function *fn) 1150 { 1151 struct audio_dev *agdev = func_to_agdev(fn); 1152 struct snd_uac2_chip *uac2 = &agdev->uac2; 1153 1154 free_ep(&uac2->p_prm, agdev->in_ep); 1155 agdev->as_in_alt = 0; 1156 1157 free_ep(&uac2->c_prm, agdev->out_ep); 1158 agdev->as_out_alt = 0; 1159 } 1160 1161 static int 1162 in_rq_cur(struct usb_function *fn, const struct usb_ctrlrequest *cr) 1163 { 1164 struct usb_request *req = fn->config->cdev->req; 1165 struct audio_dev *agdev = func_to_agdev(fn); 1166 struct snd_uac2_chip *uac2 = &agdev->uac2; 1167 u16 w_length = le16_to_cpu(cr->wLength); 1168 u16 w_index = le16_to_cpu(cr->wIndex); 1169 u16 w_value = le16_to_cpu(cr->wValue); 1170 u8 entity_id = (w_index >> 8) & 0xff; 1171 u8 control_selector = w_value >> 8; 1172 int value = -EOPNOTSUPP; 1173 1174 if (control_selector == UAC2_CS_CONTROL_SAM_FREQ) { 1175 struct cntrl_cur_lay3 c; 1176 1177 if (entity_id == USB_IN_CLK_ID) 1178 c.dCUR = p_srate; 1179 else if (entity_id == USB_OUT_CLK_ID) 1180 c.dCUR = c_srate; 1181 1182 value = min_t(unsigned, w_length, sizeof c); 1183 memcpy(req->buf, &c, value); 1184 } else if (control_selector == UAC2_CS_CONTROL_CLOCK_VALID) { 1185 *(u8 *)req->buf = 1; 1186 value = min_t(unsigned, w_length, 1); 1187 } else { 1188 dev_err(&uac2->pdev.dev, 1189 "%s:%d control_selector=%d TODO!\n", 1190 __func__, __LINE__, control_selector); 1191 } 1192 1193 return value; 1194 } 1195 1196 static int 1197 in_rq_range(struct usb_function *fn, const struct usb_ctrlrequest *cr) 1198 { 1199 struct usb_request *req = fn->config->cdev->req; 1200 struct audio_dev *agdev = func_to_agdev(fn); 1201 struct snd_uac2_chip *uac2 = &agdev->uac2; 1202 u16 w_length = le16_to_cpu(cr->wLength); 1203 u16 w_index = le16_to_cpu(cr->wIndex); 1204 u16 w_value = le16_to_cpu(cr->wValue); 1205 u8 entity_id = (w_index >> 8) & 0xff; 1206 u8 control_selector = w_value >> 8; 1207 struct cntrl_range_lay3 r; 1208 int value = -EOPNOTSUPP; 1209 1210 if (control_selector == UAC2_CS_CONTROL_SAM_FREQ) { 1211 if (entity_id == USB_IN_CLK_ID) 1212 r.dMIN = p_srate; 1213 else if (entity_id == USB_OUT_CLK_ID) 1214 r.dMIN = c_srate; 1215 else 1216 return -EOPNOTSUPP; 1217 1218 r.dMAX = r.dMIN; 1219 r.dRES = 0; 1220 r.wNumSubRanges = 1; 1221 1222 value = min_t(unsigned, w_length, sizeof r); 1223 memcpy(req->buf, &r, value); 1224 } else { 1225 dev_err(&uac2->pdev.dev, 1226 "%s:%d control_selector=%d TODO!\n", 1227 __func__, __LINE__, control_selector); 1228 } 1229 1230 return value; 1231 } 1232 1233 static int 1234 ac_rq_in(struct usb_function *fn, const struct usb_ctrlrequest *cr) 1235 { 1236 if (cr->bRequest == UAC2_CS_CUR) 1237 return in_rq_cur(fn, cr); 1238 else if (cr->bRequest == UAC2_CS_RANGE) 1239 return in_rq_range(fn, cr); 1240 else 1241 return -EOPNOTSUPP; 1242 } 1243 1244 static int 1245 out_rq_cur(struct usb_function *fn, const struct usb_ctrlrequest *cr) 1246 { 1247 u16 w_length = le16_to_cpu(cr->wLength); 1248 u16 w_value = le16_to_cpu(cr->wValue); 1249 u8 control_selector = w_value >> 8; 1250 1251 if (control_selector == UAC2_CS_CONTROL_SAM_FREQ) 1252 return w_length; 1253 1254 return -EOPNOTSUPP; 1255 } 1256 1257 static int 1258 setup_rq_inf(struct usb_function *fn, const struct usb_ctrlrequest *cr) 1259 { 1260 struct audio_dev *agdev = func_to_agdev(fn); 1261 struct snd_uac2_chip *uac2 = &agdev->uac2; 1262 u16 w_index = le16_to_cpu(cr->wIndex); 1263 u8 intf = w_index & 0xff; 1264 1265 if (intf != agdev->ac_intf) { 1266 dev_err(&uac2->pdev.dev, 1267 "%s:%d Error!\n", __func__, __LINE__); 1268 return -EOPNOTSUPP; 1269 } 1270 1271 if (cr->bRequestType & USB_DIR_IN) 1272 return ac_rq_in(fn, cr); 1273 else if (cr->bRequest == UAC2_CS_CUR) 1274 return out_rq_cur(fn, cr); 1275 1276 return -EOPNOTSUPP; 1277 } 1278 1279 static int 1280 afunc_setup(struct usb_function *fn, const struct usb_ctrlrequest *cr) 1281 { 1282 struct usb_composite_dev *cdev = fn->config->cdev; 1283 struct audio_dev *agdev = func_to_agdev(fn); 1284 struct snd_uac2_chip *uac2 = &agdev->uac2; 1285 struct usb_request *req = cdev->req; 1286 u16 w_length = le16_to_cpu(cr->wLength); 1287 int value = -EOPNOTSUPP; 1288 1289 /* Only Class specific requests are supposed to reach here */ 1290 if ((cr->bRequestType & USB_TYPE_MASK) != USB_TYPE_CLASS) 1291 return -EOPNOTSUPP; 1292 1293 if ((cr->bRequestType & USB_RECIP_MASK) == USB_RECIP_INTERFACE) 1294 value = setup_rq_inf(fn, cr); 1295 else 1296 dev_err(&uac2->pdev.dev, "%s:%d Error!\n", __func__, __LINE__); 1297 1298 if (value >= 0) { 1299 req->length = value; 1300 req->zero = value < w_length; 1301 value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC); 1302 if (value < 0) { 1303 dev_err(&uac2->pdev.dev, 1304 "%s:%d Error!\n", __func__, __LINE__); 1305 req->status = 0; 1306 } 1307 } 1308 1309 return value; 1310 } 1311 1312 static int audio_bind_config(struct usb_configuration *cfg) 1313 { 1314 int res; 1315 1316 agdev_g = kzalloc(sizeof *agdev_g, GFP_KERNEL); 1317 if (agdev_g == NULL) 1318 return -ENOMEM; 1319 1320 res = usb_string_ids_tab(cfg->cdev, strings_fn); 1321 if (res) 1322 return res; 1323 iad_desc.iFunction = strings_fn[STR_ASSOC].id; 1324 std_ac_if_desc.iInterface = strings_fn[STR_IF_CTRL].id; 1325 in_clk_src_desc.iClockSource = strings_fn[STR_CLKSRC_IN].id; 1326 out_clk_src_desc.iClockSource = strings_fn[STR_CLKSRC_OUT].id; 1327 usb_out_it_desc.iTerminal = strings_fn[STR_USB_IT].id; 1328 io_in_it_desc.iTerminal = strings_fn[STR_IO_IT].id; 1329 usb_in_ot_desc.iTerminal = strings_fn[STR_USB_OT].id; 1330 io_out_ot_desc.iTerminal = strings_fn[STR_IO_OT].id; 1331 std_as_out_if0_desc.iInterface = strings_fn[STR_AS_OUT_ALT0].id; 1332 std_as_out_if1_desc.iInterface = strings_fn[STR_AS_OUT_ALT1].id; 1333 std_as_in_if0_desc.iInterface = strings_fn[STR_AS_IN_ALT0].id; 1334 std_as_in_if1_desc.iInterface = strings_fn[STR_AS_IN_ALT1].id; 1335 1336 agdev_g->func.name = "uac2_func"; 1337 agdev_g->func.strings = fn_strings; 1338 agdev_g->func.bind = afunc_bind; 1339 agdev_g->func.unbind = afunc_unbind; 1340 agdev_g->func.set_alt = afunc_set_alt; 1341 agdev_g->func.get_alt = afunc_get_alt; 1342 agdev_g->func.disable = afunc_disable; 1343 agdev_g->func.setup = afunc_setup; 1344 1345 /* Initialize the configurable parameters */ 1346 usb_out_it_desc.bNrChannels = num_channels(c_chmask); 1347 usb_out_it_desc.bmChannelConfig = cpu_to_le32(c_chmask); 1348 io_in_it_desc.bNrChannels = num_channels(p_chmask); 1349 io_in_it_desc.bmChannelConfig = cpu_to_le32(p_chmask); 1350 as_out_hdr_desc.bNrChannels = num_channels(c_chmask); 1351 as_out_hdr_desc.bmChannelConfig = cpu_to_le32(c_chmask); 1352 as_in_hdr_desc.bNrChannels = num_channels(p_chmask); 1353 as_in_hdr_desc.bmChannelConfig = cpu_to_le32(p_chmask); 1354 as_out_fmt1_desc.bSubslotSize = c_ssize; 1355 as_out_fmt1_desc.bBitResolution = c_ssize * 8; 1356 as_in_fmt1_desc.bSubslotSize = p_ssize; 1357 as_in_fmt1_desc.bBitResolution = p_ssize * 8; 1358 1359 snprintf(clksrc_in, sizeof(clksrc_in), "%uHz", p_srate); 1360 snprintf(clksrc_out, sizeof(clksrc_out), "%uHz", c_srate); 1361 1362 res = usb_add_function(cfg, &agdev_g->func); 1363 if (res < 0) 1364 kfree(agdev_g); 1365 1366 return res; 1367 } 1368 1369 static void 1370 uac2_unbind_config(struct usb_configuration *cfg) 1371 { 1372 kfree(agdev_g); 1373 agdev_g = NULL; 1374 } 1375