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