1 /*
2 * linux/drivers/sound/vidc.c
3 *
4 * Copyright (C) 1997-2000 by Russell King <rmk@arm.linux.org.uk>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License version 2 as
8 * published by the Free Software Foundation.
9 *
10 * VIDC20 audio driver.
11 *
12 * The VIDC20 sound hardware consists of the VIDC20 itself, a DAC and a DMA
13 * engine. The DMA transfers fixed-format (16-bit little-endian linear)
14 * samples to the VIDC20, which then transfers this data serially to the
15 * DACs. The samplerate is controlled by the VIDC.
16 *
17 * We currently support a mixer device, but it is currently non-functional.
18 */
19
20 #include <linux/gfp.h>
21 #include <linux/init.h>
22 #include <linux/module.h>
23 #include <linux/kernel.h>
24 #include <linux/interrupt.h>
25
26 #include <mach/hardware.h>
27 #include <asm/dma.h>
28 #include <asm/io.h>
29 #include <asm/hardware/iomd.h>
30 #include <asm/irq.h>
31
32 #include "sound_config.h"
33 #include "vidc.h"
34
35 #ifndef _SIOC_TYPE
36 #define _SIOC_TYPE(x) _IOC_TYPE(x)
37 #endif
38 #ifndef _SIOC_NR
39 #define _SIOC_NR(x) _IOC_NR(x)
40 #endif
41
42 #define VIDC_SOUND_CLOCK (250000)
43 #define VIDC_SOUND_CLOCK_EXT (176400)
44
45 /*
46 * When using SERIAL SOUND mode (external DAC), the number of physical
47 * channels is fixed at 2.
48 */
49 static int vidc_busy;
50 static int vidc_adev;
51 static int vidc_audio_rate;
52 static char vidc_audio_format;
53 static char vidc_audio_channels;
54
55 static unsigned char vidc_level_l[SOUND_MIXER_NRDEVICES] = {
56 85, /* master */
57 50, /* bass */
58 50, /* treble */
59 0, /* synth */
60 75, /* pcm */
61 0, /* speaker */
62 100, /* ext line */
63 0, /* mic */
64 100, /* CD */
65 0,
66 };
67
68 static unsigned char vidc_level_r[SOUND_MIXER_NRDEVICES] = {
69 85, /* master */
70 50, /* bass */
71 50, /* treble */
72 0, /* synth */
73 75, /* pcm */
74 0, /* speaker */
75 100, /* ext line */
76 0, /* mic */
77 100, /* CD */
78 0,
79 };
80
81 static unsigned int vidc_audio_volume_l; /* left PCM vol, 0 - 65536 */
82 static unsigned int vidc_audio_volume_r; /* right PCM vol, 0 - 65536 */
83
84 extern void vidc_update_filler(int bits, int channels);
85 extern int softoss_dev;
86
87 static void
vidc_mixer_set(int mdev,unsigned int level)88 vidc_mixer_set(int mdev, unsigned int level)
89 {
90 unsigned int lev_l = level & 0x007f;
91 unsigned int lev_r = (level & 0x7f00) >> 8;
92 unsigned int mlev_l, mlev_r;
93
94 if (lev_l > 100)
95 lev_l = 100;
96 if (lev_r > 100)
97 lev_r = 100;
98
99 #define SCALE(lev,master) ((lev) * (master) * 65536 / 10000)
100
101 mlev_l = vidc_level_l[SOUND_MIXER_VOLUME];
102 mlev_r = vidc_level_r[SOUND_MIXER_VOLUME];
103
104 switch (mdev) {
105 case SOUND_MIXER_VOLUME:
106 case SOUND_MIXER_PCM:
107 vidc_level_l[mdev] = lev_l;
108 vidc_level_r[mdev] = lev_r;
109
110 vidc_audio_volume_l = SCALE(lev_l, mlev_l);
111 vidc_audio_volume_r = SCALE(lev_r, mlev_r);
112 /*printk("VIDC: PCM vol %05X %05X\n", vidc_audio_volume_l, vidc_audio_volume_r);*/
113 break;
114 }
115 #undef SCALE
116 }
117
vidc_mixer_ioctl(int dev,unsigned int cmd,void __user * arg)118 static int vidc_mixer_ioctl(int dev, unsigned int cmd, void __user *arg)
119 {
120 unsigned int val;
121 unsigned int mdev;
122
123 if (_SIOC_TYPE(cmd) != 'M')
124 return -EINVAL;
125
126 mdev = _SIOC_NR(cmd);
127
128 if (_SIOC_DIR(cmd) & _SIOC_WRITE) {
129 if (get_user(val, (unsigned int __user *)arg))
130 return -EFAULT;
131
132 if (mdev < SOUND_MIXER_NRDEVICES)
133 vidc_mixer_set(mdev, val);
134 else
135 return -EINVAL;
136 }
137
138 /*
139 * Return parameters
140 */
141 switch (mdev) {
142 case SOUND_MIXER_RECSRC:
143 val = 0;
144 break;
145
146 case SOUND_MIXER_DEVMASK:
147 val = SOUND_MASK_VOLUME | SOUND_MASK_PCM | SOUND_MASK_SYNTH;
148 break;
149
150 case SOUND_MIXER_STEREODEVS:
151 val = SOUND_MASK_VOLUME | SOUND_MASK_PCM | SOUND_MASK_SYNTH;
152 break;
153
154 case SOUND_MIXER_RECMASK:
155 val = 0;
156 break;
157
158 case SOUND_MIXER_CAPS:
159 val = 0;
160 break;
161
162 default:
163 if (mdev < SOUND_MIXER_NRDEVICES)
164 val = vidc_level_l[mdev] | vidc_level_r[mdev] << 8;
165 else
166 return -EINVAL;
167 }
168
169 return put_user(val, (unsigned int __user *)arg) ? -EFAULT : 0;
170 }
171
vidc_audio_set_format(int dev,unsigned int fmt)172 static unsigned int vidc_audio_set_format(int dev, unsigned int fmt)
173 {
174 switch (fmt) {
175 default:
176 fmt = AFMT_S16_LE;
177 case AFMT_U8:
178 case AFMT_S8:
179 case AFMT_S16_LE:
180 vidc_audio_format = fmt;
181 vidc_update_filler(vidc_audio_format, vidc_audio_channels);
182 case AFMT_QUERY:
183 break;
184 }
185 return vidc_audio_format;
186 }
187
188 #define my_abs(i) ((i)<0 ? -(i) : (i))
189
vidc_audio_set_speed(int dev,int rate)190 static int vidc_audio_set_speed(int dev, int rate)
191 {
192 if (rate) {
193 unsigned int hwctrl, hwrate, hwrate_ext, rate_int, rate_ext;
194 unsigned int diff_int, diff_ext;
195 unsigned int newsize, new2size;
196
197 hwctrl = 0x00000003;
198
199 /* Using internal clock */
200 hwrate = (((VIDC_SOUND_CLOCK * 2) / rate) + 1) >> 1;
201 if (hwrate < 3)
202 hwrate = 3;
203 if (hwrate > 255)
204 hwrate = 255;
205
206 /* Using exernal clock */
207 hwrate_ext = (((VIDC_SOUND_CLOCK_EXT * 2) / rate) + 1) >> 1;
208 if (hwrate_ext < 3)
209 hwrate_ext = 3;
210 if (hwrate_ext > 255)
211 hwrate_ext = 255;
212
213 rate_int = VIDC_SOUND_CLOCK / hwrate;
214 rate_ext = VIDC_SOUND_CLOCK_EXT / hwrate_ext;
215
216 /* Chose between external and internal clock */
217 diff_int = my_abs(rate_ext-rate);
218 diff_ext = my_abs(rate_int-rate);
219 if (diff_ext < diff_int) {
220 /*printk("VIDC: external %d %d %d\n", rate, rate_ext, hwrate_ext);*/
221 hwrate=hwrate_ext;
222 hwctrl=0x00000002;
223 /* Allow roughly 0.4% tolerance */
224 if (diff_ext > (rate/256))
225 rate=rate_ext;
226 } else {
227 /*printk("VIDC: internal %d %d %d\n", rate, rate_int, hwrate);*/
228 hwctrl=0x00000003;
229 /* Allow roughly 0.4% tolerance */
230 if (diff_int > (rate/256))
231 rate=rate_int;
232 }
233
234 vidc_writel(0xb0000000 | (hwrate - 2));
235 vidc_writel(0xb1000000 | hwctrl);
236
237 newsize = (10000 / hwrate) & ~3;
238 if (newsize < 208)
239 newsize = 208;
240 if (newsize > 4096)
241 newsize = 4096;
242 for (new2size = 128; new2size < newsize; new2size <<= 1);
243 if (new2size - newsize > newsize - (new2size >> 1))
244 new2size >>= 1;
245 if (new2size > 4096) {
246 printk(KERN_ERR "VIDC: error: dma buffer (%d) %d > 4K\n",
247 newsize, new2size);
248 new2size = 4096;
249 }
250 /*printk("VIDC: dma size %d\n", new2size);*/
251 dma_bufsize = new2size;
252 vidc_audio_rate = rate;
253 }
254 return vidc_audio_rate;
255 }
256
vidc_audio_set_channels(int dev,short channels)257 static short vidc_audio_set_channels(int dev, short channels)
258 {
259 switch (channels) {
260 default:
261 channels = 2;
262 case 1:
263 case 2:
264 vidc_audio_channels = channels;
265 vidc_update_filler(vidc_audio_format, vidc_audio_channels);
266 case 0:
267 break;
268 }
269 return vidc_audio_channels;
270 }
271
272 /*
273 * Open the device
274 */
vidc_audio_open(int dev,int mode)275 static int vidc_audio_open(int dev, int mode)
276 {
277 /* This audio device does not have recording capability */
278 if (mode == OPEN_READ)
279 return -EPERM;
280
281 if (vidc_busy)
282 return -EBUSY;
283
284 vidc_busy = 1;
285 return 0;
286 }
287
288 /*
289 * Close the device
290 */
vidc_audio_close(int dev)291 static void vidc_audio_close(int dev)
292 {
293 vidc_busy = 0;
294 }
295
296 /*
297 * Output a block via DMA to sound device.
298 *
299 * We just set the DMA start and count; the DMA interrupt routine
300 * will take care of formatting the samples (via the appropriate
301 * vidc_filler routine), and flag via vidc_audio_dma_interrupt when
302 * more data is required.
303 */
304 static void
vidc_audio_output_block(int dev,unsigned long buf,int total_count,int one)305 vidc_audio_output_block(int dev, unsigned long buf, int total_count, int one)
306 {
307 struct dma_buffparms *dmap = audio_devs[dev]->dmap_out;
308 unsigned long flags;
309
310 local_irq_save(flags);
311 dma_start = buf - (unsigned long)dmap->raw_buf_phys + (unsigned long)dmap->raw_buf;
312 dma_count = total_count;
313 local_irq_restore(flags);
314 }
315
316 static void
vidc_audio_start_input(int dev,unsigned long buf,int count,int intrflag)317 vidc_audio_start_input(int dev, unsigned long buf, int count, int intrflag)
318 {
319 }
320
vidc_audio_prepare_for_input(int dev,int bsize,int bcount)321 static int vidc_audio_prepare_for_input(int dev, int bsize, int bcount)
322 {
323 return -EINVAL;
324 }
325
vidc_audio_dma_interrupt(void)326 static irqreturn_t vidc_audio_dma_interrupt(void)
327 {
328 DMAbuf_outputintr(vidc_adev, 1);
329 return IRQ_HANDLED;
330 }
331
332 /*
333 * Prepare for outputting samples.
334 *
335 * Each buffer that will be passed will be `bsize' bytes long,
336 * with a total of `bcount' buffers.
337 */
vidc_audio_prepare_for_output(int dev,int bsize,int bcount)338 static int vidc_audio_prepare_for_output(int dev, int bsize, int bcount)
339 {
340 struct audio_operations *adev = audio_devs[dev];
341
342 dma_interrupt = NULL;
343 adev->dmap_out->flags |= DMA_NODMA;
344
345 return 0;
346 }
347
348 /*
349 * Stop our current operation.
350 */
vidc_audio_reset(int dev)351 static void vidc_audio_reset(int dev)
352 {
353 dma_interrupt = NULL;
354 }
355
vidc_audio_local_qlen(int dev)356 static int vidc_audio_local_qlen(int dev)
357 {
358 return /*dma_count !=*/ 0;
359 }
360
vidc_audio_trigger(int dev,int enable_bits)361 static void vidc_audio_trigger(int dev, int enable_bits)
362 {
363 struct audio_operations *adev = audio_devs[dev];
364
365 if (enable_bits & PCM_ENABLE_OUTPUT) {
366 if (!(adev->dmap_out->flags & DMA_ACTIVE)) {
367 unsigned long flags;
368
369 local_irq_save(flags);
370
371 /* prevent recusion */
372 adev->dmap_out->flags |= DMA_ACTIVE;
373
374 dma_interrupt = vidc_audio_dma_interrupt;
375 vidc_sound_dma_irq(0, NULL);
376 iomd_writeb(DMA_CR_E | 0x10, IOMD_SD0CR);
377
378 local_irq_restore(flags);
379 }
380 }
381 }
382
383 static struct audio_driver vidc_audio_driver =
384 {
385 .owner = THIS_MODULE,
386 .open = vidc_audio_open,
387 .close = vidc_audio_close,
388 .output_block = vidc_audio_output_block,
389 .start_input = vidc_audio_start_input,
390 .prepare_for_input = vidc_audio_prepare_for_input,
391 .prepare_for_output = vidc_audio_prepare_for_output,
392 .halt_io = vidc_audio_reset,
393 .local_qlen = vidc_audio_local_qlen,
394 .trigger = vidc_audio_trigger,
395 .set_speed = vidc_audio_set_speed,
396 .set_bits = vidc_audio_set_format,
397 .set_channels = vidc_audio_set_channels
398 };
399
400 static struct mixer_operations vidc_mixer_operations = {
401 .owner = THIS_MODULE,
402 .id = "VIDC",
403 .name = "VIDCsound",
404 .ioctl = vidc_mixer_ioctl
405 };
406
vidc_update_filler(int format,int channels)407 void vidc_update_filler(int format, int channels)
408 {
409 #define TYPE(fmt,ch) (((fmt)<<2) | ((ch)&3))
410
411 switch (TYPE(format, channels)) {
412 default:
413 case TYPE(AFMT_U8, 1):
414 vidc_filler = vidc_fill_1x8_u;
415 break;
416
417 case TYPE(AFMT_U8, 2):
418 vidc_filler = vidc_fill_2x8_u;
419 break;
420
421 case TYPE(AFMT_S8, 1):
422 vidc_filler = vidc_fill_1x8_s;
423 break;
424
425 case TYPE(AFMT_S8, 2):
426 vidc_filler = vidc_fill_2x8_s;
427 break;
428
429 case TYPE(AFMT_S16_LE, 1):
430 vidc_filler = vidc_fill_1x16_s;
431 break;
432
433 case TYPE(AFMT_S16_LE, 2):
434 vidc_filler = vidc_fill_2x16_s;
435 break;
436 }
437 }
438
attach_vidc(struct address_info * hw_config)439 static void __init attach_vidc(struct address_info *hw_config)
440 {
441 char name[32];
442 int i, adev;
443
444 sprintf(name, "VIDC %d-bit sound", hw_config->card_subtype);
445 conf_printf(name, hw_config);
446 memset(dma_buf, 0, sizeof(dma_buf));
447
448 adev = sound_install_audiodrv(AUDIO_DRIVER_VERSION, name,
449 &vidc_audio_driver, sizeof(vidc_audio_driver),
450 DMA_AUTOMODE, AFMT_U8 | AFMT_S8 | AFMT_S16_LE,
451 NULL, hw_config->dma, hw_config->dma2);
452
453 if (adev < 0)
454 goto audio_failed;
455
456 /*
457 * 1024 bytes => 64 buffers
458 */
459 audio_devs[adev]->min_fragment = 10;
460 audio_devs[adev]->mixer_dev = num_mixers;
461
462 audio_devs[adev]->mixer_dev =
463 sound_install_mixer(MIXER_DRIVER_VERSION,
464 name, &vidc_mixer_operations,
465 sizeof(vidc_mixer_operations), NULL);
466
467 if (audio_devs[adev]->mixer_dev < 0)
468 goto mixer_failed;
469
470 for (i = 0; i < 2; i++) {
471 dma_buf[i] = get_zeroed_page(GFP_KERNEL);
472 if (!dma_buf[i]) {
473 printk(KERN_ERR "%s: can't allocate required buffers\n",
474 name);
475 goto mem_failed;
476 }
477 dma_pbuf[i] = virt_to_phys((void *)dma_buf[i]);
478 }
479
480 if (sound_alloc_dma(hw_config->dma, hw_config->name)) {
481 printk(KERN_ERR "%s: DMA %d is in use\n", name, hw_config->dma);
482 goto dma_failed;
483 }
484
485 if (request_irq(hw_config->irq, vidc_sound_dma_irq, 0,
486 hw_config->name, &dma_start)) {
487 printk(KERN_ERR "%s: IRQ %d is in use\n", name, hw_config->irq);
488 goto irq_failed;
489 }
490 vidc_adev = adev;
491 vidc_mixer_set(SOUND_MIXER_VOLUME, (85 | 85 << 8));
492
493 return;
494
495 irq_failed:
496 sound_free_dma(hw_config->dma);
497 dma_failed:
498 mem_failed:
499 for (i = 0; i < 2; i++)
500 free_page(dma_buf[i]);
501 sound_unload_mixerdev(audio_devs[adev]->mixer_dev);
502 mixer_failed:
503 sound_unload_audiodev(adev);
504 audio_failed:
505 return;
506 }
507
probe_vidc(struct address_info * hw_config)508 static int __init probe_vidc(struct address_info *hw_config)
509 {
510 hw_config->irq = IRQ_DMAS0;
511 hw_config->dma = DMA_VIRTUAL_SOUND;
512 hw_config->dma2 = -1;
513 hw_config->card_subtype = 16;
514 hw_config->name = "VIDC20";
515 return 1;
516 }
517
unload_vidc(struct address_info * hw_config)518 static void __exit unload_vidc(struct address_info *hw_config)
519 {
520 int i, adev = vidc_adev;
521
522 vidc_adev = -1;
523
524 free_irq(hw_config->irq, &dma_start);
525 sound_free_dma(hw_config->dma);
526
527 if (adev >= 0) {
528 sound_unload_mixerdev(audio_devs[adev]->mixer_dev);
529 sound_unload_audiodev(adev);
530 for (i = 0; i < 2; i++)
531 free_page(dma_buf[i]);
532 }
533 }
534
535 static struct address_info cfg;
536
init_vidc(void)537 static int __init init_vidc(void)
538 {
539 if (probe_vidc(&cfg) == 0)
540 return -ENODEV;
541
542 attach_vidc(&cfg);
543
544 return 0;
545 }
546
cleanup_vidc(void)547 static void __exit cleanup_vidc(void)
548 {
549 unload_vidc(&cfg);
550 }
551
552 module_init(init_vidc);
553 module_exit(cleanup_vidc);
554
555 MODULE_AUTHOR("Russell King");
556 MODULE_DESCRIPTION("VIDC20 audio driver");
557 MODULE_LICENSE("GPL");
558