drivers/usb/gadget/function/u_audio.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * u_audio.c -- interface to USB gadget "ALSA sound card" utilities
   4  *
   5  * Copyright (C) 2016
   6  * Author: Ruslan Bilovol <ruslan.bilovol@gmail.com>
   7  *
   8  * Sound card implementation was cut-and-pasted with changes
   9  * from f_uac2.c and has:
  10  *    Copyright (C) 2011
  11  *    Yadwinder Singh (yadi.brar01@gmail.com)
  12  *    Jaswinder Singh (jaswinder.singh@linaro.org)
  13  */
  14
  15 #include <linux/kernel.h>
  16 #include <linux/module.h>
  17 #include <sound/core.h>
  18 #include <sound/pcm.h>
  19 #include <sound/pcm_params.h>
  20 #include <sound/control.h>
  21 #include <sound/tlv.h>
  22 #include <linux/usb/audio.h>
  23
  24 #include "u_audio.h"
  25
  26 #define BUFF_SIZE_MAX   (PAGE_SIZE * 16)
  27 #define PRD_SIZE_MAX    PAGE_SIZE
  28 #define MIN_PERIODS     4
  29
  30 enum {
  31         UAC_FBACK_CTRL,
  32         UAC_P_PITCH_CTRL,
  33         UAC_MUTE_CTRL,
  34         UAC_VOLUME_CTRL,
  35 };
  36
  37 /* Runtime data params for one stream */
  38 struct uac_rtd_params {
  39         struct snd_uac_chip *uac; /* parent chip */
  40         bool ep_enabled; /* if the ep is enabled */
  41
  42         struct snd_pcm_substream *ss;
  43
  44         /* Ring buffer */
  45         ssize_t hw_ptr;
  46
  47         void *rbuf;
  48
  49         unsigned int pitch;     /* Stream pitch ratio to 1000000 */
  50         unsigned int max_psize; /* MaxPacketSize of endpoint */
  51
  52         struct usb_request **reqs;
  53
  54         struct usb_request *req_fback; /* Feedback endpoint request */
  55         bool fb_ep_enabled; /* if the ep is enabled */
  56
  57   /* Volume/Mute controls and their state */
  58   int fu_id; /* Feature Unit ID */
  59   struct snd_kcontrol *snd_kctl_volume;
  60   struct snd_kcontrol *snd_kctl_mute;
  61   s16 volume_min, volume_max, volume_res;
  62   s16 volume;
  63   int mute;
  64
  65   spinlock_t lock; /* lock for control transfers */
  66
  67 };
  68
  69 struct snd_uac_chip {
  70         struct g_audio *audio_dev;
  71
  72         struct uac_rtd_params p_prm;
  73         struct uac_rtd_params c_prm;
  74
  75         struct snd_card *card;
  76         struct snd_pcm *pcm;
  77
  78         /* pre-calculated values for playback iso completion */
  79         unsigned long long p_residue_mil;
  80         unsigned int p_interval;
  81         unsigned int p_framesize;
  82 };
  83
  84 static const struct snd_pcm_hardware uac_pcm_hardware = {
  85         .info = SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER
  86                  | SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID
  87                  | SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_RESUME,
  88         .rates = SNDRV_PCM_RATE_CONTINUOUS,
  89         .periods_max = BUFF_SIZE_MAX / PRD_SIZE_MAX,
  90         .buffer_bytes_max = BUFF_SIZE_MAX,
  91         .period_bytes_max = PRD_SIZE_MAX,
  92         .periods_min = MIN_PERIODS,
  93 };
  94
  95 static void u_audio_set_fback_frequency(enum usb_device_speed speed,
  96                                         struct usb_ep *out_ep,
  97                                         unsigned long long freq,
  98                                         unsigned int pitch,
  99                                         void *buf)
 100 {
 101         u32 ff = 0;
 102         const struct usb_endpoint_descriptor *ep_desc;
 103
 104         /*
 105          * Because the pitch base is 1000000, the final divider here
 106          * will be 1000 * 1000000 = 1953125 << 9
 107          *
 108          * Instead of dealing with big numbers lets fold this 9 left shift
 109          */
 110
 111         if (speed == USB_SPEED_FULL) {
 112                 /*
 113                  * Full-speed feedback endpoints report frequency
 114                  * in samples/frame
 115                  * Format is encoded in Q10.10 left-justified in the 24 bits,
 116                  * so that it has a Q10.14 format.
 117                  *
 118                  * ff = (freq << 14) / 1000
 119                  */
 120                 freq <<= 5;
 121         } else {
 122                 /*
 123                  * High-speed feedback endpoints report frequency
 124                  * in samples/microframe.
 125                  * Format is encoded in Q12.13 fitted into four bytes so that
 126                  * the binary point is located between the second and the third
 127                  * byte fromat (that is Q16.16)
 128                  *
 129                  * ff = (freq << 16) / 8000
 130                  *
 131                  * Win10 and OSX UAC2 drivers require number of samples per packet
 132                  * in order to honor the feedback value.
 133                  * Linux snd-usb-audio detects the applied bit-shift automatically.
 134                  */
 135                 ep_desc = out_ep->desc;
 136                 freq <<= 4 + (ep_desc->bInterval - 1);
 137         }
 138
 139         ff = DIV_ROUND_CLOSEST_ULL((freq * pitch), 1953125);
 140
 141         *(__le32 *)buf = cpu_to_le32(ff);
 142 }
 143
 144 static void u_audio_iso_complete(struct usb_ep *ep, struct usb_request *req)
 145 {
 146         unsigned int pending;
 147         unsigned int hw_ptr;
 148         int status = req->status;
 149         struct snd_pcm_substream *substream;
 150         struct snd_pcm_runtime *runtime;
 151         struct uac_rtd_params *prm = req->context;
 152         struct snd_uac_chip *uac = prm->uac;
 153         struct g_audio *audio_dev = uac->audio_dev;
 154         struct uac_params *params = &audio_dev->params;
 155         unsigned int frames, p_pktsize;
 156         unsigned long long pitched_rate_mil, p_pktsize_residue_mil,
 157                         residue_frames_mil, div_result;
 158
 159         /* i/f shutting down */
 160         if (!prm->ep_enabled) {
 161                 usb_ep_free_request(ep, req);
 162                 return;
 163         }
 164
 165         if (req->status == -ESHUTDOWN)
 166                 return;
 167
 168         /*
 169          * We can't really do much about bad xfers.
 170          * Afterall, the ISOCH xfers could fail legitimately.
 171          */
 172         if (status)
 173                 pr_debug("%s: iso_complete status(%d) %d/%d\n",
 174                         __func__, status, req->actual, req->length);
 175
 176         substream = prm->ss;
 177
 178         /* Do nothing if ALSA isn't active */
 179         if (!substream)
 180                 goto exit;
 181
 182         snd_pcm_stream_lock(substream);
 183
 184         runtime = substream->runtime;
 185         if (!runtime || !snd_pcm_running(substream)) {
 186                 snd_pcm_stream_unlock(substream);
 187                 goto exit;
 188         }
 189
 190         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
 191                 /*
 192                  * For each IN packet, take the quotient of the current data
 193                  * rate and the endpoint's interval as the base packet size.
 194                  * If there is a residue from this division, add it to the
 195                  * residue accumulator.
 196                  */
 197                 unsigned long long p_interval_mil = uac->p_interval * 1000000ULL;
 198
 199                 pitched_rate_mil = (unsigned long long)
 200                                 params->p_srate * prm->pitch;
 201                 div_result = pitched_rate_mil;
 202                 do_div(div_result, uac->p_interval);
 203                 do_div(div_result, 1000000);
 204                 frames = (unsigned int) div_result;
 205
 206                 pr_debug("p_srate %d, pitch %d, interval_mil %llu, frames %d\n",
 207                                 params->p_srate, prm->pitch, p_interval_mil, frames);
 208
 209                 p_pktsize = min_t(unsigned int,
 210                                         uac->p_framesize * frames,
 211                                         ep->maxpacket);
 212
 213                 if (p_pktsize < ep->maxpacket) {
 214                         residue_frames_mil = pitched_rate_mil - frames * p_interval_mil;
 215                         p_pktsize_residue_mil = uac->p_framesize * residue_frames_mil;
 216                 } else
 217                         p_pktsize_residue_mil = 0;
 218
 219                 req->length = p_pktsize;
 220                 uac->p_residue_mil += p_pktsize_residue_mil;
 221
 222                 /*
 223                  * Whenever there are more bytes in the accumulator p_residue_mil than we
 224                  * need to add one more sample frame, increase this packet's
 225                  * size and decrease the accumulator.
 226                  */
 227                 div_result = uac->p_residue_mil;
 228                 do_div(div_result, uac->p_interval);
 229                 do_div(div_result, 1000000);
 230                 if ((unsigned int) div_result >= uac->p_framesize) {
 231                         req->length += uac->p_framesize;
 232                         uac->p_residue_mil -= uac->p_framesize * p_interval_mil;
 233                         pr_debug("increased req length to %d\n", req->length);
 234                 }
 235                 pr_debug("remains uac->p_residue_mil %llu\n", uac->p_residue_mil);
 236
 237                 req->actual = req->length;
 238         }
 239
 240         hw_ptr = prm->hw_ptr;
 241
 242         /* Pack USB load in ALSA ring buffer */
 243         pending = runtime->dma_bytes - hw_ptr;
 244
 245         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
 246                 if (unlikely(pending < req->actual)) {
 247                         memcpy(req->buf, runtime->dma_area + hw_ptr, pending);
 248                         memcpy(req->buf + pending, runtime->dma_area,
 249                                req->actual - pending);
 250                 } else {
 251                         memcpy(req->buf, runtime->dma_area + hw_ptr,
 252                                req->actual);
 253                 }
 254         } else {
 255                 if (unlikely(pending < req->actual)) {
 256                         memcpy(runtime->dma_area + hw_ptr, req->buf, pending);
 257                         memcpy(runtime->dma_area, req->buf + pending,
 258                                req->actual - pending);
 259                 } else {
 260                         memcpy(runtime->dma_area + hw_ptr, req->buf,
 261                                req->actual);
 262                 }
 263         }
 264
 265         /* update hw_ptr after data is copied to memory */
 266         prm->hw_ptr = (hw_ptr + req->actual) % runtime->dma_bytes;
 267         hw_ptr = prm->hw_ptr;
 268         snd_pcm_stream_unlock(substream);
 269
 270         if ((hw_ptr % snd_pcm_lib_period_bytes(substream)) < req->actual)
 271                 snd_pcm_period_elapsed(substream);
 272
 273 exit:
 274         if (usb_ep_queue(ep, req, GFP_ATOMIC))
 275                 dev_err(uac->card->dev, "%d Error!\n", __LINE__);
 276 }
 277
 278 static void u_audio_iso_fback_complete(struct usb_ep *ep,
 279                                        struct usb_request *req)
 280 {
 281         struct uac_rtd_params *prm = req->context;
 282         struct snd_uac_chip *uac = prm->uac;
 283         struct g_audio *audio_dev = uac->audio_dev;
 284         struct uac_params *params = &audio_dev->params;
 285         int status = req->status;
 286
 287         /* i/f shutting down */
 288         if (!prm->fb_ep_enabled) {
 289                 kfree(req->buf);
 290                 usb_ep_free_request(ep, req);
 291                 return;
 292         }
 293
 294         if (req->status == -ESHUTDOWN)
 295                 return;
 296
 297         /*
 298          * We can't really do much about bad xfers.
 299          * Afterall, the ISOCH xfers could fail legitimately.
 300          */
 301         if (status)
 302                 pr_debug("%s: iso_complete status(%d) %d/%d\n",
 303                         __func__, status, req->actual, req->length);
 304
 305         u_audio_set_fback_frequency(audio_dev->gadget->speed, audio_dev->out_ep,
 306                                     params->c_srate, prm->pitch,
 307                                     req->buf);
 308
 309         if (usb_ep_queue(ep, req, GFP_ATOMIC))
 310                 dev_err(uac->card->dev, "%d Error!\n", __LINE__);
 311 }
 312
 313 static int uac_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
 314 {
 315         struct snd_uac_chip *uac = snd_pcm_substream_chip(substream);
 316         struct uac_rtd_params *prm;
 317         struct g_audio *audio_dev;
 318         struct uac_params *params;
 319         int err = 0;
 320
 321         audio_dev = uac->audio_dev;
 322         params = &audio_dev->params;
 323
 324         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
 325                 prm = &uac->p_prm;
 326         else
 327                 prm = &uac->c_prm;
 328
 329         /* Reset */
 330         prm->hw_ptr = 0;
 331
 332         switch (cmd) {
 333         case SNDRV_PCM_TRIGGER_START:
 334         case SNDRV_PCM_TRIGGER_RESUME:
 335                 prm->ss = substream;
 336                 break;
 337         case SNDRV_PCM_TRIGGER_STOP:
 338         case SNDRV_PCM_TRIGGER_SUSPEND:
 339                 prm->ss = NULL;
 340                 break;
 341         default:
 342                 err = -EINVAL;
 343         }
 344
 345         /* Clear buffer after Play stops */
 346         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK && !prm->ss)
 347                 memset(prm->rbuf, 0, prm->max_psize * params->req_number);
 348
 349         return err;
 350 }
 351
 352 static snd_pcm_uframes_t uac_pcm_pointer(struct snd_pcm_substream *substream)
 353 {
 354         struct snd_uac_chip *uac = snd_pcm_substream_chip(substream);
 355         struct uac_rtd_params *prm;
 356
 357         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
 358                 prm = &uac->p_prm;
 359         else
 360                 prm = &uac->c_prm;
 361
 362         return bytes_to_frames(substream->runtime, prm->hw_ptr);
 363 }
 364
 365 static u64 uac_ssize_to_fmt(int ssize)
 366 {
 367         u64 ret;
 368
 369         switch (ssize) {
 370         case 3:
 371                 ret = SNDRV_PCM_FMTBIT_S24_3LE;
 372                 break;
 373         case 4:
 374                 ret = SNDRV_PCM_FMTBIT_S32_LE;
 375                 break;
 376         default:
 377                 ret = SNDRV_PCM_FMTBIT_S16_LE;
 378                 break;
 379         }
 380
 381         return ret;
 382 }
 383
 384 static int uac_pcm_open(struct snd_pcm_substream *substream)
 385 {
 386         struct snd_uac_chip *uac = snd_pcm_substream_chip(substream);
 387         struct snd_pcm_runtime *runtime = substream->runtime;
 388         struct g_audio *audio_dev;
 389         struct uac_params *params;
 390         int p_ssize, c_ssize;
 391         int p_srate, c_srate;
 392         int p_chmask, c_chmask;
 393
 394         audio_dev = uac->audio_dev;
 395         params = &audio_dev->params;
 396         p_ssize = params->p_ssize;
 397         c_ssize = params->c_ssize;
 398         p_srate = params->p_srate;
 399         c_srate = params->c_srate;
 400         p_chmask = params->p_chmask;
 401         c_chmask = params->c_chmask;
 402         uac->p_residue_mil = 0;
 403
 404         runtime->hw = uac_pcm_hardware;
 405
 406         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
 407                 runtime->hw.rate_min = p_srate;
 408                 runtime->hw.formats = uac_ssize_to_fmt(p_ssize);
 409                 runtime->hw.channels_min = num_channels(p_chmask);
 410                 runtime->hw.period_bytes_min = 2 * uac->p_prm.max_psize
 411                                                 / runtime->hw.periods_min;
 412         } else {
 413                 runtime->hw.rate_min = c_srate;
 414                 runtime->hw.formats = uac_ssize_to_fmt(c_ssize);
 415                 runtime->hw.channels_min = num_channels(c_chmask);
 416                 runtime->hw.period_bytes_min = 2 * uac->c_prm.max_psize
 417                                                 / runtime->hw.periods_min;
 418         }
 419
 420         runtime->hw.rate_max = runtime->hw.rate_min;
 421         runtime->hw.channels_max = runtime->hw.channels_min;
 422
 423         snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
 424
 425         return 0;
 426 }
 427
 428 /* ALSA cries without these function pointers */
 429 static int uac_pcm_null(struct snd_pcm_substream *substream)
 430 {
 431         return 0;
 432 }
 433
 434 static const struct snd_pcm_ops uac_pcm_ops = {
 435         .open = uac_pcm_open,
 436         .close = uac_pcm_null,
 437         .trigger = uac_pcm_trigger,
 438         .pointer = uac_pcm_pointer,
 439         .prepare = uac_pcm_null,
 440 };
 441
 442 static inline void free_ep(struct uac_rtd_params *prm, struct usb_ep *ep)
 443 {
 444         struct snd_uac_chip *uac = prm->uac;
 445         struct g_audio *audio_dev;
 446         struct uac_params *params;
 447         int i;
 448
 449         if (!prm->ep_enabled)
 450                 return;
 451
 452         audio_dev = uac->audio_dev;
 453         params = &audio_dev->params;
 454
 455         for (i = 0; i < params->req_number; i++) {
 456                 if (prm->reqs[i]) {
 457                         if (usb_ep_dequeue(ep, prm->reqs[i]))
 458                                 usb_ep_free_request(ep, prm->reqs[i]);
 459                         /*
 460                          * If usb_ep_dequeue() cannot successfully dequeue the
 461                          * request, the request will be freed by the completion
 462                          * callback.
 463                          */
 464
 465                         prm->reqs[i] = NULL;
 466                 }
 467         }
 468
 469         prm->ep_enabled = false;
 470
 471         if (usb_ep_disable(ep))
 472                 dev_err(uac->card->dev, "%s:%d Error!\n", __func__, __LINE__);
 473 }
 474
 475 static inline void free_ep_fback(struct uac_rtd_params *prm, struct usb_ep *ep)
 476 {
 477         struct snd_uac_chip *uac = prm->uac;
 478
 479         if (!prm->fb_ep_enabled)
 480                 return;
 481
 482         if (prm->req_fback) {
 483                 if (usb_ep_dequeue(ep, prm->req_fback)) {
 484                         kfree(prm->req_fback->buf);
 485                         usb_ep_free_request(ep, prm->req_fback);
 486                 }
 487                 prm->req_fback = NULL;
 488         }
 489
 490         prm->fb_ep_enabled = false;
 491
 492         if (usb_ep_disable(ep))
 493                 dev_err(uac->card->dev, "%s:%d Error!\n", __func__, __LINE__);
 494 }
 495
 496 int u_audio_start_capture(struct g_audio *audio_dev)
 497 {
 498         struct snd_uac_chip *uac = audio_dev->uac;
 499         struct usb_gadget *gadget = audio_dev->gadget;
 500         struct device *dev = &gadget->dev;
 501         struct usb_request *req, *req_fback;
 502         struct usb_ep *ep, *ep_fback;
 503         struct uac_rtd_params *prm;
 504         struct uac_params *params = &audio_dev->params;
 505         int req_len, i;
 506
 507         ep = audio_dev->out_ep;
 508         prm = &uac->c_prm;
 509         config_ep_by_speed(gadget, &audio_dev->func, ep);
 510         req_len = ep->maxpacket;
 511
 512         prm->ep_enabled = true;
 513         usb_ep_enable(ep);
 514
 515         for (i = 0; i < params->req_number; i++) {
 516                 if (!prm->reqs[i]) {
 517                         req = usb_ep_alloc_request(ep, GFP_ATOMIC);
 518                         if (req == NULL)
 519                                 return -ENOMEM;
 520
 521                         prm->reqs[i] = req;
 522
 523                         req->zero = 0;
 524                         req->context = prm;
 525                         req->length = req_len;
 526                         req->complete = u_audio_iso_complete;
 527                         req->buf = prm->rbuf + i * ep->maxpacket;
 528                 }
 529
 530                 if (usb_ep_queue(ep, prm->reqs[i], GFP_ATOMIC))
 531                         dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
 532         }
 533
 534         ep_fback = audio_dev->in_ep_fback;
 535         if (!ep_fback)
 536                 return 0;
 537
 538         /* Setup feedback endpoint */
 539         config_ep_by_speed(gadget, &audio_dev->func, ep_fback);
 540         prm->fb_ep_enabled = true;
 541         usb_ep_enable(ep_fback);
 542         req_len = ep_fback->maxpacket;
 543
 544         req_fback = usb_ep_alloc_request(ep_fback, GFP_ATOMIC);
 545         if (req_fback == NULL)
 546                 return -ENOMEM;
 547
 548         prm->req_fback = req_fback;
 549         req_fback->zero = 0;
 550         req_fback->context = prm;
 551         req_fback->length = req_len;
 552         req_fback->complete = u_audio_iso_fback_complete;
 553
 554         req_fback->buf = kzalloc(req_len, GFP_ATOMIC);
 555         if (!req_fback->buf)
 556                 return -ENOMEM;
 557
 558         /*
 559          * Configure the feedback endpoint's reported frequency.
 560          * Always start with original frequency since its deviation can't
 561          * be meauserd at start of playback
 562          */
 563         prm->pitch = 1000000;
 564         u_audio_set_fback_frequency(audio_dev->gadget->speed, ep,
 565                                     params->c_srate, prm->pitch,
 566                                     req_fback->buf);
 567
 568         if (usb_ep_queue(ep_fback, req_fback, GFP_ATOMIC))
 569                 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
 570
 571         return 0;
 572 }
 573 EXPORT_SYMBOL_GPL(u_audio_start_capture);
 574
 575 void u_audio_stop_capture(struct g_audio *audio_dev)
 576 {
 577         struct snd_uac_chip *uac = audio_dev->uac;
 578
 579         if (audio_dev->in_ep_fback)
 580                 free_ep_fback(&uac->c_prm, audio_dev->in_ep_fback);
 581         free_ep(&uac->c_prm, audio_dev->out_ep);
 582 }
 583 EXPORT_SYMBOL_GPL(u_audio_stop_capture);
 584
 585 int u_audio_start_playback(struct g_audio *audio_dev)
 586 {
 587         struct snd_uac_chip *uac = audio_dev->uac;
 588         struct usb_gadget *gadget = audio_dev->gadget;
 589         struct device *dev = &gadget->dev;
 590         struct usb_request *req;
 591         struct usb_ep *ep;
 592         struct uac_rtd_params *prm;
 593         struct uac_params *params = &audio_dev->params;
 594         unsigned int factor;
 595         const struct usb_endpoint_descriptor *ep_desc;
 596         int req_len, i;
 597         unsigned int p_pktsize;
 598
 599         ep = audio_dev->in_ep;
 600         prm = &uac->p_prm;
 601         config_ep_by_speed(gadget, &audio_dev->func, ep);
 602
 603         ep_desc = ep->desc;
 604         /*
 605          * Always start with original frequency
 606          */
 607         prm->pitch = 1000000;
 608
 609         /* pre-calculate the playback endpoint's interval */
 610         if (gadget->speed == USB_SPEED_FULL)
 611                 factor = 1000;
 612         else
 613                 factor = 8000;
 614
 615         /* pre-compute some values for iso_complete() */
 616         uac->p_framesize = params->p_ssize *
 617                             num_channels(params->p_chmask);
 618         uac->p_interval = factor / (1 << (ep_desc->bInterval - 1));
 619         p_pktsize = min_t(unsigned int,
 620                                 uac->p_framesize *
 621                                         (params->p_srate / uac->p_interval),
 622                                 ep->maxpacket);
 623
 624         req_len = p_pktsize;
 625         uac->p_residue_mil = 0;
 626
 627         prm->ep_enabled = true;
 628         usb_ep_enable(ep);
 629
 630         for (i = 0; i < params->req_number; i++) {
 631                 if (!prm->reqs[i]) {
 632                         req = usb_ep_alloc_request(ep, GFP_ATOMIC);
 633                         if (req == NULL)
 634                                 return -ENOMEM;
 635
 636                         prm->reqs[i] = req;
 637
 638                         req->zero = 0;
 639                         req->context = prm;
 640                         req->length = req_len;
 641                         req->complete = u_audio_iso_complete;
 642                         req->buf = prm->rbuf + i * ep->maxpacket;
 643                 }
 644
 645                 if (usb_ep_queue(ep, prm->reqs[i], GFP_ATOMIC))
 646                         dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
 647         }
 648
 649         return 0;
 650 }
 651 EXPORT_SYMBOL_GPL(u_audio_start_playback);
 652
 653 void u_audio_stop_playback(struct g_audio *audio_dev)
 654 {
 655         struct snd_uac_chip *uac = audio_dev->uac;
 656
 657         free_ep(&uac->p_prm, audio_dev->in_ep);
 658 }
 659 EXPORT_SYMBOL_GPL(u_audio_stop_playback);
 660
 661 int u_audio_get_volume(struct g_audio *audio_dev, int playback, s16 *val)
 662 {
 663         struct snd_uac_chip *uac = audio_dev->uac;
 664         struct uac_rtd_params *prm;
 665         unsigned long flags;
 666
 667         if (playback)
 668                 prm = &uac->p_prm;
 669         else
 670                 prm = &uac->c_prm;
 671
 672         spin_lock_irqsave(&prm->lock, flags);
 673         *val = prm->volume;
 674         spin_unlock_irqrestore(&prm->lock, flags);
 675
 676         return 0;
 677 }
 678 EXPORT_SYMBOL_GPL(u_audio_get_volume);
 679
 680 int u_audio_set_volume(struct g_audio *audio_dev, int playback, s16 val)
 681 {
 682         struct snd_uac_chip *uac = audio_dev->uac;
 683         struct uac_rtd_params *prm;
 684         unsigned long flags;
 685         int change = 0;
 686
 687         if (playback)
 688                 prm = &uac->p_prm;
 689         else
 690                 prm = &uac->c_prm;
 691
 692         spin_lock_irqsave(&prm->lock, flags);
 693         val = clamp(val, prm->volume_min, prm->volume_max);
 694         if (prm->volume != val) {
 695                 prm->volume = val;
 696                 change = 1;
 697         }
 698         spin_unlock_irqrestore(&prm->lock, flags);
 699
 700         if (change)
 701                 snd_ctl_notify(uac->card, SNDRV_CTL_EVENT_MASK_VALUE,
 702                                 &prm->snd_kctl_volume->id);
 703
 704         return 0;
 705 }
 706 EXPORT_SYMBOL_GPL(u_audio_set_volume);
 707
 708 int u_audio_get_mute(struct g_audio *audio_dev, int playback, int *val)
 709 {
 710         struct snd_uac_chip *uac = audio_dev->uac;
 711         struct uac_rtd_params *prm;
 712         unsigned long flags;
 713
 714         if (playback)
 715                 prm = &uac->p_prm;
 716         else
 717                 prm = &uac->c_prm;
 718
 719         spin_lock_irqsave(&prm->lock, flags);
 720         *val = prm->mute;
 721         spin_unlock_irqrestore(&prm->lock, flags);
 722
 723         return 0;
 724 }
 725 EXPORT_SYMBOL_GPL(u_audio_get_mute);
 726
 727 int u_audio_set_mute(struct g_audio *audio_dev, int playback, int val)
 728 {
 729         struct snd_uac_chip *uac = audio_dev->uac;
 730         struct uac_rtd_params *prm;
 731         unsigned long flags;
 732         int change = 0;
 733         int mute;
 734
 735         if (playback)
 736                 prm = &uac->p_prm;
 737         else
 738                 prm = &uac->c_prm;
 739
 740         mute = val ? 1 : 0;
 741
 742         spin_lock_irqsave(&prm->lock, flags);
 743         if (prm->mute != mute) {
 744                 prm->mute = mute;
 745                 change = 1;
 746         }
 747         spin_unlock_irqrestore(&prm->lock, flags);
 748
 749         if (change)
 750                 snd_ctl_notify(uac->card, SNDRV_CTL_EVENT_MASK_VALUE,
 751                                &prm->snd_kctl_mute->id);
 752
 753         return 0;
 754 }
 755 EXPORT_SYMBOL_GPL(u_audio_set_mute);
 756
 757
 758 static int u_audio_pitch_info(struct snd_kcontrol *kcontrol,
 759                                    struct snd_ctl_elem_info *uinfo)
 760 {
 761         struct uac_rtd_params *prm = snd_kcontrol_chip(kcontrol);
 762         struct snd_uac_chip *uac = prm->uac;
 763         struct g_audio *audio_dev = uac->audio_dev;
 764         struct uac_params *params = &audio_dev->params;
 765         unsigned int pitch_min, pitch_max;
 766
 767         pitch_min = (1000 - FBACK_SLOW_MAX) * 1000;
 768         pitch_max = (1000 + params->fb_max) * 1000;
 769
 770         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 771         uinfo->count = 1;
 772         uinfo->value.integer.min = pitch_min;
 773         uinfo->value.integer.max = pitch_max;
 774         uinfo->value.integer.step = 1;
 775         return 0;
 776 }
 777
 778 static int u_audio_pitch_get(struct snd_kcontrol *kcontrol,
 779                                    struct snd_ctl_elem_value *ucontrol)
 780 {
 781         struct uac_rtd_params *prm = snd_kcontrol_chip(kcontrol);
 782
 783         ucontrol->value.integer.value[0] = prm->pitch;
 784
 785         return 0;
 786 }
 787
 788 static int u_audio_pitch_put(struct snd_kcontrol *kcontrol,
 789                                   struct snd_ctl_elem_value *ucontrol)
 790 {
 791         struct uac_rtd_params *prm = snd_kcontrol_chip(kcontrol);
 792         struct snd_uac_chip *uac = prm->uac;
 793         struct g_audio *audio_dev = uac->audio_dev;
 794         struct uac_params *params = &audio_dev->params;
 795         unsigned int val;
 796         unsigned int pitch_min, pitch_max;
 797         int change = 0;
 798
 799         pitch_min = (1000 - FBACK_SLOW_MAX) * 1000;
 800         pitch_max = (1000 + params->fb_max) * 1000;
 801
 802         val = ucontrol->value.integer.value[0];
 803
 804         if (val < pitch_min)
 805                 val = pitch_min;
 806         if (val > pitch_max)
 807                 val = pitch_max;
 808
 809         if (prm->pitch != val) {
 810                 prm->pitch = val;
 811                 change = 1;
 812         }
 813
 814         return change;
 815 }
 816
 817 static int u_audio_mute_info(struct snd_kcontrol *kcontrol,
 818                                    struct snd_ctl_elem_info *uinfo)
 819 {
 820         uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
 821         uinfo->count = 1;
 822         uinfo->value.integer.min = 0;
 823         uinfo->value.integer.max = 1;
 824         uinfo->value.integer.step = 1;
 825
 826         return 0;
 827 }
 828
 829 static int u_audio_mute_get(struct snd_kcontrol *kcontrol,
 830                                    struct snd_ctl_elem_value *ucontrol)
 831 {
 832         struct uac_rtd_params *prm = snd_kcontrol_chip(kcontrol);
 833         unsigned long flags;
 834
 835         spin_lock_irqsave(&prm->lock, flags);
 836         ucontrol->value.integer.value[0] = !prm->mute;
 837         spin_unlock_irqrestore(&prm->lock, flags);
 838
 839         return 0;
 840 }
 841
 842 static int u_audio_mute_put(struct snd_kcontrol *kcontrol,
 843                                   struct snd_ctl_elem_value *ucontrol)
 844 {
 845         struct uac_rtd_params *prm = snd_kcontrol_chip(kcontrol);
 846         struct snd_uac_chip *uac = prm->uac;
 847         struct g_audio *audio_dev = uac->audio_dev;
 848         unsigned int val;
 849         unsigned long flags;
 850         int change = 0;
 851
 852         val = !ucontrol->value.integer.value[0];
 853
 854         spin_lock_irqsave(&prm->lock, flags);
 855         if (val != prm->mute) {
 856                 prm->mute = val;
 857                 change = 1;
 858         }
 859         spin_unlock_irqrestore(&prm->lock, flags);
 860
 861         if (change && audio_dev->notify)
 862                 audio_dev->notify(audio_dev, prm->fu_id, UAC_FU_MUTE);
 863
 864         return change;
 865 }
 866
 867 /*
 868  * TLV callback for mixer volume controls
 869  */
 870 static int u_audio_volume_tlv(struct snd_kcontrol *kcontrol, int op_flag,
 871                          unsigned int size, unsigned int __user *_tlv)
 872 {
 873         struct uac_rtd_params *prm = snd_kcontrol_chip(kcontrol);
 874         DECLARE_TLV_DB_MINMAX(scale, 0, 0);
 875
 876         if (size < sizeof(scale))
 877                 return -ENOMEM;
 878
 879         /* UAC volume resolution is 1/256 dB, TLV is 1/100 dB */
 880         scale[2] = (prm->volume_min * 100) / 256;
 881         scale[3] = (prm->volume_max * 100) / 256;
 882         if (copy_to_user(_tlv, scale, sizeof(scale)))
 883                 return -EFAULT;
 884
 885         return 0;
 886 }
 887
 888 static int u_audio_volume_info(struct snd_kcontrol *kcontrol,
 889                                    struct snd_ctl_elem_info *uinfo)
 890 {
 891         struct uac_rtd_params *prm = snd_kcontrol_chip(kcontrol);
 892
 893         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 894         uinfo->count = 1;
 895         uinfo->value.integer.min = 0;
 896         uinfo->value.integer.max =
 897                 (prm->volume_max - prm->volume_min + prm->volume_res - 1)
 898                 / prm->volume_res;
 899         uinfo->value.integer.step = 1;
 900
 901         return 0;
 902 }
 903
 904 static int u_audio_volume_get(struct snd_kcontrol *kcontrol,
 905                                    struct snd_ctl_elem_value *ucontrol)
 906 {
 907         struct uac_rtd_params *prm = snd_kcontrol_chip(kcontrol);
 908         unsigned long flags;
 909
 910         spin_lock_irqsave(&prm->lock, flags);
 911         ucontrol->value.integer.value[0] =
 912                         (prm->volume - prm->volume_min) / prm->volume_res;
 913         spin_unlock_irqrestore(&prm->lock, flags);
 914
 915         return 0;
 916 }
 917
 918 static int u_audio_volume_put(struct snd_kcontrol *kcontrol,
 919                                   struct snd_ctl_elem_value *ucontrol)
 920 {
 921         struct uac_rtd_params *prm = snd_kcontrol_chip(kcontrol);
 922         struct snd_uac_chip *uac = prm->uac;
 923         struct g_audio *audio_dev = uac->audio_dev;
 924         unsigned int val;
 925         s16 volume;
 926         unsigned long flags;
 927         int change = 0;
 928
 929         val = ucontrol->value.integer.value[0];
 930
 931         spin_lock_irqsave(&prm->lock, flags);
 932         volume = (val * prm->volume_res) + prm->volume_min;
 933         volume = clamp(volume, prm->volume_min, prm->volume_max);
 934         if (volume != prm->volume) {
 935                 prm->volume = volume;
 936                 change = 1;
 937         }
 938         spin_unlock_irqrestore(&prm->lock, flags);
 939
 940         if (change && audio_dev->notify)
 941                 audio_dev->notify(audio_dev, prm->fu_id, UAC_FU_VOLUME);
 942
 943         return change;
 944 }
 945
 946
 947 static struct snd_kcontrol_new u_audio_controls[]  = {
 948   [UAC_FBACK_CTRL] {
 949     .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
 950     .name =         "Capture Pitch 1000000",
 951     .info =         u_audio_pitch_info,
 952     .get =          u_audio_pitch_get,
 953     .put =          u_audio_pitch_put,
 954   },
 955         [UAC_P_PITCH_CTRL] {
 956                 .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
 957                 .name =         "Playback Pitch 1000000",
 958                 .info =         u_audio_pitch_info,
 959                 .get =          u_audio_pitch_get,
 960                 .put =          u_audio_pitch_put,
 961         },
 962   [UAC_MUTE_CTRL] {
 963                 .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 964                 .name =         "", /* will be filled later */
 965                 .info =         u_audio_mute_info,
 966                 .get =          u_audio_mute_get,
 967                 .put =          u_audio_mute_put,
 968         },
 969         [UAC_VOLUME_CTRL] {
 970                 .iface =        SNDRV_CTL_ELEM_IFACE_MIXER,
 971                 .name =         "", /* will be filled later */
 972                 .info =         u_audio_volume_info,
 973                 .get =          u_audio_volume_get,
 974                 .put =          u_audio_volume_put,
 975         },
 976 };
 977
 978 int g_audio_setup(struct g_audio *g_audio, const char *pcm_name,
 979                                         const char *card_name)
 980 {
 981         struct snd_uac_chip *uac;
 982         struct snd_card *card;
 983         struct snd_pcm *pcm;
 984         struct snd_kcontrol *kctl;
 985         struct uac_params *params;
 986         int p_chmask, c_chmask;
 987         int i, err;
 988
 989         if (!g_audio)
 990                 return -EINVAL;
 991
 992         uac = kzalloc(sizeof(*uac), GFP_KERNEL);
 993         if (!uac)
 994                 return -ENOMEM;
 995         g_audio->uac = uac;
 996         uac->audio_dev = g_audio;
 997
 998         params = &g_audio->params;
 999         p_chmask = params->p_chmask;
1000         c_chmask = params->c_chmask;
1001
1002         if (c_chmask) {
1003                 struct uac_rtd_params *prm = &uac->c_prm;
1004
1005     spin_lock_init(&prm->lock);
1006     uac->c_prm.uac = uac;
1007                 prm->max_psize = g_audio->out_ep_maxpsize;
1008
1009                 prm->reqs = kcalloc(params->req_number,
1010                                     sizeof(struct usb_request *),
1011                                     GFP_KERNEL);
1012                 if (!prm->reqs) {
1013                         err = -ENOMEM;
1014                         goto fail;
1015                 }
1016
1017                 prm->rbuf = kcalloc(params->req_number, prm->max_psize,
1018                                 GFP_KERNEL);
1019                 if (!prm->rbuf) {
1020                         prm->max_psize = 0;
1021                         err = -ENOMEM;
1022                         goto fail;
1023                 }
1024         }
1025
1026         if (p_chmask) {
1027                 struct uac_rtd_params *prm = &uac->p_prm;
1028
1029                 spin_lock_init(&prm->lock);
1030                 uac->p_prm.uac = uac;
1031                 prm->max_psize = g_audio->in_ep_maxpsize;
1032
1033                 prm->reqs = kcalloc(params->req_number,
1034                                     sizeof(struct usb_request *),
1035                                     GFP_KERNEL);
1036                 if (!prm->reqs) {
1037                         err = -ENOMEM;
1038                         goto fail;
1039                 }
1040
1041                 prm->rbuf = kcalloc(params->req_number, prm->max_psize,
1042                                 GFP_KERNEL);
1043                 if (!prm->rbuf) {
1044                         prm->max_psize = 0;
1045                         err = -ENOMEM;
1046                         goto fail;
1047                 }
1048         }
1049
1050         /* Choose any slot, with no id */
1051         err = snd_card_new(&g_audio->gadget->dev,
1052                         -1, NULL, THIS_MODULE, 0, &card);
1053         if (err < 0)
1054                 goto fail;
1055
1056         uac->card = card;
1057
1058         /*
1059          * Create first PCM device
1060          * Create a substream only for non-zero channel streams
1061          */
1062         err = snd_pcm_new(uac->card, pcm_name, 0,
1063                                p_chmask ? 1 : 0, c_chmask ? 1 : 0, &pcm);
1064         if (err < 0)
1065                 goto snd_fail;
1066
1067         strscpy(pcm->name, pcm_name, sizeof(pcm->name));
1068         pcm->private_data = uac;
1069         uac->pcm = pcm;
1070
1071         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &uac_pcm_ops);
1072         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &uac_pcm_ops);
1073
1074         /*
1075          * Create mixer and controls
1076          * Create only if it's required on USB side
1077          */
1078         if ((c_chmask && g_audio->in_ep_fback)
1079                         || (p_chmask && params->p_fu.id)
1080                         || (c_chmask && params->c_fu.id))
1081                 strscpy(card->mixername, card_name, sizeof(card->driver));
1082
1083         if (c_chmask && g_audio->in_ep_fback) {
1084                 kctl = snd_ctl_new1(&u_audio_controls[UAC_FBACK_CTRL],
1085                                     &uac->c_prm);
1086                 if (!kctl) {
1087                         err = -ENOMEM;
1088                         goto snd_fail;
1089                 }
1090
1091                 kctl->id.device = pcm->device;
1092                 kctl->id.subdevice = 0;
1093
1094                 err = snd_ctl_add(card, kctl);
1095                 if (err < 0)
1096                         goto snd_fail;
1097         }
1098
1099         if (p_chmask) {
1100                 kctl = snd_ctl_new1(&u_audio_controls[UAC_P_PITCH_CTRL],
1101                                     &uac->p_prm);
1102                 if (!kctl) {
1103                         err = -ENOMEM;
1104                         goto snd_fail;
1105                 }
1106
1107                 kctl->id.device = pcm->device;
1108                 kctl->id.subdevice = 0;
1109
1110                 err = snd_ctl_add(card, kctl);
1111                 if (err < 0)
1112                         goto snd_fail;
1113         }
1114
1115         for (i = 0; i <= SNDRV_PCM_STREAM_LAST; i++) {
1116                 struct uac_rtd_params *prm;
1117                 struct uac_fu_params *fu;
1118                 char ctrl_name[24];
1119                 char *direction;
1120
1121                 if (!pcm->streams[i].substream_count)
1122                         continue;
1123
1124                 if (i == SNDRV_PCM_STREAM_PLAYBACK) {
1125                         prm = &uac->p_prm;
1126                         fu = &params->p_fu;
1127                         direction = "Playback";
1128                 } else {
1129                         prm = &uac->c_prm;
1130                         fu = &params->c_fu;
1131                         direction = "Capture";
1132                 }
1133
1134                 prm->fu_id = fu->id;
1135
1136                 if (fu->mute_present) {
1137                         snprintf(ctrl_name, sizeof(ctrl_name),
1138                                         "PCM %s Switch", direction);
1139
1140                         u_audio_controls[UAC_MUTE_CTRL].name = ctrl_name;
1141
1142                         kctl = snd_ctl_new1(&u_audio_controls[UAC_MUTE_CTRL],
1143                                             prm);
1144                         if (!kctl) {
1145                                 err = -ENOMEM;
1146                                 goto snd_fail;
1147                         }
1148
1149                         kctl->id.device = pcm->device;
1150                         kctl->id.subdevice = 0;
1151
1152                         err = snd_ctl_add(card, kctl);
1153                         if (err < 0)
1154                                 goto snd_fail;
1155                         prm->snd_kctl_mute = kctl;
1156                         prm->mute = 0;
1157                 }
1158
1159                 if (fu->volume_present) {
1160                         snprintf(ctrl_name, sizeof(ctrl_name),
1161                                         "PCM %s Volume", direction);
1162
1163                         u_audio_controls[UAC_VOLUME_CTRL].name = ctrl_name;
1164
1165                         kctl = snd_ctl_new1(&u_audio_controls[UAC_VOLUME_CTRL],
1166                                             prm);
1167                         if (!kctl) {
1168                                 err = -ENOMEM;
1169                                 goto snd_fail;
1170                         }
1171
1172                         kctl->id.device = pcm->device;
1173                         kctl->id.subdevice = 0;
1174
1175
1176                         kctl->tlv.c = u_audio_volume_tlv;
1177                         kctl->vd[0].access |= SNDRV_CTL_ELEM_ACCESS_TLV_READ |
1178                                         SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK;
1179
1180                         err = snd_ctl_add(card, kctl);
1181                         if (err < 0)
1182                                 goto snd_fail;
1183                         prm->snd_kctl_volume = kctl;
1184                         prm->volume = fu->volume_max;
1185                         prm->volume_max = fu->volume_max;
1186                         prm->volume_min = fu->volume_min;
1187                         prm->volume_res = fu->volume_res;
1188                 }
1189         }
1190
1191         strscpy(card->driver, card_name, sizeof(card->driver));
1192         strscpy(card->shortname, card_name, sizeof(card->shortname));
1193         sprintf(card->longname, "%s %i", card_name, card->dev->id);
1194
1195         snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_CONTINUOUS,
1196                                        NULL, 0, BUFF_SIZE_MAX);
1197
1198         err = snd_card_register(card);
1199
1200         if (!err)
1201                 return 0;
1202
1203 snd_fail:
1204         snd_card_free(card);
1205 fail:
1206         kfree(uac->p_prm.reqs);
1207         kfree(uac->c_prm.reqs);
1208         kfree(uac->p_prm.rbuf);
1209         kfree(uac->c_prm.rbuf);
1210         kfree(uac);
1211
1212         return err;
1213 }
1214 EXPORT_SYMBOL_GPL(g_audio_setup);
1215
1216 void g_audio_cleanup(struct g_audio *g_audio)
1217 {
1218         struct snd_uac_chip *uac;
1219         struct snd_card *card;
1220
1221         if (!g_audio || !g_audio->uac)
1222                 return;
1223
1224         uac = g_audio->uac;
1225         card = uac->card;
1226         if (card)
1227                 snd_card_free(card);
1228
1229         kfree(uac->p_prm.reqs);
1230         kfree(uac->c_prm.reqs);
1231         kfree(uac->p_prm.rbuf);
1232         kfree(uac->c_prm.rbuf);
1233         kfree(uac);
1234 }
1235 EXPORT_SYMBOL_GPL(g_audio_cleanup);
1236
1237 MODULE_LICENSE("GPL");
1238 MODULE_DESCRIPTION("USB gadget \"ALSA sound card\" utilities");
1239 MODULE_AUTHOR("Ruslan Bilovol");