drivers/media/usb/em28xx/em28xx-audio.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 //
   3 // Empiatech em28x1 audio extension
   4 //
   5 // Copyright (C) 2006 Markus Rechberger <mrechberger@gmail.com>
   6 //
   7 // Copyright (C) 2007-2016 Mauro Carvalho Chehab
   8 //      - Port to work with the in-kernel driver
   9 //      - Cleanups, fixes, alsa-controls, etc.
  10 //
  11 // This driver is based on my previous au600 usb pstn audio driver
  12 // and inherits all the copyrights
  13
  14 #include "em28xx.h"
  15
  16 #include <linux/kernel.h>
  17 #include <linux/usb.h>
  18 #include <linux/init.h>
  19 #include <linux/sound.h>
  20 #include <linux/spinlock.h>
  21 #include <linux/soundcard.h>
  22 #include <linux/slab.h>
  23 #include <linux/module.h>
  24 #include <sound/core.h>
  25 #include <sound/pcm.h>
  26 #include <sound/pcm_params.h>
  27 #include <sound/info.h>
  28 #include <sound/initval.h>
  29 #include <sound/control.h>
  30 #include <sound/tlv.h>
  31 #include <sound/ac97_codec.h>
  32 #include <media/v4l2-common.h>
  33
  34 static int debug;
  35 module_param(debug, int, 0644);
  36 MODULE_PARM_DESC(debug, "activates debug info");
  37
  38 #define EM28XX_MAX_AUDIO_BUFS           5
  39 #define EM28XX_MIN_AUDIO_PACKETS        64
  40
  41 #define dprintk(fmt, arg...) do {                                       \
  42         if (debug)                                              \
  43                 dev_printk(KERN_DEBUG, &dev->intf->dev,                 \
  44                            "video: %s: " fmt, __func__, ## arg);        \
  45 } while (0)
  46
  47 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;
  48
  49 static int em28xx_deinit_isoc_audio(struct em28xx *dev)
  50 {
  51         int i;
  52
  53         dprintk("Stopping isoc\n");
  54         for (i = 0; i < dev->adev.num_urb; i++) {
  55                 struct urb *urb = dev->adev.urb[i];
  56
  57                 if (!irqs_disabled())
  58                         usb_kill_urb(urb);
  59                 else
  60                         usb_unlink_urb(urb);
  61         }
  62
  63         return 0;
  64 }
  65
  66 static void em28xx_audio_isocirq(struct urb *urb)
  67 {
  68         struct em28xx            *dev = urb->context;
  69         int                      i;
  70         unsigned int             oldptr;
  71         int                      period_elapsed = 0;
  72         int                      status;
  73         unsigned char            *cp;
  74         unsigned int             stride;
  75         struct snd_pcm_substream *substream;
  76         struct snd_pcm_runtime   *runtime;
  77
  78         if (dev->disconnected) {
  79                 dprintk("device disconnected while streaming. URB status=%d.\n",
  80                         urb->status);
  81                 atomic_set(&dev->adev.stream_started, 0);
  82                 return;
  83         }
  84
  85         switch (urb->status) {
  86         case 0:             /* success */
  87         case -ETIMEDOUT:    /* NAK */
  88                 break;
  89         case -ECONNRESET:   /* kill */
  90         case -ENOENT:
  91         case -ESHUTDOWN:
  92                 return;
  93         default:            /* error */
  94                 dprintk("urb completion error %d.\n", urb->status);
  95                 break;
  96         }
  97
  98         if (atomic_read(&dev->adev.stream_started) == 0)
  99                 return;
 100
 101         if (dev->adev.capture_pcm_substream) {
 102                 substream = dev->adev.capture_pcm_substream;
 103                 runtime = substream->runtime;
 104                 stride = runtime->frame_bits >> 3;
 105
 106                 for (i = 0; i < urb->number_of_packets; i++) {
 107                         unsigned long flags;
 108                         int length =
 109                             urb->iso_frame_desc[i].actual_length / stride;
 110                         cp = (unsigned char *)urb->transfer_buffer +
 111                             urb->iso_frame_desc[i].offset;
 112
 113                         if (!length)
 114                                 continue;
 115
 116                         oldptr = dev->adev.hwptr_done_capture;
 117                         if (oldptr + length >= runtime->buffer_size) {
 118                                 unsigned int cnt =
 119                                     runtime->buffer_size - oldptr;
 120                                 memcpy(runtime->dma_area + oldptr * stride, cp,
 121                                        cnt * stride);
 122                                 memcpy(runtime->dma_area, cp + cnt * stride,
 123                                        length * stride - cnt * stride);
 124                         } else {
 125                                 memcpy(runtime->dma_area + oldptr * stride, cp,
 126                                        length * stride);
 127                         }
 128
 129                         snd_pcm_stream_lock_irqsave(substream, flags);
 130
 131                         dev->adev.hwptr_done_capture += length;
 132                         if (dev->adev.hwptr_done_capture >=
 133                             runtime->buffer_size)
 134                                 dev->adev.hwptr_done_capture -=
 135                                     runtime->buffer_size;
 136
 137                         dev->adev.capture_transfer_done += length;
 138                         if (dev->adev.capture_transfer_done >=
 139                             runtime->period_size) {
 140                                 dev->adev.capture_transfer_done -=
 141                                     runtime->period_size;
 142                                 period_elapsed = 1;
 143                         }
 144
 145                         snd_pcm_stream_unlock_irqrestore(substream, flags);
 146                 }
 147                 if (period_elapsed)
 148                         snd_pcm_period_elapsed(substream);
 149         }
 150         urb->status = 0;
 151
 152         status = usb_submit_urb(urb, GFP_ATOMIC);
 153         if (status < 0)
 154                 dev_err(&dev->intf->dev,
 155                         "resubmit of audio urb failed (error=%i)\n",
 156                         status);
 157 }
 158
 159 static int em28xx_init_audio_isoc(struct em28xx *dev)
 160 {
 161         int       i, err;
 162
 163         dprintk("Starting isoc transfers\n");
 164
 165         /* Start streaming */
 166         for (i = 0; i < dev->adev.num_urb; i++) {
 167                 memset(dev->adev.transfer_buffer[i], 0x80,
 168                        dev->adev.urb[i]->transfer_buffer_length);
 169
 170                 err = usb_submit_urb(dev->adev.urb[i], GFP_ATOMIC);
 171                 if (err) {
 172                         dev_err(&dev->intf->dev,
 173                                 "submit of audio urb failed (error=%i)\n",
 174                                 err);
 175                         em28xx_deinit_isoc_audio(dev);
 176                         atomic_set(&dev->adev.stream_started, 0);
 177                         return err;
 178                 }
 179         }
 180
 181         return 0;
 182 }
 183
 184 static const struct snd_pcm_hardware snd_em28xx_hw_capture = {
 185         .info = SNDRV_PCM_INFO_BLOCK_TRANSFER |
 186                 SNDRV_PCM_INFO_MMAP           |
 187                 SNDRV_PCM_INFO_INTERLEAVED    |
 188                 SNDRV_PCM_INFO_BATCH          |
 189                 SNDRV_PCM_INFO_MMAP_VALID,
 190
 191         .formats = SNDRV_PCM_FMTBIT_S16_LE,
 192
 193         .rates = SNDRV_PCM_RATE_48000,
 194
 195         .rate_min = 48000,
 196         .rate_max = 48000,
 197         .channels_min = 2,
 198         .channels_max = 2,
 199         .buffer_bytes_max = 62720 * 8,  /* just about the value in usbaudio.c */
 200
 201         /*
 202          * The period is 12.288 bytes. Allow a 10% of variation along its
 203          * value, in order to avoid overruns/underruns due to some clock
 204          * drift.
 205          *
 206          * FIXME: This period assumes 64 packets, and a 48000 PCM rate.
 207          * Calculate it dynamically.
 208          */
 209         .period_bytes_min = 11059,
 210         .period_bytes_max = 13516,
 211
 212         .periods_min = 2,
 213         .periods_max = 98,              /* 12544, */
 214 };
 215
 216 static int snd_em28xx_capture_open(struct snd_pcm_substream *substream)
 217 {
 218         struct em28xx *dev = snd_pcm_substream_chip(substream);
 219         struct snd_pcm_runtime *runtime = substream->runtime;
 220         int nonblock, ret = 0;
 221
 222         if (!dev) {
 223                 pr_err("em28xx-audio: BUG: em28xx can't find device struct. Can't proceed with open\n");
 224                 return -ENODEV;
 225         }
 226
 227         if (dev->disconnected)
 228                 return -ENODEV;
 229
 230         dprintk("opening device and trying to acquire exclusive lock\n");
 231
 232         nonblock = !!(substream->f_flags & O_NONBLOCK);
 233         if (nonblock) {
 234                 if (!mutex_trylock(&dev->lock))
 235                         return -EAGAIN;
 236         } else {
 237                 mutex_lock(&dev->lock);
 238         }
 239
 240         runtime->hw = snd_em28xx_hw_capture;
 241
 242         if (dev->adev.users == 0) {
 243                 if (!dev->alt || dev->is_audio_only) {
 244                         struct usb_device *udev;
 245
 246                         udev = interface_to_usbdev(dev->intf);
 247
 248                         if (dev->is_audio_only)
 249                                 /* audio is on a separate interface */
 250                                 dev->alt = 1;
 251                         else
 252                                 /* audio is on the same interface as video */
 253                                 dev->alt = 7;
 254                                 /*
 255                                  * FIXME: The intention seems to be to select
 256                                  * the alt setting with the largest
 257                                  * wMaxPacketSize for the video endpoint.
 258                                  * At least dev->alt should be used instead, but
 259                                  * we should probably not touch it at all if it
 260                                  * is already >0, because wMaxPacketSize of the
 261                                  * audio endpoints seems to be the same for all.
 262                                  */
 263                         dprintk("changing alternate number on interface %d to %d\n",
 264                                 dev->ifnum, dev->alt);
 265                         usb_set_interface(udev, dev->ifnum, dev->alt);
 266                 }
 267
 268                 /* Sets volume, mute, etc */
 269                 dev->mute = 0;
 270                 ret = em28xx_audio_analog_set(dev);
 271                 if (ret < 0)
 272                         goto err;
 273         }
 274
 275         kref_get(&dev->ref);
 276         dev->adev.users++;
 277         mutex_unlock(&dev->lock);
 278
 279         /* Dynamically adjust the period size */
 280         snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
 281         snd_pcm_hw_constraint_minmax(runtime, SNDRV_PCM_HW_PARAM_PERIOD_BYTES,
 282                                      dev->adev.period * 95 / 100,
 283                                      dev->adev.period * 105 / 100);
 284
 285         dev->adev.capture_pcm_substream = substream;
 286
 287         return 0;
 288 err:
 289         mutex_unlock(&dev->lock);
 290
 291         dev_err(&dev->intf->dev,
 292                 "Error while configuring em28xx mixer\n");
 293         return ret;
 294 }
 295
 296 static int snd_em28xx_pcm_close(struct snd_pcm_substream *substream)
 297 {
 298         struct em28xx *dev = snd_pcm_substream_chip(substream);
 299
 300         dprintk("closing device\n");
 301
 302         dev->mute = 1;
 303         mutex_lock(&dev->lock);
 304         dev->adev.users--;
 305         if (atomic_read(&dev->adev.stream_started) > 0) {
 306                 atomic_set(&dev->adev.stream_started, 0);
 307                 schedule_work(&dev->adev.wq_trigger);
 308         }
 309
 310         em28xx_audio_analog_set(dev);
 311         mutex_unlock(&dev->lock);
 312         kref_put(&dev->ref, em28xx_free_device);
 313
 314         return 0;
 315 }
 316
 317 static int snd_em28xx_prepare(struct snd_pcm_substream *substream)
 318 {
 319         struct em28xx *dev = snd_pcm_substream_chip(substream);
 320
 321         if (dev->disconnected)
 322                 return -ENODEV;
 323
 324         dev->adev.hwptr_done_capture = 0;
 325         dev->adev.capture_transfer_done = 0;
 326
 327         return 0;
 328 }
 329
 330 static void audio_trigger(struct work_struct *work)
 331 {
 332         struct em28xx_audio *adev =
 333                             container_of(work, struct em28xx_audio, wq_trigger);
 334         struct em28xx *dev = container_of(adev, struct em28xx, adev);
 335
 336         if (atomic_read(&adev->stream_started)) {
 337                 dprintk("starting capture");
 338                 em28xx_init_audio_isoc(dev);
 339         } else {
 340                 dprintk("stopping capture");
 341                 em28xx_deinit_isoc_audio(dev);
 342         }
 343 }
 344
 345 static int snd_em28xx_capture_trigger(struct snd_pcm_substream *substream,
 346                                       int cmd)
 347 {
 348         struct em28xx *dev = snd_pcm_substream_chip(substream);
 349         int retval = 0;
 350
 351         if (dev->disconnected)
 352                 return -ENODEV;
 353
 354         switch (cmd) {
 355         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
 356         case SNDRV_PCM_TRIGGER_RESUME:
 357         case SNDRV_PCM_TRIGGER_START:
 358                 atomic_set(&dev->adev.stream_started, 1);
 359                 break;
 360         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
 361         case SNDRV_PCM_TRIGGER_SUSPEND:
 362         case SNDRV_PCM_TRIGGER_STOP:
 363                 atomic_set(&dev->adev.stream_started, 0);
 364                 break;
 365         default:
 366                 retval = -EINVAL;
 367         }
 368         schedule_work(&dev->adev.wq_trigger);
 369         return retval;
 370 }
 371
 372 static snd_pcm_uframes_t snd_em28xx_capture_pointer(struct snd_pcm_substream
 373                                                     *substream)
 374 {
 375         unsigned long flags;
 376         struct em28xx *dev;
 377         snd_pcm_uframes_t hwptr_done;
 378
 379         dev = snd_pcm_substream_chip(substream);
 380         if (dev->disconnected)
 381                 return SNDRV_PCM_POS_XRUN;
 382
 383         spin_lock_irqsave(&dev->adev.slock, flags);
 384         hwptr_done = dev->adev.hwptr_done_capture;
 385         spin_unlock_irqrestore(&dev->adev.slock, flags);
 386
 387         return hwptr_done;
 388 }
 389
 390 /*
 391  * AC97 volume control support
 392  */
 393 static int em28xx_vol_info(struct snd_kcontrol *kcontrol,
 394                            struct snd_ctl_elem_info *info)
 395 {
 396         struct em28xx *dev = snd_kcontrol_chip(kcontrol);
 397
 398         if (dev->disconnected)
 399                 return -ENODEV;
 400
 401         info->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 402         info->count = 2;
 403         info->value.integer.min = 0;
 404         info->value.integer.max = 0x1f;
 405
 406         return 0;
 407 }
 408
 409 static int em28xx_vol_put(struct snd_kcontrol *kcontrol,
 410                           struct snd_ctl_elem_value *value)
 411 {
 412         struct em28xx *dev = snd_kcontrol_chip(kcontrol);
 413         struct snd_pcm_substream *substream = dev->adev.capture_pcm_substream;
 414         u16 val = (0x1f - (value->value.integer.value[0] & 0x1f)) |
 415                   (0x1f - (value->value.integer.value[1] & 0x1f)) << 8;
 416         int nonblock = 0;
 417         int rc;
 418
 419         if (dev->disconnected)
 420                 return -ENODEV;
 421
 422         if (substream)
 423                 nonblock = !!(substream->f_flags & O_NONBLOCK);
 424         if (nonblock) {
 425                 if (!mutex_trylock(&dev->lock))
 426                         return -EAGAIN;
 427         } else {
 428                 mutex_lock(&dev->lock);
 429         }
 430         rc = em28xx_read_ac97(dev, kcontrol->private_value);
 431         if (rc < 0)
 432                 goto err;
 433
 434         val |= rc & 0x8000;     /* Preserve the mute flag */
 435
 436         rc = em28xx_write_ac97(dev, kcontrol->private_value, val);
 437         if (rc < 0)
 438                 goto err;
 439
 440         dprintk("%sleft vol %d, right vol %d (0x%04x) to ac97 volume control 0x%04x\n",
 441                 (val & 0x8000) ? "muted " : "",
 442                 0x1f - ((val >> 8) & 0x1f), 0x1f - (val & 0x1f),
 443                 val, (int)kcontrol->private_value);
 444
 445 err:
 446         mutex_unlock(&dev->lock);
 447         return rc;
 448 }
 449
 450 static int em28xx_vol_get(struct snd_kcontrol *kcontrol,
 451                           struct snd_ctl_elem_value *value)
 452 {
 453         struct em28xx *dev = snd_kcontrol_chip(kcontrol);
 454         struct snd_pcm_substream *substream = dev->adev.capture_pcm_substream;
 455         int nonblock = 0;
 456         int val;
 457
 458         if (dev->disconnected)
 459                 return -ENODEV;
 460
 461         if (substream)
 462                 nonblock = !!(substream->f_flags & O_NONBLOCK);
 463         if (nonblock) {
 464                 if (!mutex_trylock(&dev->lock))
 465                         return -EAGAIN;
 466         } else {
 467                 mutex_lock(&dev->lock);
 468         }
 469         val = em28xx_read_ac97(dev, kcontrol->private_value);
 470         mutex_unlock(&dev->lock);
 471         if (val < 0)
 472                 return val;
 473
 474         dprintk("%sleft vol %d, right vol %d (0x%04x) from ac97 volume control 0x%04x\n",
 475                 (val & 0x8000) ? "muted " : "",
 476                 0x1f - ((val >> 8) & 0x1f), 0x1f - (val & 0x1f),
 477                 val, (int)kcontrol->private_value);
 478
 479         value->value.integer.value[0] = 0x1f - (val & 0x1f);
 480         value->value.integer.value[1] = 0x1f - ((val >> 8) & 0x1f);
 481
 482         return 0;
 483 }
 484
 485 static int em28xx_vol_put_mute(struct snd_kcontrol *kcontrol,
 486                                struct snd_ctl_elem_value *value)
 487 {
 488         struct em28xx *dev = snd_kcontrol_chip(kcontrol);
 489         u16 val = value->value.integer.value[0];
 490         struct snd_pcm_substream *substream = dev->adev.capture_pcm_substream;
 491         int nonblock = 0;
 492         int rc;
 493
 494         if (dev->disconnected)
 495                 return -ENODEV;
 496
 497         if (substream)
 498                 nonblock = !!(substream->f_flags & O_NONBLOCK);
 499         if (nonblock) {
 500                 if (!mutex_trylock(&dev->lock))
 501                         return -EAGAIN;
 502         } else {
 503                 mutex_lock(&dev->lock);
 504         }
 505         rc = em28xx_read_ac97(dev, kcontrol->private_value);
 506         if (rc < 0)
 507                 goto err;
 508
 509         if (val)
 510                 rc &= 0x1f1f;
 511         else
 512                 rc |= 0x8000;
 513
 514         rc = em28xx_write_ac97(dev, kcontrol->private_value, rc);
 515         if (rc < 0)
 516                 goto err;
 517
 518         dprintk("%sleft vol %d, right vol %d (0x%04x) to ac97 volume control 0x%04x\n",
 519                 (val & 0x8000) ? "muted " : "",
 520                 0x1f - ((val >> 8) & 0x1f), 0x1f - (val & 0x1f),
 521                 val, (int)kcontrol->private_value);
 522
 523 err:
 524         mutex_unlock(&dev->lock);
 525         return rc;
 526 }
 527
 528 static int em28xx_vol_get_mute(struct snd_kcontrol *kcontrol,
 529                                struct snd_ctl_elem_value *value)
 530 {
 531         struct em28xx *dev = snd_kcontrol_chip(kcontrol);
 532         struct snd_pcm_substream *substream = dev->adev.capture_pcm_substream;
 533         int nonblock = 0;
 534         int val;
 535
 536         if (dev->disconnected)
 537                 return -ENODEV;
 538
 539         if (substream)
 540                 nonblock = !!(substream->f_flags & O_NONBLOCK);
 541         if (nonblock) {
 542                 if (!mutex_trylock(&dev->lock))
 543                         return -EAGAIN;
 544         } else {
 545                 mutex_lock(&dev->lock);
 546         }
 547         val = em28xx_read_ac97(dev, kcontrol->private_value);
 548         mutex_unlock(&dev->lock);
 549         if (val < 0)
 550                 return val;
 551
 552         if (val & 0x8000)
 553                 value->value.integer.value[0] = 0;
 554         else
 555                 value->value.integer.value[0] = 1;
 556
 557         dprintk("%sleft vol %d, right vol %d (0x%04x) from ac97 volume control 0x%04x\n",
 558                 (val & 0x8000) ? "muted " : "",
 559                 0x1f - ((val >> 8) & 0x1f), 0x1f - (val & 0x1f),
 560                 val, (int)kcontrol->private_value);
 561
 562         return 0;
 563 }
 564
 565 static const DECLARE_TLV_DB_SCALE(em28xx_db_scale, -3450, 150, 0);
 566
 567 static int em28xx_cvol_new(struct snd_card *card, struct em28xx *dev,
 568                            char *name, int id)
 569 {
 570         int err;
 571         char ctl_name[44];
 572         struct snd_kcontrol *kctl;
 573         struct snd_kcontrol_new tmp;
 574
 575         memset(&tmp, 0, sizeof(tmp));
 576         tmp.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
 577         tmp.private_value = id;
 578         tmp.name  = ctl_name;
 579
 580         /* Add Mute Control */
 581         sprintf(ctl_name, "%s Switch", name);
 582         tmp.get  = em28xx_vol_get_mute;
 583         tmp.put  = em28xx_vol_put_mute;
 584         tmp.info = snd_ctl_boolean_mono_info;
 585         kctl = snd_ctl_new1(&tmp, dev);
 586         err = snd_ctl_add(card, kctl);
 587         if (err < 0)
 588                 return err;
 589         dprintk("Added control %s for ac97 volume control 0x%04x\n",
 590                 ctl_name, id);
 591
 592         memset(&tmp, 0, sizeof(tmp));
 593         tmp.iface = SNDRV_CTL_ELEM_IFACE_MIXER;
 594         tmp.private_value = id;
 595         tmp.name  = ctl_name;
 596
 597         /* Add Volume Control */
 598         sprintf(ctl_name, "%s Volume", name);
 599         tmp.get   = em28xx_vol_get;
 600         tmp.put   = em28xx_vol_put;
 601         tmp.info  = em28xx_vol_info;
 602         tmp.tlv.p = em28xx_db_scale;
 603         kctl = snd_ctl_new1(&tmp, dev);
 604         err = snd_ctl_add(card, kctl);
 605         if (err < 0)
 606                 return err;
 607         dprintk("Added control %s for ac97 volume control 0x%04x\n",
 608                 ctl_name, id);
 609
 610         return 0;
 611 }
 612
 613 /*
 614  * register/unregister code and data
 615  */
 616 static const struct snd_pcm_ops snd_em28xx_pcm_capture = {
 617         .open      = snd_em28xx_capture_open,
 618         .close     = snd_em28xx_pcm_close,
 619         .prepare   = snd_em28xx_prepare,
 620         .trigger   = snd_em28xx_capture_trigger,
 621         .pointer   = snd_em28xx_capture_pointer,
 622 };
 623
 624 static void em28xx_audio_free_urb(struct em28xx *dev)
 625 {
 626         struct usb_device *udev = interface_to_usbdev(dev->intf);
 627         int i;
 628
 629         for (i = 0; i < dev->adev.num_urb; i++) {
 630                 struct urb *urb = dev->adev.urb[i];
 631
 632                 if (!urb)
 633                         continue;
 634
 635                 usb_free_coherent(udev, urb->transfer_buffer_length,
 636                                   dev->adev.transfer_buffer[i],
 637                                   urb->transfer_dma);
 638
 639                 usb_free_urb(urb);
 640         }
 641         kfree(dev->adev.urb);
 642         kfree(dev->adev.transfer_buffer);
 643         dev->adev.num_urb = 0;
 644 }
 645
 646 /* high bandwidth multiplier, as encoded in highspeed endpoint descriptors */
 647 static int em28xx_audio_ep_packet_size(struct usb_device *udev,
 648                                        struct usb_endpoint_descriptor *e)
 649 {
 650         int size = le16_to_cpu(e->wMaxPacketSize);
 651
 652         if (udev->speed == USB_SPEED_HIGH)
 653                 return (size & 0x7ff) *  (1 + (((size) >> 11) & 0x03));
 654
 655         return size & 0x7ff;
 656 }
 657
 658 static int em28xx_audio_urb_init(struct em28xx *dev)
 659 {
 660         struct usb_interface *intf;
 661         struct usb_endpoint_descriptor *e, *ep = NULL;
 662         struct usb_device *udev = interface_to_usbdev(dev->intf);
 663         int                 i, ep_size, interval, num_urb, npackets;
 664         int                 urb_size, bytes_per_transfer;
 665         u8 alt;
 666
 667         if (dev->ifnum)
 668                 alt = 1;
 669         else
 670                 alt = 7;
 671
 672         intf = usb_ifnum_to_if(udev, dev->ifnum);
 673
 674         if (intf->num_altsetting <= alt) {
 675                 dev_err(&dev->intf->dev, "alt %d doesn't exist on interface %d\n",
 676                         dev->ifnum, alt);
 677                 return -ENODEV;
 678         }
 679
 680         for (i = 0; i < intf->altsetting[alt].desc.bNumEndpoints; i++) {
 681                 e = &intf->altsetting[alt].endpoint[i].desc;
 682                 if (!usb_endpoint_dir_in(e))
 683                         continue;
 684                 if (e->bEndpointAddress == EM28XX_EP_AUDIO) {
 685                         ep = e;
 686                         break;
 687                 }
 688         }
 689
 690         if (!ep) {
 691                 dev_err(&dev->intf->dev, "Couldn't find an audio endpoint");
 692                 return -ENODEV;
 693         }
 694
 695         ep_size = em28xx_audio_ep_packet_size(udev, ep);
 696         interval = 1 << (ep->bInterval - 1);
 697
 698         dev_info(&dev->intf->dev,
 699                  "Endpoint 0x%02x %s on intf %d alt %d interval = %d, size %d\n",
 700                  EM28XX_EP_AUDIO, usb_speed_string(udev->speed),
 701                  dev->ifnum, alt, interval, ep_size);
 702
 703         /* Calculate the number and size of URBs to better fit the audio samples */
 704
 705         /*
 706          * Estimate the number of bytes per DMA transfer.
 707          *
 708          * This is given by the bit rate (for now, only 48000 Hz) multiplied
 709          * by 2 channels and 2 bytes/sample divided by the number of microframe
 710          * intervals and by the microframe rate (125 us)
 711          */
 712         bytes_per_transfer = DIV_ROUND_UP(48000 * 2 * 2, 125 * interval);
 713
 714         /*
 715          * Estimate the number of transfer URBs. Don't let it go past the
 716          * maximum number of URBs that is known to be supported by the device.
 717          */
 718         num_urb = DIV_ROUND_UP(bytes_per_transfer, ep_size);
 719         if (num_urb > EM28XX_MAX_AUDIO_BUFS)
 720                 num_urb = EM28XX_MAX_AUDIO_BUFS;
 721
 722         /*
 723          * Now that we know the number of bytes per transfer and the number of
 724          * URBs, estimate the typical size of an URB, in order to adjust the
 725          * minimal number of packets.
 726          */
 727         urb_size = bytes_per_transfer / num_urb;
 728
 729         /*
 730          * Now, calculate the amount of audio packets to be filled on each
 731          * URB. In order to preserve the old behaviour, use a minimal
 732          * threshold for this value.
 733          */
 734         npackets = EM28XX_MIN_AUDIO_PACKETS;
 735         if (urb_size > ep_size * npackets)
 736                 npackets = DIV_ROUND_UP(urb_size, ep_size);
 737
 738         dev_info(&dev->intf->dev,
 739                  "Number of URBs: %d, with %d packets and %d size\n",
 740                  num_urb, npackets, urb_size);
 741
 742         /* Estimate the bytes per period */
 743         dev->adev.period = urb_size * npackets;
 744
 745         /* Allocate space to store the number of URBs to be used */
 746
 747         dev->adev.transfer_buffer = kcalloc(num_urb,
 748                                             sizeof(*dev->adev.transfer_buffer),
 749                                             GFP_KERNEL);
 750         if (!dev->adev.transfer_buffer)
 751                 return -ENOMEM;
 752
 753         dev->adev.urb = kcalloc(num_urb, sizeof(*dev->adev.urb), GFP_KERNEL);
 754         if (!dev->adev.urb) {
 755                 kfree(dev->adev.transfer_buffer);
 756                 return -ENOMEM;
 757         }
 758
 759         /* Alloc memory for each URB and for each transfer buffer */
 760         dev->adev.num_urb = num_urb;
 761         for (i = 0; i < num_urb; i++) {
 762                 struct urb *urb;
 763                 int j, k;
 764                 void *buf;
 765
 766                 urb = usb_alloc_urb(npackets, GFP_KERNEL);
 767                 if (!urb) {
 768                         em28xx_audio_free_urb(dev);
 769                         return -ENOMEM;
 770                 }
 771                 dev->adev.urb[i] = urb;
 772
 773                 buf = usb_alloc_coherent(udev, npackets * ep_size, GFP_KERNEL,
 774                                          &urb->transfer_dma);
 775                 if (!buf) {
 776                         dev_err(&dev->intf->dev,
 777                                 "usb_alloc_coherent failed!\n");
 778                         em28xx_audio_free_urb(dev);
 779                         return -ENOMEM;
 780                 }
 781                 dev->adev.transfer_buffer[i] = buf;
 782
 783                 urb->dev = udev;
 784                 urb->context = dev;
 785                 urb->pipe = usb_rcvisocpipe(udev, EM28XX_EP_AUDIO);
 786                 urb->transfer_flags = URB_ISO_ASAP | URB_NO_TRANSFER_DMA_MAP;
 787                 urb->transfer_buffer = buf;
 788                 urb->interval = interval;
 789                 urb->complete = em28xx_audio_isocirq;
 790                 urb->number_of_packets = npackets;
 791                 urb->transfer_buffer_length = ep_size * npackets;
 792
 793                 for (j = k = 0; j < npackets; j++, k += ep_size) {
 794                         urb->iso_frame_desc[j].offset = k;
 795                         urb->iso_frame_desc[j].length = ep_size;
 796                 }
 797         }
 798
 799         return 0;
 800 }
 801
 802 static int em28xx_audio_init(struct em28xx *dev)
 803 {
 804         struct em28xx_audio *adev = &dev->adev;
 805         struct usb_device *udev = interface_to_usbdev(dev->intf);
 806         struct snd_pcm      *pcm;
 807         struct snd_card     *card;
 808         static int          devnr;
 809         int                 err;
 810
 811         if (dev->usb_audio_type != EM28XX_USB_AUDIO_VENDOR) {
 812                 /*
 813                  * This device does not support the extension (in this case
 814                  * the device is expecting the snd-usb-audio module or
 815                  * doesn't have analog audio support at all)
 816                  */
 817                 return 0;
 818         }
 819
 820         dev_info(&dev->intf->dev, "Binding audio extension\n");
 821
 822         kref_get(&dev->ref);
 823
 824         dev_info(&dev->intf->dev,
 825                  "em28xx-audio.c: Copyright (C) 2006 Markus Rechberger\n");
 826         dev_info(&dev->intf->dev,
 827                  "em28xx-audio.c: Copyright (C) 2007-2016 Mauro Carvalho Chehab\n");
 828
 829         err = snd_card_new(&dev->intf->dev, index[devnr], "Em28xx Audio",
 830                            THIS_MODULE, 0, &card);
 831         if (err < 0)
 832                 return err;
 833
 834         spin_lock_init(&adev->slock);
 835         adev->sndcard = card;
 836         adev->udev = udev;
 837
 838         err = snd_pcm_new(card, "Em28xx Audio", 0, 0, 1, &pcm);
 839         if (err < 0)
 840                 goto card_free;
 841
 842         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_em28xx_pcm_capture);
 843         snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_VMALLOC, NULL, 0, 0);
 844         pcm->info_flags = 0;
 845         pcm->private_data = dev;
 846         strscpy(pcm->name, "Empia 28xx Capture", sizeof(pcm->name));
 847
 848         strscpy(card->driver, "Em28xx-Audio", sizeof(card->driver));
 849         strscpy(card->shortname, "Em28xx Audio", sizeof(card->shortname));
 850         strscpy(card->longname, "Empia Em28xx Audio", sizeof(card->longname));
 851
 852         INIT_WORK(&adev->wq_trigger, audio_trigger);
 853
 854         if (dev->audio_mode.ac97 != EM28XX_NO_AC97) {
 855                 em28xx_cvol_new(card, dev, "Video", AC97_VIDEO);
 856                 em28xx_cvol_new(card, dev, "Line In", AC97_LINE);
 857                 em28xx_cvol_new(card, dev, "Phone", AC97_PHONE);
 858                 em28xx_cvol_new(card, dev, "Microphone", AC97_MIC);
 859                 em28xx_cvol_new(card, dev, "CD", AC97_CD);
 860                 em28xx_cvol_new(card, dev, "AUX", AC97_AUX);
 861                 em28xx_cvol_new(card, dev, "PCM", AC97_PCM);
 862
 863                 em28xx_cvol_new(card, dev, "Master", AC97_MASTER);
 864                 em28xx_cvol_new(card, dev, "Line", AC97_HEADPHONE);
 865                 em28xx_cvol_new(card, dev, "Mono", AC97_MASTER_MONO);
 866                 em28xx_cvol_new(card, dev, "LFE", AC97_CENTER_LFE_MASTER);
 867                 em28xx_cvol_new(card, dev, "Surround", AC97_SURROUND_MASTER);
 868         }
 869
 870         err = em28xx_audio_urb_init(dev);
 871         if (err)
 872                 goto card_free;
 873
 874         err = snd_card_register(card);
 875         if (err < 0)
 876                 goto urb_free;
 877
 878         dev_info(&dev->intf->dev, "Audio extension successfully initialized\n");
 879         return 0;
 880
 881 urb_free:
 882         em28xx_audio_free_urb(dev);
 883
 884 card_free:
 885         snd_card_free(card);
 886         adev->sndcard = NULL;
 887
 888         return err;
 889 }
 890
 891 static int em28xx_audio_fini(struct em28xx *dev)
 892 {
 893         if (!dev)
 894                 return 0;
 895
 896         if (dev->usb_audio_type != EM28XX_USB_AUDIO_VENDOR) {
 897                 /*
 898                  * This device does not support the extension (in this case
 899                  * the device is expecting the snd-usb-audio module or
 900                  * doesn't have analog audio support at all)
 901                  */
 902                 return 0;
 903         }
 904
 905         dev_info(&dev->intf->dev, "Closing audio extension\n");
 906
 907         if (dev->adev.sndcard) {
 908                 snd_card_disconnect(dev->adev.sndcard);
 909                 flush_work(&dev->adev.wq_trigger);
 910
 911                 em28xx_audio_free_urb(dev);
 912
 913                 snd_card_free(dev->adev.sndcard);
 914                 dev->adev.sndcard = NULL;
 915         }
 916
 917         kref_put(&dev->ref, em28xx_free_device);
 918         return 0;
 919 }
 920
 921 static int em28xx_audio_suspend(struct em28xx *dev)
 922 {
 923         if (!dev)
 924                 return 0;
 925
 926         if (dev->usb_audio_type != EM28XX_USB_AUDIO_VENDOR)
 927                 return 0;
 928
 929         dev_info(&dev->intf->dev, "Suspending audio extension\n");
 930         em28xx_deinit_isoc_audio(dev);
 931         atomic_set(&dev->adev.stream_started, 0);
 932         return 0;
 933 }
 934
 935 static int em28xx_audio_resume(struct em28xx *dev)
 936 {
 937         if (!dev)
 938                 return 0;
 939
 940         if (dev->usb_audio_type != EM28XX_USB_AUDIO_VENDOR)
 941                 return 0;
 942
 943         dev_info(&dev->intf->dev, "Resuming audio extension\n");
 944         /* Nothing to do other than schedule_work() ?? */
 945         schedule_work(&dev->adev.wq_trigger);
 946         return 0;
 947 }
 948
 949 static struct em28xx_ops audio_ops = {
 950         .id   = EM28XX_AUDIO,
 951         .name = "Em28xx Audio Extension",
 952         .init = em28xx_audio_init,
 953         .fini = em28xx_audio_fini,
 954         .suspend = em28xx_audio_suspend,
 955         .resume = em28xx_audio_resume,
 956 };
 957
 958 static int __init em28xx_alsa_register(void)
 959 {
 960         return em28xx_register_extension(&audio_ops);
 961 }
 962
 963 static void __exit em28xx_alsa_unregister(void)
 964 {
 965         em28xx_unregister_extension(&audio_ops);
 966 }
 967
 968 MODULE_LICENSE("GPL v2");
 969 MODULE_AUTHOR("Markus Rechberger <mrechberger@gmail.com>");
 970 MODULE_AUTHOR("Mauro Carvalho Chehab");
 971 MODULE_DESCRIPTION(DRIVER_DESC " - audio interface");
 972 MODULE_VERSION(EM28XX_VERSION);
 973
 974 module_init(em28xx_alsa_register);
 975 module_exit(em28xx_alsa_unregister);