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
 43static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;	/* Index 0-MAX */
 44
 45static int 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 <mchehab@redhat.com>");
 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_VIDEO_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_VIDEO_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_MMAP |
150		SNDRV_PCM_INFO_INTERLEAVED |
151		SNDRV_PCM_INFO_BLOCK_TRANSFER |
152		SNDRV_PCM_INFO_MMAP_VALID,
153	.formats = SNDRV_PCM_FMTBIT_S16_LE,
154
155	.rates = SNDRV_PCM_RATE_CONTINUOUS,
156	.rate_min = 48000,
157	.rate_max = 48000,
158	.channels_min = 2,
159	.channels_max = 2,
160	.period_bytes_min = 64,
161	.period_bytes_max = 12544,
162	.periods_min = 1,
163	.periods_max = 98,
164	.buffer_bytes_max = 62720 * 8,
165};
166
167/*
168 * audio pcm capture open callback
169 */
170static int snd_tm6000_pcm_open(struct snd_pcm_substream *substream)
171{
172	struct snd_tm6000_card *chip = snd_pcm_substream_chip(substream);
173	struct snd_pcm_runtime *runtime = substream->runtime;
174	int err;
175
176	err = snd_pcm_hw_constraint_pow2(runtime, 0,
177					 SNDRV_PCM_HW_PARAM_PERIODS);
178	if (err < 0)
179		goto _error;
180
181	chip->substream = substream;
182
183	runtime->hw = snd_tm6000_digital_hw;
184
185	return 0;
186_error:
187	dprintk(1, "Error opening PCM!\n");
188	return err;
189}
190
191/*
192 * audio close callback
193 */
194static int snd_tm6000_close(struct snd_pcm_substream *substream)
195{
196	struct snd_tm6000_card *chip = snd_pcm_substream_chip(substream);
197	struct tm6000_core *core = chip->core;
198
199	if (atomic_read(&core->stream_started) > 0) {
200		atomic_set(&core->stream_started, 0);
201		schedule_work(&core->wq_trigger);
202	}
203
204	return 0;
205}
206
207static int tm6000_fillbuf(struct tm6000_core *core, char *buf, int size)
208{
209	struct snd_tm6000_card *chip = core->adev;
210	struct snd_pcm_substream *substream = chip->substream;
211	struct snd_pcm_runtime *runtime;
212	int period_elapsed = 0;
213	unsigned int stride, buf_pos;
214	int length;
215
216	if (atomic_read(&core->stream_started) == 0)
217		return 0;
218
219	if (!size || !substream) {
220		dprintk(1, "substream was NULL\n");
221		return -EINVAL;
222	}
223
224	runtime = substream->runtime;
225	if (!runtime || !runtime->dma_area) {
226		dprintk(1, "runtime was NULL\n");
227		return -EINVAL;
228	}
229
230	buf_pos = chip->buf_pos;
231	stride = runtime->frame_bits >> 3;
232
233	if (stride == 0) {
234		dprintk(1, "stride is zero\n");
235		return -EINVAL;
236	}
237
238	length = size / stride;
239	if (length == 0) {
240		dprintk(1, "%s: length was zero\n", __func__);
241		return -EINVAL;
242	}
243
244	dprintk(1, "Copying %d bytes at %p[%d] - buf size=%d x %d\n", size,
245		runtime->dma_area, buf_pos,
246		(unsigned int)runtime->buffer_size, stride);
247
248	if (buf_pos + length >= runtime->buffer_size) {
249		unsigned int cnt = runtime->buffer_size - buf_pos;
250		memcpy(runtime->dma_area + buf_pos * stride, buf, cnt * stride);
251		memcpy(runtime->dma_area, buf + cnt * stride,
252			length * stride - cnt * stride);
253	} else
254		memcpy(runtime->dma_area + buf_pos * stride, buf,
255			length * stride);
256
257	snd_pcm_stream_lock(substream);
258
259	chip->buf_pos += length;
260	if (chip->buf_pos >= runtime->buffer_size)
261		chip->buf_pos -= runtime->buffer_size;
262
263	chip->period_pos += length;
264	if (chip->period_pos >= runtime->period_size) {
265		chip->period_pos -= runtime->period_size;
266		period_elapsed = 1;
267	}
268
269	snd_pcm_stream_unlock(substream);
270
271	if (period_elapsed)
272		snd_pcm_period_elapsed(substream);
273
274	return 0;
275}
276
277/*
278 * hw_params callback
279 */
280static int snd_tm6000_hw_params(struct snd_pcm_substream *substream,
281			      struct snd_pcm_hw_params *hw_params)
282{
283	int size, rc;
284
285	size = params_period_bytes(hw_params) * params_periods(hw_params);
286
287	rc = dsp_buffer_alloc(substream, size);
288	if (rc < 0)
289		return rc;
290
291	return 0;
292}
293
294/*
295 * hw free callback
296 */
297static int snd_tm6000_hw_free(struct snd_pcm_substream *substream)
298{
299	struct snd_tm6000_card *chip = snd_pcm_substream_chip(substream);
300	struct tm6000_core *core = chip->core;
301
302	if (atomic_read(&core->stream_started) > 0) {
303		atomic_set(&core->stream_started, 0);
304		schedule_work(&core->wq_trigger);
305	}
306
307	return 0;
308}
309
310/*
311 * prepare callback
312 */
313static int snd_tm6000_prepare(struct snd_pcm_substream *substream)
314{
315	struct snd_tm6000_card *chip = snd_pcm_substream_chip(substream);
316
317	chip->buf_pos = 0;
318	chip->period_pos = 0;
319
320	return 0;
321}
322
323
324/*
325 * trigger callback
326 */
327static void audio_trigger(struct work_struct *work)
328{
329	struct tm6000_core *core = container_of(work, struct tm6000_core,
330						wq_trigger);
331	struct snd_tm6000_card *chip = core->adev;
332
333	if (atomic_read(&core->stream_started)) {
334		dprintk(1, "starting capture");
335		_tm6000_start_audio_dma(chip);
336	} else {
337		dprintk(1, "stopping capture");
338		_tm6000_stop_audio_dma(chip);
339	}
340}
341
342static int snd_tm6000_card_trigger(struct snd_pcm_substream *substream, int cmd)
343{
344	struct snd_tm6000_card *chip = snd_pcm_substream_chip(substream);
345	struct tm6000_core *core = chip->core;
346	int err = 0;
347
348	switch (cmd) {
349	case SNDRV_PCM_TRIGGER_START:
350		atomic_set(&core->stream_started, 1);
351		break;
352	case SNDRV_PCM_TRIGGER_STOP:
353		atomic_set(&core->stream_started, 0);
354		break;
355	default:
356		err = -EINVAL;
357		break;
358	}
359	schedule_work(&core->wq_trigger);
360
361	return err;
362}
363/*
364 * pointer callback
365 */
366static snd_pcm_uframes_t snd_tm6000_pointer(struct snd_pcm_substream *substream)
367{
368	struct snd_tm6000_card *chip = snd_pcm_substream_chip(substream);
369
370	return chip->buf_pos;
371}
372
373/*
374 * operators
375 */
376static struct snd_pcm_ops snd_tm6000_pcm_ops = {
377	.open = snd_tm6000_pcm_open,
378	.close = snd_tm6000_close,
379	.ioctl = snd_pcm_lib_ioctl,
380	.hw_params = snd_tm6000_hw_params,
381	.hw_free = snd_tm6000_hw_free,
382	.prepare = snd_tm6000_prepare,
383	.trigger = snd_tm6000_card_trigger,
384	.pointer = snd_tm6000_pointer,
385};
386
387/*
388 * create a PCM device
389 */
390
391/* FIXME: Control interface - How to control volume/mute? */
392
393/****************************************************************************
394			Basic Flow for Sound Devices
395 ****************************************************************************/
396
397/*
398 * Alsa Constructor - Component probe
399 */
400int tm6000_audio_init(struct tm6000_core *dev)
401{
402	struct snd_card		*card;
403	struct snd_tm6000_card	*chip;
404	int			rc;
405	static int		devnr;
406	char			component[14];
407	struct snd_pcm		*pcm;
408
409	if (!dev)
410		return 0;
411
412	if (devnr >= SNDRV_CARDS)
413		return -ENODEV;
414
415	if (!enable[devnr])
416		return -ENOENT;
417
418	rc = snd_card_create(index[devnr], "tm6000", THIS_MODULE, 0, &card);
419	if (rc < 0) {
420		snd_printk(KERN_ERR "cannot create card instance %d\n", devnr);
421		return rc;
422	}
423	strcpy(card->driver, "tm6000-alsa");
424	strcpy(card->shortname, "TM5600/60x0");
425	sprintf(card->longname, "TM5600/60x0 Audio at bus %d device %d",
426		dev->udev->bus->busnum, dev->udev->devnum);
427
428	sprintf(component, "USB%04x:%04x",
429		le16_to_cpu(dev->udev->descriptor.idVendor),
430		le16_to_cpu(dev->udev->descriptor.idProduct));
431	snd_component_add(card, component);
432	snd_card_set_dev(card, &dev->udev->dev);
433
434	chip = kzalloc(sizeof(struct snd_tm6000_card), GFP_KERNEL);
435	if (!chip) {
436		rc = -ENOMEM;
437		goto error;
438	}
439
440	chip->core = dev;
441	chip->card = card;
442	dev->adev = chip;
443	spin_lock_init(&chip->reg_lock);
444
445	rc = snd_pcm_new(card, "TM6000 Audio", 0, 0, 1, &pcm);
446	if (rc < 0)
447		goto error_chip;
448
449	pcm->info_flags = 0;
450	pcm->private_data = chip;
451	strcpy(pcm->name, "Trident TM5600/60x0");
452
453	snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_tm6000_pcm_ops);
454
455	INIT_WORK(&dev->wq_trigger, audio_trigger);
456	rc = snd_card_register(card);
457	if (rc < 0)
458		goto error_chip;
459
460	dprintk(1, "Registered audio driver for %s\n", card->longname);
461
462	return 0;
463
464error_chip:
465	kfree(chip);
466	dev->adev = NULL;
467error:
468	snd_card_free(card);
469	return rc;
470}
471
472static int tm6000_audio_fini(struct tm6000_core *dev)
473{
474	struct snd_tm6000_card	*chip = dev->adev;
475
476	if (!dev)
477		return 0;
478
479	if (!chip)
480		return 0;
481
482	if (!chip->card)
483		return 0;
484
485	snd_card_free(chip->card);
486	chip->card = NULL;
487	kfree(chip);
488	dev->adev = NULL;
489
490	return 0;
491}
492
493struct tm6000_ops audio_ops = {
494	.type	= TM6000_AUDIO,
495	.name	= "TM6000 Audio Extension",
496	.init	= tm6000_audio_init,
497	.fini	= tm6000_audio_fini,
498	.fillbuf = tm6000_fillbuf,
499};
500
501static int __init tm6000_alsa_register(void)
502{
503	return tm6000_register_extension(&audio_ops);
504}
505
506static void __exit tm6000_alsa_unregister(void)
507{
508	tm6000_unregister_extension(&audio_ops);
509}
510
511module_init(tm6000_alsa_register);
512module_exit(tm6000_alsa_unregister);