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         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                 runtime->hw.formats = SNDRV_PCM_FMTBIT_S16_LE; /* ! p_ssize ! */
 352                 runtime->hw.channels_min = num_channels(p_chmask);
 353                 runtime->hw.period_bytes_min = 2 * uac2->p_prm.max_psize
 354                                                 / runtime->hw.periods_min;
 355         } else {
 356                 spin_lock_init(&uac2->c_prm.lock);
 357                 runtime->hw.rate_min = c_srate;
 358                 runtime->hw.formats = SNDRV_PCM_FMTBIT_S16_LE; /* ! c_ssize ! */
 359                 runtime->hw.channels_min = num_channels(c_chmask);
 360                 runtime->hw.period_bytes_min = 2 * uac2->c_prm.max_psize
 361                                                 / runtime->hw.periods_min;
 362         }
 363
 364         runtime->hw.rate_max = runtime->hw.rate_min;
 365         runtime->hw.channels_max = runtime->hw.channels_min;
 366
 367         snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
 368
 369         return 0;
 370 }
 371
 372 /* ALSA cries without these function pointers */
 373 static int uac2_pcm_null(struct snd_pcm_substream *substream)
 374 {
 375         return 0;
 376 }
 377
 378 static struct snd_pcm_ops uac2_pcm_ops = {
 379         .open = uac2_pcm_open,
 380         .close = uac2_pcm_null,
 381         .ioctl = snd_pcm_lib_ioctl,
 382         .hw_params = uac2_pcm_hw_params,
 383         .hw_free = uac2_pcm_hw_free,
 384         .trigger = uac2_pcm_trigger,
 385         .pointer = uac2_pcm_pointer,
 386         .prepare = uac2_pcm_null,
 387 };
 388
 389 static int snd_uac2_probe(struct platform_device *pdev)
 390 {
 391         struct snd_uac2_chip *uac2 = pdev_to_uac2(pdev);
 392         struct snd_card *card;
 393         struct snd_pcm *pcm;
 394         int err;
 395
 396         /* Choose any slot, with no id */
 397         err = snd_card_new(&pdev->dev, -1, NULL, THIS_MODULE, 0, &card);
 398         if (err < 0)
 399                 return err;
 400
 401         uac2->card = card;
 402
 403         /*
 404          * Create first PCM device
 405          * Create a substream only for non-zero channel streams
 406          */
 407         err = snd_pcm_new(uac2->card, "UAC2 PCM", 0,
 408                                p_chmask ? 1 : 0, c_chmask ? 1 : 0, &pcm);
 409         if (err < 0)
 410                 goto snd_fail;
 411
 412         strcpy(pcm->name, "UAC2 PCM");
 413         pcm->private_data = uac2;
 414
 415         uac2->pcm = pcm;
 416
 417         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &uac2_pcm_ops);
 418         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &uac2_pcm_ops);
 419
 420         strcpy(card->driver, "UAC2_Gadget");
 421         strcpy(card->shortname, "UAC2_Gadget");
 422         sprintf(card->longname, "UAC2_Gadget %i", pdev->id);
 423
 424         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_CONTINUOUS,
 425                 snd_dma_continuous_data(GFP_KERNEL), 0, BUFF_SIZE_MAX);
 426
 427         err = snd_card_register(card);
 428         if (!err) {
 429                 platform_set_drvdata(pdev, card);
 430                 return 0;
 431         }
 432
 433 snd_fail:
 434         snd_card_free(card);
 435
 436         uac2->pcm = NULL;
 437         uac2->card = NULL;
 438
 439         return err;
 440 }
 441
 442 static int snd_uac2_remove(struct platform_device *pdev)
 443 {
 444         struct snd_card *card = platform_get_drvdata(pdev);
 445
 446         if (card)
 447                 return snd_card_free(card);
 448
 449         return 0;
 450 }
 451
 452 static int alsa_uac2_init(struct audio_dev *agdev)
 453 {
 454         struct snd_uac2_chip *uac2 = &agdev->uac2;
 455         int err;
 456
 457         uac2->pdrv.probe = snd_uac2_probe;
 458         uac2->pdrv.remove = snd_uac2_remove;
 459         uac2->pdrv.driver.name = uac2_name;
 460
 461         uac2->pdev.id = 0;
 462         uac2->pdev.name = uac2_name;
 463
 464         /* Register snd_uac2 driver */
 465         err = platform_driver_register(&uac2->pdrv);
 466         if (err)
 467                 return err;
 468
 469         /* Register snd_uac2 device */
 470         err = platform_device_register(&uac2->pdev);
 471         if (err)
 472                 platform_driver_unregister(&uac2->pdrv);
 473
 474         return err;
 475 }
 476
 477 static void alsa_uac2_exit(struct audio_dev *agdev)
 478 {
 479         struct snd_uac2_chip *uac2 = &agdev->uac2;
 480
 481         platform_driver_unregister(&uac2->pdrv);
 482         platform_device_unregister(&uac2->pdev);
 483 }
 484
 485
 486 /* --------- USB Function Interface ------------- */
 487
 488 enum {
 489         STR_ASSOC,
 490         STR_IF_CTRL,
 491         STR_CLKSRC_IN,
 492         STR_CLKSRC_OUT,
 493         STR_USB_IT,
 494         STR_IO_IT,
 495         STR_USB_OT,
 496         STR_IO_OT,
 497         STR_AS_OUT_ALT0,
 498         STR_AS_OUT_ALT1,
 499         STR_AS_IN_ALT0,
 500         STR_AS_IN_ALT1,
 501 };
 502
 503 static char clksrc_in[8];
 504 static char clksrc_out[8];
 505
 506 static struct usb_string strings_fn[] = {
 507         [STR_ASSOC].s = "Source/Sink",
 508         [STR_IF_CTRL].s = "Topology Control",
 509         [STR_CLKSRC_IN].s = clksrc_in,
 510         [STR_CLKSRC_OUT].s = clksrc_out,
 511         [STR_USB_IT].s = "USBH Out",
 512         [STR_IO_IT].s = "USBD Out",
 513         [STR_USB_OT].s = "USBH In",
 514         [STR_IO_OT].s = "USBD In",
 515         [STR_AS_OUT_ALT0].s = "Playback Inactive",
 516         [STR_AS_OUT_ALT1].s = "Playback Active",
 517         [STR_AS_IN_ALT0].s = "Capture Inactive",
 518         [STR_AS_IN_ALT1].s = "Capture Active",
 519         { },
 520 };
 521
 522 static struct usb_gadget_strings str_fn = {
 523         .language = 0x0409,     /* en-us */
 524         .strings = strings_fn,
 525 };
 526
 527 static struct usb_gadget_strings *fn_strings[] = {
 528         &str_fn,
 529         NULL,
 530 };
 531
 532 static struct usb_qualifier_descriptor devqual_desc = {
 533         .bLength = sizeof devqual_desc,
 534         .bDescriptorType = USB_DT_DEVICE_QUALIFIER,
 535
 536         .bcdUSB = cpu_to_le16(0x200),
 537         .bDeviceClass = USB_CLASS_MISC,
 538         .bDeviceSubClass = 0x02,
 539         .bDeviceProtocol = 0x01,
 540         .bNumConfigurations = 1,
 541         .bRESERVED = 0,
 542 };
 543
 544 static struct usb_interface_assoc_descriptor iad_desc = {
 545         .bLength = sizeof iad_desc,
 546         .bDescriptorType = USB_DT_INTERFACE_ASSOCIATION,
 547
 548         .bFirstInterface = 0,
 549         .bInterfaceCount = 3,
 550         .bFunctionClass = USB_CLASS_AUDIO,
 551         .bFunctionSubClass = UAC2_FUNCTION_SUBCLASS_UNDEFINED,
 552         .bFunctionProtocol = UAC_VERSION_2,
 553 };
 554
 555 /* Audio Control Interface */
 556 static struct usb_interface_descriptor std_ac_if_desc = {
 557         .bLength = sizeof std_ac_if_desc,
 558         .bDescriptorType = USB_DT_INTERFACE,
 559
 560         .bAlternateSetting = 0,
 561         .bNumEndpoints = 0,
 562         .bInterfaceClass = USB_CLASS_AUDIO,
 563         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
 564         .bInterfaceProtocol = UAC_VERSION_2,
 565 };
 566
 567 /* Clock source for IN traffic */
 568 struct uac_clock_source_descriptor in_clk_src_desc = {
 569         .bLength = sizeof in_clk_src_desc,
 570         .bDescriptorType = USB_DT_CS_INTERFACE,
 571
 572         .bDescriptorSubtype = UAC2_CLOCK_SOURCE,
 573         .bClockID = USB_IN_CLK_ID,
 574         .bmAttributes = UAC_CLOCK_SOURCE_TYPE_INT_FIXED,
 575         .bmControls = (CONTROL_RDONLY << CLK_FREQ_CTRL),
 576         .bAssocTerminal = 0,
 577 };
 578
 579 /* Clock source for OUT traffic */
 580 struct uac_clock_source_descriptor out_clk_src_desc = {
 581         .bLength = sizeof out_clk_src_desc,
 582         .bDescriptorType = USB_DT_CS_INTERFACE,
 583
 584         .bDescriptorSubtype = UAC2_CLOCK_SOURCE,
 585         .bClockID = USB_OUT_CLK_ID,
 586         .bmAttributes = UAC_CLOCK_SOURCE_TYPE_INT_FIXED,
 587         .bmControls = (CONTROL_RDONLY << CLK_FREQ_CTRL),
 588         .bAssocTerminal = 0,
 589 };
 590
 591 /* Input Terminal for USB_OUT */
 592 struct uac2_input_terminal_descriptor usb_out_it_desc = {
 593         .bLength = sizeof usb_out_it_desc,
 594         .bDescriptorType = USB_DT_CS_INTERFACE,
 595
 596         .bDescriptorSubtype = UAC_INPUT_TERMINAL,
 597         .bTerminalID = USB_OUT_IT_ID,
 598         .wTerminalType = cpu_to_le16(UAC_TERMINAL_STREAMING),
 599         .bAssocTerminal = 0,
 600         .bCSourceID = USB_OUT_CLK_ID,
 601         .iChannelNames = 0,
 602         .bmControls = (CONTROL_RDWR << COPY_CTRL),
 603 };
 604
 605 /* Input Terminal for I/O-In */
 606 struct uac2_input_terminal_descriptor io_in_it_desc = {
 607         .bLength = sizeof io_in_it_desc,
 608         .bDescriptorType = USB_DT_CS_INTERFACE,
 609
 610         .bDescriptorSubtype = UAC_INPUT_TERMINAL,
 611         .bTerminalID = IO_IN_IT_ID,
 612         .wTerminalType = cpu_to_le16(UAC_INPUT_TERMINAL_UNDEFINED),
 613         .bAssocTerminal = 0,
 614         .bCSourceID = USB_IN_CLK_ID,
 615         .iChannelNames = 0,
 616         .bmControls = (CONTROL_RDWR << COPY_CTRL),
 617 };
 618
 619 /* Ouput Terminal for USB_IN */
 620 struct uac2_output_terminal_descriptor usb_in_ot_desc = {
 621         .bLength = sizeof usb_in_ot_desc,
 622         .bDescriptorType = USB_DT_CS_INTERFACE,
 623
 624         .bDescriptorSubtype = UAC_OUTPUT_TERMINAL,
 625         .bTerminalID = USB_IN_OT_ID,
 626         .wTerminalType = cpu_to_le16(UAC_TERMINAL_STREAMING),
 627         .bAssocTerminal = 0,
 628         .bSourceID = IO_IN_IT_ID,
 629         .bCSourceID = USB_IN_CLK_ID,
 630         .bmControls = (CONTROL_RDWR << COPY_CTRL),
 631 };
 632
 633 /* Ouput Terminal for I/O-Out */
 634 struct uac2_output_terminal_descriptor io_out_ot_desc = {
 635         .bLength = sizeof io_out_ot_desc,
 636         .bDescriptorType = USB_DT_CS_INTERFACE,
 637
 638         .bDescriptorSubtype = UAC_OUTPUT_TERMINAL,
 639         .bTerminalID = IO_OUT_OT_ID,
 640         .wTerminalType = cpu_to_le16(UAC_OUTPUT_TERMINAL_UNDEFINED),
 641         .bAssocTerminal = 0,
 642         .bSourceID = USB_OUT_IT_ID,
 643         .bCSourceID = USB_OUT_CLK_ID,
 644         .bmControls = (CONTROL_RDWR << COPY_CTRL),
 645 };
 646
 647 struct uac2_ac_header_descriptor ac_hdr_desc = {
 648         .bLength = sizeof ac_hdr_desc,
 649         .bDescriptorType = USB_DT_CS_INTERFACE,
 650
 651         .bDescriptorSubtype = UAC_MS_HEADER,
 652         .bcdADC = cpu_to_le16(0x200),
 653         .bCategory = UAC2_FUNCTION_IO_BOX,
 654         .wTotalLength = sizeof in_clk_src_desc + sizeof out_clk_src_desc
 655                          + sizeof usb_out_it_desc + sizeof io_in_it_desc
 656                         + sizeof usb_in_ot_desc + sizeof io_out_ot_desc,
 657         .bmControls = 0,
 658 };
 659
 660 /* Audio Streaming OUT Interface - Alt0 */
 661 static struct usb_interface_descriptor std_as_out_if0_desc = {
 662         .bLength = sizeof std_as_out_if0_desc,
 663         .bDescriptorType = USB_DT_INTERFACE,
 664
 665         .bAlternateSetting = 0,
 666         .bNumEndpoints = 0,
 667         .bInterfaceClass = USB_CLASS_AUDIO,
 668         .bInterfaceSubClass = USB_SUBCLASS_AUDIOSTREAMING,
 669         .bInterfaceProtocol = UAC_VERSION_2,
 670 };
 671
 672 /* Audio Streaming OUT Interface - Alt1 */
 673 static struct usb_interface_descriptor std_as_out_if1_desc = {
 674         .bLength = sizeof std_as_out_if1_desc,
 675         .bDescriptorType = USB_DT_INTERFACE,
 676
 677         .bAlternateSetting = 1,
 678         .bNumEndpoints = 1,
 679         .bInterfaceClass = USB_CLASS_AUDIO,
 680         .bInterfaceSubClass = USB_SUBCLASS_AUDIOSTREAMING,
 681         .bInterfaceProtocol = UAC_VERSION_2,
 682 };
 683
 684 /* Audio Stream OUT Intface Desc */
 685 struct uac2_as_header_descriptor as_out_hdr_desc = {
 686         .bLength = sizeof as_out_hdr_desc,
 687         .bDescriptorType = USB_DT_CS_INTERFACE,
 688
 689         .bDescriptorSubtype = UAC_AS_GENERAL,
 690         .bTerminalLink = USB_OUT_IT_ID,
 691         .bmControls = 0,
 692         .bFormatType = UAC_FORMAT_TYPE_I,
 693         .bmFormats = cpu_to_le32(UAC_FORMAT_TYPE_I_PCM),
 694         .iChannelNames = 0,
 695 };
 696
 697 /* Audio USB_OUT Format */
 698 struct uac2_format_type_i_descriptor as_out_fmt1_desc = {
 699         .bLength = sizeof as_out_fmt1_desc,
 700         .bDescriptorType = USB_DT_CS_INTERFACE,
 701         .bDescriptorSubtype = UAC_FORMAT_TYPE,
 702         .bFormatType = UAC_FORMAT_TYPE_I,
 703 };
 704
 705 /* STD AS ISO OUT Endpoint */
 706 struct usb_endpoint_descriptor fs_epout_desc = {
 707         .bLength = USB_DT_ENDPOINT_SIZE,
 708         .bDescriptorType = USB_DT_ENDPOINT,
 709
 710         .bEndpointAddress = USB_DIR_OUT,
 711         .bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC,
 712         .bInterval = 1,
 713 };
 714
 715 struct usb_endpoint_descriptor hs_epout_desc = {
 716         .bLength = USB_DT_ENDPOINT_SIZE,
 717         .bDescriptorType = USB_DT_ENDPOINT,
 718
 719         .bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC,
 720         .bInterval = 4,
 721 };
 722
 723 /* CS AS ISO OUT Endpoint */
 724 static struct uac2_iso_endpoint_descriptor as_iso_out_desc = {
 725         .bLength = sizeof as_iso_out_desc,
 726         .bDescriptorType = USB_DT_CS_ENDPOINT,
 727
 728         .bDescriptorSubtype = UAC_EP_GENERAL,
 729         .bmAttributes = 0,
 730         .bmControls = 0,
 731         .bLockDelayUnits = 0,
 732         .wLockDelay = 0,
 733 };
 734
 735 /* Audio Streaming IN Interface - Alt0 */
 736 static struct usb_interface_descriptor std_as_in_if0_desc = {
 737         .bLength = sizeof std_as_in_if0_desc,
 738         .bDescriptorType = USB_DT_INTERFACE,
 739
 740         .bAlternateSetting = 0,
 741         .bNumEndpoints = 0,
 742         .bInterfaceClass = USB_CLASS_AUDIO,
 743         .bInterfaceSubClass = USB_SUBCLASS_AUDIOSTREAMING,
 744         .bInterfaceProtocol = UAC_VERSION_2,
 745 };
 746
 747 /* Audio Streaming IN Interface - Alt1 */
 748 static struct usb_interface_descriptor std_as_in_if1_desc = {
 749         .bLength = sizeof std_as_in_if1_desc,
 750         .bDescriptorType = USB_DT_INTERFACE,
 751
 752         .bAlternateSetting = 1,
 753         .bNumEndpoints = 1,
 754         .bInterfaceClass = USB_CLASS_AUDIO,
 755         .bInterfaceSubClass = USB_SUBCLASS_AUDIOSTREAMING,
 756         .bInterfaceProtocol = UAC_VERSION_2,
 757 };
 758
 759 /* Audio Stream IN Intface Desc */
 760 struct uac2_as_header_descriptor as_in_hdr_desc = {
 761         .bLength = sizeof as_in_hdr_desc,
 762         .bDescriptorType = USB_DT_CS_INTERFACE,
 763
 764         .bDescriptorSubtype = UAC_AS_GENERAL,
 765         .bTerminalLink = USB_IN_OT_ID,
 766         .bmControls = 0,
 767         .bFormatType = UAC_FORMAT_TYPE_I,
 768         .bmFormats = cpu_to_le32(UAC_FORMAT_TYPE_I_PCM),
 769         .iChannelNames = 0,
 770 };
 771
 772 /* Audio USB_IN Format */
 773 struct uac2_format_type_i_descriptor as_in_fmt1_desc = {
 774         .bLength = sizeof as_in_fmt1_desc,
 775         .bDescriptorType = USB_DT_CS_INTERFACE,
 776         .bDescriptorSubtype = UAC_FORMAT_TYPE,
 777         .bFormatType = UAC_FORMAT_TYPE_I,
 778 };
 779
 780 /* STD AS ISO IN Endpoint */
 781 struct usb_endpoint_descriptor fs_epin_desc = {
 782         .bLength = USB_DT_ENDPOINT_SIZE,
 783         .bDescriptorType = USB_DT_ENDPOINT,
 784
 785         .bEndpointAddress = USB_DIR_IN,
 786         .bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC,
 787         .bInterval = 1,
 788 };
 789
 790 struct usb_endpoint_descriptor hs_epin_desc = {
 791         .bLength = USB_DT_ENDPOINT_SIZE,
 792         .bDescriptorType = USB_DT_ENDPOINT,
 793
 794         .bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC,
 795         .bInterval = 4,
 796 };
 797
 798 /* CS AS ISO IN Endpoint */
 799 static struct uac2_iso_endpoint_descriptor as_iso_in_desc = {
 800         .bLength = sizeof as_iso_in_desc,
 801         .bDescriptorType = USB_DT_CS_ENDPOINT,
 802
 803         .bDescriptorSubtype = UAC_EP_GENERAL,
 804         .bmAttributes = 0,
 805         .bmControls = 0,
 806         .bLockDelayUnits = 0,
 807         .wLockDelay = 0,
 808 };
 809
 810 static struct usb_descriptor_header *fs_audio_desc[] = {
 811         (struct usb_descriptor_header *)&iad_desc,
 812         (struct usb_descriptor_header *)&std_ac_if_desc,
 813
 814         (struct usb_descriptor_header *)&ac_hdr_desc,
 815         (struct usb_descriptor_header *)&in_clk_src_desc,
 816         (struct usb_descriptor_header *)&out_clk_src_desc,
 817         (struct usb_descriptor_header *)&usb_out_it_desc,
 818         (struct usb_descriptor_header *)&io_in_it_desc,
 819         (struct usb_descriptor_header *)&usb_in_ot_desc,
 820         (struct usb_descriptor_header *)&io_out_ot_desc,
 821
 822         (struct usb_descriptor_header *)&std_as_out_if0_desc,
 823         (struct usb_descriptor_header *)&std_as_out_if1_desc,
 824
 825         (struct usb_descriptor_header *)&as_out_hdr_desc,
 826         (struct usb_descriptor_header *)&as_out_fmt1_desc,
 827         (struct usb_descriptor_header *)&fs_epout_desc,
 828         (struct usb_descriptor_header *)&as_iso_out_desc,
 829
 830         (struct usb_descriptor_header *)&std_as_in_if0_desc,
 831         (struct usb_descriptor_header *)&std_as_in_if1_desc,
 832
 833         (struct usb_descriptor_header *)&as_in_hdr_desc,
 834         (struct usb_descriptor_header *)&as_in_fmt1_desc,
 835         (struct usb_descriptor_header *)&fs_epin_desc,
 836         (struct usb_descriptor_header *)&as_iso_in_desc,
 837         NULL,
 838 };
 839
 840 static struct usb_descriptor_header *hs_audio_desc[] = {
 841         (struct usb_descriptor_header *)&iad_desc,
 842         (struct usb_descriptor_header *)&std_ac_if_desc,
 843
 844         (struct usb_descriptor_header *)&ac_hdr_desc,
 845         (struct usb_descriptor_header *)&in_clk_src_desc,
 846         (struct usb_descriptor_header *)&out_clk_src_desc,
 847         (struct usb_descriptor_header *)&usb_out_it_desc,
 848         (struct usb_descriptor_header *)&io_in_it_desc,
 849         (struct usb_descriptor_header *)&usb_in_ot_desc,
 850         (struct usb_descriptor_header *)&io_out_ot_desc,
 851
 852         (struct usb_descriptor_header *)&std_as_out_if0_desc,
 853         (struct usb_descriptor_header *)&std_as_out_if1_desc,
 854
 855         (struct usb_descriptor_header *)&as_out_hdr_desc,
 856         (struct usb_descriptor_header *)&as_out_fmt1_desc,
 857         (struct usb_descriptor_header *)&hs_epout_desc,
 858         (struct usb_descriptor_header *)&as_iso_out_desc,
 859
 860         (struct usb_descriptor_header *)&std_as_in_if0_desc,
 861         (struct usb_descriptor_header *)&std_as_in_if1_desc,
 862
 863         (struct usb_descriptor_header *)&as_in_hdr_desc,
 864         (struct usb_descriptor_header *)&as_in_fmt1_desc,
 865         (struct usb_descriptor_header *)&hs_epin_desc,
 866         (struct usb_descriptor_header *)&as_iso_in_desc,
 867         NULL,
 868 };
 869
 870 struct cntrl_cur_lay3 {
 871         __u32   dCUR;
 872 };
 873
 874 struct cntrl_range_lay3 {
 875         __u16   wNumSubRanges;
 876         __u32   dMIN;
 877         __u32   dMAX;
 878         __u32   dRES;
 879 } __packed;
 880
 881 static inline void
 882 free_ep(struct uac2_rtd_params *prm, struct usb_ep *ep)
 883 {
 884         struct snd_uac2_chip *uac2 = prm->uac2;
 885         int i;
 886
 887         prm->ep_enabled = false;
 888
 889         for (i = 0; i < USB_XFERS; i++) {
 890                 if (prm->ureq[i].req) {
 891                         usb_ep_dequeue(ep, prm->ureq[i].req);
 892                         usb_ep_free_request(ep, prm->ureq[i].req);
 893                         prm->ureq[i].req = NULL;
 894                 }
 895         }
 896
 897         if (usb_ep_disable(ep))
 898                 dev_err(&uac2->pdev.dev,
 899                         "%s:%d Error!\n", __func__, __LINE__);
 900 }
 901
 902 static int __init
 903 afunc_bind(struct usb_configuration *cfg, struct usb_function *fn)
 904 {
 905         struct audio_dev *agdev = func_to_agdev(fn);
 906         struct snd_uac2_chip *uac2 = &agdev->uac2;
 907         struct usb_composite_dev *cdev = cfg->cdev;
 908         struct usb_gadget *gadget = cdev->gadget;
 909         struct uac2_rtd_params *prm;
 910         int ret;
 911
 912         ret = usb_interface_id(cfg, fn);
 913         if (ret < 0) {
 914                 dev_err(&uac2->pdev.dev,
 915                         "%s:%d Error!\n", __func__, __LINE__);
 916                 return ret;
 917         }
 918         std_ac_if_desc.bInterfaceNumber = ret;
 919         agdev->ac_intf = ret;
 920         agdev->ac_alt = 0;
 921
 922         ret = usb_interface_id(cfg, fn);
 923         if (ret < 0) {
 924                 dev_err(&uac2->pdev.dev,
 925                         "%s:%d Error!\n", __func__, __LINE__);
 926                 return ret;
 927         }
 928         std_as_out_if0_desc.bInterfaceNumber = ret;
 929         std_as_out_if1_desc.bInterfaceNumber = ret;
 930         agdev->as_out_intf = ret;
 931         agdev->as_out_alt = 0;
 932
 933         ret = usb_interface_id(cfg, fn);
 934         if (ret < 0) {
 935                 dev_err(&uac2->pdev.dev,
 936                         "%s:%d Error!\n", __func__, __LINE__);
 937                 return ret;
 938         }
 939         std_as_in_if0_desc.bInterfaceNumber = ret;
 940         std_as_in_if1_desc.bInterfaceNumber = ret;
 941         agdev->as_in_intf = ret;
 942         agdev->as_in_alt = 0;
 943
 944         agdev->out_ep = usb_ep_autoconfig(gadget, &fs_epout_desc);
 945         if (!agdev->out_ep) {
 946                 dev_err(&uac2->pdev.dev,
 947                         "%s:%d Error!\n", __func__, __LINE__);
 948                 goto err;
 949         }
 950         agdev->out_ep->driver_data = agdev;
 951
 952         agdev->in_ep = usb_ep_autoconfig(gadget, &fs_epin_desc);
 953         if (!agdev->in_ep) {
 954                 dev_err(&uac2->pdev.dev,
 955                         "%s:%d Error!\n", __func__, __LINE__);
 956                 goto err;
 957         }
 958         agdev->in_ep->driver_data = agdev;
 959
 960         uac2->p_prm.uac2 = uac2;
 961         uac2->c_prm.uac2 = uac2;
 962
 963         hs_epout_desc.bEndpointAddress = fs_epout_desc.bEndpointAddress;
 964         hs_epout_desc.wMaxPacketSize = fs_epout_desc.wMaxPacketSize;
 965         hs_epin_desc.bEndpointAddress = fs_epin_desc.bEndpointAddress;
 966         hs_epin_desc.wMaxPacketSize = fs_epin_desc.wMaxPacketSize;
 967
 968         ret = usb_assign_descriptors(fn, fs_audio_desc, hs_audio_desc, NULL);
 969         if (ret)
 970                 goto err;
 971
 972         prm = &agdev->uac2.c_prm;
 973         prm->max_psize = hs_epout_desc.wMaxPacketSize;
 974         prm->rbuf = kzalloc(prm->max_psize * USB_XFERS, GFP_KERNEL);
 975         if (!prm->rbuf) {
 976                 prm->max_psize = 0;
 977                 goto err;
 978         }
 979
 980         prm = &agdev->uac2.p_prm;
 981         prm->max_psize = hs_epin_desc.wMaxPacketSize;
 982         prm->rbuf = kzalloc(prm->max_psize * USB_XFERS, GFP_KERNEL);
 983         if (!prm->rbuf) {
 984                 prm->max_psize = 0;
 985                 goto err;
 986         }
 987
 988         ret = alsa_uac2_init(agdev);
 989         if (ret)
 990                 goto err;
 991         return 0;
 992 err:
 993         kfree(agdev->uac2.p_prm.rbuf);
 994         kfree(agdev->uac2.c_prm.rbuf);
 995         usb_free_all_descriptors(fn);
 996         if (agdev->in_ep)
 997                 agdev->in_ep->driver_data = NULL;
 998         if (agdev->out_ep)
 999                 agdev->out_ep->driver_data = NULL;
1000         return -EINVAL;
1001 }
1002
1003 static void
1004 afunc_unbind(struct usb_configuration *cfg, struct usb_function *fn)
1005 {
1006         struct audio_dev *agdev = func_to_agdev(fn);
1007         struct uac2_rtd_params *prm;
1008
1009         alsa_uac2_exit(agdev);
1010
1011         prm = &agdev->uac2.p_prm;
1012         kfree(prm->rbuf);
1013
1014         prm = &agdev->uac2.c_prm;
1015         kfree(prm->rbuf);
1016         usb_free_all_descriptors(fn);
1017
1018         if (agdev->in_ep)
1019                 agdev->in_ep->driver_data = NULL;
1020         if (agdev->out_ep)
1021                 agdev->out_ep->driver_data = NULL;
1022 }
1023
1024 static int
1025 afunc_set_alt(struct usb_function *fn, unsigned intf, unsigned alt)
1026 {
1027         struct usb_composite_dev *cdev = fn->config->cdev;
1028         struct audio_dev *agdev = func_to_agdev(fn);
1029         struct snd_uac2_chip *uac2 = &agdev->uac2;
1030         struct usb_gadget *gadget = cdev->gadget;
1031         struct usb_request *req;
1032         struct usb_ep *ep;
1033         struct uac2_rtd_params *prm;
1034         int i;
1035
1036         /* No i/f has more than 2 alt settings */
1037         if (alt > 1) {
1038                 dev_err(&uac2->pdev.dev,
1039                         "%s:%d Error!\n", __func__, __LINE__);
1040                 return -EINVAL;
1041         }
1042
1043         if (intf == agdev->ac_intf) {
1044                 /* Control I/f has only 1 AltSetting - 0 */
1045                 if (alt) {
1046                         dev_err(&uac2->pdev.dev,
1047                                 "%s:%d Error!\n", __func__, __LINE__);
1048                         return -EINVAL;
1049                 }
1050                 return 0;
1051         }
1052
1053         if (intf == agdev->as_out_intf) {
1054                 ep = agdev->out_ep;
1055                 prm = &uac2->c_prm;
1056                 config_ep_by_speed(gadget, fn, ep);
1057                 agdev->as_out_alt = alt;
1058         } else if (intf == agdev->as_in_intf) {
1059                 ep = agdev->in_ep;
1060                 prm = &uac2->p_prm;
1061                 config_ep_by_speed(gadget, fn, ep);
1062                 agdev->as_in_alt = alt;
1063         } else {
1064                 dev_err(&uac2->pdev.dev,
1065                         "%s:%d Error!\n", __func__, __LINE__);
1066                 return -EINVAL;
1067         }
1068
1069         if (alt == 0) {
1070                 free_ep(prm, ep);
1071                 return 0;
1072         }
1073
1074         prm->ep_enabled = true;
1075         usb_ep_enable(ep);
1076
1077         for (i = 0; i < USB_XFERS; i++) {
1078                 if (prm->ureq[i].req) {
1079                         if (usb_ep_queue(ep, prm->ureq[i].req, GFP_ATOMIC))
1080                                 dev_err(&uac2->pdev.dev, "%d Error!\n",
1081                                         __LINE__);
1082                         continue;
1083                 }
1084
1085                 req = usb_ep_alloc_request(ep, GFP_ATOMIC);
1086                 if (req == NULL) {
1087                         dev_err(&uac2->pdev.dev,
1088                                 "%s:%d Error!\n", __func__, __LINE__);
1089                         return -EINVAL;
1090                 }
1091
1092                 prm->ureq[i].req = req;
1093                 prm->ureq[i].pp = prm;
1094
1095                 req->zero = 0;
1096                 req->context = &prm->ureq[i];
1097                 req->length = prm->max_psize;
1098                 req->complete = agdev_iso_complete;
1099                 req->buf = prm->rbuf + i * req->length;
1100
1101                 if (usb_ep_queue(ep, req, GFP_ATOMIC))
1102                         dev_err(&uac2->pdev.dev, "%d Error!\n", __LINE__);
1103         }
1104
1105         return 0;
1106 }
1107
1108 static int
1109 afunc_get_alt(struct usb_function *fn, unsigned intf)
1110 {
1111         struct audio_dev *agdev = func_to_agdev(fn);
1112         struct snd_uac2_chip *uac2 = &agdev->uac2;
1113
1114         if (intf == agdev->ac_intf)
1115                 return agdev->ac_alt;
1116         else if (intf == agdev->as_out_intf)
1117                 return agdev->as_out_alt;
1118         else if (intf == agdev->as_in_intf)
1119                 return agdev->as_in_alt;
1120         else
1121                 dev_err(&uac2->pdev.dev,
1122                         "%s:%d Invalid Interface %d!\n",
1123                         __func__, __LINE__, intf);
1124
1125         return -EINVAL;
1126 }
1127
1128 static void
1129 afunc_disable(struct usb_function *fn)
1130 {
1131         struct audio_dev *agdev = func_to_agdev(fn);
1132         struct snd_uac2_chip *uac2 = &agdev->uac2;
1133
1134         free_ep(&uac2->p_prm, agdev->in_ep);
1135         agdev->as_in_alt = 0;
1136
1137         free_ep(&uac2->c_prm, agdev->out_ep);
1138         agdev->as_out_alt = 0;
1139 }
1140
1141 static int
1142 in_rq_cur(struct usb_function *fn, const struct usb_ctrlrequest *cr)
1143 {
1144         struct usb_request *req = fn->config->cdev->req;
1145         struct audio_dev *agdev = func_to_agdev(fn);
1146         struct snd_uac2_chip *uac2 = &agdev->uac2;
1147         u16 w_length = le16_to_cpu(cr->wLength);
1148         u16 w_index = le16_to_cpu(cr->wIndex);
1149         u16 w_value = le16_to_cpu(cr->wValue);
1150         u8 entity_id = (w_index >> 8) & 0xff;
1151         u8 control_selector = w_value >> 8;
1152         int value = -EOPNOTSUPP;
1153
1154         if (control_selector == UAC2_CS_CONTROL_SAM_FREQ) {
1155                 struct cntrl_cur_lay3 c;
1156
1157                 if (entity_id == USB_IN_CLK_ID)
1158                         c.dCUR = p_srate;
1159                 else if (entity_id == USB_OUT_CLK_ID)
1160                         c.dCUR = c_srate;
1161
1162                 value = min_t(unsigned, w_length, sizeof c);
1163                 memcpy(req->buf, &c, value);
1164         } else if (control_selector == UAC2_CS_CONTROL_CLOCK_VALID) {
1165                 *(u8 *)req->buf = 1;
1166                 value = min_t(unsigned, w_length, 1);
1167         } else {
1168                 dev_err(&uac2->pdev.dev,
1169                         "%s:%d control_selector=%d TODO!\n",
1170                         __func__, __LINE__, control_selector);
1171         }
1172
1173         return value;
1174 }
1175
1176 static int
1177 in_rq_range(struct usb_function *fn, const struct usb_ctrlrequest *cr)
1178 {
1179         struct usb_request *req = fn->config->cdev->req;
1180         struct audio_dev *agdev = func_to_agdev(fn);
1181         struct snd_uac2_chip *uac2 = &agdev->uac2;
1182         u16 w_length = le16_to_cpu(cr->wLength);
1183         u16 w_index = le16_to_cpu(cr->wIndex);
1184         u16 w_value = le16_to_cpu(cr->wValue);
1185         u8 entity_id = (w_index >> 8) & 0xff;
1186         u8 control_selector = w_value >> 8;
1187         struct cntrl_range_lay3 r;
1188         int value = -EOPNOTSUPP;
1189
1190         if (control_selector == UAC2_CS_CONTROL_SAM_FREQ) {
1191                 if (entity_id == USB_IN_CLK_ID)
1192                         r.dMIN = p_srate;
1193                 else if (entity_id == USB_OUT_CLK_ID)
1194                         r.dMIN = c_srate;
1195                 else
1196                         return -EOPNOTSUPP;
1197
1198                 r.dMAX = r.dMIN;
1199                 r.dRES = 0;
1200                 r.wNumSubRanges = 1;
1201
1202                 value = min_t(unsigned, w_length, sizeof r);
1203                 memcpy(req->buf, &r, value);
1204         } else {
1205                 dev_err(&uac2->pdev.dev,
1206                         "%s:%d control_selector=%d TODO!\n",
1207                         __func__, __LINE__, control_selector);
1208         }
1209
1210         return value;
1211 }
1212
1213 static int
1214 ac_rq_in(struct usb_function *fn, const struct usb_ctrlrequest *cr)
1215 {
1216         if (cr->bRequest == UAC2_CS_CUR)
1217                 return in_rq_cur(fn, cr);
1218         else if (cr->bRequest == UAC2_CS_RANGE)
1219                 return in_rq_range(fn, cr);
1220         else
1221                 return -EOPNOTSUPP;
1222 }
1223
1224 static int
1225 out_rq_cur(struct usb_function *fn, const struct usb_ctrlrequest *cr)
1226 {
1227         u16 w_length = le16_to_cpu(cr->wLength);
1228         u16 w_value = le16_to_cpu(cr->wValue);
1229         u8 control_selector = w_value >> 8;
1230
1231         if (control_selector == UAC2_CS_CONTROL_SAM_FREQ)
1232                 return w_length;
1233
1234         return -EOPNOTSUPP;
1235 }
1236
1237 static int
1238 setup_rq_inf(struct usb_function *fn, const struct usb_ctrlrequest *cr)
1239 {
1240         struct audio_dev *agdev = func_to_agdev(fn);
1241         struct snd_uac2_chip *uac2 = &agdev->uac2;
1242         u16 w_index = le16_to_cpu(cr->wIndex);
1243         u8 intf = w_index & 0xff;
1244
1245         if (intf != agdev->ac_intf) {
1246                 dev_err(&uac2->pdev.dev,
1247                         "%s:%d Error!\n", __func__, __LINE__);
1248                 return -EOPNOTSUPP;
1249         }
1250
1251         if (cr->bRequestType & USB_DIR_IN)
1252                 return ac_rq_in(fn, cr);
1253         else if (cr->bRequest == UAC2_CS_CUR)
1254                 return out_rq_cur(fn, cr);
1255
1256         return -EOPNOTSUPP;
1257 }
1258
1259 static int
1260 afunc_setup(struct usb_function *fn, const struct usb_ctrlrequest *cr)
1261 {
1262         struct usb_composite_dev *cdev = fn->config->cdev;
1263         struct audio_dev *agdev = func_to_agdev(fn);
1264         struct snd_uac2_chip *uac2 = &agdev->uac2;
1265         struct usb_request *req = cdev->req;
1266         u16 w_length = le16_to_cpu(cr->wLength);
1267         int value = -EOPNOTSUPP;
1268
1269         /* Only Class specific requests are supposed to reach here */
1270         if ((cr->bRequestType & USB_TYPE_MASK) != USB_TYPE_CLASS)
1271                 return -EOPNOTSUPP;
1272
1273         if ((cr->bRequestType & USB_RECIP_MASK) == USB_RECIP_INTERFACE)
1274                 value = setup_rq_inf(fn, cr);
1275         else
1276                 dev_err(&uac2->pdev.dev, "%s:%d Error!\n", __func__, __LINE__);
1277
1278         if (value >= 0) {
1279                 req->length = value;
1280                 req->zero = value < w_length;
1281                 value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
1282                 if (value < 0) {
1283                         dev_err(&uac2->pdev.dev,
1284                                 "%s:%d Error!\n", __func__, __LINE__);
1285                         req->status = 0;
1286                 }
1287         }
1288
1289         return value;
1290 }
1291
1292 static int audio_bind_config(struct usb_configuration *cfg)
1293 {
1294         int res;
1295
1296         agdev_g = kzalloc(sizeof *agdev_g, GFP_KERNEL);
1297         if (agdev_g == NULL)
1298                 return -ENOMEM;
1299
1300         res = usb_string_ids_tab(cfg->cdev, strings_fn);
1301         if (res)
1302                 return res;
1303         iad_desc.iFunction = strings_fn[STR_ASSOC].id;
1304         std_ac_if_desc.iInterface = strings_fn[STR_IF_CTRL].id;
1305         in_clk_src_desc.iClockSource = strings_fn[STR_CLKSRC_IN].id;
1306         out_clk_src_desc.iClockSource = strings_fn[STR_CLKSRC_OUT].id;
1307         usb_out_it_desc.iTerminal = strings_fn[STR_USB_IT].id;
1308         io_in_it_desc.iTerminal = strings_fn[STR_IO_IT].id;
1309         usb_in_ot_desc.iTerminal = strings_fn[STR_USB_OT].id;
1310         io_out_ot_desc.iTerminal = strings_fn[STR_IO_OT].id;
1311         std_as_out_if0_desc.iInterface = strings_fn[STR_AS_OUT_ALT0].id;
1312         std_as_out_if1_desc.iInterface = strings_fn[STR_AS_OUT_ALT1].id;
1313         std_as_in_if0_desc.iInterface = strings_fn[STR_AS_IN_ALT0].id;
1314         std_as_in_if1_desc.iInterface = strings_fn[STR_AS_IN_ALT1].id;
1315
1316         agdev_g->func.name = "uac2_func";
1317         agdev_g->func.strings = fn_strings;
1318         agdev_g->func.bind = afunc_bind;
1319         agdev_g->func.unbind = afunc_unbind;
1320         agdev_g->func.set_alt = afunc_set_alt;
1321         agdev_g->func.get_alt = afunc_get_alt;
1322         agdev_g->func.disable = afunc_disable;
1323         agdev_g->func.setup = afunc_setup;
1324
1325         /* Initialize the configurable parameters */
1326         usb_out_it_desc.bNrChannels = num_channels(c_chmask);
1327         usb_out_it_desc.bmChannelConfig = cpu_to_le32(c_chmask);
1328         io_in_it_desc.bNrChannels = num_channels(p_chmask);
1329         io_in_it_desc.bmChannelConfig = cpu_to_le32(p_chmask);
1330         as_out_hdr_desc.bNrChannels = num_channels(c_chmask);
1331         as_out_hdr_desc.bmChannelConfig = cpu_to_le32(c_chmask);
1332         as_in_hdr_desc.bNrChannels = num_channels(p_chmask);
1333         as_in_hdr_desc.bmChannelConfig = cpu_to_le32(p_chmask);
1334         as_out_fmt1_desc.bSubslotSize = c_ssize;
1335         as_out_fmt1_desc.bBitResolution = c_ssize * 8;
1336         as_in_fmt1_desc.bSubslotSize = p_ssize;
1337         as_in_fmt1_desc.bBitResolution = p_ssize * 8;
1338
1339         snprintf(clksrc_in, sizeof(clksrc_in), "%uHz", p_srate);
1340         snprintf(clksrc_out, sizeof(clksrc_out), "%uHz", c_srate);
1341
1342         res = usb_add_function(cfg, &agdev_g->func);
1343         if (res < 0)
1344                 kfree(agdev_g);
1345
1346         return res;
1347 }
1348
1349 static void
1350 uac2_unbind_config(struct usb_configuration *cfg)
1351 {
1352         kfree(agdev_g);
1353         agdev_g = NULL;
1354 }