?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
x86: cpa: move clflush_cache_range()
[wrt350n-kernel.git] / drivers / char / dsp56k.c
bloba69c6528326005694809005a546436a1af5cd5d1
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/slab.h> /* for kmalloc() and kfree() */
28 #include <linux/major.h>
29 #include <linux/types.h>
30 #include <linux/errno.h>
31 #include <linux/delay.h> /* guess what */
32 #include <linux/fs.h>
33 #include <linux/mm.h>
34 #include <linux/init.h>
35 #include <linux/device.h>
36
37 #include <asm/atarihw.h>
38 #include <asm/traps.h>
39 #include <asm/uaccess.h> /* For put_user and get_user */
40
41 #include <asm/dsp56k.h>
42
43 /* minor devices */
44 #define DSP56K_DEV_56001 0 /* The only device so far */
45
46 #define TIMEOUT 10 /* Host port timeout in number of tries */
47 #define MAXIO 2048 /* Maximum number of words before sleep */
48 #define DSP56K_MAX_BINARY_LENGTH (3*64*1024)
49
50 #define DSP56K_TX_INT_ON dsp56k_host_interface.icr |= DSP56K_ICR_TREQ
51 #define DSP56K_RX_INT_ON dsp56k_host_interface.icr |= DSP56K_ICR_RREQ
52 #define DSP56K_TX_INT_OFF dsp56k_host_interface.icr &= ~DSP56K_ICR_TREQ
53 #define DSP56K_RX_INT_OFF dsp56k_host_interface.icr &= ~DSP56K_ICR_RREQ
54
55 #define DSP56K_TRANSMIT (dsp56k_host_interface.isr & DSP56K_ISR_TXDE)
56 #define DSP56K_RECEIVE (dsp56k_host_interface.isr & DSP56K_ISR_RXDF)
57
58 #define handshake(count, maxio, timeout, ENABLE, f) \
59 { \
60 long i, t, m; \
61 while (count > 0) { \
62 m = min_t(unsigned long, count, maxio); \
63 for (i = 0; i < m; i++) { \
64 for (t = 0; t < timeout && !ENABLE; t++) \
65 msleep(20); \
66 if(!ENABLE) \
67 return -EIO; \
68 f; \
69 } \
70 count -= m; \
71 if (m == maxio) msleep(20); \
72 } \
73 }
74
75 #define tx_wait(n) \
76 { \
77 int t; \
78 for(t = 0; t < n && !DSP56K_TRANSMIT; t++) \
79 msleep(10); \
80 if(!DSP56K_TRANSMIT) { \
81 return -EIO; \
82 } \
83 }
84
85 #define rx_wait(n) \
86 { \
87 int t; \
88 for(t = 0; t < n && !DSP56K_RECEIVE; t++) \
89 msleep(10); \
90 if(!DSP56K_RECEIVE) { \
91 return -EIO; \
92 } \
93 }
94
95 /* DSP56001 bootstrap code */
96 static char bootstrap[] = {
97 0x0c, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
98 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
99 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
100 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
101 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
102 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
103 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
104 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
105 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
106 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
107 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
108 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
109 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
110 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
111 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
112 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
113 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
114 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
115 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
116 0x00, 0x00, 0x60, 0xf4, 0x00, 0x00, 0x00, 0x4f, 0x61, 0xf4,
117 0x00, 0x00, 0x7e, 0xa9, 0x06, 0x2e, 0x80, 0x00, 0x00, 0x47,
118 0x07, 0xd8, 0x84, 0x07, 0x59, 0x84, 0x08, 0xf4, 0xa8, 0x00,
119 0x00, 0x04, 0x08, 0xf4, 0xbf, 0x00, 0x0c, 0x00, 0x00, 0xfe,
120 0xb8, 0x0a, 0xf0, 0x80, 0x00, 0x7e, 0xa9, 0x08, 0xf4, 0xa0,
121 0x00, 0x00, 0x01, 0x08, 0xf4, 0xbe, 0x00, 0x00, 0x00, 0x0a,
122 0xa9, 0x80, 0x00, 0x7e, 0xad, 0x08, 0x4e, 0x2b, 0x44, 0xf4,
123 0x00, 0x00, 0x00, 0x03, 0x44, 0xf4, 0x45, 0x00, 0x00, 0x01,
124 0x0e, 0xa0, 0x00, 0x0a, 0xa9, 0x80, 0x00, 0x7e, 0xb5, 0x08,
125 0x50, 0x2b, 0x0a, 0xa9, 0x80, 0x00, 0x7e, 0xb8, 0x08, 0x46,
126 0x2b, 0x44, 0xf4, 0x45, 0x00, 0x00, 0x02, 0x0a, 0xf0, 0xaa,
127 0x00, 0x7e, 0xc9, 0x20, 0x00, 0x45, 0x0a, 0xf0, 0xaa, 0x00,
128 0x7e, 0xd0, 0x06, 0xc6, 0x00, 0x00, 0x7e, 0xc6, 0x0a, 0xa9,
129 0x80, 0x00, 0x7e, 0xc4, 0x08, 0x58, 0x6b, 0x0a, 0xf0, 0x80,
130 0x00, 0x7e, 0xad, 0x06, 0xc6, 0x00, 0x00, 0x7e, 0xcd, 0x0a,
131 0xa9, 0x80, 0x00, 0x7e, 0xcb, 0x08, 0x58, 0xab, 0x0a, 0xf0,
132 0x80, 0x00, 0x7e, 0xad, 0x06, 0xc6, 0x00, 0x00, 0x7e, 0xd4,
133 0x0a, 0xa9, 0x80, 0x00, 0x7e, 0xd2, 0x08, 0x58, 0xeb, 0x0a,
134 0xf0, 0x80, 0x00, 0x7e, 0xad};
135 static int sizeof_bootstrap = 375;
136
137
138 static struct dsp56k_device {
139 unsigned long in_use;
140 long maxio, timeout;
141 int tx_wsize, rx_wsize;
142 } dsp56k;
143
144 static struct class *dsp56k_class;
145
146 static int dsp56k_reset(void)
147 {
148 u_char status;
149
150 /* Power down the DSP */
151 sound_ym.rd_data_reg_sel = 14;
152 status = sound_ym.rd_data_reg_sel & 0xef;
153 sound_ym.wd_data = status;
154 sound_ym.wd_data = status | 0x10;
155
156 udelay(10);
157
158 /* Power up the DSP */
159 sound_ym.rd_data_reg_sel = 14;
160 sound_ym.wd_data = sound_ym.rd_data_reg_sel & 0xef;
161
162 return 0;
163 }
164
165 static int dsp56k_upload(u_char __user *bin, int len)
166 {
167 int i;
168 u_char *p;
169
170 dsp56k_reset();
171
172 p = bootstrap;
173 for (i = 0; i < sizeof_bootstrap/3; i++) {
174 /* tx_wait(10); */
175 dsp56k_host_interface.data.b[1] = *p++;
176 dsp56k_host_interface.data.b[2] = *p++;
177 dsp56k_host_interface.data.b[3] = *p++;
178 }
179 for (; i < 512; i++) {
180 /* tx_wait(10); */
181 dsp56k_host_interface.data.b[1] = 0;
182 dsp56k_host_interface.data.b[2] = 0;
183 dsp56k_host_interface.data.b[3] = 0;
184 }
185
186 for (i = 0; i < len; i++) {
187 tx_wait(10);
188 get_user(dsp56k_host_interface.data.b[1], bin++);
189 get_user(dsp56k_host_interface.data.b[2], bin++);
190 get_user(dsp56k_host_interface.data.b[3], bin++);
191 }
192
193 tx_wait(10);
194 dsp56k_host_interface.data.l = 3; /* Magic execute */
195
196 return 0;
197 }
198
199 static ssize_t dsp56k_read(struct file *file, char __user *buf, size_t count,
200 loff_t *ppos)
201 {
202 struct inode *inode = file->f_path.dentry->d_inode;
203 int dev = iminor(inode) & 0x0f;
204
205 switch(dev)
206 {
207 case DSP56K_DEV_56001:
208 {
209
210 long n;
211
212 /* Don't do anything if nothing is to be done */
213 if (!count) return 0;
214
215 n = 0;
216 switch (dsp56k.rx_wsize) {
217 case 1: /* 8 bit */
218 {
219 handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_RECEIVE,
220 put_user(dsp56k_host_interface.data.b[3], buf+n++));
221 return n;
222 }
223 case 2: /* 16 bit */
224 {
225 short __user *data;
226
227 count /= 2;
228 data = (short __user *) buf;
229 handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_RECEIVE,
230 put_user(dsp56k_host_interface.data.w[1], data+n++));
231 return 2*n;
232 }
233 case 3: /* 24 bit */
234 {
235 count /= 3;
236 handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_RECEIVE,
237 put_user(dsp56k_host_interface.data.b[1], buf+n++);
238 put_user(dsp56k_host_interface.data.b[2], buf+n++);
239 put_user(dsp56k_host_interface.data.b[3], buf+n++));
240 return 3*n;
241 }
242 case 4: /* 32 bit */
243 {
244 long __user *data;
245
246 count /= 4;
247 data = (long __user *) buf;
248 handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_RECEIVE,
249 put_user(dsp56k_host_interface.data.l, data+n++));
250 return 4*n;
251 }
252 }
253 return -EFAULT;
254 }
255
256 default:
257 printk(KERN_ERR "DSP56k driver: Unknown minor device: %d\n", dev);
258 return -ENXIO;
259 }
260 }
261
262 static ssize_t dsp56k_write(struct file *file, const char __user *buf, size_t count,
263 loff_t *ppos)
264 {
265 struct inode *inode = file->f_path.dentry->d_inode;
266 int dev = iminor(inode) & 0x0f;
267
268 switch(dev)
269 {
270 case DSP56K_DEV_56001:
271 {
272 long n;
273
274 /* Don't do anything if nothing is to be done */
275 if (!count) return 0;
276
277 n = 0;
278 switch (dsp56k.tx_wsize) {
279 case 1: /* 8 bit */
280 {
281 handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_TRANSMIT,
282 get_user(dsp56k_host_interface.data.b[3], buf+n++));
283 return n;
284 }
285 case 2: /* 16 bit */
286 {
287 const short __user *data;
288
289 count /= 2;
290 data = (const short __user *)buf;
291 handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_TRANSMIT,
292 get_user(dsp56k_host_interface.data.w[1], data+n++));
293 return 2*n;
294 }
295 case 3: /* 24 bit */
296 {
297 count /= 3;
298 handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_TRANSMIT,
299 get_user(dsp56k_host_interface.data.b[1], buf+n++);
300 get_user(dsp56k_host_interface.data.b[2], buf+n++);
301 get_user(dsp56k_host_interface.data.b[3], buf+n++));
302 return 3*n;
303 }
304 case 4: /* 32 bit */
305 {
306 const long __user *data;
307
308 count /= 4;
309 data = (const long __user *)buf;
310 handshake(count, dsp56k.maxio, dsp56k.timeout, DSP56K_TRANSMIT,
311 get_user(dsp56k_host_interface.data.l, data+n++));
312 return 4*n;
313 }
314 }
315
316 return -EFAULT;
317 }
318 default:
319 printk(KERN_ERR "DSP56k driver: Unknown minor device: %d\n", dev);
320 return -ENXIO;
321 }
322 }
323
324 static int dsp56k_ioctl(struct inode *inode, struct file *file,
325 unsigned int cmd, unsigned long arg)
326 {
327 int dev = iminor(inode) & 0x0f;
328 void __user *argp = (void __user *)arg;
329
330 switch(dev)
331 {
332 case DSP56K_DEV_56001:
333
334 switch(cmd) {
335 case DSP56K_UPLOAD:
336 {
337 char __user *bin;
338 int r, len;
339 struct dsp56k_upload __user *binary = argp;
340
341 if(get_user(len, &binary->len) < 0)
342 return -EFAULT;
343 if(get_user(bin, &binary->bin) < 0)
344 return -EFAULT;
345
346 if (len == 0) {
347 return -EINVAL; /* nothing to upload?!? */
348 }
349 if (len > DSP56K_MAX_BINARY_LENGTH) {
350 return -EINVAL;
351 }
352
353 r = dsp56k_upload(bin, len);
354 if (r < 0) {
355 return r;
356 }
357
358 break;
359 }
360 case DSP56K_SET_TX_WSIZE:
361 if (arg > 4 || arg < 1)
362 return -EINVAL;
363 dsp56k.tx_wsize = (int) arg;
364 break;
365 case DSP56K_SET_RX_WSIZE:
366 if (arg > 4 || arg < 1)
367 return -EINVAL;
368 dsp56k.rx_wsize = (int) arg;
369 break;
370 case DSP56K_HOST_FLAGS:
371 {
372 int dir, out, status;
373 struct dsp56k_host_flags __user *hf = argp;
374
375 if(get_user(dir, &hf->dir) < 0)
376 return -EFAULT;
377 if(get_user(out, &hf->out) < 0)
378 return -EFAULT;
379
380 if ((dir & 0x1) && (out & 0x1))
381 dsp56k_host_interface.icr |= DSP56K_ICR_HF0;
382 else if (dir & 0x1)
383 dsp56k_host_interface.icr &= ~DSP56K_ICR_HF0;
384 if ((dir & 0x2) && (out & 0x2))
385 dsp56k_host_interface.icr |= DSP56K_ICR_HF1;
386 else if (dir & 0x2)
387 dsp56k_host_interface.icr &= ~DSP56K_ICR_HF1;
388
389 status = 0;
390 if (dsp56k_host_interface.icr & DSP56K_ICR_HF0) status |= 0x1;
391 if (dsp56k_host_interface.icr & DSP56K_ICR_HF1) status |= 0x2;
392 if (dsp56k_host_interface.isr & DSP56K_ISR_HF2) status |= 0x4;
393 if (dsp56k_host_interface.isr & DSP56K_ISR_HF3) status |= 0x8;
394
395 return put_user(status, &hf->status);
396 }
397 case DSP56K_HOST_CMD:
398 if (arg > 31 || arg < 0)
399 return -EINVAL;
400 dsp56k_host_interface.cvr = (u_char)((arg & DSP56K_CVR_HV_MASK) |
401 DSP56K_CVR_HC);
402 break;
403 default:
404 return -EINVAL;
405 }
406 return 0;
407
408 default:
409 printk(KERN_ERR "DSP56k driver: Unknown minor device: %d\n", dev);
410 return -ENXIO;
411 }
412 }
413
414 /* As of 2.1.26 this should be dsp56k_poll,
415 * but how do I then check device minor number?
416 * Do I need this function at all???
417 */
418 #if 0
419 static unsigned int dsp56k_poll(struct file *file, poll_table *wait)
420 {
421 int dev = iminor(file->f_path.dentry->d_inode) & 0x0f;
422
423 switch(dev)
424 {
425 case DSP56K_DEV_56001:
426 /* poll_wait(file, ???, wait); */
427 return POLLIN | POLLRDNORM | POLLOUT;
428
429 default:
430 printk("DSP56k driver: Unknown minor device: %d\n", dev);
431 return 0;
432 }
433 }
434 #endif
435
436 static int dsp56k_open(struct inode *inode, struct file *file)
437 {
438 int dev = iminor(inode) & 0x0f;
439
440 switch(dev)
441 {
442 case DSP56K_DEV_56001:
443
444 if (test_and_set_bit(0, &dsp56k.in_use))
445 return -EBUSY;
446
447 dsp56k.timeout = TIMEOUT;
448 dsp56k.maxio = MAXIO;
449 dsp56k.rx_wsize = dsp56k.tx_wsize = 4;
450
451 DSP56K_TX_INT_OFF;
452 DSP56K_RX_INT_OFF;
453
454 /* Zero host flags */
455 dsp56k_host_interface.icr &= ~DSP56K_ICR_HF0;
456 dsp56k_host_interface.icr &= ~DSP56K_ICR_HF1;
457
458 break;
459
460 default:
461 return -ENODEV;
462 }
463
464 return 0;
465 }
466
467 static int dsp56k_release(struct inode *inode, struct file *file)
468 {
469 int dev = iminor(inode) & 0x0f;
470
471 switch(dev)
472 {
473 case DSP56K_DEV_56001:
474 clear_bit(0, &dsp56k.in_use);
475 break;
476 default:
477 printk(KERN_ERR "DSP56k driver: Unknown minor device: %d\n", dev);
478 return -ENXIO;
479 }
480
481 return 0;
482 }
483
484 static const struct file_operations dsp56k_fops = {
485 .owner = THIS_MODULE,
486 .read = dsp56k_read,
487 .write = dsp56k_write,
488 .ioctl = dsp56k_ioctl,
489 .open = dsp56k_open,
490 .release = dsp56k_release,
491 };
492
493
494 /****** Init and module functions ******/
495
496 static char banner[] __initdata = KERN_INFO "DSP56k driver installed\n";
497
498 static int __init dsp56k_init_driver(void)
499 {
500 int err = 0;
501
502 if(!MACH_IS_ATARI || !ATARIHW_PRESENT(DSP56K)) {
503 printk("DSP56k driver: Hardware not present\n");
504 return -ENODEV;
505 }
506
507 if(register_chrdev(DSP56K_MAJOR, "dsp56k", &dsp56k_fops)) {
508 printk("DSP56k driver: Unable to register driver\n");
509 return -ENODEV;
510 }
511 dsp56k_class = class_create(THIS_MODULE, "dsp56k");
512 if (IS_ERR(dsp56k_class)) {
513 err = PTR_ERR(dsp56k_class);
514 goto out_chrdev;
515 }
516 device_create(dsp56k_class, NULL, MKDEV(DSP56K_MAJOR, 0), "dsp56k");
517
518 printk(banner);
519 goto out;
520
521 out_chrdev:
522 unregister_chrdev(DSP56K_MAJOR, "dsp56k");
523 out:
524 return err;
525 }
526 module_init(dsp56k_init_driver);
527
528 static void __exit dsp56k_cleanup_driver(void)
529 {
530 device_destroy(dsp56k_class, MKDEV(DSP56K_MAJOR, 0));
531 class_destroy(dsp56k_class);
532 unregister_chrdev(DSP56K_MAJOR, "dsp56k");
533 }
534 module_exit(dsp56k_cleanup_driver);
535
536 MODULE_LICENSE("GPL");
WRT350N Kernel Patches