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); 976