1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17#include <linux/module.h>
18#include <linux/init.h>
19#include <linux/slab.h>
20#include <linux/soundcard.h>
21#include <linux/interrupt.h>
22
23#include <asm/uaccess.h>
24#include <asm/q40ints.h>
25#include <asm/q40_master.h>
26
27#include "dmasound.h"
28
29#define DMASOUND_Q40_REVISION 0
30#define DMASOUND_Q40_EDITION 3
31
32static int expand_bal;
33static int expand_data;
34
35
36
37
38
39static void *Q40Alloc(unsigned int size, gfp_t flags);
40static void Q40Free(void *, unsigned int);
41static int Q40IrqInit(void);
42#ifdef MODULE
43static void Q40IrqCleanUp(void);
44#endif
45static void Q40Silence(void);
46static void Q40Init(void);
47static int Q40SetFormat(int format);
48static int Q40SetVolume(int volume);
49static void Q40PlayNextFrame(int index);
50static void Q40Play(void);
51static irqreturn_t Q40StereoInterrupt(int irq, void *dummy);
52static irqreturn_t Q40MonoInterrupt(int irq, void *dummy);
53static void Q40Interrupt(void);
54
55
56
57
58
59
60
61static ssize_t q40_ct_law(const u_char __user *userPtr, size_t userCount,
62 u_char frame[], ssize_t *frameUsed,
63 ssize_t frameLeft)
64{
65 char *table = dmasound.soft.format == AFMT_MU_LAW ? dmasound_ulaw2dma8: dmasound_alaw2dma8;
66 ssize_t count, used;
67 u_char *p = (u_char *) &frame[*frameUsed];
68
69 used = count = min_t(size_t, userCount, frameLeft);
70 if (copy_from_user(p,userPtr,count))
71 return -EFAULT;
72 while (count > 0) {
73 *p = table[*p]+128;
74 p++;
75 count--;
76 }
77 *frameUsed += used ;
78 return used;
79}
80
81
82static ssize_t q40_ct_s8(const u_char __user *userPtr, size_t userCount,
83 u_char frame[], ssize_t *frameUsed,
84 ssize_t frameLeft)
85{
86 ssize_t count, used;
87 u_char *p = (u_char *) &frame[*frameUsed];
88
89 used = count = min_t(size_t, userCount, frameLeft);
90 if (copy_from_user(p,userPtr,count))
91 return -EFAULT;
92 while (count > 0) {
93 *p = *p + 128;
94 p++;
95 count--;
96 }
97 *frameUsed += used;
98 return used;
99}
100
101static ssize_t q40_ct_u8(const u_char __user *userPtr, size_t userCount,
102 u_char frame[], ssize_t *frameUsed,
103 ssize_t frameLeft)
104{
105 ssize_t count, used;
106 u_char *p = (u_char *) &frame[*frameUsed];
107
108 used = count = min_t(size_t, userCount, frameLeft);
109 if (copy_from_user(p,userPtr,count))
110 return -EFAULT;
111 *frameUsed += used;
112 return used;
113}
114
115
116
117static ssize_t q40_ctx_law(const u_char __user *userPtr, size_t userCount,
118 u_char frame[], ssize_t *frameUsed,
119 ssize_t frameLeft)
120{
121 unsigned char *table = (unsigned char *)
122 (dmasound.soft.format == AFMT_MU_LAW ? dmasound_ulaw2dma8: dmasound_alaw2dma8);
123 unsigned int data = expand_data;
124 u_char *p = (u_char *) &frame[*frameUsed];
125 int bal = expand_bal;
126 int hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed;
127 int utotal, ftotal;
128
129 ftotal = frameLeft;
130 utotal = userCount;
131 while (frameLeft) {
132 u_char c;
133 if (bal < 0) {
134 if (userCount == 0)
135 break;
136 if (get_user(c, userPtr++))
137 return -EFAULT;
138 data = table[c];
139 data += 0x80;
140 userCount--;
141 bal += hSpeed;
142 }
143 *p++ = data;
144 frameLeft--;
145 bal -= sSpeed;
146 }
147 expand_bal = bal;
148 expand_data = data;
149 *frameUsed += (ftotal - frameLeft);
150 utotal -= userCount;
151 return utotal;
152}
153
154
155static ssize_t q40_ctx_s8(const u_char __user *userPtr, size_t userCount,
156 u_char frame[], ssize_t *frameUsed,
157 ssize_t frameLeft)
158{
159 u_char *p = (u_char *) &frame[*frameUsed];
160 unsigned int data = expand_data;
161 int bal = expand_bal;
162 int hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed;
163 int utotal, ftotal;
164
165
166 ftotal = frameLeft;
167 utotal = userCount;
168 while (frameLeft) {
169 u_char c;
170 if (bal < 0) {
171 if (userCount == 0)
172 break;
173 if (get_user(c, userPtr++))
174 return -EFAULT;
175 data = c ;
176 data += 0x80;
177 userCount--;
178 bal += hSpeed;
179 }
180 *p++ = data;
181 frameLeft--;
182 bal -= sSpeed;
183 }
184 expand_bal = bal;
185 expand_data = data;
186 *frameUsed += (ftotal - frameLeft);
187 utotal -= userCount;
188 return utotal;
189}
190
191
192static ssize_t q40_ctx_u8(const u_char __user *userPtr, size_t userCount,
193 u_char frame[], ssize_t *frameUsed,
194 ssize_t frameLeft)
195{
196 u_char *p = (u_char *) &frame[*frameUsed];
197 unsigned int data = expand_data;
198 int bal = expand_bal;
199 int hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed;
200 int utotal, ftotal;
201
202 ftotal = frameLeft;
203 utotal = userCount;
204 while (frameLeft) {
205 u_char c;
206 if (bal < 0) {
207 if (userCount == 0)
208 break;
209 if (get_user(c, userPtr++))
210 return -EFAULT;
211 data = c ;
212 userCount--;
213 bal += hSpeed;
214 }
215 *p++ = data;
216 frameLeft--;
217 bal -= sSpeed;
218 }
219 expand_bal = bal;
220 expand_data = data;
221 *frameUsed += (ftotal - frameLeft) ;
222 utotal -= userCount;
223 return utotal;
224}
225
226
227static ssize_t q40_ctc_law(const u_char __user *userPtr, size_t userCount,
228 u_char frame[], ssize_t *frameUsed,
229 ssize_t frameLeft)
230{
231 unsigned char *table = (unsigned char *)
232 (dmasound.soft.format == AFMT_MU_LAW ? dmasound_ulaw2dma8: dmasound_alaw2dma8);
233 unsigned int data = expand_data;
234 u_char *p = (u_char *) &frame[*frameUsed];
235 int bal = expand_bal;
236 int hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed;
237 int utotal, ftotal;
238
239 ftotal = frameLeft;
240 utotal = userCount;
241 while (frameLeft) {
242 u_char c;
243 while(bal<0) {
244 if (userCount == 0)
245 goto lout;
246 if (!(bal<(-hSpeed))) {
247 if (get_user(c, userPtr))
248 return -EFAULT;
249 data = 0x80 + table[c];
250 }
251 userPtr++;
252 userCount--;
253 bal += hSpeed;
254 }
255 *p++ = data;
256 frameLeft--;
257 bal -= sSpeed;
258 }
259 lout:
260 expand_bal = bal;
261 expand_data = data;
262 *frameUsed += (ftotal - frameLeft);
263 utotal -= userCount;
264 return utotal;
265}
266
267
268static ssize_t q40_ctc_s8(const u_char __user *userPtr, size_t userCount,
269 u_char frame[], ssize_t *frameUsed,
270 ssize_t frameLeft)
271{
272 u_char *p = (u_char *) &frame[*frameUsed];
273 unsigned int data = expand_data;
274 int bal = expand_bal;
275 int hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed;
276 int utotal, ftotal;
277
278 ftotal = frameLeft;
279 utotal = userCount;
280 while (frameLeft) {
281 u_char c;
282 while (bal < 0) {
283 if (userCount == 0)
284 goto lout;
285 if (!(bal<(-hSpeed))) {
286 if (get_user(c, userPtr))
287 return -EFAULT;
288 data = c + 0x80;
289 }
290 userPtr++;
291 userCount--;
292 bal += hSpeed;
293 }
294 *p++ = data;
295 frameLeft--;
296 bal -= sSpeed;
297 }
298 lout:
299 expand_bal = bal;
300 expand_data = data;
301 *frameUsed += (ftotal - frameLeft);
302 utotal -= userCount;
303 return utotal;
304}
305
306
307static ssize_t q40_ctc_u8(const u_char __user *userPtr, size_t userCount,
308 u_char frame[], ssize_t *frameUsed,
309 ssize_t frameLeft)
310{
311 u_char *p = (u_char *) &frame[*frameUsed];
312 unsigned int data = expand_data;
313 int bal = expand_bal;
314 int hSpeed = dmasound.hard.speed, sSpeed = dmasound.soft.speed;
315 int utotal, ftotal;
316
317 ftotal = frameLeft;
318 utotal = userCount;
319 while (frameLeft) {
320 u_char c;
321 while (bal < 0) {
322 if (userCount == 0)
323 goto lout;
324 if (!(bal<(-hSpeed))) {
325 if (get_user(c, userPtr))
326 return -EFAULT;
327 data = c ;
328 }
329 userPtr++;
330 userCount--;
331 bal += hSpeed;
332 }
333 *p++ = data;
334 frameLeft--;
335 bal -= sSpeed;
336 }
337 lout:
338 expand_bal = bal;
339 expand_data = data;
340 *frameUsed += (ftotal - frameLeft) ;
341 utotal -= userCount;
342 return utotal;
343}
344
345
346static TRANS transQ40Normal = {
347 q40_ct_law, q40_ct_law, q40_ct_s8, q40_ct_u8, NULL, NULL, NULL, NULL
348};
349
350static TRANS transQ40Expanding = {
351 q40_ctx_law, q40_ctx_law, q40_ctx_s8, q40_ctx_u8, NULL, NULL, NULL, NULL
352};
353
354static TRANS transQ40Compressing = {
355 q40_ctc_law, q40_ctc_law, q40_ctc_s8, q40_ctc_u8, NULL, NULL, NULL, NULL
356};
357
358
359
360
361static void *Q40Alloc(unsigned int size, gfp_t flags)
362{
363 return kmalloc(size, flags);
364}
365
366static void Q40Free(void *ptr, unsigned int size)
367{
368 kfree(ptr);
369}
370
371static int __init Q40IrqInit(void)
372{
373
374 if (request_irq(Q40_IRQ_SAMPLE, Q40StereoInterrupt, 0,
375 "DMA sound", Q40Interrupt))
376 return 0;
377
378 return(1);
379}
380
381
382#ifdef MODULE
383static void Q40IrqCleanUp(void)
384{
385 master_outb(0,SAMPLE_ENABLE_REG);
386 free_irq(Q40_IRQ_SAMPLE, Q40Interrupt);
387}
388#endif
389
390
391static void Q40Silence(void)
392{
393 master_outb(0,SAMPLE_ENABLE_REG);
394 *DAC_LEFT=*DAC_RIGHT=127;
395}
396
397static char *q40_pp;
398static unsigned int q40_sc;
399
400static void Q40PlayNextFrame(int index)
401{
402 u_char *start;
403 u_long size;
404 u_char speed;
405 int error;
406
407
408
409
410 start = write_sq.buffers[write_sq.front];
411 size = (write_sq.count == index ? write_sq.rear_size : write_sq.block_size);
412
413 q40_pp=start;
414 q40_sc=size;
415
416 write_sq.front = (write_sq.front+1) % write_sq.max_count;
417 write_sq.active++;
418
419 speed=(dmasound.hard.speed==10000 ? 0 : 1);
420
421 master_outb( 0,SAMPLE_ENABLE_REG);
422 free_irq(Q40_IRQ_SAMPLE, Q40Interrupt);
423 if (dmasound.soft.stereo)
424 error = request_irq(Q40_IRQ_SAMPLE, Q40StereoInterrupt, 0,
425 "Q40 sound", Q40Interrupt);
426 else
427 error = request_irq(Q40_IRQ_SAMPLE, Q40MonoInterrupt, 0,
428 "Q40 sound", Q40Interrupt);
429 if (error && printk_ratelimit())
430 pr_err("Couldn't register sound interrupt\n");
431
432 master_outb( speed, SAMPLE_RATE_REG);
433 master_outb( 1,SAMPLE_CLEAR_REG);
434 master_outb( 1,SAMPLE_ENABLE_REG);
435}
436
437static void Q40Play(void)
438{
439 unsigned long flags;
440
441 if (write_sq.active || write_sq.count<=0 ) {
442
443 return;
444 }
445
446
447 if (write_sq.count <= 1 && write_sq.rear_size < write_sq.block_size && !write_sq.syncing) {
448
449
450
451 return;
452 }
453 spin_lock_irqsave(&dmasound.lock, flags);
454 Q40PlayNextFrame(1);
455 spin_unlock_irqrestore(&dmasound.lock, flags);
456}
457
458static irqreturn_t Q40StereoInterrupt(int irq, void *dummy)
459{
460 spin_lock(&dmasound.lock);
461 if (q40_sc>1){
462 *DAC_LEFT=*q40_pp++;
463 *DAC_RIGHT=*q40_pp++;
464 q40_sc -=2;
465 master_outb(1,SAMPLE_CLEAR_REG);
466 }else Q40Interrupt();
467 spin_unlock(&dmasound.lock);
468 return IRQ_HANDLED;
469}
470static irqreturn_t Q40MonoInterrupt(int irq, void *dummy)
471{
472 spin_lock(&dmasound.lock);
473 if (q40_sc>0){
474 *DAC_LEFT=*q40_pp;
475 *DAC_RIGHT=*q40_pp++;
476 q40_sc --;
477 master_outb(1,SAMPLE_CLEAR_REG);
478 }else Q40Interrupt();
479 spin_unlock(&dmasound.lock);
480 return IRQ_HANDLED;
481}
482static void Q40Interrupt(void)
483{
484 if (!write_sq.active) {
485
486
487
488 WAKE_UP(write_sq.sync_queue);
489 master_outb(0,SAMPLE_ENABLE_REG);
490 goto exit;
491 } else write_sq.active=0;
492 write_sq.count--;
493 Q40Play();
494
495 if (q40_sc<2)
496 {
497 master_outb(0,SAMPLE_ENABLE_REG);
498 *DAC_LEFT=*DAC_RIGHT=127;
499 }
500 WAKE_UP(write_sq.action_queue);
501
502 exit:
503 master_outb(1,SAMPLE_CLEAR_REG);
504}
505
506
507static void Q40Init(void)
508{
509 int i, idx;
510 const int freq[] = {10000, 20000};
511
512
513
514 idx = -1;
515 for (i = 0; i < 2; i++)
516 if ((100 * abs(dmasound.soft.speed - freq[i]) / freq[i]) <= catchRadius)
517 idx = i;
518
519 dmasound.hard = dmasound.soft;
520
521 dmasound.hard.size=8;
522
523 if (idx > -1) {
524 dmasound.soft.speed = freq[idx];
525 dmasound.trans_write = &transQ40Normal;
526 } else
527 dmasound.trans_write = &transQ40Expanding;
528
529 Q40Silence();
530
531 if (dmasound.hard.speed > 20200) {
532
533 dmasound.hard.speed = 20000;
534 dmasound.trans_write = &transQ40Compressing;
535 } else if (dmasound.hard.speed > 10000) {
536 dmasound.hard.speed = 20000;
537 } else {
538 dmasound.hard.speed = 10000;
539 }
540 expand_bal = -dmasound.soft.speed;
541}
542
543
544static int Q40SetFormat(int format)
545{
546
547
548 switch (format) {
549 case AFMT_QUERY:
550 return(dmasound.soft.format);
551 case AFMT_MU_LAW:
552 case AFMT_A_LAW:
553 case AFMT_S8:
554 case AFMT_U8:
555 break;
556 default:
557 format = AFMT_S8;
558 }
559
560 dmasound.soft.format = format;
561 dmasound.soft.size = 8;
562 if (dmasound.minDev == SND_DEV_DSP) {
563 dmasound.dsp.format = format;
564 dmasound.dsp.size = 8;
565 }
566 Q40Init();
567
568 return(format);
569}
570
571static int Q40SetVolume(int volume)
572{
573 return 0;
574}
575
576
577
578
579static SETTINGS def_hard = {
580 .format = AFMT_U8,
581 .stereo = 0,
582 .size = 8,
583 .speed = 10000
584} ;
585
586static SETTINGS def_soft = {
587 .format = AFMT_U8,
588 .stereo = 0,
589 .size = 8,
590 .speed = 8000
591} ;
592
593static MACHINE machQ40 = {
594 .name = "Q40",
595 .name2 = "Q40",
596 .owner = THIS_MODULE,
597 .dma_alloc = Q40Alloc,
598 .dma_free = Q40Free,
599 .irqinit = Q40IrqInit,
600#ifdef MODULE
601 .irqcleanup = Q40IrqCleanUp,
602#endif
603 .init = Q40Init,
604 .silence = Q40Silence,
605 .setFormat = Q40SetFormat,
606 .setVolume = Q40SetVolume,
607 .play = Q40Play,
608 .min_dsp_speed = 10000,
609 .version = ((DMASOUND_Q40_REVISION<<8) | DMASOUND_Q40_EDITION),
610 .hardware_afmts = AFMT_U8,
611 .capabilities = DSP_CAP_BATCH
612};
613
614
615
616
617
618static int __init dmasound_q40_init(void)
619{
620 if (MACH_IS_Q40) {
621 dmasound.mach = machQ40;
622 dmasound.mach.default_hard = def_hard ;
623 dmasound.mach.default_soft = def_soft ;
624 return dmasound_init();
625 } else
626 return -ENODEV;
627}
628
629static void __exit dmasound_q40_cleanup(void)
630{
631 dmasound_deinit();
632}
633
634module_init(dmasound_q40_init);
635module_exit(dmasound_q40_cleanup);
636
637MODULE_DESCRIPTION("Q40/Q60 sound driver");
638MODULE_LICENSE("GPL");
639
