1 /*
2  * The DSP56001 Device Driver, saviour of the Free World(tm)
3  *
4  * Authors: Fredrik Noring   <noring@nocrew.org>
5  *          lars brinkhoff   <lars@nocrew.org>
6  *          Tomas Berndtsson <tomas@nocrew.org>
7  *
8  * First version May 1996
9  *
10  * History:
11  *  97-01-29   Tomas Berndtsson,
12  *               Integrated with Linux 2.1.21 kernel sources.
13  *  97-02-15   Tomas Berndtsson,
14  *               Fixed for kernel 2.1.26
15  *
16  * BUGS:
17  *  Hmm... there must be something here :)
18  *
19  * Copyright (C) 1996,1997 Fredrik Noring, lars brinkhoff & Tomas Berndtsson
20  *
21  * This file is subject to the terms and conditions of the GNU General Public
22  * License.  See the file COPYING in the main directory of this archive
23  * for more details.
24  */
25 
26 #include <linux/module.h>
27 #include <linux/major.h>
28 #include <linux/types.h>
29 #include <linux/errno.h>
30 #include <linux/delay.h>	/* guess what */
31 #include <linux/fs.h>
32 #include <linux/mm.h>
33 #include <linux/init.h>
34 #include <linux/device.h>
35 #include <linux/mutex.h>
36 #include <linux/firmware.h>
37 #include <linux/platform_device.h>
38 #include <linux/uaccess.h>	/* For put_user and get_user */
39 
40 #include <asm/atarihw.h>
41 #include <asm/traps.h>
42 
43 #include <asm/dsp56k.h>
44 
45 /* minor devices */
46 #define DSP56K_DEV_56001        0    /* The only device so far */
47 
48 #define TIMEOUT    10   /* Host port timeout in number of tries */
49 #define MAXIO    2048   /* Maximum number of words before sleep */
50 #define DSP56K_MAX_BINARY_LENGTH (3*64*1024)
51 
52 #define DSP56K_TX_INT_ON	dsp56k_host_interface.icr |=  DSP56K_ICR_TREQ
53 #define DSP56K_RX_INT_ON	dsp56k_host_interface.icr |=  DSP56K_ICR_RREQ
54 #define DSP56K_TX_INT_OFF	dsp56k_host_interface.icr &= ~DSP56K_ICR_TREQ
55 #define DSP56K_RX_INT_OFF	dsp56k_host_interface.icr &= ~DSP56K_ICR_RREQ
56 
57 #define DSP56K_TRANSMIT		(dsp56k_host_interface.isr & DSP56K_ISR_TXDE)
58 #define DSP56K_RECEIVE		(dsp56k_host_interface.isr & DSP56K_ISR_RXDF)
59 
60 #define handshake(count, maxio, timeout, ENABLE, f) \
61 { \
62 	long i, t, m; \
63 	while (count > 0) { \
64 		m = min_t(unsigned long, count, maxio); \
65 		for (i = 0; i < m; i++) { \
66 			for (t = 0; t < timeout && !ENABLE; t++) \
67 				msleep(20); \
68 			if(!ENABLE) \
69 				return -EIO; \
70 			f; \
71 		} \
72 		count -= m; \
73 		if (m == maxio) msleep(20); \
74 	} \
75 }
76 
77 #define tx_wait(n) \
78 { \
79 	int t; \
80 	for(t = 0; t < n && !DSP56K_TRANSMIT; t++) \
81 		msleep(10); \
82 	if(!DSP56K_TRANSMIT) { \
83 		return -EIO; \
84 	} \
85 }
86 
87 #define rx_wait(n) \
88 { \
89 	int t; \
90 	for(t = 0; t < n && !DSP56K_RECEIVE; t++) \
91 		msleep(10); \
92 	if(!DSP56K_RECEIVE) { \
93 		return -EIO; \
94 	} \
95 }
96 
97 static DEFINE_MUTEX(dsp56k_mutex);
98 static struct dsp56k_device {
99 	unsigned long in_use;
100 	long maxio, timeout;
101 	int tx_wsize, rx_wsize;
102 } dsp56k;
103 
104 static const struct class dsp56k_class = {
105 	.name = "dsp56k",
106 };
107 
dsp56k_reset(void)108 static int dsp56k_reset(void)
109 {
110 	u_char status;
111 
112 	/* Power down the DSP */
113 	sound_ym.rd_data_reg_sel = 14;
114 	status = sound_ym.rd_data_reg_sel & 0xef;
115 	sound_ym.wd_data = status;
116 	sound_ym.wd_data = status | 0x10;
117 
118 	udelay(10);
119 
120 	/* Power up the DSP */
121 	sound_ym.rd_data_reg_sel = 14;
122 	sound_ym.wd_data = sound_ym.rd_data_reg_sel & 0xef;
123 
124 	return 0;
125 }
126 
dsp56k_upload(u_char __user * bin,int len)127 static int dsp56k_upload(u_char __user *bin, int len)
128 {
129 	struct platform_device *pdev;
130 	const struct firmware *fw;
131 	const char fw_name[] = "dsp56k/bootstrap.bin";
132 	int err;
133 	int i;
134 
135 	dsp56k_reset();
136 
137 	pdev = platform_device_register_simple("dsp56k", 0, NULL, 0);
138 	if (IS_ERR(pdev)) {
139 		printk(KERN_ERR "Failed to register device for \"%s\"\n",
140 		       fw_name);
141 		return -EINVAL;
142 	}
143 	err = request_firmware(&fw, fw_name, &pdev->dev);
144 	platform_device_unregister(pdev);
145 	if (err) {
146 		printk(KERN_ERR "Failed to load image \"%s\" err %d\n",
147 		       fw_name, err);
148 		return err;
149 	}
150 	if (fw->size % 3) {
151 		printk(KERN_ERR "Bogus length %d in image \"%s\"\n",
152 		       fw->size, fw_name);
153 		release_firmware(fw);
154 		return -EINVAL;
155 	}
156 	for (i = 0; i < fw->size; i = i + 3) {
157 		/* tx_wait(10); */
158 		dsp56k_host_interface.data.b[1] = fw->data[i];
159 		dsp56k_host_interface.data.b[2] = fw->data[i + 1];
160 		dsp56k_host_interface.data.b[3] = fw->data[i + 2];
161 	}
162 	release_firmware(fw);
163 	for (; i < 512; i++) {
164 		/* tx_wait(10); */
165 		dsp56k_host_interface.data.b[1] = 0;
166 		dsp56k_host_interface.data.b[2] = 0;
167 		dsp56k_host_interface.data.b[3] = 0;
168 	}
169 
170 	for (i = 0; i < len; i++) {
171 		tx_wait(10);
172 		get_user(dsp56k_host_interface.data.b[1], bin++);
173 		get_user(dsp56k_host_interface.data.b[2], bin++);
174 		get_user(dsp56k_host_interface.data.b[3], bin++);
175 	}
176 
177 	tx_wait(10);
178 	dsp56k_host_interface.data.l = 3;    /* Magic execute */
179 
180 	return 0;
181 }
182 
dsp56k_read(struct file * file,char __user * buf,size_t count,loff_t * ppos)183 static ssize_t dsp56k_read(struct file *file, char __user *buf, size_t count,
184 			   loff_t *ppos)
185 {
186 	struct inode *inode = file_inode(file);
187 	int dev = iminor(inode) & 0x0f;
188 
189 	switch(dev)
190 	{
191 	case DSP56K_DEV_56001:
192 	{
193 
194 		long n;
195 
196 		/* Don't do anything if nothing is to be done */
197 		if (!count) return 0;
198 
199 		n = 0;
200 		switch (dsp56k.rx_wsize) {
201 		case 1:  /* 8 bit */
202 		{
203 			handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_RECEIVE,
204 				  put_user(dsp56k_host_interface.data.b[3], buf+n++));
205 			return n;
206 		}
207 		case 2:  /* 16 bit */
208 		{
209 			short __user *data;
210 
211 			count /= 2;
212 			data = (short __user *) buf;
213 			handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_RECEIVE,
214 				  put_user(dsp56k_host_interface.data.w[1], data+n++));
215 			return 2*n;
216 		}
217 		case 3:  /* 24 bit */
218 		{
219 			count /= 3;
220 			handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_RECEIVE,
221 				  put_user(dsp56k_host_interface.data.b[1], buf+n++);
222 				  put_user(dsp56k_host_interface.data.b[2], buf+n++);
223 				  put_user(dsp56k_host_interface.data.b[3], buf+n++));
224 			return 3*n;
225 		}
226 		case 4:  /* 32 bit */
227 		{
228 			long __user *data;
229 
230 			count /= 4;
231 			data = (long __user *) buf;
232 			handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_RECEIVE,
233 				  put_user(dsp56k_host_interface.data.l, data+n++));
234 			return 4*n;
235 		}
236 		}
237 		return -EFAULT;
238 	}
239 
240 	default:
241 		printk(KERN_ERR "DSP56k driver: Unknown minor device: %d\n", dev);
242 		return -ENXIO;
243 	}
244 }
245 
dsp56k_write(struct file * file,const char __user * buf,size_t count,loff_t * ppos)246 static ssize_t dsp56k_write(struct file *file, const char __user *buf, size_t count,
247 			    loff_t *ppos)
248 {
249 	struct inode *inode = file_inode(file);
250 	int dev = iminor(inode) & 0x0f;
251 
252 	switch(dev)
253 	{
254 	case DSP56K_DEV_56001:
255 	{
256 		long n;
257 
258 		/* Don't do anything if nothing is to be done */
259 		if (!count) return 0;
260 
261 		n = 0;
262 		switch (dsp56k.tx_wsize) {
263 		case 1:  /* 8 bit */
264 		{
265 			handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_TRANSMIT,
266 				  get_user(dsp56k_host_interface.data.b[3], buf+n++));
267 			return n;
268 		}
269 		case 2:  /* 16 bit */
270 		{
271 			const short __user *data;
272 
273 			count /= 2;
274 			data = (const short __user *)buf;
275 			handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_TRANSMIT,
276 				  get_user(dsp56k_host_interface.data.w[1], data+n++));
277 			return 2*n;
278 		}
279 		case 3:  /* 24 bit */
280 		{
281 			count /= 3;
282 			handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_TRANSMIT,
283 				  get_user(dsp56k_host_interface.data.b[1], buf+n++);
284 				  get_user(dsp56k_host_interface.data.b[2], buf+n++);
285 				  get_user(dsp56k_host_interface.data.b[3], buf+n++));
286 			return 3*n;
287 		}
288 		case 4:  /* 32 bit */
289 		{
290 			const long __user *data;
291 
292 			count /= 4;
293 			data = (const long __user *)buf;
294 			handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_TRANSMIT,
295 				  get_user(dsp56k_host_interface.data.l, data+n++));
296 			return 4*n;
297 		}
298 		}
299 
300 		return -EFAULT;
301 	}
302 	default:
303 		printk(KERN_ERR "DSP56k driver: Unknown minor device: %d\n", dev);
304 		return -ENXIO;
305 	}
306 }
307 
dsp56k_ioctl(struct file * file,unsigned int cmd,unsigned long arg)308 static long dsp56k_ioctl(struct file *file, unsigned int cmd,
309 			 unsigned long arg)
310 {
311 	int dev = iminor(file_inode(file)) & 0x0f;
312 	void __user *argp = (void __user *)arg;
313 
314 	switch(dev)
315 	{
316 	case DSP56K_DEV_56001:
317 
318 		switch(cmd) {
319 		case DSP56K_UPLOAD:
320 		{
321 			char __user *bin;
322 			int r, len;
323 			struct dsp56k_upload __user *binary = argp;
324 
325 			if(get_user(len, &binary->len) < 0)
326 				return -EFAULT;
327 			if(get_user(bin, &binary->bin) < 0)
328 				return -EFAULT;
329 
330 			if (len <= 0) {
331 				return -EINVAL;      /* nothing to upload?!? */
332 			}
333 			if (len > DSP56K_MAX_BINARY_LENGTH) {
334 				return -EINVAL;
335 			}
336 			mutex_lock(&dsp56k_mutex);
337 			r = dsp56k_upload(bin, len);
338 			mutex_unlock(&dsp56k_mutex);
339 			if (r < 0) {
340 				return r;
341 			}
342 
343 			break;
344 		}
345 		case DSP56K_SET_TX_WSIZE:
346 			if (arg > 4 || arg < 1)
347 				return -EINVAL;
348 			mutex_lock(&dsp56k_mutex);
349 			dsp56k.tx_wsize = (int) arg;
350 			mutex_unlock(&dsp56k_mutex);
351 			break;
352 		case DSP56K_SET_RX_WSIZE:
353 			if (arg > 4 || arg < 1)
354 				return -EINVAL;
355 			mutex_lock(&dsp56k_mutex);
356 			dsp56k.rx_wsize = (int) arg;
357 			mutex_unlock(&dsp56k_mutex);
358 			break;
359 		case DSP56K_HOST_FLAGS:
360 		{
361 			int dir, out, status;
362 			struct dsp56k_host_flags __user *hf = argp;
363 
364 			if(get_user(dir, &hf->dir) < 0)
365 				return -EFAULT;
366 			if(get_user(out, &hf->out) < 0)
367 				return -EFAULT;
368 
369 			mutex_lock(&dsp56k_mutex);
370 			if ((dir & 0x1) && (out & 0x1))
371 				dsp56k_host_interface.icr |= DSP56K_ICR_HF0;
372 			else if (dir & 0x1)
373 				dsp56k_host_interface.icr &= ~DSP56K_ICR_HF0;
374 			if ((dir & 0x2) && (out & 0x2))
375 				dsp56k_host_interface.icr |= DSP56K_ICR_HF1;
376 			else if (dir & 0x2)
377 				dsp56k_host_interface.icr &= ~DSP56K_ICR_HF1;
378 
379 			status = 0;
380 			if (dsp56k_host_interface.icr & DSP56K_ICR_HF0) status |= 0x1;
381 			if (dsp56k_host_interface.icr & DSP56K_ICR_HF1) status |= 0x2;
382 			if (dsp56k_host_interface.isr & DSP56K_ISR_HF2) status |= 0x4;
383 			if (dsp56k_host_interface.isr & DSP56K_ISR_HF3) status |= 0x8;
384 			mutex_unlock(&dsp56k_mutex);
385 			return put_user(status, &hf->status);
386 		}
387 		case DSP56K_HOST_CMD:
388 			if (arg > 31)
389 				return -EINVAL;
390 			mutex_lock(&dsp56k_mutex);
391 			dsp56k_host_interface.cvr = (u_char)((arg & DSP56K_CVR_HV_MASK) |
392 							     DSP56K_CVR_HC);
393 			mutex_unlock(&dsp56k_mutex);
394 			break;
395 		default:
396 			return -EINVAL;
397 		}
398 		return 0;
399 
400 	default:
401 		printk(KERN_ERR "DSP56k driver: Unknown minor device: %d\n", dev);
402 		return -ENXIO;
403 	}
404 }
405 
406 /* As of 2.1.26 this should be dsp56k_poll,
407  * but how do I then check device minor number?
408  * Do I need this function at all???
409  */
410 #if 0
411 static __poll_t dsp56k_poll(struct file *file, poll_table *wait)
412 {
413 	int dev = iminor(file_inode(file)) & 0x0f;
414 
415 	switch(dev)
416 	{
417 	case DSP56K_DEV_56001:
418 		/* poll_wait(file, ???, wait); */
419 		return EPOLLIN | EPOLLRDNORM | EPOLLOUT;
420 
421 	default:
422 		printk("DSP56k driver: Unknown minor device: %d\n", dev);
423 		return 0;
424 	}
425 }
426 #endif
427 
dsp56k_open(struct inode * inode,struct file * file)428 static int dsp56k_open(struct inode *inode, struct file *file)
429 {
430 	int dev = iminor(inode) & 0x0f;
431 	int ret = 0;
432 
433 	mutex_lock(&dsp56k_mutex);
434 	switch(dev)
435 	{
436 	case DSP56K_DEV_56001:
437 
438 		if (test_and_set_bit(0, &dsp56k.in_use)) {
439 			ret = -EBUSY;
440 			goto out;
441 		}
442 
443 		dsp56k.timeout = TIMEOUT;
444 		dsp56k.maxio = MAXIO;
445 		dsp56k.rx_wsize = dsp56k.tx_wsize = 4;
446 
447 		DSP56K_TX_INT_OFF;
448 		DSP56K_RX_INT_OFF;
449 
450 		/* Zero host flags */
451 		dsp56k_host_interface.icr &= ~DSP56K_ICR_HF0;
452 		dsp56k_host_interface.icr &= ~DSP56K_ICR_HF1;
453 
454 		break;
455 
456 	default:
457 		ret = -ENODEV;
458 	}
459 out:
460 	mutex_unlock(&dsp56k_mutex);
461 	return ret;
462 }
463 
dsp56k_release(struct inode * inode,struct file * file)464 static int dsp56k_release(struct inode *inode, struct file *file)
465 {
466 	int dev = iminor(inode) & 0x0f;
467 
468 	switch(dev)
469 	{
470 	case DSP56K_DEV_56001:
471 		clear_bit(0, &dsp56k.in_use);
472 		break;
473 	default:
474 		printk(KERN_ERR "DSP56k driver: Unknown minor device: %d\n", dev);
475 		return -ENXIO;
476 	}
477 
478 	return 0;
479 }
480 
481 static const struct file_operations dsp56k_fops = {
482 	.owner		= THIS_MODULE,
483 	.read		= dsp56k_read,
484 	.write		= dsp56k_write,
485 	.unlocked_ioctl	= dsp56k_ioctl,
486 	.open		= dsp56k_open,
487 	.release	= dsp56k_release,
488 	.llseek		= noop_llseek,
489 };
490 
491 
492 /****** Init and module functions ******/
493 
494 static const char banner[] __initconst = KERN_INFO "DSP56k driver installed\n";
495 
dsp56k_init_driver(void)496 static int __init dsp56k_init_driver(void)
497 {
498 	int err;
499 
500 	if(!MACH_IS_ATARI || !ATARIHW_PRESENT(DSP56K)) {
501 		printk("DSP56k driver: Hardware not present\n");
502 		return -ENODEV;
503 	}
504 
505 	if(register_chrdev(DSP56K_MAJOR, "dsp56k", &dsp56k_fops)) {
506 		printk("DSP56k driver: Unable to register driver\n");
507 		return -ENODEV;
508 	}
509 	err = class_register(&dsp56k_class);
510 	if (err)
511 		goto out_chrdev;
512 	device_create(&dsp56k_class, NULL, MKDEV(DSP56K_MAJOR, 0), NULL,
513 		      "dsp56k");
514 
515 	printk(banner);
516 	goto out;
517 
518 out_chrdev:
519 	unregister_chrdev(DSP56K_MAJOR, "dsp56k");
520 out:
521 	return err;
522 }
523 module_init(dsp56k_init_driver);
524 
dsp56k_cleanup_driver(void)525 static void __exit dsp56k_cleanup_driver(void)
526 {
527 	device_destroy(&dsp56k_class, MKDEV(DSP56K_MAJOR, 0));
528 	class_unregister(&dsp56k_class);
529 	unregister_chrdev(DSP56K_MAJOR, "dsp56k");
530 }
531 module_exit(dsp56k_cleanup_driver);
532 
533 MODULE_DESCRIPTION("Atari DSP56001 Device Driver");
534 MODULE_LICENSE("GPL");
535 MODULE_FIRMWARE("dsp56k/bootstrap.bin");
536