1 /*
2 *
3 * Support for audio capture for tm5600/6000/6010
4 * (c) 2007-2008 Mauro Carvalho Chehab <mchehab@redhat.com>
5 *
6 * Based on cx88-alsa.c
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation.
11 */
12
13 #include <linux/module.h>
14 #include <linux/init.h>
15 #include <linux/device.h>
16 #include <linux/interrupt.h>
17 #include <linux/usb.h>
18 #include <linux/slab.h>
19 #include <linux/vmalloc.h>
20
21 #include <linux/delay.h>
22 #include <sound/core.h>
23 #include <sound/pcm.h>
24 #include <sound/pcm_params.h>
25 #include <sound/control.h>
26 #include <sound/initval.h>
27
28
29 #include "tm6000.h"
30 #include "tm6000-regs.h"
31
32 #undef dprintk
33
34 #define dprintk(level, fmt, arg...) do { \
35 if (debug >= level) \
36 printk(KERN_INFO "%s/1: " fmt, chip->core->name , ## arg); \
37 } while (0)
38
39 /****************************************************************************
40 Module global static vars
41 ****************************************************************************/
42
43 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX; /* Index 0-MAX */
44
45 static bool enable[SNDRV_CARDS] = {1, [1 ... (SNDRV_CARDS - 1)] = 1};
46
47 module_param_array(enable, bool, NULL, 0444);
48 MODULE_PARM_DESC(enable, "Enable tm6000x soundcard. default enabled.");
49
50 module_param_array(index, int, NULL, 0444);
51 MODULE_PARM_DESC(index, "Index value for tm6000x capture interface(s).");
52
53
54 /****************************************************************************
55 Module macros
56 ****************************************************************************/
57
58 MODULE_DESCRIPTION("ALSA driver module for tm5600/tm6000/tm6010 based TV cards");
59 MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@redhat.com>");
60 MODULE_LICENSE("GPL");
61 MODULE_SUPPORTED_DEVICE("{{Trident,tm5600},"
62 "{{Trident,tm6000},"
63 "{{Trident,tm6010}");
64 static unsigned int debug;
65 module_param(debug, int, 0644);
66 MODULE_PARM_DESC(debug, "enable debug messages");
67
68 /****************************************************************************
69 Module specific funtions
70 ****************************************************************************/
71
72 /*
73 * BOARD Specific: Sets audio DMA
74 */
75
_tm6000_start_audio_dma(struct snd_tm6000_card * chip)76 static int _tm6000_start_audio_dma(struct snd_tm6000_card *chip)
77 {
78 struct tm6000_core *core = chip->core;
79
80 dprintk(1, "Starting audio DMA\n");
81
82 /* Enables audio */
83 tm6000_set_reg_mask(core, TM6010_REQ07_RCC_ACTIVE_IF, 0x40, 0x40);
84
85 tm6000_set_audio_bitrate(core, 48000);
86
87 return 0;
88 }
89
90 /*
91 * BOARD Specific: Resets audio DMA
92 */
_tm6000_stop_audio_dma(struct snd_tm6000_card * chip)93 static int _tm6000_stop_audio_dma(struct snd_tm6000_card *chip)
94 {
95 struct tm6000_core *core = chip->core;
96
97 dprintk(1, "Stopping audio DMA\n");
98
99 /* Disables audio */
100 tm6000_set_reg_mask(core, TM6010_REQ07_RCC_ACTIVE_IF, 0x00, 0x40);
101
102 return 0;
103 }
104
dsp_buffer_free(struct snd_pcm_substream * substream)105 static void dsp_buffer_free(struct snd_pcm_substream *substream)
106 {
107 struct snd_tm6000_card *chip = snd_pcm_substream_chip(substream);
108
109 dprintk(2, "Freeing buffer\n");
110
111 vfree(substream->runtime->dma_area);
112 substream->runtime->dma_area = NULL;
113 substream->runtime->dma_bytes = 0;
114 }
115
dsp_buffer_alloc(struct snd_pcm_substream * substream,int size)116 static int dsp_buffer_alloc(struct snd_pcm_substream *substream, int size)
117 {
118 struct snd_tm6000_card *chip = snd_pcm_substream_chip(substream);
119
120 dprintk(2, "Allocating buffer\n");
121
122 if (substream->runtime->dma_area) {
123 if (substream->runtime->dma_bytes > size)
124 return 0;
125
126 dsp_buffer_free(substream);
127 }
128
129 substream->runtime->dma_area = vmalloc(size);
130 if (!substream->runtime->dma_area)
131 return -ENOMEM;
132
133 substream->runtime->dma_bytes = size;
134
135 return 0;
136 }
137
138
139 /****************************************************************************
140 ALSA PCM Interface
141 ****************************************************************************/
142
143 /*
144 * Digital hardware definition
145 */
146 #define DEFAULT_FIFO_SIZE 4096
147
148 static struct snd_pcm_hardware snd_tm6000_digital_hw = {
149 .info = SNDRV_PCM_INFO_BATCH |
150 SNDRV_PCM_INFO_MMAP |
151 SNDRV_PCM_INFO_INTERLEAVED |
152 SNDRV_PCM_INFO_BLOCK_TRANSFER |
153 SNDRV_PCM_INFO_MMAP_VALID,
154 .formats = SNDRV_PCM_FMTBIT_S16_LE,
155
156 .rates = SNDRV_PCM_RATE_CONTINUOUS | SNDRV_PCM_RATE_KNOT,
157 .rate_min = 48000,
158 .rate_max = 48000,
159 .channels_min = 2,
160 .channels_max = 2,
161 .period_bytes_min = 64,
162 .period_bytes_max = 12544,
163 .periods_min = 2,
164 .periods_max = 98,
165 .buffer_bytes_max = 62720 * 8,
166 };
167
168 /*
169 * audio pcm capture open callback
170 */
snd_tm6000_pcm_open(struct snd_pcm_substream * substream)171 static int snd_tm6000_pcm_open(struct snd_pcm_substream *substream)
172 {
173 struct snd_tm6000_card *chip = snd_pcm_substream_chip(substream);
174 struct snd_pcm_runtime *runtime = substream->runtime;
175 int err;
176
177 err = snd_pcm_hw_constraint_pow2(runtime, 0,
178 SNDRV_PCM_HW_PARAM_PERIODS);
179 if (err < 0)
180 goto _error;
181
182 chip->substream = substream;
183
184 runtime->hw = snd_tm6000_digital_hw;
185 snd_pcm_hw_constraint_integer(runtime, SNDRV_PCM_HW_PARAM_PERIODS);
186
187 return 0;
188 _error:
189 dprintk(1, "Error opening PCM!\n");
190 return err;
191 }
192
193 /*
194 * audio close callback
195 */
snd_tm6000_close(struct snd_pcm_substream * substream)196 static int snd_tm6000_close(struct snd_pcm_substream *substream)
197 {
198 struct snd_tm6000_card *chip = snd_pcm_substream_chip(substream);
199 struct tm6000_core *core = chip->core;
200
201 if (atomic_read(&core->stream_started) > 0) {
202 atomic_set(&core->stream_started, 0);
203 schedule_work(&core->wq_trigger);
204 }
205
206 return 0;
207 }
208
tm6000_fillbuf(struct tm6000_core * core,char * buf,int size)209 static int tm6000_fillbuf(struct tm6000_core *core, char *buf, int size)
210 {
211 struct snd_tm6000_card *chip = core->adev;
212 struct snd_pcm_substream *substream = chip->substream;
213 struct snd_pcm_runtime *runtime;
214 int period_elapsed = 0;
215 unsigned int stride, buf_pos;
216 int length;
217
218 if (atomic_read(&core->stream_started) == 0)
219 return 0;
220
221 if (!size || !substream) {
222 dprintk(1, "substream was NULL\n");
223 return -EINVAL;
224 }
225
226 runtime = substream->runtime;
227 if (!runtime || !runtime->dma_area) {
228 dprintk(1, "runtime was NULL\n");
229 return -EINVAL;
230 }
231
232 buf_pos = chip->buf_pos;
233 stride = runtime->frame_bits >> 3;
234
235 if (stride == 0) {
236 dprintk(1, "stride is zero\n");
237 return -EINVAL;
238 }
239
240 length = size / stride;
241 if (length == 0) {
242 dprintk(1, "%s: length was zero\n", __func__);
243 return -EINVAL;
244 }
245
246 dprintk(1, "Copying %d bytes at %p[%d] - buf size=%d x %d\n", size,
247 runtime->dma_area, buf_pos,
248 (unsigned int)runtime->buffer_size, stride);
249
250 if (buf_pos + length >= runtime->buffer_size) {
251 unsigned int cnt = runtime->buffer_size - buf_pos;
252 memcpy(runtime->dma_area + buf_pos * stride, buf, cnt * stride);
253 memcpy(runtime->dma_area, buf + cnt * stride,
254 length * stride - cnt * stride);
255 } else
256 memcpy(runtime->dma_area + buf_pos * stride, buf,
257 length * stride);
258
259 snd_pcm_stream_lock(substream);
260
261 chip->buf_pos += length;
262 if (chip->buf_pos >= runtime->buffer_size)
263 chip->buf_pos -= runtime->buffer_size;
264
265 chip->period_pos += length;
266 if (chip->period_pos >= runtime->period_size) {
267 chip->period_pos -= runtime->period_size;
268 period_elapsed = 1;
269 }
270
271 snd_pcm_stream_unlock(substream);
272
273 if (period_elapsed)
274 snd_pcm_period_elapsed(substream);
275
276 return 0;
277 }
278
279 /*
280 * hw_params callback
281 */
snd_tm6000_hw_params(struct snd_pcm_substream * substream,struct snd_pcm_hw_params * hw_params)282 static int snd_tm6000_hw_params(struct snd_pcm_substream *substream,
283 struct snd_pcm_hw_params *hw_params)
284 {
285 int size, rc;
286
287 size = params_period_bytes(hw_params) * params_periods(hw_params);
288
289 rc = dsp_buffer_alloc(substream, size);
290 if (rc < 0)
291 return rc;
292
293 return 0;
294 }
295
296 /*
297 * hw free callback
298 */
snd_tm6000_hw_free(struct snd_pcm_substream * substream)299 static int snd_tm6000_hw_free(struct snd_pcm_substream *substream)
300 {
301 struct snd_tm6000_card *chip = snd_pcm_substream_chip(substream);
302 struct tm6000_core *core = chip->core;
303
304 if (atomic_read(&core->stream_started) > 0) {
305 atomic_set(&core->stream_started, 0);
306 schedule_work(&core->wq_trigger);
307 }
308
309 dsp_buffer_free(substream);
310 return 0;
311 }
312
313 /*
314 * prepare callback
315 */
snd_tm6000_prepare(struct snd_pcm_substream * substream)316 static int snd_tm6000_prepare(struct snd_pcm_substream *substream)
317 {
318 struct snd_tm6000_card *chip = snd_pcm_substream_chip(substream);
319
320 chip->buf_pos = 0;
321 chip->period_pos = 0;
322
323 return 0;
324 }
325
326
327 /*
328 * trigger callback
329 */
audio_trigger(struct work_struct * work)330 static void audio_trigger(struct work_struct *work)
331 {
332 struct tm6000_core *core = container_of(work, struct tm6000_core,
333 wq_trigger);
334 struct snd_tm6000_card *chip = core->adev;
335
336 if (atomic_read(&core->stream_started)) {
337 dprintk(1, "starting capture");
338 _tm6000_start_audio_dma(chip);
339 } else {
340 dprintk(1, "stopping capture");
341 _tm6000_stop_audio_dma(chip);
342 }
343 }
344
snd_tm6000_card_trigger(struct snd_pcm_substream * substream,int cmd)345 static int snd_tm6000_card_trigger(struct snd_pcm_substream *substream, int cmd)
346 {
347 struct snd_tm6000_card *chip = snd_pcm_substream_chip(substream);
348 struct tm6000_core *core = chip->core;
349 int err = 0;
350
351 switch (cmd) {
352 case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: /* fall through */
353 case SNDRV_PCM_TRIGGER_RESUME: /* fall through */
354 case SNDRV_PCM_TRIGGER_START:
355 atomic_set(&core->stream_started, 1);
356 break;
357 case SNDRV_PCM_TRIGGER_PAUSE_PUSH: /* fall through */
358 case SNDRV_PCM_TRIGGER_SUSPEND: /* fall through */
359 case SNDRV_PCM_TRIGGER_STOP:
360 atomic_set(&core->stream_started, 0);
361 break;
362 default:
363 err = -EINVAL;
364 break;
365 }
366 schedule_work(&core->wq_trigger);
367
368 return err;
369 }
370 /*
371 * pointer callback
372 */
snd_tm6000_pointer(struct snd_pcm_substream * substream)373 static snd_pcm_uframes_t snd_tm6000_pointer(struct snd_pcm_substream *substream)
374 {
375 struct snd_tm6000_card *chip = snd_pcm_substream_chip(substream);
376
377 return chip->buf_pos;
378 }
379
snd_pcm_get_vmalloc_page(struct snd_pcm_substream * subs,unsigned long offset)380 static struct page *snd_pcm_get_vmalloc_page(struct snd_pcm_substream *subs,
381 unsigned long offset)
382 {
383 void *pageptr = subs->runtime->dma_area + offset;
384
385 return vmalloc_to_page(pageptr);
386 }
387
388 /*
389 * operators
390 */
391 static struct snd_pcm_ops snd_tm6000_pcm_ops = {
392 .open = snd_tm6000_pcm_open,
393 .close = snd_tm6000_close,
394 .ioctl = snd_pcm_lib_ioctl,
395 .hw_params = snd_tm6000_hw_params,
396 .hw_free = snd_tm6000_hw_free,
397 .prepare = snd_tm6000_prepare,
398 .trigger = snd_tm6000_card_trigger,
399 .pointer = snd_tm6000_pointer,
400 .page = snd_pcm_get_vmalloc_page,
401 };
402
403 /*
404 * create a PCM device
405 */
406
407 /* FIXME: Control interface - How to control volume/mute? */
408
409 /****************************************************************************
410 Basic Flow for Sound Devices
411 ****************************************************************************/
412
413 /*
414 * Alsa Constructor - Component probe
415 */
tm6000_audio_init(struct tm6000_core * dev)416 static int tm6000_audio_init(struct tm6000_core *dev)
417 {
418 struct snd_card *card;
419 struct snd_tm6000_card *chip;
420 int rc;
421 static int devnr;
422 char component[14];
423 struct snd_pcm *pcm;
424
425 if (!dev)
426 return 0;
427
428 if (devnr >= SNDRV_CARDS)
429 return -ENODEV;
430
431 if (!enable[devnr])
432 return -ENOENT;
433
434 rc = snd_card_create(index[devnr], "tm6000", THIS_MODULE, 0, &card);
435 if (rc < 0) {
436 snd_printk(KERN_ERR "cannot create card instance %d\n", devnr);
437 return rc;
438 }
439 strcpy(card->driver, "tm6000-alsa");
440 strcpy(card->shortname, "TM5600/60x0");
441 sprintf(card->longname, "TM5600/60x0 Audio at bus %d device %d",
442 dev->udev->bus->busnum, dev->udev->devnum);
443
444 sprintf(component, "USB%04x:%04x",
445 le16_to_cpu(dev->udev->descriptor.idVendor),
446 le16_to_cpu(dev->udev->descriptor.idProduct));
447 snd_component_add(card, component);
448 snd_card_set_dev(card, &dev->udev->dev);
449
450 chip = kzalloc(sizeof(struct snd_tm6000_card), GFP_KERNEL);
451 if (!chip) {
452 rc = -ENOMEM;
453 goto error;
454 }
455
456 chip->core = dev;
457 chip->card = card;
458 dev->adev = chip;
459 spin_lock_init(&chip->reg_lock);
460
461 rc = snd_pcm_new(card, "TM6000 Audio", 0, 0, 1, &pcm);
462 if (rc < 0)
463 goto error_chip;
464
465 pcm->info_flags = 0;
466 pcm->private_data = chip;
467 strcpy(pcm->name, "Trident TM5600/60x0");
468
469 snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_tm6000_pcm_ops);
470
471 INIT_WORK(&dev->wq_trigger, audio_trigger);
472 rc = snd_card_register(card);
473 if (rc < 0)
474 goto error_chip;
475
476 dprintk(1, "Registered audio driver for %s\n", card->longname);
477
478 return 0;
479
480 error_chip:
481 kfree(chip);
482 dev->adev = NULL;
483 error:
484 snd_card_free(card);
485 return rc;
486 }
487
tm6000_audio_fini(struct tm6000_core * dev)488 static int tm6000_audio_fini(struct tm6000_core *dev)
489 {
490 struct snd_tm6000_card *chip = dev->adev;
491
492 if (!dev)
493 return 0;
494
495 if (!chip)
496 return 0;
497
498 if (!chip->card)
499 return 0;
500
501 snd_card_free(chip->card);
502 chip->card = NULL;
503 kfree(chip);
504 dev->adev = NULL;
505
506 return 0;
507 }
508
509 static struct tm6000_ops audio_ops = {
510 .type = TM6000_AUDIO,
511 .name = "TM6000 Audio Extension",
512 .init = tm6000_audio_init,
513 .fini = tm6000_audio_fini,
514 .fillbuf = tm6000_fillbuf,
515 };
516
tm6000_alsa_register(void)517 static int __init tm6000_alsa_register(void)
518 {
519 return tm6000_register_extension(&audio_ops);
520 }
521
tm6000_alsa_unregister(void)522 static void __exit tm6000_alsa_unregister(void)
523 {
524 tm6000_unregister_extension(&audio_ops);
525 }
526
527 module_init(tm6000_alsa_register);
528 module_exit(tm6000_alsa_unregister);
529