drivers/usb/gadget/f_uac2.c

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