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