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