ce081cd44ad4a08e82cc9902ff8a1ecbd4f1724e
[karo-tx-linux.git] / drivers / staging / tm6000 / tm6000-alsa.c
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
19 #include <asm/delay.h>
20 #include <sound/core.h>
21 #include <sound/pcm.h>
22 #include <sound/pcm_params.h>
23 #include <sound/control.h>
24 #include <sound/initval.h>
25
26
27 #include "tm6000.h"
28 #include "tm6000-regs.h"
29
30 #undef dprintk
31
32 #define dprintk(level, fmt, arg...) do {                                   \
33         if (debug >= level)                                                \
34                 printk(KERN_INFO "%s/1: " fmt, chip->core->name , ## arg); \
35         } while (0)
36
37 /****************************************************************************
38         Data type declarations - Can be moded to a header file later
39  ****************************************************************************/
40
41 struct snd_tm6000_card {
42         struct snd_card            *card;
43
44         spinlock_t                 reg_lock;
45
46         atomic_t                   count;
47
48         unsigned int               period_size;
49         unsigned int               num_periods;
50
51         struct tm6000_core         *core;
52         struct tm6000_buffer       *buf;
53
54         int                        bufsize;
55
56         struct snd_pcm_substream *substream;
57 };
58
59
60 /****************************************************************************
61                         Module global static vars
62  ****************************************************************************/
63
64 static int index[SNDRV_CARDS] = SNDRV_DEFAULT_IDX;      /* Index 0-MAX */
65 static char *id[SNDRV_CARDS] = SNDRV_DEFAULT_STR;       /* ID for this card */
66 static int enable[SNDRV_CARDS] = {1, [1 ... (SNDRV_CARDS - 1)] = 1};
67
68 module_param_array(enable, bool, NULL, 0444);
69 MODULE_PARM_DESC(enable, "Enable tm6000x soundcard. default enabled.");
70
71 module_param_array(index, int, NULL, 0444);
72 MODULE_PARM_DESC(index, "Index value for tm6000x capture interface(s).");
73
74
75 /****************************************************************************
76                                 Module macros
77  ****************************************************************************/
78
79 MODULE_DESCRIPTION("ALSA driver module for tm5600/tm6000/tm6010 based TV cards");
80 MODULE_AUTHOR("Mauro Carvalho Chehab <mchehab@redhat.com>");
81 MODULE_LICENSE("GPL");
82 MODULE_SUPPORTED_DEVICE("{{Trident,tm5600},"
83                         "{{Trident,tm6000},"
84                         "{{Trident,tm6010}");
85 static unsigned int debug;
86 module_param(debug, int, 0644);
87 MODULE_PARM_DESC(debug, "enable debug messages");
88
89 /****************************************************************************
90                         Module specific funtions
91  ****************************************************************************/
92
93 /*
94  * BOARD Specific: Sets audio DMA
95  */
96
97 static int _tm6000_start_audio_dma(struct snd_tm6000_card *chip)
98 {
99         struct tm6000_core *core = chip->core;
100         int val;
101
102         /* Enables audio */
103         val = tm6000_get_reg(core, TM6010_REQ07_RCC_ACTIVE_VIDEO_IF, 0x0);
104         val |= 0x20;
105         tm6000_set_reg(core, TM6010_REQ07_RCC_ACTIVE_VIDEO_IF, val);
106
107         tm6000_set_reg(core, TM6010_REQ08_R01_A_INIT, 0x80);
108
109         return 0;
110 }
111
112 /*
113  * BOARD Specific: Resets audio DMA
114  */
115 static int _tm6000_stop_audio_dma(struct snd_tm6000_card *chip)
116 {
117         struct tm6000_core *core = chip->core;
118         int val;
119         dprintk(1, "Stopping audio DMA\n");
120
121         /* Enables audio */
122         val = tm6000_get_reg(core, TM6010_REQ07_RCC_ACTIVE_VIDEO_IF, 0x0);
123         val &= ~0x20;
124         tm6000_set_reg(core, TM6010_REQ07_RCC_ACTIVE_VIDEO_IF, val);
125
126         tm6000_set_reg(core, TM6010_REQ08_R01_A_INIT, 0);
127
128         return 0;
129 }
130
131 static int dsp_buffer_free(struct snd_tm6000_card *chip)
132 {
133         BUG_ON(!chip->bufsize);
134
135         dprintk(2, "Freeing buffer\n");
136
137         /* FIXME: Frees buffer */
138
139         chip->bufsize = 0;
140
141        return 0;
142 }
143
144 /****************************************************************************
145                                 ALSA PCM Interface
146  ****************************************************************************/
147
148 /*
149  * Digital hardware definition
150  */
151 #define DEFAULT_FIFO_SIZE       4096
152
153 static struct snd_pcm_hardware snd_tm6000_digital_hw = {
154         .info = SNDRV_PCM_INFO_MMAP |
155                 SNDRV_PCM_INFO_INTERLEAVED |
156                 SNDRV_PCM_INFO_BLOCK_TRANSFER |
157                 SNDRV_PCM_INFO_MMAP_VALID,
158         .formats = SNDRV_PCM_FMTBIT_S16_LE,
159
160         .rates =                SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000,
161         .rate_min =             44100,
162         .rate_max =             48000,
163         .channels_min = 2,
164         .channels_max = 2,
165         .period_bytes_min = DEFAULT_FIFO_SIZE/4,
166         .period_bytes_max = DEFAULT_FIFO_SIZE/4,
167         .periods_min = 1,
168         .periods_max = 1024,
169         .buffer_bytes_max = (1024*1024),
170 };
171
172 /*
173  * audio pcm capture open callback
174  */
175 static int snd_tm6000_pcm_open(struct snd_pcm_substream *substream)
176 {
177         struct snd_tm6000_card *chip = snd_pcm_substream_chip(substream);
178         struct snd_pcm_runtime *runtime = substream->runtime;
179         int err;
180
181         err = snd_pcm_hw_constraint_pow2(runtime, 0,
182                                          SNDRV_PCM_HW_PARAM_PERIODS);
183         if (err < 0)
184                 goto _error;
185
186         chip->substream = substream;
187
188         runtime->hw = snd_tm6000_digital_hw;
189
190         return 0;
191 _error:
192         dprintk(1, "Error opening PCM!\n");
193         return err;
194 }
195
196 /*
197  * audio close callback
198  */
199 static int snd_tm6000_close(struct snd_pcm_substream *substream)
200 {
201         return 0;
202 }
203
204 /*
205  * hw_params callback
206  */
207 static int snd_tm6000_hw_params(struct snd_pcm_substream *substream,
208                               struct snd_pcm_hw_params *hw_params)
209 {
210         struct snd_tm6000_card *chip = snd_pcm_substream_chip(substream);
211
212         if (substream->runtime->dma_area) {
213                 dsp_buffer_free(chip);
214                 substream->runtime->dma_area = NULL;
215         }
216
217         chip->period_size = params_period_bytes(hw_params);
218         chip->num_periods = params_periods(hw_params);
219         chip->bufsize = chip->period_size * params_periods(hw_params);
220
221         BUG_ON(!chip->bufsize);
222
223         dprintk(1, "Setting buffer\n");
224
225         /* FIXME: Allocate buffer for audio */
226
227
228         return 0;
229 }
230
231 /*
232  * hw free callback
233  */
234 static int snd_tm6000_hw_free(struct snd_pcm_substream *substream)
235 {
236
237         struct snd_tm6000_card *chip = snd_pcm_substream_chip(substream);
238
239         if (substream->runtime->dma_area) {
240                 dsp_buffer_free(chip);
241                 substream->runtime->dma_area = NULL;
242         }
243
244         return 0;
245 }
246
247 /*
248  * prepare callback
249  */
250 static int snd_tm6000_prepare(struct snd_pcm_substream *substream)
251 {
252         return 0;
253 }
254
255
256 /*
257  * trigger callback
258  */
259 static int snd_tm6000_card_trigger(struct snd_pcm_substream *substream, int cmd)
260 {
261         struct snd_tm6000_card *chip = snd_pcm_substream_chip(substream);
262         int err;
263
264         spin_lock(&chip->reg_lock);
265
266         switch (cmd) {
267         case SNDRV_PCM_TRIGGER_START:
268                 err = _tm6000_start_audio_dma(chip);
269                 break;
270         case SNDRV_PCM_TRIGGER_STOP:
271                 err = _tm6000_stop_audio_dma(chip);
272                 break;
273         default:
274                 err = -EINVAL;
275                 break;
276         }
277
278         spin_unlock(&chip->reg_lock);
279
280         return err;
281 }
282
283 /*
284  * pointer callback
285  */
286 static snd_pcm_uframes_t snd_tm6000_pointer(struct snd_pcm_substream *substream)
287 {
288         struct snd_tm6000_card *chip = snd_pcm_substream_chip(substream);
289         struct snd_pcm_runtime *runtime = substream->runtime;
290         u16 count;
291
292         count = atomic_read(&chip->count);
293
294         return runtime->period_size * (count & (runtime->periods-1));
295 }
296
297 /*
298  * operators
299  */
300 static struct snd_pcm_ops snd_tm6000_pcm_ops = {
301         .open = snd_tm6000_pcm_open,
302         .close = snd_tm6000_close,
303         .ioctl = snd_pcm_lib_ioctl,
304         .hw_params = snd_tm6000_hw_params,
305         .hw_free = snd_tm6000_hw_free,
306         .prepare = snd_tm6000_prepare,
307         .trigger = snd_tm6000_card_trigger,
308         .pointer = snd_tm6000_pointer,
309 };
310
311 /*
312  * create a PCM device
313  */
314 static int __devinit snd_tm6000_pcm(struct snd_tm6000_card *chip,
315                                     int device, char *name)
316 {
317         int err;
318         struct snd_pcm *pcm;
319
320         err = snd_pcm_new(chip->card, name, device, 0, 1, &pcm);
321         if (err < 0)
322                 return err;
323         pcm->private_data = chip;
324         strcpy(pcm->name, name);
325         snd_pcm_set_ops(pcm, SNDRV_PCM_STREAM_CAPTURE, &snd_tm6000_pcm_ops);
326
327         return 0;
328 }
329
330 /* FIXME: Control interface - How to control volume/mute? */
331
332 /****************************************************************************
333                         Basic Flow for Sound Devices
334  ****************************************************************************/
335
336 /*
337  * Alsa Constructor - Component probe
338  */
339
340 int tm6000_audio_init(struct tm6000_core *dev, int idx)
341 {
342         struct snd_card         *card;
343         struct snd_tm6000_card  *chip;
344         int                     rc, len;
345         char                    component[14];
346
347         if (idx >= SNDRV_CARDS)
348                 return -ENODEV;
349
350         if (!enable[idx])
351                 return -ENOENT;
352
353         rc = snd_card_create(index[idx], id[idx], THIS_MODULE, 0, &card);
354         if (rc < 0) {
355                 snd_printk(KERN_ERR "cannot create card instance %d\n", idx);
356                 return rc;
357         }
358
359         chip = kzalloc(sizeof(*chip), GFP_KERNEL);
360         if (!chip) {
361                 rc = -ENOMEM;
362                 goto error;
363         }
364
365         chip->core = dev;
366         chip->card = card;
367
368         strcpy(card->driver, "tm6000-alsa");
369         sprintf(component, "USB%04x:%04x",
370                 le16_to_cpu(dev->udev->descriptor.idVendor),
371                 le16_to_cpu(dev->udev->descriptor.idProduct));
372         snd_component_add(card, component);
373
374         if (dev->udev->descriptor.iManufacturer)
375                 len = usb_string(dev->udev,
376                                  dev->udev->descriptor.iManufacturer,
377                                  card->longname, sizeof(card->longname));
378         else
379                 len = 0;
380
381         if (len > 0)
382                 strlcat(card->longname, " ", sizeof(card->longname));
383
384         strlcat(card->longname, card->shortname, sizeof(card->longname));
385
386         len = strlcat(card->longname, " at ", sizeof(card->longname));
387
388         if (len < sizeof(card->longname))
389                 usb_make_path(dev->udev, card->longname + len,
390                               sizeof(card->longname) - len);
391
392         strlcat(card->longname,
393                 dev->udev->speed == USB_SPEED_LOW ? ", low speed" :
394                 dev->udev->speed == USB_SPEED_FULL ? ", full speed" :
395                                                            ", high speed",
396                 sizeof(card->longname));
397
398         rc = snd_tm6000_pcm(chip, 0, "tm6000 Digital");
399         if (rc < 0)
400                 goto error;
401
402         rc = snd_card_register(card);
403         if (rc < 0)
404                 goto error;
405
406
407         return 0;
408
409 error:
410         snd_card_free(card);
411         return rc;
412 }
413
414 static int tm6000_audio_fini(struct tm6000_core *dev)
415 {
416         return 0;
417 }
418
419 struct tm6000_ops audio_ops = {
420         .id     = TM6000_AUDIO,
421         .name   = "TM6000 Audio Extension",
422         .init   = tm6000_audio_init,
423         .fini   = tm6000_audio_fini,
424 };
425
426 static int __init tm6000_alsa_register(void)
427 {
428         return tm6000_register_extension(&audio_ops);
429 }
430
431 static void __exit tm6000_alsa_unregister(void)
432 {
433         tm6000_unregister_extension(&audio_ops);
434 }
435
436 module_init(tm6000_alsa_register);
437 module_exit(tm6000_alsa_unregister);