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 | |
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 | |
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(name: "dsp56k" , id: 0, NULL, num: 0); |
138 | if (IS_ERR(ptr: 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: fw_name, device: &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 | |
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(f: 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 | |
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(f: 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 | |
308 | static long dsp56k_ioctl(struct file *file, unsigned int cmd, |
309 | unsigned long arg) |
310 | { |
311 | int dev = iminor(inode: file_inode(f: 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(lock: &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(lock: &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(lock: &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(lock: &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(lock: &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 | |
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(nr: 0, addr: &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(lock: &dsp56k_mutex); |
461 | return ret; |
462 | } |
463 | |
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(nr: 0, addr: &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 | |
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, name: "dsp56k" , fops: &dsp56k_fops)) { |
506 | printk("DSP56k driver: Unable to register driver\n" ); |
507 | return -ENODEV; |
508 | } |
509 | err = class_register(class: &dsp56k_class); |
510 | if (err) |
511 | goto out_chrdev; |
512 | device_create(cls: &dsp56k_class, NULL, MKDEV(DSP56K_MAJOR, 0), NULL, |
513 | fmt: "dsp56k" ); |
514 | |
515 | printk(banner); |
516 | goto out; |
517 | |
518 | out_chrdev: |
519 | unregister_chrdev(DSP56K_MAJOR, name: "dsp56k" ); |
520 | out: |
521 | return err; |
522 | } |
523 | module_init(dsp56k_init_driver); |
524 | |
525 | static void __exit dsp56k_cleanup_driver(void) |
526 | { |
527 | device_destroy(cls: &dsp56k_class, MKDEV(DSP56K_MAJOR, 0)); |
528 | class_unregister(class: &dsp56k_class); |
529 | unregister_chrdev(DSP56K_MAJOR, name: "dsp56k" ); |
530 | } |
531 | module_exit(dsp56k_cleanup_driver); |
532 | |
533 | MODULE_LICENSE("GPL" ); |
534 | MODULE_FIRMWARE("dsp56k/bootstrap.bin" ); |
535 | |