1/*
2 *
3 *  Support for audio capture for tm5600/6000/6010
4 *    (c) 2007-2008 Mauro Carvalho Chehab
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
43static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;	/* Index 0-MAX */
44
45static bool enable[SNDRV_CARDS] = {1, [1 ... (SNDRV_CARDS - 1)] = 1};
46
47module_param_array(enable, bool, NULL, 0444);
48MODULE_PARM_DESC(enable, "Enable tm6000x soundcard. default enabled.");
49
50module_param_array(index, int, NULL, 0444);
51MODULE_PARM_DESC(index, "Index value for tm6000x capture interface(s).");
52
53
54/****************************************************************************
55				Module macros
56 ****************************************************************************/
57
58MODULE_DESCRIPTION("ALSA driver module for tm5600/tm6000/tm6010 based TV cards");
59MODULE_AUTHOR("Mauro Carvalho Chehab");
60MODULE_LICENSE("GPL");
61MODULE_SUPPORTED_DEVICE("{{Trident,tm5600},"
62			"{{Trident,tm6000},"
63			"{{Trident,tm6010}");
64static unsigned int debug;
65module_param(debug, int, 0644);
66MODULE_PARM_DESC(debug, "enable debug messages");
67
68/****************************************************************************
69			Module specific funtions
70 ****************************************************************************/
71
72/*
73 * BOARD Specific: Sets audio DMA
74 */
75
76static 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 */
93static 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
105static 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
116static 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
148static 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 */
171static 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 */
196static 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
209static 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 */
282static 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 */
299static 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 */
316static 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 */
330static 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
345static 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 */
373static 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
380static 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 */
391static 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 */
416static 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_new(&dev->udev->dev, index[devnr], "tm6000",
435			  THIS_MODULE, 0, &card);
436	if (rc < 0) {
437		snd_printk(KERN_ERR "cannot create card instance %d\n", devnr);
438		return rc;
439	}
440	strcpy(card->driver, "tm6000-alsa");
441	strcpy(card->shortname, "TM5600/60x0");
442	sprintf(card->longname, "TM5600/60x0 Audio at bus %d device %d",
443		dev->udev->bus->busnum, dev->udev->devnum);
444
445	sprintf(component, "USB%04x:%04x",
446		le16_to_cpu(dev->udev->descriptor.idVendor),
447		le16_to_cpu(dev->udev->descriptor.idProduct));
448	snd_component_add(card, component);
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
480error_chip:
481	kfree(chip);
482	dev->adev = NULL;
483error:
484	snd_card_free(card);
485	return rc;
486}
487
488static int tm6000_audio_fini(struct tm6000_core *dev)
489{
490	struct snd_tm6000_card *chip;
491
492	if (!dev)
493		return 0;
494	chip = dev->adev;
495
496	if (!chip)
497		return 0;
498
499	if (!chip->card)
500		return 0;
501
502	snd_card_free(chip->card);
503	chip->card = NULL;
504	kfree(chip);
505	dev->adev = NULL;
506
507	return 0;
508}
509
510static struct tm6000_ops audio_ops = {
511	.type	= TM6000_AUDIO,
512	.name	= "TM6000 Audio Extension",
513	.init	= tm6000_audio_init,
514	.fini	= tm6000_audio_fini,
515	.fillbuf = tm6000_fillbuf,
516};
517
518static int __init tm6000_alsa_register(void)
519{
520	return tm6000_register_extension(&audio_ops);
521}
522
523static void __exit tm6000_alsa_unregister(void)
524{
525	tm6000_unregister_extension(&audio_ops);
526}
527
528module_init(tm6000_alsa_register);
529module_exit(tm6000_alsa_unregister);
530