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(v: &dev->adev.stream_started, i: 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(v: &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(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(v: &dev->adev.stream_started, i: 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(lock: &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(dev: udev, ifnum: dev->ifnum, alternate: 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(kref: &dev->ref); |
276 | dev->adev.users++; |
277 | mutex_unlock(lock: &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 | min: dev->adev.period * 95 / 100, |
283 | max: dev->adev.period * 105 / 100); |
284 | |
285 | dev->adev.capture_pcm_substream = substream; |
286 | |
287 | return 0; |
288 | err: |
289 | mutex_unlock(lock: &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(v: &dev->adev.stream_started) > 0) { |
306 | atomic_set(v: &dev->adev.stream_started, i: 0); |
307 | schedule_work(work: &dev->adev.wq_trigger); |
308 | } |
309 | |
310 | em28xx_audio_analog_set(dev); |
311 | mutex_unlock(lock: &dev->lock); |
312 | kref_put(kref: &dev->ref, release: 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(v: &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(v: &dev->adev.stream_started, i: 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(v: &dev->adev.stream_started, i: 0); |
364 | break; |
365 | default: |
366 | retval = -EINVAL; |
367 | } |
368 | schedule_work(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(lock: &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(lock: &dev->lock)) |
426 | return -EAGAIN; |
427 | } else { |
428 | mutex_lock(&dev->lock); |
429 | } |
430 | rc = em28xx_read_ac97(dev, reg: 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, reg: 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(lock: &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(lock: &dev->lock)) |
465 | return -EAGAIN; |
466 | } else { |
467 | mutex_lock(&dev->lock); |
468 | } |
469 | val = em28xx_read_ac97(dev, reg: kcontrol->private_value); |
470 | mutex_unlock(lock: &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(lock: &dev->lock)) |
501 | return -EAGAIN; |
502 | } else { |
503 | mutex_lock(&dev->lock); |
504 | } |
505 | rc = em28xx_read_ac97(dev, reg: 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, reg: kcontrol->private_value, val: 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(lock: &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(lock: &dev->lock)) |
543 | return -EAGAIN; |
544 | } else { |
545 | mutex_lock(&dev->lock); |
546 | } |
547 | val = em28xx_read_ac97(dev, reg: kcontrol->private_value); |
548 | mutex_unlock(lock: &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(buf: ctl_name, fmt: "%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(kcontrolnew: &tmp, private_data: dev); |
586 | err = snd_ctl_add(card, kcontrol: 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(buf: ctl_name, fmt: "%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(kcontrolnew: &tmp, private_data: dev); |
604 | err = snd_ctl_add(card, kcontrol: 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(dev: udev, size: urb->transfer_buffer_length, |
636 | addr: dev->adev.transfer_buffer[i], |
637 | dma: urb->transfer_dma); |
638 | |
639 | usb_free_urb(urb); |
640 | } |
641 | kfree(objp: dev->adev.urb); |
642 | kfree(objp: 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(dev: udev, ifnum: 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(epd: 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, e: 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(n: num_urb, |
748 | size: sizeof(*dev->adev.transfer_buffer), |
749 | GFP_KERNEL); |
750 | if (!dev->adev.transfer_buffer) |
751 | return -ENOMEM; |
752 | |
753 | dev->adev.urb = kcalloc(n: num_urb, size: sizeof(*dev->adev.urb), GFP_KERNEL); |
754 | if (!dev->adev.urb) { |
755 | kfree(objp: 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(iso_packets: 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(dev: udev, size: npackets * ep_size, GFP_KERNEL, |
774 | dma: &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(kref: &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(parent: &dev->intf->dev, idx: index[devnr], xid: "Em28xx Audio" , |
830 | THIS_MODULE, extra_size: 0, card_ret: &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, id: "Em28xx Audio" , device: 0, playback_count: 0, capture_count: 1, rpcm: &pcm); |
839 | if (err < 0) |
840 | goto card_free; |
841 | |
842 | snd_pcm_set_ops(pcm, direction: SNDRV_PCM_STREAM_CAPTURE, ops: &snd_em28xx_pcm_capture); |
843 | snd_pcm_set_managed_buffer_all(pcm, SNDRV_DMA_TYPE_VMALLOC, NULL, size: 0, max: 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, name: "Video" , AC97_VIDEO); |
856 | em28xx_cvol_new(card, dev, name: "Line In" , AC97_LINE); |
857 | em28xx_cvol_new(card, dev, name: "Phone" , AC97_PHONE); |
858 | em28xx_cvol_new(card, dev, name: "Microphone" , AC97_MIC); |
859 | em28xx_cvol_new(card, dev, name: "CD" , AC97_CD); |
860 | em28xx_cvol_new(card, dev, name: "AUX" , AC97_AUX); |
861 | em28xx_cvol_new(card, dev, name: "PCM" , AC97_PCM); |
862 | |
863 | em28xx_cvol_new(card, dev, name: "Master" , AC97_MASTER); |
864 | em28xx_cvol_new(card, dev, name: "Line" , AC97_HEADPHONE); |
865 | em28xx_cvol_new(card, dev, name: "Mono" , AC97_MASTER_MONO); |
866 | em28xx_cvol_new(card, dev, name: "LFE" , AC97_CENTER_LFE_MASTER); |
867 | em28xx_cvol_new(card, dev, name: "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(card: dev->adev.sndcard); |
909 | flush_work(work: &dev->adev.wq_trigger); |
910 | |
911 | em28xx_audio_free_urb(dev); |
912 | |
913 | snd_card_free(card: dev->adev.sndcard); |
914 | dev->adev.sndcard = NULL; |
915 | } |
916 | |
917 | kref_put(kref: &dev->ref, release: 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(v: &dev->adev.stream_started, i: 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(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(dev: &audio_ops); |
961 | } |
962 | |
963 | static void __exit em28xx_alsa_unregister(void) |
964 | { |
965 | em28xx_unregister_extension(dev: &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 | |