drivers/usb/gadget/function/f_uac2.c

   1 /*
   2  * f_uac2.c -- USB Audio Class 2.0 Function
   3  *
   4  * Copyright (C) 2011
   5  *    Yadwinder Singh (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 #include "u_uac2.h"
  24
  25 /* Keep everyone on toes */
  26 #define USB_XFERS       2
  27
  28 /*
  29  * The driver implements a simple UAC_2 topology.
  30  * USB-OUT -> IT_1 -> OT_3 -> ALSA_Capture
  31  * ALSA_Playback -> IT_2 -> OT_4 -> USB-IN
  32  * Capture and Playback sampling rates are independently
  33  *  controlled by two clock sources :
  34  *    CLK_5 := c_srate, and CLK_6 := p_srate
  35  */
  36 #define USB_OUT_IT_ID   1
  37 #define IO_IN_IT_ID     2
  38 #define IO_OUT_OT_ID    3
  39 #define USB_IN_OT_ID    4
  40 #define USB_OUT_CLK_ID  5
  41 #define USB_IN_CLK_ID   6
  42
  43 #define CONTROL_ABSENT  0
  44 #define CONTROL_RDONLY  1
  45 #define CONTROL_RDWR    3
  46
  47 #define CLK_FREQ_CTRL   0
  48 #define CLK_VLD_CTRL    2
  49
  50 #define COPY_CTRL       0
  51 #define CONN_CTRL       2
  52 #define OVRLD_CTRL      4
  53 #define CLSTR_CTRL      6
  54 #define UNFLW_CTRL      8
  55 #define OVFLW_CTRL      10
  56
  57 static const char *uac2_name = "snd_uac2";
  58
  59 struct uac2_req {
  60         struct uac2_rtd_params *pp; /* parent param */
  61         struct usb_request *req;
  62 };
  63
  64 struct uac2_rtd_params {
  65         struct snd_uac2_chip *uac2; /* parent chip */
  66         bool ep_enabled; /* if the ep is enabled */
  67         /* Size of the ring buffer */
  68         size_t dma_bytes;
  69         unsigned char *dma_area;
  70
  71         struct snd_pcm_substream *ss;
  72
  73         /* Ring buffer */
  74         ssize_t hw_ptr;
  75
  76         void *rbuf;
  77
  78         size_t period_size;
  79
  80         unsigned max_psize;
  81         struct uac2_req ureq[USB_XFERS];
  82
  83         spinlock_t lock;
  84 };
  85
  86 struct snd_uac2_chip {
  87         struct platform_device pdev;
  88         struct platform_driver pdrv;
  89
  90         struct uac2_rtd_params p_prm;
  91         struct uac2_rtd_params c_prm;
  92
  93         struct snd_card *card;
  94         struct snd_pcm *pcm;
  95
  96         /* timekeeping for the playback endpoint */
  97         unsigned int p_interval;
  98         unsigned int p_residue;
  99
 100         /* pre-calculated values for playback iso completion */
 101         unsigned int p_pktsize;
 102         unsigned int p_pktsize_residue;
 103         unsigned int p_framesize;
 104 };
 105
 106 #define BUFF_SIZE_MAX   (PAGE_SIZE * 16)
 107 #define PRD_SIZE_MAX    PAGE_SIZE
 108 #define MIN_PERIODS     4
 109
 110 static struct snd_pcm_hardware uac2_pcm_hardware = {
 111         .info = SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER
 112                  | SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID
 113                  | SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_RESUME,
 114         .rates = SNDRV_PCM_RATE_CONTINUOUS,
 115         .periods_max = BUFF_SIZE_MAX / PRD_SIZE_MAX,
 116         .buffer_bytes_max = BUFF_SIZE_MAX,
 117         .period_bytes_max = PRD_SIZE_MAX,
 118         .periods_min = MIN_PERIODS,
 119 };
 120
 121 struct audio_dev {
 122         u8 ac_intf, ac_alt;
 123         u8 as_out_intf, as_out_alt;
 124         u8 as_in_intf, as_in_alt;
 125
 126         struct usb_ep *in_ep, *out_ep;
 127         struct usb_function func;
 128
 129         /* The ALSA Sound Card it represents on the USB-Client side */
 130         struct snd_uac2_chip uac2;
 131 };
 132
 133 static inline
 134 struct audio_dev *func_to_agdev(struct usb_function *f)
 135 {
 136         return container_of(f, struct audio_dev, func);
 137 }
 138
 139 static inline
 140 struct audio_dev *uac2_to_agdev(struct snd_uac2_chip *u)
 141 {
 142         return container_of(u, struct audio_dev, uac2);
 143 }
 144
 145 static inline
 146 struct snd_uac2_chip *pdev_to_uac2(struct platform_device *p)
 147 {
 148         return container_of(p, struct snd_uac2_chip, pdev);
 149 }
 150
 151 static inline
 152 struct f_uac2_opts *agdev_to_uac2_opts(struct audio_dev *agdev)
 153 {
 154         return container_of(agdev->func.fi, struct f_uac2_opts, func_inst);
 155 }
 156
 157 static inline
 158 uint num_channels(uint chanmask)
 159 {
 160         uint num = 0;
 161
 162         while (chanmask) {
 163                 num += (chanmask & 1);
 164                 chanmask >>= 1;
 165         }
 166
 167         return num;
 168 }
 169
 170 static void
 171 agdev_iso_complete(struct usb_ep *ep, struct usb_request *req)
 172 {
 173         unsigned pending;
 174         unsigned long flags;
 175         unsigned int hw_ptr;
 176         bool update_alsa = false;
 177         int status = req->status;
 178         struct uac2_req *ur = req->context;
 179         struct snd_pcm_substream *substream;
 180         struct uac2_rtd_params *prm = ur->pp;
 181         struct snd_uac2_chip *uac2 = prm->uac2;
 182
 183         /* i/f shutting down */
 184         if (!prm->ep_enabled || req->status == -ESHUTDOWN)
 185                 return;
 186
 187         /*
 188          * We can't really do much about bad xfers.
 189          * Afterall, the ISOCH xfers could fail legitimately.
 190          */
 191         if (status)
 192                 pr_debug("%s: iso_complete status(%d) %d/%d\n",
 193                         __func__, status, req->actual, req->length);
 194
 195         substream = prm->ss;
 196
 197         /* Do nothing if ALSA isn't active */
 198         if (!substream)
 199                 goto exit;
 200
 201         spin_lock_irqsave(&prm->lock, flags);
 202
 203         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
 204                 /*
 205                  * For each IN packet, take the quotient of the current data
 206                  * rate and the endpoint's interval as the base packet size.
 207                  * If there is a residue from this division, add it to the
 208                  * residue accumulator.
 209                  */
 210                 req->length = uac2->p_pktsize;
 211                 uac2->p_residue += uac2->p_pktsize_residue;
 212
 213                 /*
 214                  * Whenever there are more bytes in the accumulator than we
 215                  * need to add one more sample frame, increase this packet's
 216                  * size and decrease the accumulator.
 217                  */
 218                 if (uac2->p_residue / uac2->p_interval >= uac2->p_framesize) {
 219                         req->length += uac2->p_framesize;
 220                         uac2->p_residue -= uac2->p_framesize *
 221                                            uac2->p_interval;
 222                 }
 223
 224                 req->actual = req->length;
 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         hw_ptr = prm->hw_ptr;
 233         prm->hw_ptr = (prm->hw_ptr + req->actual) % prm->dma_bytes;
 234
 235         spin_unlock_irqrestore(&prm->lock, flags);
 236
 237         /* Pack USB load in ALSA ring buffer */
 238         pending = prm->dma_bytes - hw_ptr;
 239
 240         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
 241                 if (unlikely(pending < req->actual)) {
 242                         memcpy(req->buf, prm->dma_area + hw_ptr, pending);
 243                         memcpy(req->buf + pending, prm->dma_area,
 244                                req->actual - pending);
 245                 } else {
 246                         memcpy(req->buf, prm->dma_area + hw_ptr, req->actual);
 247                 }
 248         } else {
 249                 if (unlikely(pending < req->actual)) {
 250                         memcpy(prm->dma_area + hw_ptr, req->buf, pending);
 251                         memcpy(prm->dma_area, req->buf + pending,
 252                                req->actual - pending);
 253                 } else {
 254                         memcpy(prm->dma_area + hw_ptr, req->buf, req->actual);
 255                 }
 256         }
 257
 258 exit:
 259         if (usb_ep_queue(ep, req, GFP_ATOMIC))
 260                 dev_err(&uac2->pdev.dev, "%d Error!\n", __LINE__);
 261
 262         if (update_alsa)
 263                 snd_pcm_period_elapsed(substream);
 264
 265         return;
 266 }
 267
 268 static int
 269 uac2_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
 270 {
 271         struct snd_uac2_chip *uac2 = snd_pcm_substream_chip(substream);
 272         struct uac2_rtd_params *prm;
 273         unsigned long flags;
 274         int err = 0;
 275
 276         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
 277                 prm = &uac2->p_prm;
 278         else
 279                 prm = &uac2->c_prm;
 280
 281         spin_lock_irqsave(&prm->lock, flags);
 282
 283         /* Reset */
 284         prm->hw_ptr = 0;
 285
 286         switch (cmd) {
 287         case SNDRV_PCM_TRIGGER_START:
 288         case SNDRV_PCM_TRIGGER_RESUME:
 289                 prm->ss = substream;
 290                 break;
 291         case SNDRV_PCM_TRIGGER_STOP:
 292         case SNDRV_PCM_TRIGGER_SUSPEND:
 293                 prm->ss = NULL;
 294                 break;
 295         default:
 296                 err = -EINVAL;
 297         }
 298
 299         spin_unlock_irqrestore(&prm->lock, flags);
 300
 301         /* Clear buffer after Play stops */
 302         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK && !prm->ss)
 303                 memset(prm->rbuf, 0, prm->max_psize * USB_XFERS);
 304
 305         return err;
 306 }
 307
 308 static snd_pcm_uframes_t uac2_pcm_pointer(struct snd_pcm_substream *substream)
 309 {
 310         struct snd_uac2_chip *uac2 = snd_pcm_substream_chip(substream);
 311         struct uac2_rtd_params *prm;
 312
 313         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
 314                 prm = &uac2->p_prm;
 315         else
 316                 prm = &uac2->c_prm;
 317
 318         return bytes_to_frames(substream->runtime, prm->hw_ptr);
 319 }
 320
 321 static int uac2_pcm_hw_params(struct snd_pcm_substream *substream,
 322                                struct snd_pcm_hw_params *hw_params)
 323 {
 324         struct snd_uac2_chip *uac2 = snd_pcm_substream_chip(substream);
 325         struct uac2_rtd_params *prm;
 326         int err;
 327
 328         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
 329                 prm = &uac2->p_prm;
 330         else
 331                 prm = &uac2->c_prm;
 332
 333         err = snd_pcm_lib_malloc_pages(substream,
 334                                         params_buffer_bytes(hw_params));
 335         if (err >= 0) {
 336                 prm->dma_bytes = substream->runtime->dma_bytes;
 337                 prm->dma_area = substream->runtime->dma_area;
 338                 prm->period_size = params_period_bytes(hw_params);
 339         }
 340
 341         return err;
 342 }
 343
 344 static int uac2_pcm_hw_free(struct snd_pcm_substream *substream)
 345 {
 346         struct snd_uac2_chip *uac2 = snd_pcm_substream_chip(substream);
 347         struct uac2_rtd_params *prm;
 348
 349         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
 350                 prm = &uac2->p_prm;
 351         else
 352                 prm = &uac2->c_prm;
 353
 354         prm->dma_area = NULL;
 355         prm->dma_bytes = 0;
 356         prm->period_size = 0;
 357
 358         return snd_pcm_lib_free_pages(substream);
 359 }
 360
 361 static int uac2_pcm_open(struct snd_pcm_substream *substream)
 362 {
 363         struct snd_uac2_chip *uac2 = snd_pcm_substream_chip(substream);
 364         struct snd_pcm_runtime *runtime = substream->runtime;
 365         struct audio_dev *audio_dev;
 366         struct f_uac2_opts *opts;
 367         int p_ssize, c_ssize;
 368         int p_srate, c_srate;
 369         int p_chmask, c_chmask;
 370
 371         audio_dev = uac2_to_agdev(uac2);
 372         opts = container_of(audio_dev->func.fi, struct f_uac2_opts, func_inst);
 373         p_ssize = opts->p_ssize;
 374         c_ssize = opts->c_ssize;
 375         p_srate = opts->p_srate;
 376         c_srate = opts->c_srate;
 377         p_chmask = opts->p_chmask;
 378         c_chmask = opts->c_chmask;
 379         uac2->p_residue = 0;
 380
 381         runtime->hw = uac2_pcm_hardware;
 382
 383         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
 384                 spin_lock_init(&uac2->p_prm.lock);
 385                 runtime->hw.rate_min = p_srate;
 386                 switch (p_ssize) {
 387                 case 3:
 388                         runtime->hw.formats = SNDRV_PCM_FMTBIT_S24_3LE;
 389                         break;
 390                 case 4:
 391                         runtime->hw.formats = SNDRV_PCM_FMTBIT_S32_LE;
 392                         break;
 393                 default:
 394                         runtime->hw.formats = SNDRV_PCM_FMTBIT_S16_LE;
 395                         break;
 396                 }
 397                 runtime->hw.channels_min = num_channels(p_chmask);
 398                 runtime->hw.period_bytes_min = 2 * uac2->p_prm.max_psize
 399                                                 / runtime->hw.periods_min;
 400         } else {
 401                 spin_lock_init(&uac2->c_prm.lock);
 402                 runtime->hw.rate_min = c_srate;
 403                 switch (c_ssize) {
 404                 case 3:
 405                         runtime->hw.formats = SNDRV_PCM_FMTBIT_S24_3LE;
 406                         break;
 407                 case 4:
 408                         runtime->hw.formats = SNDRV_PCM_FMTBIT_S32_LE;
 409                         break;
 410                 default:
 411                         runtime->hw.formats = SNDRV_PCM_FMTBIT_S16_LE;
 412                         break;
 413                 }
 414                 runtime->hw.channels_min = num_channels(c_chmask);
 415                 runtime->hw.period_bytes_min = 2 * uac2->c_prm.max_psize
 416                                                 / runtime->hw.periods_min;
 417         }
 418
 419         runtime->hw.rate_max = runtime->hw.rate_min;
 420         runtime->hw.channels_max = runtime->hw.channels_min;
 421
 422         snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
 423
 424         return 0;
 425 }
 426
 427 /* ALSA cries without these function pointers */
 428 static int uac2_pcm_null(struct snd_pcm_substream *substream)
 429 {
 430         return 0;
 431 }
 432
 433 static struct snd_pcm_ops uac2_pcm_ops = {
 434         .open = uac2_pcm_open,
 435         .close = uac2_pcm_null,
 436         .ioctl = snd_pcm_lib_ioctl,
 437         .hw_params = uac2_pcm_hw_params,
 438         .hw_free = uac2_pcm_hw_free,
 439         .trigger = uac2_pcm_trigger,
 440         .pointer = uac2_pcm_pointer,
 441         .prepare = uac2_pcm_null,
 442 };
 443
 444 static int snd_uac2_probe(struct platform_device *pdev)
 445 {
 446         struct snd_uac2_chip *uac2 = pdev_to_uac2(pdev);
 447         struct snd_card *card;
 448         struct snd_pcm *pcm;
 449         struct audio_dev *audio_dev;
 450         struct f_uac2_opts *opts;
 451         int err;
 452         int p_chmask, c_chmask;
 453
 454         audio_dev = uac2_to_agdev(uac2);
 455         opts = container_of(audio_dev->func.fi, struct f_uac2_opts, func_inst);
 456         p_chmask = opts->p_chmask;
 457         c_chmask = opts->c_chmask;
 458
 459         /* Choose any slot, with no id */
 460         err = snd_card_new(&pdev->dev, -1, NULL, THIS_MODULE, 0, &card);
 461         if (err < 0)
 462                 return err;
 463
 464         uac2->card = card;
 465
 466         /*
 467          * Create first PCM device
 468          * Create a substream only for non-zero channel streams
 469          */
 470         err = snd_pcm_new(uac2->card, "UAC2 PCM", 0,
 471                                p_chmask ? 1 : 0, c_chmask ? 1 : 0, &pcm);
 472         if (err < 0)
 473                 goto snd_fail;
 474
 475         strcpy(pcm->name, "UAC2 PCM");
 476         pcm->private_data = uac2;
 477
 478         uac2->pcm = pcm;
 479
 480         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &uac2_pcm_ops);
 481         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &uac2_pcm_ops);
 482
 483         strcpy(card->driver, "UAC2_Gadget");
 484         strcpy(card->shortname, "UAC2_Gadget");
 485         sprintf(card->longname, "UAC2_Gadget %i", pdev->id);
 486
 487         snd_pcm_lib_preallocate_pages_for_all(pcm, SNDRV_DMA_TYPE_CONTINUOUS,
 488                 snd_dma_continuous_data(GFP_KERNEL), 0, BUFF_SIZE_MAX);
 489
 490         err = snd_card_register(card);
 491         if (!err) {
 492                 platform_set_drvdata(pdev, card);
 493                 return 0;
 494         }
 495
 496 snd_fail:
 497         snd_card_free(card);
 498
 499         uac2->pcm = NULL;
 500         uac2->card = NULL;
 501
 502         return err;
 503 }
 504
 505 static int snd_uac2_remove(struct platform_device *pdev)
 506 {
 507         struct snd_card *card = platform_get_drvdata(pdev);
 508
 509         if (card)
 510                 return snd_card_free(card);
 511
 512         return 0;
 513 }
 514
 515 static void snd_uac2_release(struct device *dev)
 516 {
 517         dev_dbg(dev, "releasing '%s'\n", dev_name(dev));
 518 }
 519
 520 static int alsa_uac2_init(struct audio_dev *agdev)
 521 {
 522         struct snd_uac2_chip *uac2 = &agdev->uac2;
 523         int err;
 524
 525         uac2->pdrv.probe = snd_uac2_probe;
 526         uac2->pdrv.remove = snd_uac2_remove;
 527         uac2->pdrv.driver.name = uac2_name;
 528
 529         uac2->pdev.id = 0;
 530         uac2->pdev.name = uac2_name;
 531         uac2->pdev.dev.release = snd_uac2_release;
 532
 533         /* Register snd_uac2 driver */
 534         err = platform_driver_register(&uac2->pdrv);
 535         if (err)
 536                 return err;
 537
 538         /* Register snd_uac2 device */
 539         err = platform_device_register(&uac2->pdev);
 540         if (err)
 541                 platform_driver_unregister(&uac2->pdrv);
 542
 543         return err;
 544 }
 545
 546 static void alsa_uac2_exit(struct audio_dev *agdev)
 547 {
 548         struct snd_uac2_chip *uac2 = &agdev->uac2;
 549
 550         platform_driver_unregister(&uac2->pdrv);
 551         platform_device_unregister(&uac2->pdev);
 552 }
 553
 554
 555 /* --------- USB Function Interface ------------- */
 556
 557 enum {
 558         STR_ASSOC,
 559         STR_IF_CTRL,
 560         STR_CLKSRC_IN,
 561         STR_CLKSRC_OUT,
 562         STR_USB_IT,
 563         STR_IO_IT,
 564         STR_USB_OT,
 565         STR_IO_OT,
 566         STR_AS_OUT_ALT0,
 567         STR_AS_OUT_ALT1,
 568         STR_AS_IN_ALT0,
 569         STR_AS_IN_ALT1,
 570 };
 571
 572 static char clksrc_in[8];
 573 static char clksrc_out[8];
 574
 575 static struct usb_string strings_fn[] = {
 576         [STR_ASSOC].s = "Source/Sink",
 577         [STR_IF_CTRL].s = "Topology Control",
 578         [STR_CLKSRC_IN].s = clksrc_in,
 579         [STR_CLKSRC_OUT].s = clksrc_out,
 580         [STR_USB_IT].s = "USBH Out",
 581         [STR_IO_IT].s = "USBD Out",
 582         [STR_USB_OT].s = "USBH In",
 583         [STR_IO_OT].s = "USBD In",
 584         [STR_AS_OUT_ALT0].s = "Playback Inactive",
 585         [STR_AS_OUT_ALT1].s = "Playback Active",
 586         [STR_AS_IN_ALT0].s = "Capture Inactive",
 587         [STR_AS_IN_ALT1].s = "Capture Active",
 588         { },
 589 };
 590
 591 static struct usb_gadget_strings str_fn = {
 592         .language = 0x0409,     /* en-us */
 593         .strings = strings_fn,
 594 };
 595
 596 static struct usb_gadget_strings *fn_strings[] = {
 597         &str_fn,
 598         NULL,
 599 };
 600
 601 static struct usb_interface_assoc_descriptor iad_desc = {
 602         .bLength = sizeof iad_desc,
 603         .bDescriptorType = USB_DT_INTERFACE_ASSOCIATION,
 604
 605         .bFirstInterface = 0,
 606         .bInterfaceCount = 3,
 607         .bFunctionClass = USB_CLASS_AUDIO,
 608         .bFunctionSubClass = UAC2_FUNCTION_SUBCLASS_UNDEFINED,
 609         .bFunctionProtocol = UAC_VERSION_2,
 610 };
 611
 612 /* Audio Control Interface */
 613 static struct usb_interface_descriptor std_ac_if_desc = {
 614         .bLength = sizeof std_ac_if_desc,
 615         .bDescriptorType = USB_DT_INTERFACE,
 616
 617         .bAlternateSetting = 0,
 618         .bNumEndpoints = 0,
 619         .bInterfaceClass = USB_CLASS_AUDIO,
 620         .bInterfaceSubClass = USB_SUBCLASS_AUDIOCONTROL,
 621         .bInterfaceProtocol = UAC_VERSION_2,
 622 };
 623
 624 /* Clock source for IN traffic */
 625 static struct uac_clock_source_descriptor in_clk_src_desc = {
 626         .bLength = sizeof in_clk_src_desc,
 627         .bDescriptorType = USB_DT_CS_INTERFACE,
 628
 629         .bDescriptorSubtype = UAC2_CLOCK_SOURCE,
 630         .bClockID = USB_IN_CLK_ID,
 631         .bmAttributes = UAC_CLOCK_SOURCE_TYPE_INT_FIXED,
 632         .bmControls = (CONTROL_RDONLY << CLK_FREQ_CTRL),
 633         .bAssocTerminal = 0,
 634 };
 635
 636 /* Clock source for OUT traffic */
 637 static struct uac_clock_source_descriptor out_clk_src_desc = {
 638         .bLength = sizeof out_clk_src_desc,
 639         .bDescriptorType = USB_DT_CS_INTERFACE,
 640
 641         .bDescriptorSubtype = UAC2_CLOCK_SOURCE,
 642         .bClockID = USB_OUT_CLK_ID,
 643         .bmAttributes = UAC_CLOCK_SOURCE_TYPE_INT_FIXED,
 644         .bmControls = (CONTROL_RDONLY << CLK_FREQ_CTRL),
 645         .bAssocTerminal = 0,
 646 };
 647
 648 /* Input Terminal for USB_OUT */
 649 static struct uac2_input_terminal_descriptor usb_out_it_desc = {
 650         .bLength = sizeof usb_out_it_desc,
 651         .bDescriptorType = USB_DT_CS_INTERFACE,
 652
 653         .bDescriptorSubtype = UAC_INPUT_TERMINAL,
 654         .bTerminalID = USB_OUT_IT_ID,
 655         .wTerminalType = cpu_to_le16(UAC_TERMINAL_STREAMING),
 656         .bAssocTerminal = 0,
 657         .bCSourceID = USB_OUT_CLK_ID,
 658         .iChannelNames = 0,
 659         .bmControls = (CONTROL_RDWR << COPY_CTRL),
 660 };
 661
 662 /* Input Terminal for I/O-In */
 663 static struct uac2_input_terminal_descriptor io_in_it_desc = {
 664         .bLength = sizeof io_in_it_desc,
 665         .bDescriptorType = USB_DT_CS_INTERFACE,
 666
 667         .bDescriptorSubtype = UAC_INPUT_TERMINAL,
 668         .bTerminalID = IO_IN_IT_ID,
 669         .wTerminalType = cpu_to_le16(UAC_INPUT_TERMINAL_UNDEFINED),
 670         .bAssocTerminal = 0,
 671         .bCSourceID = USB_IN_CLK_ID,
 672         .iChannelNames = 0,
 673         .bmControls = (CONTROL_RDWR << COPY_CTRL),
 674 };
 675
 676 /* Ouput Terminal for USB_IN */
 677 static struct uac2_output_terminal_descriptor usb_in_ot_desc = {
 678         .bLength = sizeof usb_in_ot_desc,
 679         .bDescriptorType = USB_DT_CS_INTERFACE,
 680
 681         .bDescriptorSubtype = UAC_OUTPUT_TERMINAL,
 682         .bTerminalID = USB_IN_OT_ID,
 683         .wTerminalType = cpu_to_le16(UAC_TERMINAL_STREAMING),
 684         .bAssocTerminal = 0,
 685         .bSourceID = IO_IN_IT_ID,
 686         .bCSourceID = USB_IN_CLK_ID,
 687         .bmControls = (CONTROL_RDWR << COPY_CTRL),
 688 };
 689
 690 /* Ouput Terminal for I/O-Out */
 691 static struct uac2_output_terminal_descriptor io_out_ot_desc = {
 692         .bLength = sizeof io_out_ot_desc,
 693         .bDescriptorType = USB_DT_CS_INTERFACE,
 694
 695         .bDescriptorSubtype = UAC_OUTPUT_TERMINAL,
 696         .bTerminalID = IO_OUT_OT_ID,
 697         .wTerminalType = cpu_to_le16(UAC_OUTPUT_TERMINAL_UNDEFINED),
 698         .bAssocTerminal = 0,
 699         .bSourceID = USB_OUT_IT_ID,
 700         .bCSourceID = USB_OUT_CLK_ID,
 701         .bmControls = (CONTROL_RDWR << COPY_CTRL),
 702 };
 703
 704 static struct uac2_ac_header_descriptor ac_hdr_desc = {
 705         .bLength = sizeof ac_hdr_desc,
 706         .bDescriptorType = USB_DT_CS_INTERFACE,
 707
 708         .bDescriptorSubtype = UAC_MS_HEADER,
 709         .bcdADC = cpu_to_le16(0x200),
 710         .bCategory = UAC2_FUNCTION_IO_BOX,
 711         .wTotalLength = sizeof in_clk_src_desc + sizeof out_clk_src_desc
 712                          + sizeof usb_out_it_desc + sizeof io_in_it_desc
 713                         + sizeof usb_in_ot_desc + sizeof io_out_ot_desc,
 714         .bmControls = 0,
 715 };
 716
 717 /* Audio Streaming OUT Interface - Alt0 */
 718 static struct usb_interface_descriptor std_as_out_if0_desc = {
 719         .bLength = sizeof std_as_out_if0_desc,
 720         .bDescriptorType = USB_DT_INTERFACE,
 721
 722         .bAlternateSetting = 0,
 723         .bNumEndpoints = 0,
 724         .bInterfaceClass = USB_CLASS_AUDIO,
 725         .bInterfaceSubClass = USB_SUBCLASS_AUDIOSTREAMING,
 726         .bInterfaceProtocol = UAC_VERSION_2,
 727 };
 728
 729 /* Audio Streaming OUT Interface - Alt1 */
 730 static struct usb_interface_descriptor std_as_out_if1_desc = {
 731         .bLength = sizeof std_as_out_if1_desc,
 732         .bDescriptorType = USB_DT_INTERFACE,
 733
 734         .bAlternateSetting = 1,
 735         .bNumEndpoints = 1,
 736         .bInterfaceClass = USB_CLASS_AUDIO,
 737         .bInterfaceSubClass = USB_SUBCLASS_AUDIOSTREAMING,
 738         .bInterfaceProtocol = UAC_VERSION_2,
 739 };
 740
 741 /* Audio Stream OUT Intface Desc */
 742 static struct uac2_as_header_descriptor as_out_hdr_desc = {
 743         .bLength = sizeof as_out_hdr_desc,
 744         .bDescriptorType = USB_DT_CS_INTERFACE,
 745
 746         .bDescriptorSubtype = UAC_AS_GENERAL,
 747         .bTerminalLink = USB_OUT_IT_ID,
 748         .bmControls = 0,
 749         .bFormatType = UAC_FORMAT_TYPE_I,
 750         .bmFormats = cpu_to_le32(UAC_FORMAT_TYPE_I_PCM),
 751         .iChannelNames = 0,
 752 };
 753
 754 /* Audio USB_OUT Format */
 755 static struct uac2_format_type_i_descriptor as_out_fmt1_desc = {
 756         .bLength = sizeof as_out_fmt1_desc,
 757         .bDescriptorType = USB_DT_CS_INTERFACE,
 758         .bDescriptorSubtype = UAC_FORMAT_TYPE,
 759         .bFormatType = UAC_FORMAT_TYPE_I,
 760 };
 761
 762 /* STD AS ISO OUT Endpoint */
 763 static struct usb_endpoint_descriptor fs_epout_desc = {
 764         .bLength = USB_DT_ENDPOINT_SIZE,
 765         .bDescriptorType = USB_DT_ENDPOINT,
 766
 767         .bEndpointAddress = USB_DIR_OUT,
 768         .bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC,
 769         /* .wMaxPacketSize = DYNAMIC */
 770         .bInterval = 1,
 771 };
 772
 773 static struct usb_endpoint_descriptor hs_epout_desc = {
 774         .bLength = USB_DT_ENDPOINT_SIZE,
 775         .bDescriptorType = USB_DT_ENDPOINT,
 776
 777         .bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC,
 778         /* .wMaxPacketSize = DYNAMIC */
 779         .bInterval = 4,
 780 };
 781
 782 /* CS AS ISO OUT Endpoint */
 783 static struct uac2_iso_endpoint_descriptor as_iso_out_desc = {
 784         .bLength = sizeof as_iso_out_desc,
 785         .bDescriptorType = USB_DT_CS_ENDPOINT,
 786
 787         .bDescriptorSubtype = UAC_EP_GENERAL,
 788         .bmAttributes = 0,
 789         .bmControls = 0,
 790         .bLockDelayUnits = 0,
 791         .wLockDelay = 0,
 792 };
 793
 794 /* Audio Streaming IN Interface - Alt0 */
 795 static struct usb_interface_descriptor std_as_in_if0_desc = {
 796         .bLength = sizeof std_as_in_if0_desc,
 797         .bDescriptorType = USB_DT_INTERFACE,
 798
 799         .bAlternateSetting = 0,
 800         .bNumEndpoints = 0,
 801         .bInterfaceClass = USB_CLASS_AUDIO,
 802         .bInterfaceSubClass = USB_SUBCLASS_AUDIOSTREAMING,
 803         .bInterfaceProtocol = UAC_VERSION_2,
 804 };
 805
 806 /* Audio Streaming IN Interface - Alt1 */
 807 static struct usb_interface_descriptor std_as_in_if1_desc = {
 808         .bLength = sizeof std_as_in_if1_desc,
 809         .bDescriptorType = USB_DT_INTERFACE,
 810
 811         .bAlternateSetting = 1,
 812         .bNumEndpoints = 1,
 813         .bInterfaceClass = USB_CLASS_AUDIO,
 814         .bInterfaceSubClass = USB_SUBCLASS_AUDIOSTREAMING,
 815         .bInterfaceProtocol = UAC_VERSION_2,
 816 };
 817
 818 /* Audio Stream IN Intface Desc */
 819 static struct uac2_as_header_descriptor as_in_hdr_desc = {
 820         .bLength = sizeof as_in_hdr_desc,
 821         .bDescriptorType = USB_DT_CS_INTERFACE,
 822
 823         .bDescriptorSubtype = UAC_AS_GENERAL,
 824         .bTerminalLink = USB_IN_OT_ID,
 825         .bmControls = 0,
 826         .bFormatType = UAC_FORMAT_TYPE_I,
 827         .bmFormats = cpu_to_le32(UAC_FORMAT_TYPE_I_PCM),
 828         .iChannelNames = 0,
 829 };
 830
 831 /* Audio USB_IN Format */
 832 static struct uac2_format_type_i_descriptor as_in_fmt1_desc = {
 833         .bLength = sizeof as_in_fmt1_desc,
 834         .bDescriptorType = USB_DT_CS_INTERFACE,
 835         .bDescriptorSubtype = UAC_FORMAT_TYPE,
 836         .bFormatType = UAC_FORMAT_TYPE_I,
 837 };
 838
 839 /* STD AS ISO IN Endpoint */
 840 static struct usb_endpoint_descriptor fs_epin_desc = {
 841         .bLength = USB_DT_ENDPOINT_SIZE,
 842         .bDescriptorType = USB_DT_ENDPOINT,
 843
 844         .bEndpointAddress = USB_DIR_IN,
 845         .bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC,
 846         /* .wMaxPacketSize = DYNAMIC */
 847         .bInterval = 1,
 848 };
 849
 850 static struct usb_endpoint_descriptor hs_epin_desc = {
 851         .bLength = USB_DT_ENDPOINT_SIZE,
 852         .bDescriptorType = USB_DT_ENDPOINT,
 853
 854         .bmAttributes = USB_ENDPOINT_XFER_ISOC | USB_ENDPOINT_SYNC_ASYNC,
 855         /* .wMaxPacketSize = DYNAMIC */
 856         .bInterval = 4,
 857 };
 858
 859 /* CS AS ISO IN Endpoint */
 860 static struct uac2_iso_endpoint_descriptor as_iso_in_desc = {
 861         .bLength = sizeof as_iso_in_desc,
 862         .bDescriptorType = USB_DT_CS_ENDPOINT,
 863
 864         .bDescriptorSubtype = UAC_EP_GENERAL,
 865         .bmAttributes = 0,
 866         .bmControls = 0,
 867         .bLockDelayUnits = 0,
 868         .wLockDelay = 0,
 869 };
 870
 871 static struct usb_descriptor_header *fs_audio_desc[] = {
 872         (struct usb_descriptor_header *)&iad_desc,
 873         (struct usb_descriptor_header *)&std_ac_if_desc,
 874
 875         (struct usb_descriptor_header *)&ac_hdr_desc,
 876         (struct usb_descriptor_header *)&in_clk_src_desc,
 877         (struct usb_descriptor_header *)&out_clk_src_desc,
 878         (struct usb_descriptor_header *)&usb_out_it_desc,
 879         (struct usb_descriptor_header *)&io_in_it_desc,
 880         (struct usb_descriptor_header *)&usb_in_ot_desc,
 881         (struct usb_descriptor_header *)&io_out_ot_desc,
 882
 883         (struct usb_descriptor_header *)&std_as_out_if0_desc,
 884         (struct usb_descriptor_header *)&std_as_out_if1_desc,
 885
 886         (struct usb_descriptor_header *)&as_out_hdr_desc,
 887         (struct usb_descriptor_header *)&as_out_fmt1_desc,
 888         (struct usb_descriptor_header *)&fs_epout_desc,
 889         (struct usb_descriptor_header *)&as_iso_out_desc,
 890
 891         (struct usb_descriptor_header *)&std_as_in_if0_desc,
 892         (struct usb_descriptor_header *)&std_as_in_if1_desc,
 893
 894         (struct usb_descriptor_header *)&as_in_hdr_desc,
 895         (struct usb_descriptor_header *)&as_in_fmt1_desc,
 896         (struct usb_descriptor_header *)&fs_epin_desc,
 897         (struct usb_descriptor_header *)&as_iso_in_desc,
 898         NULL,
 899 };
 900
 901 static struct usb_descriptor_header *hs_audio_desc[] = {
 902         (struct usb_descriptor_header *)&iad_desc,
 903         (struct usb_descriptor_header *)&std_ac_if_desc,
 904
 905         (struct usb_descriptor_header *)&ac_hdr_desc,
 906         (struct usb_descriptor_header *)&in_clk_src_desc,
 907         (struct usb_descriptor_header *)&out_clk_src_desc,
 908         (struct usb_descriptor_header *)&usb_out_it_desc,
 909         (struct usb_descriptor_header *)&io_in_it_desc,
 910         (struct usb_descriptor_header *)&usb_in_ot_desc,
 911         (struct usb_descriptor_header *)&io_out_ot_desc,
 912
 913         (struct usb_descriptor_header *)&std_as_out_if0_desc,
 914         (struct usb_descriptor_header *)&std_as_out_if1_desc,
 915
 916         (struct usb_descriptor_header *)&as_out_hdr_desc,
 917         (struct usb_descriptor_header *)&as_out_fmt1_desc,
 918         (struct usb_descriptor_header *)&hs_epout_desc,
 919         (struct usb_descriptor_header *)&as_iso_out_desc,
 920
 921         (struct usb_descriptor_header *)&std_as_in_if0_desc,
 922         (struct usb_descriptor_header *)&std_as_in_if1_desc,
 923
 924         (struct usb_descriptor_header *)&as_in_hdr_desc,
 925         (struct usb_descriptor_header *)&as_in_fmt1_desc,
 926         (struct usb_descriptor_header *)&hs_epin_desc,
 927         (struct usb_descriptor_header *)&as_iso_in_desc,
 928         NULL,
 929 };
 930
 931 struct cntrl_cur_lay3 {
 932         __le32  dCUR;
 933 };
 934
 935 struct cntrl_range_lay3 {
 936         __le16  wNumSubRanges;
 937         __le32  dMIN;
 938         __le32  dMAX;
 939         __le32  dRES;
 940 } __packed;
 941
 942 static inline void
 943 free_ep(struct uac2_rtd_params *prm, struct usb_ep *ep)
 944 {
 945         struct snd_uac2_chip *uac2 = prm->uac2;
 946         int i;
 947
 948         if (!prm->ep_enabled)
 949                 return;
 950
 951         prm->ep_enabled = false;
 952
 953         for (i = 0; i < USB_XFERS; i++) {
 954                 if (prm->ureq[i].req) {
 955                         usb_ep_dequeue(ep, prm->ureq[i].req);
 956                         usb_ep_free_request(ep, prm->ureq[i].req);
 957                         prm->ureq[i].req = NULL;
 958                 }
 959         }
 960
 961         if (usb_ep_disable(ep))
 962                 dev_err(&uac2->pdev.dev,
 963                         "%s:%d Error!\n", __func__, __LINE__);
 964 }
 965
 966 static int set_ep_max_packet_size(const struct f_uac2_opts *uac2_opts,
 967         struct usb_endpoint_descriptor *ep_desc,
 968         enum usb_device_speed speed, bool is_playback)
 969 {
 970         int chmask, srate, ssize;
 971         u16 max_size_bw, max_size_ep;
 972         unsigned int factor;
 973
 974         switch (speed) {
 975         case USB_SPEED_FULL:
 976                 max_size_ep = 1023;
 977                 factor = 1000;
 978                 break;
 979
 980         case USB_SPEED_HIGH:
 981                 max_size_ep = 1024;
 982                 factor = 8000;
 983                 break;
 984
 985         default:
 986                 return -EINVAL;
 987         }
 988
 989         if (is_playback) {
 990                 chmask = uac2_opts->p_chmask;
 991                 srate = uac2_opts->p_srate;
 992                 ssize = uac2_opts->p_ssize;
 993         } else {
 994                 chmask = uac2_opts->c_chmask;
 995                 srate = uac2_opts->c_srate;
 996                 ssize = uac2_opts->c_ssize;
 997         }
 998
 999         max_size_bw = num_channels(chmask) * ssize *
1000                 ((srate / (factor / (1 << (ep_desc->bInterval - 1)))) + 1);
1001         ep_desc->wMaxPacketSize = cpu_to_le16(min_t(u16, max_size_bw,
1002                                                     max_size_ep));
1003
1004         return 0;
1005 }
1006
1007 static int
1008 afunc_bind(struct usb_configuration *cfg, struct usb_function *fn)
1009 {
1010         struct audio_dev *agdev = func_to_agdev(fn);
1011         struct snd_uac2_chip *uac2 = &agdev->uac2;
1012         struct usb_composite_dev *cdev = cfg->cdev;
1013         struct usb_gadget *gadget = cdev->gadget;
1014         struct device *dev = &uac2->pdev.dev;
1015         struct uac2_rtd_params *prm;
1016         struct f_uac2_opts *uac2_opts;
1017         struct usb_string *us;
1018         int ret;
1019
1020         uac2_opts = container_of(fn->fi, struct f_uac2_opts, func_inst);
1021
1022         us = usb_gstrings_attach(cdev, fn_strings, ARRAY_SIZE(strings_fn));
1023         if (IS_ERR(us))
1024                 return PTR_ERR(us);
1025         iad_desc.iFunction = us[STR_ASSOC].id;
1026         std_ac_if_desc.iInterface = us[STR_IF_CTRL].id;
1027         in_clk_src_desc.iClockSource = us[STR_CLKSRC_IN].id;
1028         out_clk_src_desc.iClockSource = us[STR_CLKSRC_OUT].id;
1029         usb_out_it_desc.iTerminal = us[STR_USB_IT].id;
1030         io_in_it_desc.iTerminal = us[STR_IO_IT].id;
1031         usb_in_ot_desc.iTerminal = us[STR_USB_OT].id;
1032         io_out_ot_desc.iTerminal = us[STR_IO_OT].id;
1033         std_as_out_if0_desc.iInterface = us[STR_AS_OUT_ALT0].id;
1034         std_as_out_if1_desc.iInterface = us[STR_AS_OUT_ALT1].id;
1035         std_as_in_if0_desc.iInterface = us[STR_AS_IN_ALT0].id;
1036         std_as_in_if1_desc.iInterface = us[STR_AS_IN_ALT1].id;
1037
1038
1039         /* Initialize the configurable parameters */
1040         usb_out_it_desc.bNrChannels = num_channels(uac2_opts->c_chmask);
1041         usb_out_it_desc.bmChannelConfig = cpu_to_le32(uac2_opts->c_chmask);
1042         io_in_it_desc.bNrChannels = num_channels(uac2_opts->p_chmask);
1043         io_in_it_desc.bmChannelConfig = cpu_to_le32(uac2_opts->p_chmask);
1044         as_out_hdr_desc.bNrChannels = num_channels(uac2_opts->c_chmask);
1045         as_out_hdr_desc.bmChannelConfig = cpu_to_le32(uac2_opts->c_chmask);
1046         as_in_hdr_desc.bNrChannels = num_channels(uac2_opts->p_chmask);
1047         as_in_hdr_desc.bmChannelConfig = cpu_to_le32(uac2_opts->p_chmask);
1048         as_out_fmt1_desc.bSubslotSize = uac2_opts->c_ssize;
1049         as_out_fmt1_desc.bBitResolution = uac2_opts->c_ssize * 8;
1050         as_in_fmt1_desc.bSubslotSize = uac2_opts->p_ssize;
1051         as_in_fmt1_desc.bBitResolution = uac2_opts->p_ssize * 8;
1052
1053         snprintf(clksrc_in, sizeof(clksrc_in), "%uHz", uac2_opts->p_srate);
1054         snprintf(clksrc_out, sizeof(clksrc_out), "%uHz", uac2_opts->c_srate);
1055
1056         ret = usb_interface_id(cfg, fn);
1057         if (ret < 0) {
1058                 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
1059                 return ret;
1060         }
1061         iad_desc.bFirstInterface = ret;
1062
1063         std_ac_if_desc.bInterfaceNumber = ret;
1064         agdev->ac_intf = ret;
1065         agdev->ac_alt = 0;
1066
1067         ret = usb_interface_id(cfg, fn);
1068         if (ret < 0) {
1069                 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
1070                 return ret;
1071         }
1072         std_as_out_if0_desc.bInterfaceNumber = ret;
1073         std_as_out_if1_desc.bInterfaceNumber = ret;
1074         agdev->as_out_intf = ret;
1075         agdev->as_out_alt = 0;
1076
1077         ret = usb_interface_id(cfg, fn);
1078         if (ret < 0) {
1079                 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
1080                 return ret;
1081         }
1082         std_as_in_if0_desc.bInterfaceNumber = ret;
1083         std_as_in_if1_desc.bInterfaceNumber = ret;
1084         agdev->as_in_intf = ret;
1085         agdev->as_in_alt = 0;
1086
1087         agdev->out_ep = usb_ep_autoconfig(gadget, &fs_epout_desc);
1088         if (!agdev->out_ep) {
1089                 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
1090                 return -ENODEV;
1091         }
1092
1093         agdev->in_ep = usb_ep_autoconfig(gadget, &fs_epin_desc);
1094         if (!agdev->in_ep) {
1095                 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
1096                 return -ENODEV;
1097         }
1098
1099         uac2->p_prm.uac2 = uac2;
1100         uac2->c_prm.uac2 = uac2;
1101
1102         /* Calculate wMaxPacketSize according to audio bandwidth */
1103         ret = set_ep_max_packet_size(uac2_opts, &fs_epin_desc, USB_SPEED_FULL,
1104                                      true);
1105         if (ret < 0) {
1106                 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
1107                 return ret;
1108         }
1109
1110         ret = set_ep_max_packet_size(uac2_opts, &fs_epout_desc, USB_SPEED_FULL,
1111                                      false);
1112         if (ret < 0) {
1113                 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
1114                 return ret;
1115         }
1116
1117         ret = set_ep_max_packet_size(uac2_opts, &hs_epin_desc, USB_SPEED_HIGH,
1118                                      true);
1119         if (ret < 0) {
1120                 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
1121                 return ret;
1122         }
1123
1124         ret = set_ep_max_packet_size(uac2_opts, &hs_epout_desc, USB_SPEED_HIGH,
1125                                      false);
1126         if (ret < 0) {
1127                 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
1128                 return ret;
1129         }
1130
1131         hs_epout_desc.bEndpointAddress = fs_epout_desc.bEndpointAddress;
1132         hs_epin_desc.bEndpointAddress = fs_epin_desc.bEndpointAddress;
1133
1134         ret = usb_assign_descriptors(fn, fs_audio_desc, hs_audio_desc, NULL);
1135         if (ret)
1136                 return ret;
1137
1138         prm = &agdev->uac2.c_prm;
1139         prm->max_psize = hs_epout_desc.wMaxPacketSize;
1140         prm->rbuf = kzalloc(prm->max_psize * USB_XFERS, GFP_KERNEL);
1141         if (!prm->rbuf) {
1142                 prm->max_psize = 0;
1143                 goto err_free_descs;
1144         }
1145
1146         prm = &agdev->uac2.p_prm;
1147         prm->max_psize = hs_epin_desc.wMaxPacketSize;
1148         prm->rbuf = kzalloc(prm->max_psize * USB_XFERS, GFP_KERNEL);
1149         if (!prm->rbuf) {
1150                 prm->max_psize = 0;
1151                 goto err;
1152         }
1153
1154         ret = alsa_uac2_init(agdev);
1155         if (ret)
1156                 goto err;
1157         return 0;
1158
1159 err:
1160         kfree(agdev->uac2.p_prm.rbuf);
1161         kfree(agdev->uac2.c_prm.rbuf);
1162 err_free_descs:
1163         usb_free_all_descriptors(fn);
1164         return -EINVAL;
1165 }
1166
1167 static int
1168 afunc_set_alt(struct usb_function *fn, unsigned intf, unsigned alt)
1169 {
1170         struct usb_composite_dev *cdev = fn->config->cdev;
1171         struct audio_dev *agdev = func_to_agdev(fn);
1172         struct snd_uac2_chip *uac2 = &agdev->uac2;
1173         struct usb_gadget *gadget = cdev->gadget;
1174         struct device *dev = &uac2->pdev.dev;
1175         struct usb_request *req;
1176         struct usb_ep *ep;
1177         struct uac2_rtd_params *prm;
1178         int req_len, i;
1179
1180         /* No i/f has more than 2 alt settings */
1181         if (alt > 1) {
1182                 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
1183                 return -EINVAL;
1184         }
1185
1186         if (intf == agdev->ac_intf) {
1187                 /* Control I/f has only 1 AltSetting - 0 */
1188                 if (alt) {
1189                         dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
1190                         return -EINVAL;
1191                 }
1192                 return 0;
1193         }
1194
1195         if (intf == agdev->as_out_intf) {
1196                 ep = agdev->out_ep;
1197                 prm = &uac2->c_prm;
1198                 config_ep_by_speed(gadget, fn, ep);
1199                 agdev->as_out_alt = alt;
1200                 req_len = prm->max_psize;
1201         } else if (intf == agdev->as_in_intf) {
1202                 struct f_uac2_opts *opts = agdev_to_uac2_opts(agdev);
1203                 unsigned int factor, rate;
1204                 struct usb_endpoint_descriptor *ep_desc;
1205
1206                 ep = agdev->in_ep;
1207                 prm = &uac2->p_prm;
1208                 config_ep_by_speed(gadget, fn, ep);
1209                 agdev->as_in_alt = alt;
1210
1211                 /* pre-calculate the playback endpoint's interval */
1212                 if (gadget->speed == USB_SPEED_FULL) {
1213                         ep_desc = &fs_epin_desc;
1214                         factor = 1000;
1215                 } else {
1216                         ep_desc = &hs_epin_desc;
1217                         factor = 8000;
1218                 }
1219
1220                 /* pre-compute some values for iso_complete() */
1221                 uac2->p_framesize = opts->p_ssize *
1222                                     num_channels(opts->p_chmask);
1223                 rate = opts->p_srate * uac2->p_framesize;
1224                 uac2->p_interval = factor / (1 << (ep_desc->bInterval - 1));
1225                 uac2->p_pktsize = min_t(unsigned int, rate / uac2->p_interval,
1226                                         prm->max_psize);
1227
1228                 if (uac2->p_pktsize < prm->max_psize)
1229                         uac2->p_pktsize_residue = rate % uac2->p_interval;
1230                 else
1231                         uac2->p_pktsize_residue = 0;
1232
1233                 req_len = uac2->p_pktsize;
1234                 uac2->p_residue = 0;
1235         } else {
1236                 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
1237                 return -EINVAL;
1238         }
1239
1240         if (alt == 0) {
1241                 free_ep(prm, ep);
1242                 return 0;
1243         }
1244
1245         prm->ep_enabled = true;
1246         usb_ep_enable(ep);
1247
1248         for (i = 0; i < USB_XFERS; i++) {
1249                 if (!prm->ureq[i].req) {
1250                         req = usb_ep_alloc_request(ep, GFP_ATOMIC);
1251                         if (req == NULL)
1252                                 return -ENOMEM;
1253
1254                         prm->ureq[i].req = req;
1255                         prm->ureq[i].pp = prm;
1256
1257                         req->zero = 0;
1258                         req->context = &prm->ureq[i];
1259                         req->length = req_len;
1260                         req->complete = agdev_iso_complete;
1261                         req->buf = prm->rbuf + i * prm->max_psize;
1262                 }
1263
1264                 if (usb_ep_queue(ep, prm->ureq[i].req, GFP_ATOMIC))
1265                         dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
1266         }
1267
1268         return 0;
1269 }
1270
1271 static int
1272 afunc_get_alt(struct usb_function *fn, unsigned intf)
1273 {
1274         struct audio_dev *agdev = func_to_agdev(fn);
1275         struct snd_uac2_chip *uac2 = &agdev->uac2;
1276
1277         if (intf == agdev->ac_intf)
1278                 return agdev->ac_alt;
1279         else if (intf == agdev->as_out_intf)
1280                 return agdev->as_out_alt;
1281         else if (intf == agdev->as_in_intf)
1282                 return agdev->as_in_alt;
1283         else
1284                 dev_err(&uac2->pdev.dev,
1285                         "%s:%d Invalid Interface %d!\n",
1286                         __func__, __LINE__, intf);
1287
1288         return -EINVAL;
1289 }
1290
1291 static void
1292 afunc_disable(struct usb_function *fn)
1293 {
1294         struct audio_dev *agdev = func_to_agdev(fn);
1295         struct snd_uac2_chip *uac2 = &agdev->uac2;
1296
1297         free_ep(&uac2->p_prm, agdev->in_ep);
1298         agdev->as_in_alt = 0;
1299
1300         free_ep(&uac2->c_prm, agdev->out_ep);
1301         agdev->as_out_alt = 0;
1302 }
1303
1304 static int
1305 in_rq_cur(struct usb_function *fn, const struct usb_ctrlrequest *cr)
1306 {
1307         struct usb_request *req = fn->config->cdev->req;
1308         struct audio_dev *agdev = func_to_agdev(fn);
1309         struct snd_uac2_chip *uac2 = &agdev->uac2;
1310         struct f_uac2_opts *opts;
1311         u16 w_length = le16_to_cpu(cr->wLength);
1312         u16 w_index = le16_to_cpu(cr->wIndex);
1313         u16 w_value = le16_to_cpu(cr->wValue);
1314         u8 entity_id = (w_index >> 8) & 0xff;
1315         u8 control_selector = w_value >> 8;
1316         int value = -EOPNOTSUPP;
1317         int p_srate, c_srate;
1318
1319         opts = agdev_to_uac2_opts(agdev);
1320         p_srate = opts->p_srate;
1321         c_srate = opts->c_srate;
1322
1323         if (control_selector == UAC2_CS_CONTROL_SAM_FREQ) {
1324                 struct cntrl_cur_lay3 c;
1325                 memset(&c, 0, sizeof(struct cntrl_cur_lay3));
1326
1327                 if (entity_id == USB_IN_CLK_ID)
1328                         c.dCUR = cpu_to_le32(p_srate);
1329                 else if (entity_id == USB_OUT_CLK_ID)
1330                         c.dCUR = cpu_to_le32(c_srate);
1331
1332                 value = min_t(unsigned, w_length, sizeof c);
1333                 memcpy(req->buf, &c, value);
1334         } else if (control_selector == UAC2_CS_CONTROL_CLOCK_VALID) {
1335                 *(u8 *)req->buf = 1;
1336                 value = min_t(unsigned, w_length, 1);
1337         } else {
1338                 dev_err(&uac2->pdev.dev,
1339                         "%s:%d control_selector=%d TODO!\n",
1340                         __func__, __LINE__, control_selector);
1341         }
1342
1343         return value;
1344 }
1345
1346 static int
1347 in_rq_range(struct usb_function *fn, const struct usb_ctrlrequest *cr)
1348 {
1349         struct usb_request *req = fn->config->cdev->req;
1350         struct audio_dev *agdev = func_to_agdev(fn);
1351         struct snd_uac2_chip *uac2 = &agdev->uac2;
1352         struct f_uac2_opts *opts;
1353         u16 w_length = le16_to_cpu(cr->wLength);
1354         u16 w_index = le16_to_cpu(cr->wIndex);
1355         u16 w_value = le16_to_cpu(cr->wValue);
1356         u8 entity_id = (w_index >> 8) & 0xff;
1357         u8 control_selector = w_value >> 8;
1358         struct cntrl_range_lay3 r;
1359         int value = -EOPNOTSUPP;
1360         int p_srate, c_srate;
1361
1362         opts = agdev_to_uac2_opts(agdev);
1363         p_srate = opts->p_srate;
1364         c_srate = opts->c_srate;
1365
1366         if (control_selector == UAC2_CS_CONTROL_SAM_FREQ) {
1367                 if (entity_id == USB_IN_CLK_ID)
1368                         r.dMIN = cpu_to_le32(p_srate);
1369                 else if (entity_id == USB_OUT_CLK_ID)
1370                         r.dMIN = cpu_to_le32(c_srate);
1371                 else
1372                         return -EOPNOTSUPP;
1373
1374                 r.dMAX = r.dMIN;
1375                 r.dRES = 0;
1376                 r.wNumSubRanges = cpu_to_le16(1);
1377
1378                 value = min_t(unsigned, w_length, sizeof r);
1379                 memcpy(req->buf, &r, value);
1380         } else {
1381                 dev_err(&uac2->pdev.dev,
1382                         "%s:%d control_selector=%d TODO!\n",
1383                         __func__, __LINE__, control_selector);
1384         }
1385
1386         return value;
1387 }
1388
1389 static int
1390 ac_rq_in(struct usb_function *fn, const struct usb_ctrlrequest *cr)
1391 {
1392         if (cr->bRequest == UAC2_CS_CUR)
1393                 return in_rq_cur(fn, cr);
1394         else if (cr->bRequest == UAC2_CS_RANGE)
1395                 return in_rq_range(fn, cr);
1396         else
1397                 return -EOPNOTSUPP;
1398 }
1399
1400 static int
1401 out_rq_cur(struct usb_function *fn, const struct usb_ctrlrequest *cr)
1402 {
1403         u16 w_length = le16_to_cpu(cr->wLength);
1404         u16 w_value = le16_to_cpu(cr->wValue);
1405         u8 control_selector = w_value >> 8;
1406
1407         if (control_selector == UAC2_CS_CONTROL_SAM_FREQ)
1408                 return w_length;
1409
1410         return -EOPNOTSUPP;
1411 }
1412
1413 static int
1414 setup_rq_inf(struct usb_function *fn, const struct usb_ctrlrequest *cr)
1415 {
1416         struct audio_dev *agdev = func_to_agdev(fn);
1417         struct snd_uac2_chip *uac2 = &agdev->uac2;
1418         u16 w_index = le16_to_cpu(cr->wIndex);
1419         u8 intf = w_index & 0xff;
1420
1421         if (intf != agdev->ac_intf) {
1422                 dev_err(&uac2->pdev.dev,
1423                         "%s:%d Error!\n", __func__, __LINE__);
1424                 return -EOPNOTSUPP;
1425         }
1426
1427         if (cr->bRequestType & USB_DIR_IN)
1428                 return ac_rq_in(fn, cr);
1429         else if (cr->bRequest == UAC2_CS_CUR)
1430                 return out_rq_cur(fn, cr);
1431
1432         return -EOPNOTSUPP;
1433 }
1434
1435 static int
1436 afunc_setup(struct usb_function *fn, const struct usb_ctrlrequest *cr)
1437 {
1438         struct usb_composite_dev *cdev = fn->config->cdev;
1439         struct audio_dev *agdev = func_to_agdev(fn);
1440         struct snd_uac2_chip *uac2 = &agdev->uac2;
1441         struct usb_request *req = cdev->req;
1442         u16 w_length = le16_to_cpu(cr->wLength);
1443         int value = -EOPNOTSUPP;
1444
1445         /* Only Class specific requests are supposed to reach here */
1446         if ((cr->bRequestType & USB_TYPE_MASK) != USB_TYPE_CLASS)
1447                 return -EOPNOTSUPP;
1448
1449         if ((cr->bRequestType & USB_RECIP_MASK) == USB_RECIP_INTERFACE)
1450                 value = setup_rq_inf(fn, cr);
1451         else
1452                 dev_err(&uac2->pdev.dev, "%s:%d Error!\n", __func__, __LINE__);
1453
1454         if (value >= 0) {
1455                 req->length = value;
1456                 req->zero = value < w_length;
1457                 value = usb_ep_queue(cdev->gadget->ep0, req, GFP_ATOMIC);
1458                 if (value < 0) {
1459                         dev_err(&uac2->pdev.dev,
1460                                 "%s:%d Error!\n", __func__, __LINE__);
1461                         req->status = 0;
1462                 }
1463         }
1464
1465         return value;
1466 }
1467
1468 static inline struct f_uac2_opts *to_f_uac2_opts(struct config_item *item)
1469 {
1470         return container_of(to_config_group(item), struct f_uac2_opts,
1471                             func_inst.group);
1472 }
1473
1474 static void f_uac2_attr_release(struct config_item *item)
1475 {
1476         struct f_uac2_opts *opts = to_f_uac2_opts(item);
1477
1478         usb_put_function_instance(&opts->func_inst);
1479 }
1480
1481 static struct configfs_item_operations f_uac2_item_ops = {
1482         .release        = f_uac2_attr_release,
1483 };
1484
1485 #define UAC2_ATTRIBUTE(name)                                            \
1486 static ssize_t f_uac2_opts_##name##_show(struct config_item *item,      \
1487                                          char *page)                    \
1488 {                                                                       \
1489         struct f_uac2_opts *opts = to_f_uac2_opts(item);                \
1490         int result;                                                     \
1491                                                                         \
1492         mutex_lock(&opts->lock);                                        \
1493         result = sprintf(page, "%u\n", opts->name);                     \
1494         mutex_unlock(&opts->lock);                                      \
1495                                                                         \
1496         return result;                                                  \
1497 }                                                                       \
1498                                                                         \
1499 static ssize_t f_uac2_opts_##name##_store(struct config_item *item,     \
1500                                           const char *page, size_t len) \
1501 {                                                                       \
1502         struct f_uac2_opts *opts = to_f_uac2_opts(item);                \
1503         int ret;                                                        \
1504         u32 num;                                                        \
1505                                                                         \
1506         mutex_lock(&opts->lock);                                        \
1507         if (opts->refcnt) {                                             \
1508                 ret = -EBUSY;                                           \
1509                 goto end;                                               \
1510         }                                                               \
1511                                                                         \
1512         ret = kstrtou32(page, 0, &num);                                 \
1513         if (ret)                                                        \
1514                 goto end;                                               \
1515                                                                         \
1516         opts->name = num;                                               \
1517         ret = len;                                                      \
1518                                                                         \
1519 end:                                                                    \
1520         mutex_unlock(&opts->lock);                                      \
1521         return ret;                                                     \
1522 }                                                                       \
1523                                                                         \
1524 CONFIGFS_ATTR(f_uac2_opts_, name)
1525
1526 UAC2_ATTRIBUTE(p_chmask);
1527 UAC2_ATTRIBUTE(p_srate);
1528 UAC2_ATTRIBUTE(p_ssize);
1529 UAC2_ATTRIBUTE(c_chmask);
1530 UAC2_ATTRIBUTE(c_srate);
1531 UAC2_ATTRIBUTE(c_ssize);
1532
1533 static struct configfs_attribute *f_uac2_attrs[] = {
1534         &f_uac2_opts_attr_p_chmask,
1535         &f_uac2_opts_attr_p_srate,
1536         &f_uac2_opts_attr_p_ssize,
1537         &f_uac2_opts_attr_c_chmask,
1538         &f_uac2_opts_attr_c_srate,
1539         &f_uac2_opts_attr_c_ssize,
1540         NULL,
1541 };
1542
1543 static struct config_item_type f_uac2_func_type = {
1544         .ct_item_ops    = &f_uac2_item_ops,
1545         .ct_attrs       = f_uac2_attrs,
1546         .ct_owner       = THIS_MODULE,
1547 };
1548
1549 static void afunc_free_inst(struct usb_function_instance *f)
1550 {
1551         struct f_uac2_opts *opts;
1552
1553         opts = container_of(f, struct f_uac2_opts, func_inst);
1554         kfree(opts);
1555 }
1556
1557 static struct usb_function_instance *afunc_alloc_inst(void)
1558 {
1559         struct f_uac2_opts *opts;
1560
1561         opts = kzalloc(sizeof(*opts), GFP_KERNEL);
1562         if (!opts)
1563                 return ERR_PTR(-ENOMEM);
1564
1565         mutex_init(&opts->lock);
1566         opts->func_inst.free_func_inst = afunc_free_inst;
1567
1568         config_group_init_type_name(&opts->func_inst.group, "",
1569                                     &f_uac2_func_type);
1570
1571         opts->p_chmask = UAC2_DEF_PCHMASK;
1572         opts->p_srate = UAC2_DEF_PSRATE;
1573         opts->p_ssize = UAC2_DEF_PSSIZE;
1574         opts->c_chmask = UAC2_DEF_CCHMASK;
1575         opts->c_srate = UAC2_DEF_CSRATE;
1576         opts->c_ssize = UAC2_DEF_CSSIZE;
1577         return &opts->func_inst;
1578 }
1579
1580 static void afunc_free(struct usb_function *f)
1581 {
1582         struct audio_dev *agdev;
1583         struct f_uac2_opts *opts;
1584
1585         agdev = func_to_agdev(f);
1586         opts = container_of(f->fi, struct f_uac2_opts, func_inst);
1587         kfree(agdev);
1588         mutex_lock(&opts->lock);
1589         --opts->refcnt;
1590         mutex_unlock(&opts->lock);
1591 }
1592
1593 static void afunc_unbind(struct usb_configuration *c, struct usb_function *f)
1594 {
1595         struct audio_dev *agdev = func_to_agdev(f);
1596         struct uac2_rtd_params *prm;
1597
1598         alsa_uac2_exit(agdev);
1599
1600         prm = &agdev->uac2.p_prm;
1601         kfree(prm->rbuf);
1602
1603         prm = &agdev->uac2.c_prm;
1604         kfree(prm->rbuf);
1605         usb_free_all_descriptors(f);
1606 }
1607
1608 static struct usb_function *afunc_alloc(struct usb_function_instance *fi)
1609 {
1610         struct audio_dev *agdev;
1611         struct f_uac2_opts *opts;
1612
1613         agdev = kzalloc(sizeof(*agdev), GFP_KERNEL);
1614         if (agdev == NULL)
1615                 return ERR_PTR(-ENOMEM);
1616
1617         opts = container_of(fi, struct f_uac2_opts, func_inst);
1618         mutex_lock(&opts->lock);
1619         ++opts->refcnt;
1620         mutex_unlock(&opts->lock);
1621
1622         agdev->func.name = "uac2_func";
1623         agdev->func.bind = afunc_bind;
1624         agdev->func.unbind = afunc_unbind;
1625         agdev->func.set_alt = afunc_set_alt;
1626         agdev->func.get_alt = afunc_get_alt;
1627         agdev->func.disable = afunc_disable;
1628         agdev->func.setup = afunc_setup;
1629         agdev->func.free_func = afunc_free;
1630
1631         return &agdev->func;
1632 }
1633
1634 DECLARE_USB_FUNCTION_INIT(uac2, afunc_alloc_inst, afunc_alloc);
1635 MODULE_LICENSE("GPL");
1636 MODULE_AUTHOR("Yadwinder Singh");
1637 MODULE_AUTHOR("Jaswinder Singh");