drivers/usb/gadget/function/f_uac2.c

   1 /*
   2  * f_uac2.c -- USB Audio Class 2.0 Function
   3  *
   4  * Copyright (C) 2011
   5  *    Yadwinder Singh ([email protected])
   6  *    Jaswinder Singh ([email protected])
   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 }