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/module.h>
  16 #include <sound/core.h>
  17 #include <sound/pcm.h>
  18 #include <sound/pcm_params.h>
  19 #include <sound/control.h>
  20
  21 #include "u_audio.h"
  22
  23 #define BUFF_SIZE_MAX   (PAGE_SIZE * 16)
  24 #define PRD_SIZE_MAX    PAGE_SIZE
  25 #define MIN_PERIODS     4
  26
  27 /* Runtime data params for one stream */
  28 struct uac_rtd_params {
  29         struct snd_uac_chip *uac; /* parent chip */
  30         bool ep_enabled; /* if the ep is enabled */
  31
  32         struct snd_pcm_substream *ss;
  33
  34         /* Ring buffer */
  35         ssize_t hw_ptr;
  36
  37         void *rbuf;
  38
  39         unsigned int pitch;     /* Stream pitch ratio to 1000000 */
  40         unsigned int max_psize; /* MaxPacketSize of endpoint */
  41
  42         struct usb_request **reqs;
  43
  44         struct usb_request *req_fback; /* Feedback endpoint request */
  45         bool fb_ep_enabled; /* if the ep is enabled */
  46 };
  47
  48 struct snd_uac_chip {
  49         struct g_audio *audio_dev;
  50
  51         struct uac_rtd_params p_prm;
  52         struct uac_rtd_params c_prm;
  53
  54         struct snd_card *card;
  55         struct snd_pcm *pcm;
  56
  57         /* timekeeping for the playback endpoint */
  58         unsigned int p_interval;
  59         unsigned int p_residue;
  60
  61         /* pre-calculated values for playback iso completion */
  62         unsigned int p_pktsize;
  63         unsigned int p_pktsize_residue;
  64         unsigned int p_framesize;
  65 };
  66
  67 static const struct snd_pcm_hardware uac_pcm_hardware = {
  68         .info = SNDRV_PCM_INFO_INTERLEAVED | SNDRV_PCM_INFO_BLOCK_TRANSFER
  69                  | SNDRV_PCM_INFO_MMAP | SNDRV_PCM_INFO_MMAP_VALID
  70                  | SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_RESUME,
  71         .rates = SNDRV_PCM_RATE_CONTINUOUS,
  72         .periods_max = BUFF_SIZE_MAX / PRD_SIZE_MAX,
  73         .buffer_bytes_max = BUFF_SIZE_MAX,
  74         .period_bytes_max = PRD_SIZE_MAX,
  75         .periods_min = MIN_PERIODS,
  76 };
  77
  78 static void u_audio_set_fback_frequency(enum usb_device_speed speed,
  79                                         unsigned long long freq,
  80                                         unsigned int pitch,
  81                                         void *buf)
  82 {
  83         u32 ff = 0;
  84
  85         /*
  86          * Because the pitch base is 1000000, the final divider here
  87          * will be 1000 * 1000000 = 1953125 << 9
  88          *
  89          * Instead of dealing with big numbers lets fold this 9 left shift
  90          */
  91
  92         if (speed == USB_SPEED_FULL) {
  93                 /*
  94                  * Full-speed feedback endpoints report frequency
  95                  * in samples/frame
  96                  * Format is encoded in Q10.10 left-justified in the 24 bits,
  97                  * so that it has a Q10.14 format.
  98                  *
  99                  * ff = (freq << 14) / 1000
 100                  */
 101                 freq <<= 5;
 102         } else {
 103                 /*
 104                  * High-speed feedback endpoints report frequency
 105                  * in samples/microframe.
 106                  * Format is encoded in Q12.13 fitted into four bytes so that
 107                  * the binary point is located between the second and the third
 108                  * byte fromat (that is Q16.16)
 109                  *
 110                  * ff = (freq << 16) / 8000
 111                  */
 112                 freq <<= 4;
 113         }
 114
 115         ff = DIV_ROUND_CLOSEST_ULL((freq * pitch), 1953125);
 116
 117         *(__le32 *)buf = cpu_to_le32(ff);
 118 }
 119
 120 static void u_audio_iso_complete(struct usb_ep *ep, struct usb_request *req)
 121 {
 122         unsigned int pending;
 123         unsigned int hw_ptr;
 124         int status = req->status;
 125         struct snd_pcm_substream *substream;
 126         struct snd_pcm_runtime *runtime;
 127         struct uac_rtd_params *prm = req->context;
 128         struct snd_uac_chip *uac = prm->uac;
 129
 130         /* i/f shutting down */
 131         if (!prm->ep_enabled) {
 132                 usb_ep_free_request(ep, req);
 133                 return;
 134         }
 135
 136         if (req->status == -ESHUTDOWN)
 137                 return;
 138
 139         /*
 140          * We can't really do much about bad xfers.
 141          * Afterall, the ISOCH xfers could fail legitimately.
 142          */
 143         if (status)
 144                 pr_debug("%s: iso_complete status(%d) %d/%d\n",
 145                         __func__, status, req->actual, req->length);
 146
 147         substream = prm->ss;
 148
 149         /* Do nothing if ALSA isn't active */
 150         if (!substream)
 151                 goto exit;
 152
 153         snd_pcm_stream_lock(substream);
 154
 155         runtime = substream->runtime;
 156         if (!runtime || !snd_pcm_running(substream)) {
 157                 snd_pcm_stream_unlock(substream);
 158                 goto exit;
 159         }
 160
 161         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
 162                 /*
 163                  * For each IN packet, take the quotient of the current data
 164                  * rate and the endpoint's interval as the base packet size.
 165                  * If there is a residue from this division, add it to the
 166                  * residue accumulator.
 167                  */
 168                 req->length = uac->p_pktsize;
 169                 uac->p_residue += uac->p_pktsize_residue;
 170
 171                 /*
 172                  * Whenever there are more bytes in the accumulator than we
 173                  * need to add one more sample frame, increase this packet's
 174                  * size and decrease the accumulator.
 175                  */
 176                 if (uac->p_residue / uac->p_interval >= uac->p_framesize) {
 177                         req->length += uac->p_framesize;
 178                         uac->p_residue -= uac->p_framesize *
 179                                            uac->p_interval;
 180                 }
 181
 182                 req->actual = req->length;
 183         }
 184
 185         hw_ptr = prm->hw_ptr;
 186
 187         /* Pack USB load in ALSA ring buffer */
 188         pending = runtime->dma_bytes - hw_ptr;
 189
 190         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
 191                 if (unlikely(pending < req->actual)) {
 192                         memcpy(req->buf, runtime->dma_area + hw_ptr, pending);
 193                         memcpy(req->buf + pending, runtime->dma_area,
 194                                req->actual - pending);
 195                 } else {
 196                         memcpy(req->buf, runtime->dma_area + hw_ptr,
 197                                req->actual);
 198                 }
 199         } else {
 200                 if (unlikely(pending < req->actual)) {
 201                         memcpy(runtime->dma_area + hw_ptr, req->buf, pending);
 202                         memcpy(runtime->dma_area, req->buf + pending,
 203                                req->actual - pending);
 204                 } else {
 205                         memcpy(runtime->dma_area + hw_ptr, req->buf,
 206                                req->actual);
 207                 }
 208         }
 209
 210         /* update hw_ptr after data is copied to memory */
 211         prm->hw_ptr = (hw_ptr + req->actual) % runtime->dma_bytes;
 212         hw_ptr = prm->hw_ptr;
 213         snd_pcm_stream_unlock(substream);
 214
 215         if ((hw_ptr % snd_pcm_lib_period_bytes(substream)) < req->actual)
 216                 snd_pcm_period_elapsed(substream);
 217
 218 exit:
 219         if (usb_ep_queue(ep, req, GFP_ATOMIC))
 220                 dev_err(uac->card->dev, "%d Error!\n", __LINE__);
 221 }
 222
 223 static void u_audio_iso_fback_complete(struct usb_ep *ep,
 224                                        struct usb_request *req)
 225 {
 226         struct uac_rtd_params *prm = req->context;
 227         struct snd_uac_chip *uac = prm->uac;
 228         struct g_audio *audio_dev = uac->audio_dev;
 229         struct uac_params *params = &audio_dev->params;
 230         int status = req->status;
 231
 232         /* i/f shutting down */
 233         if (!prm->fb_ep_enabled) {
 234                 kfree(req->buf);
 235                 usb_ep_free_request(ep, req);
 236                 return;
 237         }
 238
 239         if (req->status == -ESHUTDOWN)
 240                 return;
 241
 242         /*
 243          * We can't really do much about bad xfers.
 244          * Afterall, the ISOCH xfers could fail legitimately.
 245          */
 246         if (status)
 247                 pr_debug("%s: iso_complete status(%d) %d/%d\n",
 248                         __func__, status, req->actual, req->length);
 249
 250         u_audio_set_fback_frequency(audio_dev->gadget->speed,
 251                                     params->c_srate, prm->pitch,
 252                                     req->buf);
 253
 254         if (usb_ep_queue(ep, req, GFP_ATOMIC))
 255                 dev_err(uac->card->dev, "%d Error!\n", __LINE__);
 256 }
 257
 258 static int uac_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
 259 {
 260         struct snd_uac_chip *uac = snd_pcm_substream_chip(substream);
 261         struct uac_rtd_params *prm;
 262         struct g_audio *audio_dev;
 263         struct uac_params *params;
 264         int err = 0;
 265
 266         audio_dev = uac->audio_dev;
 267         params = &audio_dev->params;
 268
 269         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
 270                 prm = &uac->p_prm;
 271         else
 272                 prm = &uac->c_prm;
 273
 274         /* Reset */
 275         prm->hw_ptr = 0;
 276
 277         switch (cmd) {
 278         case SNDRV_PCM_TRIGGER_START:
 279         case SNDRV_PCM_TRIGGER_RESUME:
 280                 prm->ss = substream;
 281                 break;
 282         case SNDRV_PCM_TRIGGER_STOP:
 283         case SNDRV_PCM_TRIGGER_SUSPEND:
 284                 prm->ss = NULL;
 285                 break;
 286         default:
 287                 err = -EINVAL;
 288         }
 289
 290         /* Clear buffer after Play stops */
 291         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK && !prm->ss)
 292                 memset(prm->rbuf, 0, prm->max_psize * params->req_number);
 293
 294         return err;
 295 }
 296
 297 static snd_pcm_uframes_t uac_pcm_pointer(struct snd_pcm_substream *substream)
 298 {
 299         struct snd_uac_chip *uac = snd_pcm_substream_chip(substream);
 300         struct uac_rtd_params *prm;
 301
 302         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
 303                 prm = &uac->p_prm;
 304         else
 305                 prm = &uac->c_prm;
 306
 307         return bytes_to_frames(substream->runtime, prm->hw_ptr);
 308 }
 309
 310 static u64 uac_ssize_to_fmt(int ssize)
 311 {
 312         u64 ret;
 313
 314         switch (ssize) {
 315         case 3:
 316                 ret = SNDRV_PCM_FMTBIT_S24_3LE;
 317                 break;
 318         case 4:
 319                 ret = SNDRV_PCM_FMTBIT_S32_LE;
 320                 break;
 321         default:
 322                 ret = SNDRV_PCM_FMTBIT_S16_LE;
 323                 break;
 324         }
 325
 326         return ret;
 327 }
 328
 329 static int uac_pcm_open(struct snd_pcm_substream *substream)
 330 {
 331         struct snd_uac_chip *uac = snd_pcm_substream_chip(substream);
 332         struct snd_pcm_runtime *runtime = substream->runtime;
 333         struct g_audio *audio_dev;
 334         struct uac_params *params;
 335         int p_ssize, c_ssize;
 336         int p_srate, c_srate;
 337         int p_chmask, c_chmask;
 338
 339         audio_dev = uac->audio_dev;
 340         params = &audio_dev->params;
 341         p_ssize = params->p_ssize;
 342         c_ssize = params->c_ssize;
 343         p_srate = params->p_srate;
 344         c_srate = params->c_srate;
 345         p_chmask = params->p_chmask;
 346         c_chmask = params->c_chmask;
 347         uac->p_residue = 0;
 348
 349         runtime->hw = uac_pcm_hardware;
 350
 351         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
 352                 runtime->hw.rate_min = p_srate;
 353                 runtime->hw.formats = uac_ssize_to_fmt(p_ssize);
 354                 runtime->hw.channels_min = num_channels(p_chmask);
 355                 runtime->hw.period_bytes_min = 2 * uac->p_prm.max_psize
 356                                                 / runtime->hw.periods_min;
 357         } else {
 358                 runtime->hw.rate_min = c_srate;
 359                 runtime->hw.formats = uac_ssize_to_fmt(c_ssize);
 360                 runtime->hw.channels_min = num_channels(c_chmask);
 361                 runtime->hw.period_bytes_min = 2 * uac->c_prm.max_psize
 362                                                 / runtime->hw.periods_min;
 363         }
 364
 365         runtime->hw.rate_max = runtime->hw.rate_min;
 366         runtime->hw.channels_max = runtime->hw.channels_min;
 367
 368         snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
 369
 370         return 0;
 371 }
 372
 373 /* ALSA cries without these function pointers */
 374 static int uac_pcm_null(struct snd_pcm_substream *substream)
 375 {
 376         return 0;
 377 }
 378
 379 static const struct snd_pcm_ops uac_pcm_ops = {
 380         .open = uac_pcm_open,
 381         .close = uac_pcm_null,
 382         .trigger = uac_pcm_trigger,
 383         .pointer = uac_pcm_pointer,
 384         .prepare = uac_pcm_null,
 385 };
 386
 387 static inline void free_ep(struct uac_rtd_params *prm, struct usb_ep *ep)
 388 {
 389         struct snd_uac_chip *uac = prm->uac;
 390         struct g_audio *audio_dev;
 391         struct uac_params *params;
 392         int i;
 393
 394         if (!prm->ep_enabled)
 395                 return;
 396
 397         audio_dev = uac->audio_dev;
 398         params = &audio_dev->params;
 399
 400         for (i = 0; i < params->req_number; i++) {
 401                 if (prm->reqs[i]) {
 402                         if (usb_ep_dequeue(ep, prm->reqs[i]))
 403                                 usb_ep_free_request(ep, prm->reqs[i]);
 404                         /*
 405                          * If usb_ep_dequeue() cannot successfully dequeue the
 406                          * request, the request will be freed by the completion
 407                          * callback.
 408                          */
 409
 410                         prm->reqs[i] = NULL;
 411                 }
 412         }
 413
 414         prm->ep_enabled = false;
 415
 416         if (usb_ep_disable(ep))
 417                 dev_err(uac->card->dev, "%s:%d Error!\n", __func__, __LINE__);
 418 }
 419
 420 static inline void free_ep_fback(struct uac_rtd_params *prm, struct usb_ep *ep)
 421 {
 422         struct snd_uac_chip *uac = prm->uac;
 423
 424         if (!prm->fb_ep_enabled)
 425                 return;
 426
 427         if (prm->req_fback) {
 428                 if (usb_ep_dequeue(ep, prm->req_fback)) {
 429                         kfree(prm->req_fback->buf);
 430                         usb_ep_free_request(ep, prm->req_fback);
 431                 }
 432                 prm->req_fback = NULL;
 433         }
 434
 435         prm->fb_ep_enabled = false;
 436
 437         if (usb_ep_disable(ep))
 438                 dev_err(uac->card->dev, "%s:%d Error!\n", __func__, __LINE__);
 439 }
 440
 441 int u_audio_start_capture(struct g_audio *audio_dev)
 442 {
 443         struct snd_uac_chip *uac = audio_dev->uac;
 444         struct usb_gadget *gadget = audio_dev->gadget;
 445         struct device *dev = &gadget->dev;
 446         struct usb_request *req, *req_fback;
 447         struct usb_ep *ep, *ep_fback;
 448         struct uac_rtd_params *prm;
 449         struct uac_params *params = &audio_dev->params;
 450         int req_len, i;
 451
 452         ep = audio_dev->out_ep;
 453         prm = &uac->c_prm;
 454         config_ep_by_speed(gadget, &audio_dev->func, ep);
 455         req_len = ep->maxpacket;
 456
 457         prm->ep_enabled = true;
 458         usb_ep_enable(ep);
 459
 460         for (i = 0; i < params->req_number; i++) {
 461                 if (!prm->reqs[i]) {
 462                         req = usb_ep_alloc_request(ep, GFP_ATOMIC);
 463                         if (req == NULL)
 464                                 return -ENOMEM;
 465
 466                         prm->reqs[i] = req;
 467
 468                         req->zero = 0;
 469                         req->context = prm;
 470                         req->length = req_len;
 471                         req->complete = u_audio_iso_complete;
 472                         req->buf = prm->rbuf + i * ep->maxpacket;
 473                 }
 474
 475                 if (usb_ep_queue(ep, prm->reqs[i], GFP_ATOMIC))
 476                         dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
 477         }
 478
 479         ep_fback = audio_dev->in_ep_fback;
 480         if (!ep_fback)
 481                 return 0;
 482
 483         /* Setup feedback endpoint */
 484         config_ep_by_speed(gadget, &audio_dev->func, ep_fback);
 485         prm->fb_ep_enabled = true;
 486         usb_ep_enable(ep_fback);
 487         req_len = ep_fback->maxpacket;
 488
 489         req_fback = usb_ep_alloc_request(ep_fback, GFP_ATOMIC);
 490         if (req_fback == NULL)
 491                 return -ENOMEM;
 492
 493         prm->req_fback = req_fback;
 494         req_fback->zero = 0;
 495         req_fback->context = prm;
 496         req_fback->length = req_len;
 497         req_fback->complete = u_audio_iso_fback_complete;
 498
 499         req_fback->buf = kzalloc(req_len, GFP_ATOMIC);
 500         if (!req_fback->buf)
 501                 return -ENOMEM;
 502
 503         /*
 504          * Configure the feedback endpoint's reported frequency.
 505          * Always start with original frequency since its deviation can't
 506          * be meauserd at start of playback
 507          */
 508         prm->pitch = 1000000;
 509         u_audio_set_fback_frequency(audio_dev->gadget->speed,
 510                                     params->c_srate, prm->pitch,
 511                                     req_fback->buf);
 512
 513         if (usb_ep_queue(ep_fback, req_fback, GFP_ATOMIC))
 514                 dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
 515
 516         return 0;
 517 }
 518 EXPORT_SYMBOL_GPL(u_audio_start_capture);
 519
 520 void u_audio_stop_capture(struct g_audio *audio_dev)
 521 {
 522         struct snd_uac_chip *uac = audio_dev->uac;
 523
 524         if (audio_dev->in_ep_fback)
 525                 free_ep_fback(&uac->c_prm, audio_dev->in_ep_fback);
 526         free_ep(&uac->c_prm, audio_dev->out_ep);
 527 }
 528 EXPORT_SYMBOL_GPL(u_audio_stop_capture);
 529
 530 int u_audio_start_playback(struct g_audio *audio_dev)
 531 {
 532         struct snd_uac_chip *uac = audio_dev->uac;
 533         struct usb_gadget *gadget = audio_dev->gadget;
 534         struct device *dev = &gadget->dev;
 535         struct usb_request *req;
 536         struct usb_ep *ep;
 537         struct uac_rtd_params *prm;
 538         struct uac_params *params = &audio_dev->params;
 539         unsigned int factor;
 540         const struct usb_endpoint_descriptor *ep_desc;
 541         int req_len, i;
 542
 543         ep = audio_dev->in_ep;
 544         prm = &uac->p_prm;
 545         config_ep_by_speed(gadget, &audio_dev->func, ep);
 546
 547         ep_desc = ep->desc;
 548
 549         /* pre-calculate the playback endpoint's interval */
 550         if (gadget->speed == USB_SPEED_FULL)
 551                 factor = 1000;
 552         else
 553                 factor = 8000;
 554
 555         /* pre-compute some values for iso_complete() */
 556         uac->p_framesize = params->p_ssize *
 557                             num_channels(params->p_chmask);
 558         uac->p_interval = factor / (1 << (ep_desc->bInterval - 1));
 559         uac->p_pktsize = min_t(unsigned int,
 560                                 uac->p_framesize *
 561                                         (params->p_srate / uac->p_interval),
 562                                 ep->maxpacket);
 563
 564         if (uac->p_pktsize < ep->maxpacket)
 565                 uac->p_pktsize_residue = uac->p_framesize *
 566                         (params->p_srate % uac->p_interval);
 567         else
 568                 uac->p_pktsize_residue = 0;
 569
 570         req_len = uac->p_pktsize;
 571         uac->p_residue = 0;
 572
 573         prm->ep_enabled = true;
 574         usb_ep_enable(ep);
 575
 576         for (i = 0; i < params->req_number; i++) {
 577                 if (!prm->reqs[i]) {
 578                         req = usb_ep_alloc_request(ep, GFP_ATOMIC);
 579                         if (req == NULL)
 580                                 return -ENOMEM;
 581
 582                         prm->reqs[i] = req;
 583
 584                         req->zero = 0;
 585                         req->context = prm;
 586                         req->length = req_len;
 587                         req->complete = u_audio_iso_complete;
 588                         req->buf = prm->rbuf + i * ep->maxpacket;
 589                 }
 590
 591                 if (usb_ep_queue(ep, prm->reqs[i], GFP_ATOMIC))
 592                         dev_err(dev, "%s:%d Error!\n", __func__, __LINE__);
 593         }
 594
 595         return 0;
 596 }
 597 EXPORT_SYMBOL_GPL(u_audio_start_playback);
 598
 599 void u_audio_stop_playback(struct g_audio *audio_dev)
 600 {
 601         struct snd_uac_chip *uac = audio_dev->uac;
 602
 603         free_ep(&uac->p_prm, audio_dev->in_ep);
 604 }
 605 EXPORT_SYMBOL_GPL(u_audio_stop_playback);
 606
 607 static int u_audio_pitch_info(struct snd_kcontrol *kcontrol,
 608                                    struct snd_ctl_elem_info *uinfo)
 609 {
 610         struct uac_rtd_params *prm = snd_kcontrol_chip(kcontrol);
 611         struct snd_uac_chip *uac = prm->uac;
 612         struct g_audio *audio_dev = uac->audio_dev;
 613         struct uac_params *params = &audio_dev->params;
 614         unsigned int pitch_min, pitch_max;
 615
 616         pitch_min = (1000 - FBACK_SLOW_MAX) * 1000;
 617         pitch_max = (1000 + params->fb_max) * 1000;
 618
 619         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 620         uinfo->count = 1;
 621         uinfo->value.integer.min = pitch_min;
 622         uinfo->value.integer.max = pitch_max;
 623         uinfo->value.integer.step = 1;
 624         return 0;
 625 }
 626
 627 static int u_audio_pitch_get(struct snd_kcontrol *kcontrol,
 628                                    struct snd_ctl_elem_value *ucontrol)
 629 {
 630         struct uac_rtd_params *prm = snd_kcontrol_chip(kcontrol);
 631
 632         ucontrol->value.integer.value[0] = prm->pitch;
 633
 634         return 0;
 635 }
 636
 637 static int u_audio_pitch_put(struct snd_kcontrol *kcontrol,
 638                                   struct snd_ctl_elem_value *ucontrol)
 639 {
 640         struct uac_rtd_params *prm = snd_kcontrol_chip(kcontrol);
 641         struct snd_uac_chip *uac = prm->uac;
 642         struct g_audio *audio_dev = uac->audio_dev;
 643         struct uac_params *params = &audio_dev->params;
 644         unsigned int val;
 645         unsigned int pitch_min, pitch_max;
 646         int change = 0;
 647
 648         pitch_min = (1000 - FBACK_SLOW_MAX) * 1000;
 649         pitch_max = (1000 + params->fb_max) * 1000;
 650
 651         val = ucontrol->value.integer.value[0];
 652
 653         if (val < pitch_min)
 654                 val = pitch_min;
 655         if (val > pitch_max)
 656                 val = pitch_max;
 657
 658         if (prm->pitch != val) {
 659                 prm->pitch = val;
 660                 change = 1;
 661         }
 662
 663         return change;
 664 }
 665
 666 static const struct snd_kcontrol_new u_audio_controls[]  = {
 667 {
 668         .iface =        SNDRV_CTL_ELEM_IFACE_PCM,
 669         .name =         "Capture Pitch 1000000",
 670         .info =         u_audio_pitch_info,
 671         .get =          u_audio_pitch_get,
 672         .put =          u_audio_pitch_put,
 673 },
 674 };
 675
 676 int g_audio_setup(struct g_audio *g_audio, const char *pcm_name,
 677                                         const char *card_name)
 678 {
 679         struct snd_uac_chip *uac;
 680         struct snd_card *card;
 681         struct snd_pcm *pcm;
 682         struct snd_kcontrol *kctl;
 683         struct uac_params *params;
 684         int p_chmask, c_chmask;
 685         int err;
 686
 687         if (!g_audio)
 688                 return -EINVAL;
 689
 690         uac = kzalloc(sizeof(*uac), GFP_KERNEL);
 691         if (!uac)
 692                 return -ENOMEM;
 693         g_audio->uac = uac;
 694         uac->audio_dev = g_audio;
 695
 696         params = &g_audio->params;
 697         p_chmask = params->p_chmask;
 698         c_chmask = params->c_chmask;
 699
 700         if (c_chmask) {
 701                 struct uac_rtd_params *prm = &uac->c_prm;
 702
 703                 uac->c_prm.uac = uac;
 704                 prm->max_psize = g_audio->out_ep_maxpsize;
 705
 706                 prm->reqs = kcalloc(params->req_number,
 707                                     sizeof(struct usb_request *),
 708                                     GFP_KERNEL);
 709                 if (!prm->reqs) {
 710                         err = -ENOMEM;
 711                         goto fail;
 712                 }
 713
 714                 prm->rbuf = kcalloc(params->req_number, prm->max_psize,
 715                                 GFP_KERNEL);
 716                 if (!prm->rbuf) {
 717                         prm->max_psize = 0;
 718                         err = -ENOMEM;
 719                         goto fail;
 720                 }
 721         }
 722
 723         if (p_chmask) {
 724                 struct uac_rtd_params *prm = &uac->p_prm;
 725
 726                 uac->p_prm.uac = uac;
 727                 prm->max_psize = g_audio->in_ep_maxpsize;
 728
 729                 prm->reqs = kcalloc(params->req_number,
 730                                     sizeof(struct usb_request *),
 731                                     GFP_KERNEL);
 732                 if (!prm->reqs) {
 733                         err = -ENOMEM;
 734                         goto fail;
 735                 }
 736
 737                 prm->rbuf = kcalloc(params->req_number, prm->max_psize,
 738                                 GFP_KERNEL);
 739                 if (!prm->rbuf) {
 740                         prm->max_psize = 0;
 741                         err = -ENOMEM;
 742                         goto fail;
 743                 }
 744         }
 745
 746         /* Choose any slot, with no id */
 747         err = snd_card_new(&g_audio->gadget->dev,
 748                         -1, NULL, THIS_MODULE, 0, &card);
 749         if (err < 0)
 750                 goto fail;
 751
 752         uac->card = card;
 753
 754         /*
 755          * Create first PCM device
 756          * Create a substream only for non-zero channel streams
 757          */
 758         err = snd_pcm_new(uac->card, pcm_name, 0,
 759                                p_chmask ? 1 : 0, c_chmask ? 1 : 0, &pcm);
 760         if (err < 0)
 761                 goto snd_fail;
 762
 763         strscpy(pcm->name, pcm_name, sizeof(pcm->name));
 764         pcm->private_data = uac;
 765         uac->pcm = pcm;
 766
 767         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_PLAYBACK, &uac_pcm_ops);
 768         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &uac_pcm_ops);
 769
 770         if (c_chmask && g_audio->in_ep_fback) {
 771                 strscpy(card->mixername, card_name, sizeof(card->driver));
 772
 773                 kctl = snd_ctl_new1(&u_audio_controls[0], &uac->c_prm);
 774                 if (!kctl) {
 775                         err = -ENOMEM;
 776                         goto snd_fail;
 777                 }
 778
 779                 kctl->id.device = pcm->device;
 780                 kctl->id.subdevice = 0;
 781
 782                 err = snd_ctl_add(card, kctl);
 783                 if (err < 0)
 784                         goto snd_fail;
 785         }
 786
 787         strscpy(card->driver, card_name, sizeof(card->driver));
 788         strscpy(card->shortname, card_name, sizeof(card->shortname));
 789         sprintf(card->longname, "%s %i", card_name, card->dev->id);
 790
 791         snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_CONTINUOUS,
 792                                        NULL, 0, BUFF_SIZE_MAX);
 793
 794         err = snd_card_register(card);
 795
 796         if (!err)
 797                 return 0;
 798
 799 snd_fail:
 800         snd_card_free(card);
 801 fail:
 802         kfree(uac->p_prm.reqs);
 803         kfree(uac->c_prm.reqs);
 804         kfree(uac->p_prm.rbuf);
 805         kfree(uac->c_prm.rbuf);
 806         kfree(uac);
 807
 808         return err;
 809 }
 810 EXPORT_SYMBOL_GPL(g_audio_setup);
 811
 812 void g_audio_cleanup(struct g_audio *g_audio)
 813 {
 814         struct snd_uac_chip *uac;
 815         struct snd_card *card;
 816
 817         if (!g_audio || !g_audio->uac)
 818                 return;
 819
 820         uac = g_audio->uac;
 821         card = uac->card;
 822         if (card)
 823                 snd_card_free(card);
 824
 825         kfree(uac->p_prm.reqs);
 826         kfree(uac->c_prm.reqs);
 827         kfree(uac->p_prm.rbuf);
 828         kfree(uac->c_prm.rbuf);
 829         kfree(uac);
 830 }
 831 EXPORT_SYMBOL_GPL(g_audio_cleanup);
 832
 833 MODULE_LICENSE("GPL");
 834 MODULE_DESCRIPTION("USB gadget \"ALSA sound card\" utilities");
 835 MODULE_AUTHOR("Ruslan Bilovol");