]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - sound/oss/dmasound/dmasound_atari.c
projects / mirror_ubuntu-artful-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge git://git.skbuff.net/gitroot/yoshfuji/linux-2.6.14+advapi-fix/
[mirror_ubuntu-artful-kernel.git] / sound / oss / dmasound / dmasound_atari.c
1 /*
2 * linux/sound/oss/dmasound/dmasound_atari.c
3 *
4 * Atari TT and Falcon DMA Sound Driver
5 *
6 * See linux/sound/oss/dmasound/dmasound_core.c for copyright and credits
7 * prior to 28/01/2001
8 *
9 * 28/01/2001 [0.1] Iain Sandoe
10 * - added versioning
11 * - put in and populated the hardware_afmts field.
12 * [0.2] - put in SNDCTL_DSP_GETCAPS value.
13 * 01/02/2001 [0.3] - put in default hard/soft settings.
14 */
15
16
17 #include <linux/module.h>
18 #include <linux/kernel.h>
19 #include <linux/init.h>
20 #include <linux/soundcard.h>
21 #include <linux/mm.h>
22 #include <linux/spinlock.h>
23 #include <linux/interrupt.h>
24
25 #include <asm/uaccess.h>
26 #include <asm/atariints.h>
27 #include <asm/atari_stram.h>
28
29 #include "dmasound.h"
30
31 #define DMASOUND_ATARI_REVISION 0
32 #define DMASOUND_ATARI_EDITION 3
33
34 extern void atari_microwire_cmd(int cmd);
35
36 static int is_falcon;
37 static int write_sq_ignore_int; /* ++TeSche: used for Falcon */
38
39 static int expand_bal; /* Balance factor for expanding (not volume!) */
40 static int expand_data; /* Data for expanding */
41
42
43 /*** Translations ************************************************************/
44
45
46 /* ++TeSche: radically changed for new expanding purposes...
47 *
48 * These two routines now deal with copying/expanding/translating the samples
49 * from user space into our buffer at the right frequency. They take care about
50 * how much data there's actually to read, how much buffer space there is and
51 * to convert samples into the right frequency/encoding. They will only work on
52 * complete samples so it may happen they leave some bytes in the input stream
53 * if the user didn't write a multiple of the current sample size. They both
54 * return the number of bytes they've used from both streams so you may detect
55 * such a situation. Luckily all programs should be able to cope with that.
56 *
57 * I think I've optimized anything as far as one can do in plain C, all
58 * variables should fit in registers and the loops are really short. There's
59 * one loop for every possible situation. Writing a more generalized and thus
60 * parameterized loop would only produce slower code. Feel free to optimize
61 * this in assembler if you like. :)
62 *
63 * I think these routines belong here because they're not yet really hardware
64 * independent, especially the fact that the Falcon can play 16bit samples
65 * only in stereo is hardcoded in both of them!
66 *
67 * ++geert: split in even more functions (one per format)
68 */
69
70 static ssize_t ata_ct_law(const u_char *userPtr, size_t userCount,
71 u_char frame[], ssize_t *frameUsed,
72 ssize_t frameLeft);
73 static ssize_t ata_ct_s8(const u_char *userPtr, size_t userCount,
74 u_char frame[], ssize_t *frameUsed,
75 ssize_t frameLeft);
76 static ssize_t ata_ct_u8(const u_char *userPtr, size_t userCount,
77 u_char frame[], ssize_t *frameUsed,
78 ssize_t frameLeft);
79 static ssize_t ata_ct_s16be(const u_char *userPtr, size_t userCount,
80 u_char frame[], ssize_t *frameUsed,
81 ssize_t frameLeft);
82 static ssize_t ata_ct_u16be(const u_char *userPtr, size_t userCount,
83 u_char frame[], ssize_t *frameUsed,
84 ssize_t frameLeft);
85 static ssize_t ata_ct_s16le(const u_char *userPtr, size_t userCount,
86 u_char frame[], ssize_t *frameUsed,
87 ssize_t frameLeft);
88 static ssize_t ata_ct_u16le(const u_char *userPtr, size_t userCount,
89 u_char frame[], ssize_t *frameUsed,
90 ssize_t frameLeft);
91 static ssize_t ata_ctx_law(const u_char *userPtr, size_t userCount,
92 u_char frame[], ssize_t *frameUsed,
93 ssize_t frameLeft);
94 static ssize_t ata_ctx_s8(const u_char *userPtr, size_t userCount,
95 u_char frame[], ssize_t *frameUsed,
96 ssize_t frameLeft);
97 static ssize_t ata_ctx_u8(const u_char *userPtr, size_t userCount,
98 u_char frame[], ssize_t *frameUsed,
99 ssize_t frameLeft);
100 static ssize_t ata_ctx_s16be(const u_char *userPtr, size_t userCount,
101 u_char frame[], ssize_t *frameUsed,
102 ssize_t frameLeft);
103 static ssize_t ata_ctx_u16be(const u_char *userPtr, size_t userCount,
104 u_char frame[], ssize_t *frameUsed,
105 ssize_t frameLeft);
106 static ssize_t ata_ctx_s16le(const u_char *userPtr, size_t userCount,
107 u_char frame[], ssize_t *frameUsed,
108 ssize_t frameLeft);
109 static ssize_t ata_ctx_u16le(const u_char *userPtr, size_t userCount,
110 u_char frame[], ssize_t *frameUsed,
111 ssize_t frameLeft);
112
113
114 /*** Low level stuff *********************************************************/
115
116
117 static void *AtaAlloc(unsigned int size, gfp_t flags);
118 static void AtaFree(void *, unsigned int size);
119 static int AtaIrqInit(void);
120 #ifdef MODULE
121 static void AtaIrqCleanUp(void);
122 #endif /* MODULE */
123 static int AtaSetBass(int bass);
124 static int AtaSetTreble(int treble);
125 static void TTSilence(void);
126 static void TTInit(void);
127 static int TTSetFormat(int format);
128 static int TTSetVolume(int volume);
129 static int TTSetGain(int gain);
130 static void FalconSilence(void);
131 static void FalconInit(void);
132 static int FalconSetFormat(int format);
133 static int FalconSetVolume(int volume);
134 static void AtaPlayNextFrame(int index);
135 static void AtaPlay(void);
136 static irqreturn_t AtaInterrupt(int irq, void *dummy, struct pt_regs *fp);
137
138 /*** Mid level stuff *********************************************************/
139
140 static void TTMixerInit(void);
141 static void FalconMixerInit(void);
142 static int AtaMixerIoctl(u_int cmd, u_long arg);
143 static int TTMixerIoctl(u_int cmd, u_long arg);
144 static int FalconMixerIoctl(u_int cmd, u_long arg);
145 static int AtaWriteSqSetup(void);
146 static int AtaSqOpen(mode_t mode);
147 static int TTStateInfo(char *buffer, size_t space);
148 static int FalconStateInfo(char *buffer, size_t space);
149
150
151 /*** Translations ************************************************************/
152
153
154 static ssize_t ata_ct_law(const u_char *userPtr, size_t userCount,
155 u_char frame[], ssize_t *frameUsed,
156 ssize_t frameLeft)
157 {
158 char *table = dmasound.soft.format == AFMT_MU_LAW ? dmasound_ulaw2dma8
159 : dmasound_alaw2dma8;
160 ssize_t count, used;
161 u_char *p = &frame[*frameUsed];
162
163 count = min_t(unsigned long, userCount, frameLeft);
164 if (dmasound.soft.stereo)
165 count &= ~1;
166 used = count;
167 while (count > 0) {
168 u_char data;
169 if (get_user(data, userPtr++))
170 return -EFAULT;
171 *p++ = table[data];
172 count--;
173 }
174 *frameUsed += used;
175 return used;
176 }
177
178
179 static ssize_t ata_ct_s8(const u_char *userPtr, size_t userCount,
180 u_char frame[], ssize_t *frameUsed,
181 ssize_t frameLeft)
182 {
183 ssize_t count, used;
184 void *p = &frame[*frameUsed];
185
186 count = min_t(unsigned long, userCount, frameLeft);
187 if (dmasound.soft.stereo)
188 count &= ~1;
189 used = count;
190 if (copy_from_user(p, userPtr, count))
191 return -EFAULT;
192 *frameUsed += used;
193 return used;
194 }
195
196
197 static ssize_t ata_ct_u8(const u_char *userPtr, size_t userCount,
198 u_char frame[], ssize_t *frameUsed,
199 ssize_t frameLeft)
200 {
201 ssize_t count, used;
202
203 if (!dmasound.soft.stereo) {
204 u_char *p = &frame[*frameUsed];
205 count = min_t(unsigned long, userCount, frameLeft);
206 used = count;
207 while (count > 0) {
208 u_char data;
209 if (get_user(data, userPtr++))
210 return -EFAULT;
211 *p++ = data ^ 0x80;
212 count--;
213 }
214 } else {
215 u_short *p = (u_short *)&frame[*frameUsed];
216 count = min_t(unsigned long, userCount, frameLeft)>>1;
217 used = count*2;
218 while (count > 0) {
219 u_short data;
220 if (get_user(data, ((u_short *)userPtr)++))
221 return -EFAULT;
222 *p++ = data ^ 0x8080;
223 count--;
224 }
225 }
226 *frameUsed += used;
227 return used;
228 }
229
230
231 static ssize_t ata_ct_s16be(const u_char *userPtr, size_t userCount,
232 u_char frame[], ssize_t *frameUsed,
233 ssize_t frameLeft)
234 {
235 ssize_t count, used;
236
237 if (!dmasound.soft.stereo) {
238 u_short *p = (u_short *)&frame[*frameUsed];
239 count = min_t(unsigned long, userCount, frameLeft)>>1;
240 used = count*2;
241 while (count > 0) {
242 u_short data;
243 if (get_user(data, ((u_short *)userPtr)++))
244 return -EFAULT;
245 *p++ = data;
246 *p++ = data;
247 count--;
248 }
249 *frameUsed += used*2;
250 } else {
251 void *p = (u_short *)&frame[*frameUsed];
252 count = min_t(unsigned long, userCount, frameLeft) & ~3;
253 used = count;
254 if (copy_from_user(p, userPtr, count))
255 return -EFAULT;
256 *frameUsed += used;
257 }
258 return used;
259 }
260
261
262 static ssize_t ata_ct_u16be(const u_char *userPtr, size_t userCount,
263 u_char frame[], ssize_t *frameUsed,
264 ssize_t frameLeft)
265 {
266 ssize_t count, used;
267
268 if (!dmasound.soft.stereo) {
269 u_short *p = (u_short *)&frame[*frameUsed];
270 count = min_t(unsigned long, userCount, frameLeft)>>1;
271 used = count*2;
272 while (count > 0) {
273 u_short data;
274 if (get_user(data, ((u_short *)userPtr)++))
275 return -EFAULT;
276 data ^= 0x8000;
277 *p++ = data;
278 *p++ = data;
279 count--;
280 }
281 *frameUsed += used*2;
282 } else {
283 u_long *p = (u_long *)&frame[*frameUsed];
284 count = min_t(unsigned long, userCount, frameLeft)>>2;
285 used = count*4;
286 while (count > 0) {
287 u_long data;
288 if (get_user(data, ((u_int *)userPtr)++))
289 return -EFAULT;
290 *p++ = data ^ 0x80008000;
291 count--;
292 }
293 *frameUsed += used;
294 }
295 return used;
296 }
297
298
299 static ssize_t ata_ct_s16le(const u_char *userPtr, size_t userCount,
300 u_char frame[], ssize_t *frameUsed,
301 ssize_t frameLeft)
302 {
303 ssize_t count, used;
304
305 count = frameLeft;
306 if (!dmasound.soft.stereo) {
307 u_short *p = (u_short *)&frame[*frameUsed];
308 count = min_t(unsigned long, userCount, frameLeft)>>1;
309 used = count*2;
310 while (count > 0) {
311 u_short data;
312 if (get_user(data, ((u_short *)userPtr)++))
313 return -EFAULT;
314 data = le2be16(data);
315 *p++ = data;
316 *p++ = data;
317 count--;
318 }
319 *frameUsed += used*2;
320 } else {
321 u_long *p = (u_long *)&frame[*frameUsed];
322 count = min_t(unsigned long, userCount, frameLeft)>>2;
323 used = count*4;
324 while (count > 0) {
325 u_long data;
326 if (get_user(data, ((u_int *)userPtr)++))
327 return -EFAULT;
328 data = le2be16dbl(data);
329 *p++ = data;
330 count--;
331 }
332 *frameUsed += used;
333 }
334 return used;
335 }
336
337
338 static ssize_t ata_ct_u16le(const u_char *userPtr, size_t userCount,
339 u_char frame[], ssize_t *frameUsed,
340 ssize_t frameLeft)
341 {
342 ssize_t count, used;
343
344 count = frameLeft;
345 if (!dmasound.soft.stereo) {
346 u_short *p = (u_short *)&frame[*frameUsed];
347 count = min_t(unsigned long, userCount, frameLeft)>>1;
348 used = count*2;
349 while (count > 0) {
350 u_short data;
351 if (get_user(data, ((u_short *)userPtr)++))
352 return -EFAULT;
353 data = le2be16(data) ^ 0x8000;
354 *p++ = data;
355 *p++ = data;
356 }
357 *frameUsed += used*2;
358 } else {
359 u_long *p = (u_long *)&frame[*frameUsed];
360 count = min_t(unsigned long, userCount, frameLeft)>>2;
361 used = count;
362 while (count > 0) {
363 u_long data;
364 if (get_user(data, ((u_int *)userPtr)++))
365 return -EFAULT;
366 data = le2be16dbl(data) ^ 0x80008000;
367 *p++ = data;
368 count--;
369 }
370 *frameUsed += used;
371 }
372 return used;
373 }
374
375
376 static ssize_t ata_ctx_law(const u_char *userPtr, size_t userCount,
377 u_char frame[], ssize_t *frameUsed,
378 ssize_t frameLeft)
379 {
380 char *table = dmasound.soft.format == AFMT_MU_LAW ? dmasound_ulaw2dma8
381 : dmasound_alaw2dma8;
382 /* this should help gcc to stuff everything into registers */
383 long bal = expand_bal;
384 long hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed;
385 ssize_t used, usedf;
386
387 used = userCount;
388 usedf = frameLeft;
389 if (!dmasound.soft.stereo) {
390 u_char *p = &frame[*frameUsed];
391 u_char data = expand_data;
392 while (frameLeft) {
393 u_char c;
394 if (bal < 0) {
395 if (!userCount)
396 break;
397 if (get_user(c, userPtr++))
398 return -EFAULT;
399 data = table[c];
400 userCount--;
401 bal += hSpeed;
402 }
403 *p++ = data;
404 frameLeft--;
405 bal -= sSpeed;
406 }
407 expand_data = data;
408 } else {
409 u_short *p = (u_short *)&frame[*frameUsed];
410 u_short data = expand_data;
411 while (frameLeft >= 2) {
412 u_char c;
413 if (bal < 0) {
414 if (userCount < 2)
415 break;
416 if (get_user(c, userPtr++))
417 return -EFAULT;
418 data = table[c] << 8;
419 if (get_user(c, userPtr++))
420 return -EFAULT;
421 data |= table[c];
422 userCount -= 2;
423 bal += hSpeed;
424 }
425 *p++ = data;
426 frameLeft -= 2;
427 bal -= sSpeed;
428 }
429 expand_data = data;
430 }
431 expand_bal = bal;
432 used -= userCount;
433 *frameUsed += usedf-frameLeft;
434 return used;
435 }
436
437
438 static ssize_t ata_ctx_s8(const u_char *userPtr, size_t userCount,
439 u_char frame[], ssize_t *frameUsed,
440 ssize_t frameLeft)
441 {
442 /* this should help gcc to stuff everything into registers */
443 long bal = expand_bal;
444 long hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed;
445 ssize_t used, usedf;
446
447 used = userCount;
448 usedf = frameLeft;
449 if (!dmasound.soft.stereo) {
450 u_char *p = &frame[*frameUsed];
451 u_char data = expand_data;
452 while (frameLeft) {
453 if (bal < 0) {
454 if (!userCount)
455 break;
456 if (get_user(data, userPtr++))
457 return -EFAULT;
458 userCount--;
459 bal += hSpeed;
460 }
461 *p++ = data;
462 frameLeft--;
463 bal -= sSpeed;
464 }
465 expand_data = data;
466 } else {
467 u_short *p = (u_short *)&frame[*frameUsed];
468 u_short data = expand_data;
469 while (frameLeft >= 2) {
470 if (bal < 0) {
471 if (userCount < 2)
472 break;
473 if (get_user(data, ((u_short *)userPtr)++))
474 return -EFAULT;
475 userCount -= 2;
476 bal += hSpeed;
477 }
478 *p++ = data;
479 frameLeft -= 2;
480 bal -= sSpeed;
481 }
482 expand_data = data;
483 }
484 expand_bal = bal;
485 used -= userCount;
486 *frameUsed += usedf-frameLeft;
487 return used;
488 }
489
490
491 static ssize_t ata_ctx_u8(const u_char *userPtr, size_t userCount,
492 u_char frame[], ssize_t *frameUsed,
493 ssize_t frameLeft)
494 {
495 /* this should help gcc to stuff everything into registers */
496 long bal = expand_bal;
497 long hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed;
498 ssize_t used, usedf;
499
500 used = userCount;
501 usedf = frameLeft;
502 if (!dmasound.soft.stereo) {
503 u_char *p = &frame[*frameUsed];
504 u_char data = expand_data;
505 while (frameLeft) {
506 if (bal < 0) {
507 if (!userCount)
508 break;
509 if (get_user(data, userPtr++))
510 return -EFAULT;
511 data ^= 0x80;
512 userCount--;
513 bal += hSpeed;
514 }
515 *p++ = data;
516 frameLeft--;
517 bal -= sSpeed;
518 }
519 expand_data = data;
520 } else {
521 u_short *p = (u_short *)&frame[*frameUsed];
522 u_short data = expand_data;
523 while (frameLeft >= 2) {
524 if (bal < 0) {
525 if (userCount < 2)
526 break;
527 if (get_user(data, ((u_short *)userPtr)++))
528 return -EFAULT;
529 data ^= 0x8080;
530 userCount -= 2;
531 bal += hSpeed;
532 }
533 *p++ = data;
534 frameLeft -= 2;
535 bal -= sSpeed;
536 }
537 expand_data = data;
538 }
539 expand_bal = bal;
540 used -= userCount;
541 *frameUsed += usedf-frameLeft;
542 return used;
543 }
544
545
546 static ssize_t ata_ctx_s16be(const u_char *userPtr, size_t userCount,
547 u_char frame[], ssize_t *frameUsed,
548 ssize_t frameLeft)
549 {
550 /* this should help gcc to stuff everything into registers */
551 long bal = expand_bal;
552 long hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed;
553 ssize_t used, usedf;
554
555 used = userCount;
556 usedf = frameLeft;
557 if (!dmasound.soft.stereo) {
558 u_short *p = (u_short *)&frame[*frameUsed];
559 u_short data = expand_data;
560 while (frameLeft >= 4) {
561 if (bal < 0) {
562 if (userCount < 2)
563 break;
564 if (get_user(data, ((u_short *)userPtr)++))
565 return -EFAULT;
566 userCount -= 2;
567 bal += hSpeed;
568 }
569 *p++ = data;
570 *p++ = data;
571 frameLeft -= 4;
572 bal -= sSpeed;
573 }
574 expand_data = data;
575 } else {
576 u_long *p = (u_long *)&frame[*frameUsed];
577 u_long data = expand_data;
578 while (frameLeft >= 4) {
579 if (bal < 0) {
580 if (userCount < 4)
581 break;
582 if (get_user(data, ((u_int *)userPtr)++))
583 return -EFAULT;
584 userCount -= 4;
585 bal += hSpeed;
586 }
587 *p++ = data;
588 frameLeft -= 4;
589 bal -= sSpeed;
590 }
591 expand_data = data;
592 }
593 expand_bal = bal;
594 used -= userCount;
595 *frameUsed += usedf-frameLeft;
596 return used;
597 }
598
599
600 static ssize_t ata_ctx_u16be(const u_char *userPtr, size_t userCount,
601 u_char frame[], ssize_t *frameUsed,
602 ssize_t frameLeft)
603 {
604 /* this should help gcc to stuff everything into registers */
605 long bal = expand_bal;
606 long hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed;
607 ssize_t used, usedf;
608
609 used = userCount;
610 usedf = frameLeft;
611 if (!dmasound.soft.stereo) {
612 u_short *p = (u_short *)&frame[*frameUsed];
613 u_short data = expand_data;
614 while (frameLeft >= 4) {
615 if (bal < 0) {
616 if (userCount < 2)
617 break;
618 if (get_user(data, ((u_short *)userPtr)++))
619 return -EFAULT;
620 data ^= 0x8000;
621 userCount -= 2;
622 bal += hSpeed;
623 }
624 *p++ = data;
625 *p++ = data;
626 frameLeft -= 4;
627 bal -= sSpeed;
628 }
629 expand_data = data;
630 } else {
631 u_long *p = (u_long *)&frame[*frameUsed];
632 u_long data = expand_data;
633 while (frameLeft >= 4) {
634 if (bal < 0) {
635 if (userCount < 4)
636 break;
637 if (get_user(data, ((u_int *)userPtr)++))
638 return -EFAULT;
639 data ^= 0x80008000;
640 userCount -= 4;
641 bal += hSpeed;
642 }
643 *p++ = data;
644 frameLeft -= 4;
645 bal -= sSpeed;
646 }
647 expand_data = data;
648 }
649 expand_bal = bal;
650 used -= userCount;
651 *frameUsed += usedf-frameLeft;
652 return used;
653 }
654
655
656 static ssize_t ata_ctx_s16le(const u_char *userPtr, size_t userCount,
657 u_char frame[], ssize_t *frameUsed,
658 ssize_t frameLeft)
659 {
660 /* this should help gcc to stuff everything into registers */
661 long bal = expand_bal;
662 long hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed;
663 ssize_t used, usedf;
664
665 used = userCount;
666 usedf = frameLeft;
667 if (!dmasound.soft.stereo) {
668 u_short *p = (u_short *)&frame[*frameUsed];
669 u_short data = expand_data;
670 while (frameLeft >= 4) {
671 if (bal < 0) {
672 if (userCount < 2)
673 break;
674 if (get_user(data, ((u_short *)userPtr)++))
675 return -EFAULT;
676 data = le2be16(data);
677 userCount -= 2;
678 bal += hSpeed;
679 }
680 *p++ = data;
681 *p++ = data;
682 frameLeft -= 4;
683 bal -= sSpeed;
684 }
685 expand_data = data;
686 } else {
687 u_long *p = (u_long *)&frame[*frameUsed];
688 u_long data = expand_data;
689 while (frameLeft >= 4) {
690 if (bal < 0) {
691 if (userCount < 4)
692 break;
693 if (get_user(data, ((u_int *)userPtr)++))
694 return -EFAULT;
695 data = le2be16dbl(data);
696 userCount -= 4;
697 bal += hSpeed;
698 }
699 *p++ = data;
700 frameLeft -= 4;
701 bal -= sSpeed;
702 }
703 expand_data = data;
704 }
705 expand_bal = bal;
706 used -= userCount;
707 *frameUsed += usedf-frameLeft;
708 return used;
709 }
710
711
712 static ssize_t ata_ctx_u16le(const u_char *userPtr, size_t userCount,
713 u_char frame[], ssize_t *frameUsed,
714 ssize_t frameLeft)
715 {
716 /* this should help gcc to stuff everything into registers */
717 long bal = expand_bal;
718 long hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed;
719 ssize_t used, usedf;
720
721 used = userCount;
722 usedf = frameLeft;
723 if (!dmasound.soft.stereo) {
724 u_short *p = (u_short *)&frame[*frameUsed];
725 u_short data = expand_data;
726 while (frameLeft >= 4) {
727 if (bal < 0) {
728 if (userCount < 2)
729 break;
730 if (get_user(data, ((u_short *)userPtr)++))
731 return -EFAULT;
732 data = le2be16(data) ^ 0x8000;
733 userCount -= 2;
734 bal += hSpeed;
735 }
736 *p++ = data;
737 *p++ = data;
738 frameLeft -= 4;
739 bal -= sSpeed;
740 }
741 expand_data = data;
742 } else {
743 u_long *p = (u_long *)&frame[*frameUsed];
744 u_long data = expand_data;
745 while (frameLeft >= 4) {
746 if (bal < 0) {
747 if (userCount < 4)
748 break;
749 if (get_user(data, ((u_int *)userPtr)++))
750 return -EFAULT;
751 data = le2be16dbl(data) ^ 0x80008000;
752 userCount -= 4;
753 bal += hSpeed;
754 }
755 *p++ = data;
756 frameLeft -= 4;
757 bal -= sSpeed;
758 }
759 expand_data = data;
760 }
761 expand_bal = bal;
762 used -= userCount;
763 *frameUsed += usedf-frameLeft;
764 return used;
765 }
766
767
768 static TRANS transTTNormal = {
769 .ct_ulaw = ata_ct_law,
770 .ct_alaw = ata_ct_law,
771 .ct_s8 = ata_ct_s8,
772 .ct_u8 = ata_ct_u8,
773 };
774
775 static TRANS transTTExpanding = {
776 .ct_ulaw = ata_ctx_law,
777 .ct_alaw = ata_ctx_law,
778 .ct_s8 = ata_ctx_s8,
779 .ct_u8 = ata_ctx_u8,
780 };
781
782 static TRANS transFalconNormal = {
783 .ct_ulaw = ata_ct_law,
784 .ct_alaw = ata_ct_law,
785 .ct_s8 = ata_ct_s8,
786 .ct_u8 = ata_ct_u8,
787 .ct_s16be = ata_ct_s16be,
788 .ct_u16be = ata_ct_u16be,
789 .ct_s16le = ata_ct_s16le,
790 .ct_u16le = ata_ct_u16le
791 };
792
793 static TRANS transFalconExpanding = {
794 .ct_ulaw = ata_ctx_law,
795 .ct_alaw = ata_ctx_law,
796 .ct_s8 = ata_ctx_s8,
797 .ct_u8 = ata_ctx_u8,
798 .ct_s16be = ata_ctx_s16be,
799 .ct_u16be = ata_ctx_u16be,
800 .ct_s16le = ata_ctx_s16le,
801 .ct_u16le = ata_ctx_u16le,
802 };
803
804
805 /*** Low level stuff *********************************************************/
806
807
808
809 /*
810 * Atari (TT/Falcon)
811 */
812
813 static void *AtaAlloc(unsigned int size, gfp_t flags)
814 {
815 return atari_stram_alloc(size, "dmasound");
816 }
817
818 static void AtaFree(void *obj, unsigned int size)
819 {
820 atari_stram_free( obj );
821 }
822
823 static int __init AtaIrqInit(void)
824 {
825 /* Set up timer A. Timer A
826 will receive a signal upon end of playing from the sound
827 hardware. Furthermore Timer A is able to count events
828 and will cause an interrupt after a programmed number
829 of events. So all we need to keep the music playing is
830 to provide the sound hardware with new data upon
831 an interrupt from timer A. */
832 mfp.tim_ct_a = 0; /* ++roman: Stop timer before programming! */
833 mfp.tim_dt_a = 1; /* Cause interrupt after first event. */
834 mfp.tim_ct_a = 8; /* Turn on event counting. */
835 /* Register interrupt handler. */
836 request_irq(IRQ_MFP_TIMA, AtaInterrupt, IRQ_TYPE_SLOW, "DMA sound",
837 AtaInterrupt);
838 mfp.int_en_a |= 0x20; /* Turn interrupt on. */
839 mfp.int_mk_a |= 0x20;
840 return 1;
841 }
842
843 #ifdef MODULE
844 static void AtaIrqCleanUp(void)
845 {
846 mfp.tim_ct_a = 0; /* stop timer */
847 mfp.int_en_a &= ~0x20; /* turn interrupt off */
848 free_irq(IRQ_MFP_TIMA, AtaInterrupt);
849 }
850 #endif /* MODULE */
851
852
853 #define TONE_VOXWARE_TO_DB(v) \
854 (((v) < 0) ? -12 : ((v) > 100) ? 12 : ((v) - 50) * 6 / 25)
855 #define TONE_DB_TO_VOXWARE(v) (((v) * 25 + ((v) > 0 ? 5 : -5)) / 6 + 50)
856
857
858 static int AtaSetBass(int bass)
859 {
860 dmasound.bass = TONE_VOXWARE_TO_DB(bass);
861 atari_microwire_cmd(MW_LM1992_BASS(dmasound.bass));
862 return TONE_DB_TO_VOXWARE(dmasound.bass);
863 }
864
865
866 static int AtaSetTreble(int treble)
867 {
868 dmasound.treble = TONE_VOXWARE_TO_DB(treble);
869 atari_microwire_cmd(MW_LM1992_TREBLE(dmasound.treble));
870 return TONE_DB_TO_VOXWARE(dmasound.treble);
871 }
872
873
874
875 /*
876 * TT
877 */
878
879
880 static void TTSilence(void)
881 {
882 tt_dmasnd.ctrl = DMASND_CTRL_OFF;
883 atari_microwire_cmd(MW_LM1992_PSG_HIGH); /* mix in PSG signal 1:1 */
884 }
885
886
887 static void TTInit(void)
888 {
889 int mode, i, idx;
890 const int freq[4] = {50066, 25033, 12517, 6258};
891
892 /* search a frequency that fits into the allowed error range */
893
894 idx = -1;
895 for (i = 0; i < ARRAY_SIZE(freq); i++)
896 /* this isn't as much useful for a TT than for a Falcon, but
897 * then it doesn't hurt very much to implement it for a TT too.
898 */
899 if ((100 * abs(dmasound.soft.speed - freq[i]) / freq[i]) < catchRadius)
900 idx = i;
901 if (idx > -1) {
902 dmasound.soft.speed = freq[idx];
903 dmasound.trans_write = &transTTNormal;
904 } else
905 dmasound.trans_write = &transTTExpanding;
906
907 TTSilence();
908 dmasound.hard = dmasound.soft;
909
910 if (dmasound.hard.speed > 50066) {
911 /* we would need to squeeze the sound, but we won't do that */
912 dmasound.hard.speed = 50066;
913 mode = DMASND_MODE_50KHZ;
914 dmasound.trans_write = &transTTNormal;
915 } else if (dmasound.hard.speed > 25033) {
916 dmasound.hard.speed = 50066;
917 mode = DMASND_MODE_50KHZ;
918 } else if (dmasound.hard.speed > 12517) {
919 dmasound.hard.speed = 25033;
920 mode = DMASND_MODE_25KHZ;
921 } else if (dmasound.hard.speed > 6258) {
922 dmasound.hard.speed = 12517;
923 mode = DMASND_MODE_12KHZ;
924 } else {
925 dmasound.hard.speed = 6258;
926 mode = DMASND_MODE_6KHZ;
927 }
928
929 tt_dmasnd.mode = (dmasound.hard.stereo ?
930 DMASND_MODE_STEREO : DMASND_MODE_MONO) |
931 DMASND_MODE_8BIT | mode;
932
933 expand_bal = -dmasound.soft.speed;
934 }
935
936
937 static int TTSetFormat(int format)
938 {
939 /* TT sound DMA supports only 8bit modes */
940
941 switch (format) {
942 case AFMT_QUERY:
943 return dmasound.soft.format;
944 case AFMT_MU_LAW:
945 case AFMT_A_LAW:
946 case AFMT_S8:
947 case AFMT_U8:
948 break;
949 default:
950 format = AFMT_S8;
951 }
952
953 dmasound.soft.format = format;
954 dmasound.soft.size = 8;
955 if (dmasound.minDev == SND_DEV_DSP) {
956 dmasound.dsp.format = format;
957 dmasound.dsp.size = 8;
958 }
959 TTInit();
960
961 return format;
962 }
963
964
965 #define VOLUME_VOXWARE_TO_DB(v) \
966 (((v) < 0) ? -40 : ((v) > 100) ? 0 : ((v) * 2) / 5 - 40)
967 #define VOLUME_DB_TO_VOXWARE(v) ((((v) + 40) * 5 + 1) / 2)
968
969
970 static int TTSetVolume(int volume)
971 {
972 dmasound.volume_left = VOLUME_VOXWARE_TO_DB(volume & 0xff);
973 atari_microwire_cmd(MW_LM1992_BALLEFT(dmasound.volume_left));
974 dmasound.volume_right = VOLUME_VOXWARE_TO_DB((volume & 0xff00) >> 8);
975 atari_microwire_cmd(MW_LM1992_BALRIGHT(dmasound.volume_right));
976 return VOLUME_DB_TO_VOXWARE(dmasound.volume_left) |
977 (VOLUME_DB_TO_VOXWARE(dmasound.volume_right) << 8);
978 }
979
980
981 #define GAIN_VOXWARE_TO_DB(v) \
982 (((v) < 0) ? -80 : ((v) > 100) ? 0 : ((v) * 4) / 5 - 80)
983 #define GAIN_DB_TO_VOXWARE(v) ((((v) + 80) * 5 + 1) / 4)
984
985 static int TTSetGain(int gain)
986 {
987 dmasound.gain = GAIN_VOXWARE_TO_DB(gain);
988 atari_microwire_cmd(MW_LM1992_VOLUME(dmasound.gain));
989 return GAIN_DB_TO_VOXWARE(dmasound.gain);
990 }
991
992
993
994 /*
995 * Falcon
996 */
997
998
999 static void FalconSilence(void)
1000 {
1001 /* stop playback, set sample rate 50kHz for PSG sound */
1002 tt_dmasnd.ctrl = DMASND_CTRL_OFF;
1003 tt_dmasnd.mode = DMASND_MODE_50KHZ | DMASND_MODE_STEREO | DMASND_MODE_8BIT;
1004 tt_dmasnd.int_div = 0; /* STE compatible divider */
1005 tt_dmasnd.int_ctrl = 0x0;
1006 tt_dmasnd.cbar_src = 0x0000; /* no matrix inputs */
1007 tt_dmasnd.cbar_dst = 0x0000; /* no matrix outputs */
1008 tt_dmasnd.dac_src = 1; /* connect ADC to DAC, disconnect matrix */
1009 tt_dmasnd.adc_src = 3; /* ADC Input = PSG */
1010 }
1011
1012
1013 static void FalconInit(void)
1014 {
1015 int divider, i, idx;
1016 const int freq[8] = {49170, 32780, 24585, 19668, 16390, 12292, 9834, 8195};
1017
1018 /* search a frequency that fits into the allowed error range */
1019
1020 idx = -1;
1021 for (i = 0; i < ARRAY_SIZE(freq); i++)
1022 /* if we will tolerate 3% error 8000Hz->8195Hz (2.38%) would
1023 * be playable without expanding, but that now a kernel runtime
1024 * option
1025 */
1026 if ((100 * abs(dmasound.soft.speed - freq[i]) / freq[i]) < catchRadius)
1027 idx = i;
1028 if (idx > -1) {
1029 dmasound.soft.speed = freq[idx];
1030 dmasound.trans_write = &transFalconNormal;
1031 } else
1032 dmasound.trans_write = &transFalconExpanding;
1033
1034 FalconSilence();
1035 dmasound.hard = dmasound.soft;
1036
1037 if (dmasound.hard.size == 16) {
1038 /* the Falcon can play 16bit samples only in stereo */
1039 dmasound.hard.stereo = 1;
1040 }
1041
1042 if (dmasound.hard.speed > 49170) {
1043 /* we would need to squeeze the sound, but we won't do that */
1044 dmasound.hard.speed = 49170;
1045 divider = 1;
1046 dmasound.trans_write = &transFalconNormal;
1047 } else if (dmasound.hard.speed > 32780) {
1048 dmasound.hard.speed = 49170;
1049 divider = 1;
1050 } else if (dmasound.hard.speed > 24585) {
1051 dmasound.hard.speed = 32780;
1052 divider = 2;
1053 } else if (dmasound.hard.speed > 19668) {
1054 dmasound.hard.speed = 24585;
1055 divider = 3;
1056 } else if (dmasound.hard.speed > 16390) {
1057 dmasound.hard.speed = 19668;
1058 divider = 4;
1059 } else if (dmasound.hard.speed > 12292) {
1060 dmasound.hard.speed = 16390;
1061 divider = 5;
1062 } else if (dmasound.hard.speed > 9834) {
1063 dmasound.hard.speed = 12292;
1064 divider = 7;
1065 } else if (dmasound.hard.speed > 8195) {
1066 dmasound.hard.speed = 9834;
1067 divider = 9;
1068 } else {
1069 dmasound.hard.speed = 8195;
1070 divider = 11;
1071 }
1072 tt_dmasnd.int_div = divider;
1073
1074 /* Setup Falcon sound DMA for playback */
1075 tt_dmasnd.int_ctrl = 0x4; /* Timer A int at play end */
1076 tt_dmasnd.track_select = 0x0; /* play 1 track, track 1 */
1077 tt_dmasnd.cbar_src = 0x0001; /* DMA(25MHz) --> DAC */
1078 tt_dmasnd.cbar_dst = 0x0000;
1079 tt_dmasnd.rec_track_select = 0;
1080 tt_dmasnd.dac_src = 2; /* connect matrix to DAC */
1081 tt_dmasnd.adc_src = 0; /* ADC Input = Mic */
1082
1083 tt_dmasnd.mode = (dmasound.hard.stereo ?
1084 DMASND_MODE_STEREO : DMASND_MODE_MONO) |
1085 ((dmasound.hard.size == 8) ?
1086 DMASND_MODE_8BIT : DMASND_MODE_16BIT) |
1087 DMASND_MODE_6KHZ;
1088
1089 expand_bal = -dmasound.soft.speed;
1090 }
1091
1092
1093 static int FalconSetFormat(int format)
1094 {
1095 int size;
1096 /* Falcon sound DMA supports 8bit and 16bit modes */
1097
1098 switch (format) {
1099 case AFMT_QUERY:
1100 return dmasound.soft.format;
1101 case AFMT_MU_LAW:
1102 case AFMT_A_LAW:
1103 case AFMT_U8:
1104 case AFMT_S8:
1105 size = 8;
1106 break;
1107 case AFMT_S16_BE:
1108 case AFMT_U16_BE:
1109 case AFMT_S16_LE:
1110 case AFMT_U16_LE:
1111 size = 16;
1112 break;
1113 default: /* :-) */
1114 size = 8;
1115 format = AFMT_S8;
1116 }
1117
1118 dmasound.soft.format = format;
1119 dmasound.soft.size = size;
1120 if (dmasound.minDev == SND_DEV_DSP) {
1121 dmasound.dsp.format = format;
1122 dmasound.dsp.size = dmasound.soft.size;
1123 }
1124
1125 FalconInit();
1126
1127 return format;
1128 }
1129
1130
1131 /* This is for the Falcon output *attenuation* in 1.5dB steps,
1132 * i.e. output level from 0 to -22.5dB in -1.5dB steps.
1133 */
1134 #define VOLUME_VOXWARE_TO_ATT(v) \
1135 ((v) < 0 ? 15 : (v) > 100 ? 0 : 15 - (v) * 3 / 20)
1136 #define VOLUME_ATT_TO_VOXWARE(v) (100 - (v) * 20 / 3)
1137
1138
1139 static int FalconSetVolume(int volume)
1140 {
1141 dmasound.volume_left = VOLUME_VOXWARE_TO_ATT(volume & 0xff);
1142 dmasound.volume_right = VOLUME_VOXWARE_TO_ATT((volume & 0xff00) >> 8);
1143 tt_dmasnd.output_atten = dmasound.volume_left << 8 | dmasound.volume_right << 4;
1144 return VOLUME_ATT_TO_VOXWARE(dmasound.volume_left) |
1145 VOLUME_ATT_TO_VOXWARE(dmasound.volume_right) << 8;
1146 }
1147
1148
1149 static void AtaPlayNextFrame(int index)
1150 {
1151 char *start, *end;
1152
1153 /* used by AtaPlay() if all doubts whether there really is something
1154 * to be played are already wiped out.
1155 */
1156 start = write_sq.buffers[write_sq.front];
1157 end = start+((write_sq.count == index) ? write_sq.rear_size
1158 : write_sq.block_size);
1159 /* end might not be a legal virtual address. */
1160 DMASNDSetEnd(virt_to_phys(end - 1) + 1);
1161 DMASNDSetBase(virt_to_phys(start));
1162 /* Since only an even number of samples per frame can
1163 be played, we might lose one byte here. (TO DO) */
1164 write_sq.front = (write_sq.front+1) % write_sq.max_count;
1165 write_sq.active++;
1166 tt_dmasnd.ctrl = DMASND_CTRL_ON | DMASND_CTRL_REPEAT;
1167 }
1168
1169
1170 static void AtaPlay(void)
1171 {
1172 /* ++TeSche: Note that write_sq.active is no longer just a flag but
1173 * holds the number of frames the DMA is currently programmed for
1174 * instead, may be 0, 1 (currently being played) or 2 (pre-programmed).
1175 *
1176 * Changes done to write_sq.count and write_sq.active are a bit more
1177 * subtle again so now I must admit I also prefer disabling the irq
1178 * here rather than considering all possible situations. But the point
1179 * is that disabling the irq doesn't have any bad influence on this
1180 * version of the driver as we benefit from having pre-programmed the
1181 * DMA wherever possible: There's no need to reload the DMA at the
1182 * exact time of an interrupt but only at some time while the
1183 * pre-programmed frame is playing!
1184 */
1185 atari_disable_irq(IRQ_MFP_TIMA);
1186
1187 if (write_sq.active == 2 || /* DMA is 'full' */
1188 write_sq.count <= 0) { /* nothing to do */
1189 atari_enable_irq(IRQ_MFP_TIMA);
1190 return;
1191 }
1192
1193 if (write_sq.active == 0) {
1194 /* looks like there's nothing 'in' the DMA yet, so try
1195 * to put two frames into it (at least one is available).
1196 */
1197 if (write_sq.count == 1 &&
1198 write_sq.rear_size < write_sq.block_size &&
1199 !write_sq.syncing) {
1200 /* hmmm, the only existing frame is not
1201 * yet filled and we're not syncing?
1202 */
1203 atari_enable_irq(IRQ_MFP_TIMA);
1204 return;
1205 }
1206 AtaPlayNextFrame(1);
1207 if (write_sq.count == 1) {
1208 /* no more frames */
1209 atari_enable_irq(IRQ_MFP_TIMA);
1210 return;
1211 }
1212 if (write_sq.count == 2 &&
1213 write_sq.rear_size < write_sq.block_size &&
1214 !write_sq.syncing) {
1215 /* hmmm, there were two frames, but the second
1216 * one is not yet filled and we're not syncing?
1217 */
1218 atari_enable_irq(IRQ_MFP_TIMA);
1219 return;
1220 }
1221 AtaPlayNextFrame(2);
1222 } else {
1223 /* there's already a frame being played so we may only stuff
1224 * one new into the DMA, but even if this may be the last
1225 * frame existing the previous one is still on write_sq.count.
1226 */
1227 if (write_sq.count == 2 &&
1228 write_sq.rear_size < write_sq.block_size &&
1229 !write_sq.syncing) {
1230 /* hmmm, the only existing frame is not
1231 * yet filled and we're not syncing?
1232 */
1233 atari_enable_irq(IRQ_MFP_TIMA);
1234 return;
1235 }
1236 AtaPlayNextFrame(2);
1237 }
1238 atari_enable_irq(IRQ_MFP_TIMA);
1239 }
1240
1241
1242 static irqreturn_t AtaInterrupt(int irq, void *dummy, struct pt_regs *fp)
1243 {
1244 #if 0
1245 /* ++TeSche: if you should want to test this... */
1246 static int cnt;
1247 if (write_sq.active == 2)
1248 if (++cnt == 10) {
1249 /* simulate losing an interrupt */
1250 cnt = 0;
1251 return IRQ_HANDLED;
1252 }
1253 #endif
1254 spin_lock(&dmasound.lock);
1255 if (write_sq_ignore_int && is_falcon) {
1256 /* ++TeSche: Falcon only: ignore first irq because it comes
1257 * immediately after starting a frame. after that, irqs come
1258 * (almost) like on the TT.
1259 */
1260 write_sq_ignore_int = 0;
1261 return IRQ_HANDLED;
1262 }
1263
1264 if (!write_sq.active) {
1265 /* playing was interrupted and sq_reset() has already cleared
1266 * the sq variables, so better don't do anything here.
1267 */
1268 WAKE_UP(write_sq.sync_queue);
1269 return IRQ_HANDLED;
1270 }
1271
1272 /* Probably ;) one frame is finished. Well, in fact it may be that a
1273 * pre-programmed one is also finished because there has been a long
1274 * delay in interrupt delivery and we've completely lost one, but
1275 * there's no way to detect such a situation. In such a case the last
1276 * frame will be played more than once and the situation will recover
1277 * as soon as the irq gets through.
1278 */
1279 write_sq.count--;
1280 write_sq.active--;
1281
1282 if (!write_sq.active) {
1283 tt_dmasnd.ctrl = DMASND_CTRL_OFF;
1284 write_sq_ignore_int = 1;
1285 }
1286
1287 WAKE_UP(write_sq.action_queue);
1288 /* At least one block of the queue is free now
1289 so wake up a writing process blocked because
1290 of a full queue. */
1291
1292 if ((write_sq.active != 1) || (write_sq.count != 1))
1293 /* We must be a bit carefully here: write_sq.count indicates the
1294 * number of buffers used and not the number of frames to be
1295 * played. If write_sq.count==1 and write_sq.active==1 that
1296 * means the only remaining frame was already programmed
1297 * earlier (and is currently running) so we mustn't call
1298 * AtaPlay() here, otherwise we'll play one frame too much.
1299 */
1300 AtaPlay();
1301
1302 if (!write_sq.active) WAKE_UP(write_sq.sync_queue);
1303 /* We are not playing after AtaPlay(), so there
1304 is nothing to play any more. Wake up a process
1305 waiting for audio output to drain. */
1306 spin_unlock(&dmasound.lock);
1307 return IRQ_HANDLED;
1308 }
1309
1310
1311 /*** Mid level stuff *********************************************************/
1312
1313
1314 /*
1315 * /dev/mixer abstraction
1316 */
1317
1318 #define RECLEVEL_VOXWARE_TO_GAIN(v) \
1319 ((v) < 0 ? 0 : (v) > 100 ? 15 : (v) * 3 / 20)
1320 #define RECLEVEL_GAIN_TO_VOXWARE(v) (((v) * 20 + 2) / 3)
1321
1322
1323 static void __init TTMixerInit(void)
1324 {
1325 atari_microwire_cmd(MW_LM1992_VOLUME(0));
1326 dmasound.volume_left = 0;
1327 atari_microwire_cmd(MW_LM1992_BALLEFT(0));
1328 dmasound.volume_right = 0;
1329 atari_microwire_cmd(MW_LM1992_BALRIGHT(0));
1330 atari_microwire_cmd(MW_LM1992_TREBLE(0));
1331 atari_microwire_cmd(MW_LM1992_BASS(0));
1332 }
1333
1334 static void __init FalconMixerInit(void)
1335 {
1336 dmasound.volume_left = (tt_dmasnd.output_atten & 0xf00) >> 8;
1337 dmasound.volume_right = (tt_dmasnd.output_atten & 0xf0) >> 4;
1338 }
1339
1340 static int AtaMixerIoctl(u_int cmd, u_long arg)
1341 {
1342 int data;
1343 unsigned long flags;
1344 switch (cmd) {
1345 case SOUND_MIXER_READ_SPEAKER:
1346 if (is_falcon || MACH_IS_TT) {
1347 int porta;
1348 spin_lock_irqsave(&dmasound.lock, flags);
1349 sound_ym.rd_data_reg_sel = 14;
1350 porta = sound_ym.rd_data_reg_sel;
1351 spin_unlock_irqrestore(&dmasound.lock, flags);
1352 return IOCTL_OUT(arg, porta & 0x40 ? 0 : 100);
1353 }
1354 break;
1355 case SOUND_MIXER_WRITE_VOLUME:
1356 IOCTL_IN(arg, data);
1357 return IOCTL_OUT(arg, dmasound_set_volume(data));
1358 case SOUND_MIXER_WRITE_SPEAKER:
1359 if (is_falcon || MACH_IS_TT) {
1360 int porta;
1361 IOCTL_IN(arg, data);
1362 spin_lock_irqsave(&dmasound.lock, flags);
1363 sound_ym.rd_data_reg_sel = 14;
1364 porta = (sound_ym.rd_data_reg_sel & ~0x40) |
1365 (data < 50 ? 0x40 : 0);
1366 sound_ym.wd_data = porta;
1367 spin_unlock_irqrestore(&dmasound.lock, flags);
1368 return IOCTL_OUT(arg, porta & 0x40 ? 0 : 100);
1369 }
1370 }
1371 return -EINVAL;
1372 }
1373
1374
1375 static int TTMixerIoctl(u_int cmd, u_long arg)
1376 {
1377 int data;
1378 switch (cmd) {
1379 case SOUND_MIXER_READ_RECMASK:
1380 return IOCTL_OUT(arg, 0);
1381 case SOUND_MIXER_READ_DEVMASK:
1382 return IOCTL_OUT(arg,
1383 SOUND_MASK_VOLUME | SOUND_MASK_TREBLE | SOUND_MASK_BASS |
1384 (MACH_IS_TT ? SOUND_MASK_SPEAKER : 0));
1385 case SOUND_MIXER_READ_STEREODEVS:
1386 return IOCTL_OUT(arg, SOUND_MASK_VOLUME);
1387 case SOUND_MIXER_READ_VOLUME:
1388 return IOCTL_OUT(arg,
1389 VOLUME_DB_TO_VOXWARE(dmasound.volume_left) |
1390 (VOLUME_DB_TO_VOXWARE(dmasound.volume_right) << 8));
1391 case SOUND_MIXER_READ_BASS:
1392 return IOCTL_OUT(arg, TONE_DB_TO_VOXWARE(dmasound.bass));
1393 case SOUND_MIXER_READ_TREBLE:
1394 return IOCTL_OUT(arg, TONE_DB_TO_VOXWARE(dmasound.treble));
1395 case SOUND_MIXER_READ_OGAIN:
1396 return IOCTL_OUT(arg, GAIN_DB_TO_VOXWARE(dmasound.gain));
1397 case SOUND_MIXER_WRITE_BASS:
1398 IOCTL_IN(arg, data);
1399 return IOCTL_OUT(arg, dmasound_set_bass(data));
1400 case SOUND_MIXER_WRITE_TREBLE:
1401 IOCTL_IN(arg, data);
1402 return IOCTL_OUT(arg, dmasound_set_treble(data));
1403 case SOUND_MIXER_WRITE_OGAIN:
1404 IOCTL_IN(arg, data);
1405 return IOCTL_OUT(arg, dmasound_set_gain(data));
1406 }
1407 return AtaMixerIoctl(cmd, arg);
1408 }
1409
1410 static int FalconMixerIoctl(u_int cmd, u_long arg)
1411 {
1412 int data;
1413 switch (cmd) {
1414 case SOUND_MIXER_READ_RECMASK:
1415 return IOCTL_OUT(arg, SOUND_MASK_MIC);
1416 case SOUND_MIXER_READ_DEVMASK:
1417 return IOCTL_OUT(arg, SOUND_MASK_VOLUME | SOUND_MASK_MIC | SOUND_MASK_SPEAKER);
1418 case SOUND_MIXER_READ_STEREODEVS:
1419 return IOCTL_OUT(arg, SOUND_MASK_VOLUME | SOUND_MASK_MIC);
1420 case SOUND_MIXER_READ_VOLUME:
1421 return IOCTL_OUT(arg,
1422 VOLUME_ATT_TO_VOXWARE(dmasound.volume_left) |
1423 VOLUME_ATT_TO_VOXWARE(dmasound.volume_right) << 8);
1424 case SOUND_MIXER_READ_CAPS:
1425 return IOCTL_OUT(arg, SOUND_CAP_EXCL_INPUT);
1426 case SOUND_MIXER_WRITE_MIC:
1427 IOCTL_IN(arg, data);
1428 tt_dmasnd.input_gain =
1429 RECLEVEL_VOXWARE_TO_GAIN(data & 0xff) << 4 |
1430 RECLEVEL_VOXWARE_TO_GAIN(data >> 8 & 0xff);
1431 /* fall thru, return set value */
1432 case SOUND_MIXER_READ_MIC:
1433 return IOCTL_OUT(arg,
1434 RECLEVEL_GAIN_TO_VOXWARE(tt_dmasnd.input_gain >> 4 & 0xf) |
1435 RECLEVEL_GAIN_TO_VOXWARE(tt_dmasnd.input_gain & 0xf) << 8);
1436 }
1437 return AtaMixerIoctl(cmd, arg);
1438 }
1439
1440 static int AtaWriteSqSetup(void)
1441 {
1442 write_sq_ignore_int = 0;
1443 return 0 ;
1444 }
1445
1446 static int AtaSqOpen(mode_t mode)
1447 {
1448 write_sq_ignore_int = 1;
1449 return 0 ;
1450 }
1451
1452 static int TTStateInfo(char *buffer, size_t space)
1453 {
1454 int len = 0;
1455 len += sprintf(buffer+len, "\tvol left %ddB [-40... 0]\n",
1456 dmasound.volume_left);
1457 len += sprintf(buffer+len, "\tvol right %ddB [-40... 0]\n",
1458 dmasound.volume_right);
1459 len += sprintf(buffer+len, "\tbass %ddB [-12...+12]\n",
1460 dmasound.bass);
1461 len += sprintf(buffer+len, "\ttreble %ddB [-12...+12]\n",
1462 dmasound.treble);
1463 if (len >= space) {
1464 printk(KERN_ERR "dmasound_atari: overflowed state buffer alloc.\n") ;
1465 len = space ;
1466 }
1467 return len;
1468 }
1469
1470 static int FalconStateInfo(char *buffer, size_t space)
1471 {
1472 int len = 0;
1473 len += sprintf(buffer+len, "\tvol left %ddB [-22.5 ... 0]\n",
1474 dmasound.volume_left);
1475 len += sprintf(buffer+len, "\tvol right %ddB [-22.5 ... 0]\n",
1476 dmasound.volume_right);
1477 if (len >= space) {
1478 printk(KERN_ERR "dmasound_atari: overflowed state buffer alloc.\n") ;
1479 len = space ;
1480 }
1481 return len;
1482 }
1483
1484
1485 /*** Machine definitions *****************************************************/
1486
1487 static SETTINGS def_hard_falcon = {
1488 .format = AFMT_S8,
1489 .stereo = 0,
1490 .size = 8,
1491 .speed = 8195
1492 } ;
1493
1494 static SETTINGS def_hard_tt = {
1495 .format = AFMT_S8,
1496 .stereo = 0,
1497 .size = 8,
1498 .speed = 12517
1499 } ;
1500
1501 static SETTINGS def_soft = {
1502 .format = AFMT_U8,
1503 .stereo = 0,
1504 .size = 8,
1505 .speed = 8000
1506 } ;
1507
1508 static MACHINE machTT = {
1509 .name = "Atari",
1510 .name2 = "TT",
1511 .owner = THIS_MODULE,
1512 .dma_alloc = AtaAlloc,
1513 .dma_free = AtaFree,
1514 .irqinit = AtaIrqInit,
1515 #ifdef MODULE
1516 .irqcleanup = AtaIrqCleanUp,
1517 #endif /* MODULE */
1518 .init = TTInit,
1519 .silence = TTSilence,
1520 .setFormat = TTSetFormat,
1521 .setVolume = TTSetVolume,
1522 .setBass = AtaSetBass,
1523 .setTreble = AtaSetTreble,
1524 .setGain = TTSetGain,
1525 .play = AtaPlay,
1526 .mixer_init = TTMixerInit,
1527 .mixer_ioctl = TTMixerIoctl,
1528 .write_sq_setup = AtaWriteSqSetup,
1529 .sq_open = AtaSqOpen,
1530 .state_info = TTStateInfo,
1531 .min_dsp_speed = 6258,
1532 .version = ((DMASOUND_ATARI_REVISION<<8) | DMASOUND_ATARI_EDITION),
1533 .hardware_afmts = AFMT_S8, /* h'ware-supported formats *only* here */
1534 .capabilities = DSP_CAP_BATCH /* As per SNDCTL_DSP_GETCAPS */
1535 };
1536
1537 static MACHINE machFalcon = {
1538 .name = "Atari",
1539 .name2 = "FALCON",
1540 .dma_alloc = AtaAlloc,
1541 .dma_free = AtaFree,
1542 .irqinit = AtaIrqInit,
1543 #ifdef MODULE
1544 .irqcleanup = AtaIrqCleanUp,
1545 #endif /* MODULE */
1546 .init = FalconInit,
1547 .silence = FalconSilence,
1548 .setFormat = FalconSetFormat,
1549 .setVolume = FalconSetVolume,
1550 .setBass = AtaSetBass,
1551 .setTreble = AtaSetTreble,
1552 .play = AtaPlay,
1553 .mixer_init = FalconMixerInit,
1554 .mixer_ioctl = FalconMixerIoctl,
1555 .write_sq_setup = AtaWriteSqSetup,
1556 .sq_open = AtaSqOpen,
1557 .state_info = FalconStateInfo,
1558 .min_dsp_speed = 8195,
1559 .version = ((DMASOUND_ATARI_REVISION<<8) | DMASOUND_ATARI_EDITION),
1560 .hardware_afmts = (AFMT_S8 | AFMT_S16_BE), /* h'ware-supported formats *only* here */
1561 .capabilities = DSP_CAP_BATCH /* As per SNDCTL_DSP_GETCAPS */
1562 };
1563
1564
1565 /*** Config & Setup **********************************************************/
1566
1567
1568 static int __init dmasound_atari_init(void)
1569 {
1570 if (MACH_IS_ATARI && ATARIHW_PRESENT(PCM_8BIT)) {
1571 if (ATARIHW_PRESENT(CODEC)) {
1572 dmasound.mach = machFalcon;
1573 dmasound.mach.default_soft = def_soft ;
1574 dmasound.mach.default_hard = def_hard_falcon ;
1575 is_falcon = 1;
1576 } else if (ATARIHW_PRESENT(MICROWIRE)) {
1577 dmasound.mach = machTT;
1578 dmasound.mach.default_soft = def_soft ;
1579 dmasound.mach.default_hard = def_hard_tt ;
1580 is_falcon = 0;
1581 } else
1582 return -ENODEV;
1583 if ((mfp.int_en_a & mfp.int_mk_a & 0x20) == 0)
1584 return dmasound_init();
1585 else {
1586 printk("DMA sound driver: Timer A interrupt already in use\n");
1587 return -EBUSY;
1588 }
1589 }
1590 return -ENODEV;
1591 }
1592
1593 static void __exit dmasound_atari_cleanup(void)
1594 {
1595 dmasound_deinit();
1596 }
1597
1598 module_init(dmasound_atari_init);
1599 module_exit(dmasound_atari_cleanup);
1600 MODULE_LICENSE("GPL");
Ubuntu Artful kernel mirror