Pull dock into release branch
[linux-2.6] / arch / mips / kernel / rtlx.c
1 /*
2  * Copyright (C) 2005 MIPS Technologies, Inc.  All rights reserved.
3  * Copyright (C) 2005, 06 Ralf Baechle (ralf@linux-mips.org)
4  *
5  *  This program is free software; you can distribute it and/or modify it
6  *  under the terms of the GNU General Public License (Version 2) as
7  *  published by the Free Software Foundation.
8  *
9  *  This program is distributed in the hope it will be useful, but WITHOUT
10  *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11  *  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12  *  for more details.
13  *
14  *  You should have received a copy of the GNU General Public License along
15  *  with this program; if not, write to the Free Software Foundation, Inc.,
16  *  59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
17  *
18  */
19
20 #include <linux/device.h>
21 #include <linux/kernel.h>
22 #include <linux/module.h>
23 #include <linux/fs.h>
24 #include <linux/init.h>
25 #include <asm/uaccess.h>
26 #include <linux/slab.h>
27 #include <linux/list.h>
28 #include <linux/vmalloc.h>
29 #include <linux/elf.h>
30 #include <linux/seq_file.h>
31 #include <linux/syscalls.h>
32 #include <linux/moduleloader.h>
33 #include <linux/interrupt.h>
34 #include <linux/poll.h>
35 #include <linux/sched.h>
36 #include <linux/wait.h>
37 #include <asm/mipsmtregs.h>
38 #include <asm/mips_mt.h>
39 #include <asm/cacheflush.h>
40 #include <asm/atomic.h>
41 #include <asm/cpu.h>
42 #include <asm/processor.h>
43 #include <asm/system.h>
44 #include <asm/vpe.h>
45 #include <asm/rtlx.h>
46
47 #define RTLX_TARG_VPE 1
48
49 static struct rtlx_info *rtlx;
50 static int major;
51 static char module_name[] = "rtlx";
52
53 static struct chan_waitqueues {
54         wait_queue_head_t rt_queue;
55         wait_queue_head_t lx_queue;
56         atomic_t in_open;
57         struct mutex mutex;
58 } channel_wqs[RTLX_CHANNELS];
59
60 static struct irqaction irq;
61 static int irq_num;
62 static struct vpe_notifications notify;
63 static int sp_stopping = 0;
64
65 extern void *vpe_get_shared(int index);
66
67 static void rtlx_dispatch(void)
68 {
69         do_IRQ(MIPS_CPU_IRQ_BASE + MIPS_CPU_RTLX_IRQ);
70 }
71
72
73 /* Interrupt handler may be called before rtlx_init has otherwise had
74    a chance to run.
75 */
76 static irqreturn_t rtlx_interrupt(int irq, void *dev_id)
77 {
78         int i;
79
80         for (i = 0; i < RTLX_CHANNELS; i++) {
81                         wake_up(&channel_wqs[i].lx_queue);
82                         wake_up(&channel_wqs[i].rt_queue);
83         }
84
85         return IRQ_HANDLED;
86 }
87
88 static __attribute_used__ void dump_rtlx(void)
89 {
90         int i;
91
92         printk("id 0x%lx state %d\n", rtlx->id, rtlx->state);
93
94         for (i = 0; i < RTLX_CHANNELS; i++) {
95                 struct rtlx_channel *chan = &rtlx->channel[i];
96
97                 printk(" rt_state %d lx_state %d buffer_size %d\n",
98                        chan->rt_state, chan->lx_state, chan->buffer_size);
99
100                 printk(" rt_read %d rt_write %d\n",
101                        chan->rt_read, chan->rt_write);
102
103                 printk(" lx_read %d lx_write %d\n",
104                        chan->lx_read, chan->lx_write);
105
106                 printk(" rt_buffer <%s>\n", chan->rt_buffer);
107                 printk(" lx_buffer <%s>\n", chan->lx_buffer);
108         }
109 }
110
111 /* call when we have the address of the shared structure from the SP side. */
112 static int rtlx_init(struct rtlx_info *rtlxi)
113 {
114         if (rtlxi->id != RTLX_ID) {
115                 printk(KERN_ERR "no valid RTLX id at 0x%p 0x%x\n", rtlxi, rtlxi->id);
116                 return -ENOEXEC;
117         }
118
119         rtlx = rtlxi;
120
121         return 0;
122 }
123
124 /* notifications */
125 static void starting(int vpe)
126 {
127         int i;
128         sp_stopping = 0;
129
130         /* force a reload of rtlx */
131         rtlx=NULL;
132
133         /* wake up any sleeping rtlx_open's */
134         for (i = 0; i < RTLX_CHANNELS; i++)
135                 wake_up_interruptible(&channel_wqs[i].lx_queue);
136 }
137
138 static void stopping(int vpe)
139 {
140         int i;
141
142         sp_stopping = 1;
143         for (i = 0; i < RTLX_CHANNELS; i++)
144                 wake_up_interruptible(&channel_wqs[i].lx_queue);
145 }
146
147
148 int rtlx_open(int index, int can_sleep)
149 {
150         struct rtlx_info **p;
151         struct rtlx_channel *chan;
152         enum rtlx_state state;
153         int ret = 0;
154
155         if (index >= RTLX_CHANNELS) {
156                 printk(KERN_DEBUG "rtlx_open index out of range\n");
157                 return -ENOSYS;
158         }
159
160         if (atomic_inc_return(&channel_wqs[index].in_open) > 1) {
161                 printk(KERN_DEBUG "rtlx_open channel %d already opened\n",
162                        index);
163                 ret = -EBUSY;
164                 goto out_fail;
165         }
166
167         if (rtlx == NULL) {
168                 if( (p = vpe_get_shared(RTLX_TARG_VPE)) == NULL) {
169                         if (can_sleep) {
170                                 __wait_event_interruptible(channel_wqs[index].lx_queue,
171                                                            (p = vpe_get_shared(RTLX_TARG_VPE)),
172                                                            ret);
173                                 if (ret)
174                                         goto out_fail;
175                         } else {
176                                 printk(KERN_DEBUG "No SP program loaded, and device "
177                                         "opened with O_NONBLOCK\n");
178                                 ret = -ENOSYS;
179                                 goto out_fail;
180                         }
181                 }
182
183                 smp_rmb();
184                 if (*p == NULL) {
185                         if (can_sleep) {
186                                 DEFINE_WAIT(wait);
187
188                                 for (;;) {
189                                         prepare_to_wait(&channel_wqs[index].lx_queue, &wait, TASK_INTERRUPTIBLE);
190                                         smp_rmb();
191                                         if (*p != NULL)
192                                                 break;
193                                         if (!signal_pending(current)) {
194                                                 schedule();
195                                                 continue;
196                                         }
197                                         ret = -ERESTARTSYS;
198                                         goto out_fail;
199                                 }
200                                 finish_wait(&channel_wqs[index].lx_queue, &wait);
201                         } else {
202                                 printk(" *vpe_get_shared is NULL. "
203                                        "Has an SP program been loaded?\n");
204                                 ret = -ENOSYS;
205                                 goto out_fail;
206                         }
207                 }
208
209                 if ((unsigned int)*p < KSEG0) {
210                         printk(KERN_WARNING "vpe_get_shared returned an invalid pointer "
211                                "maybe an error code %d\n", (int)*p);
212                         ret = -ENOSYS;
213                         goto out_fail;
214                 }
215
216                 if ((ret = rtlx_init(*p)) < 0)
217                         goto out_ret;
218         }
219
220         chan = &rtlx->channel[index];
221
222         state = xchg(&chan->lx_state, RTLX_STATE_OPENED);
223         if (state == RTLX_STATE_OPENED) {
224                 ret = -EBUSY;
225                 goto out_fail;
226         }
227
228 out_fail:
229         smp_mb();
230         atomic_dec(&channel_wqs[index].in_open);
231         smp_mb();
232
233 out_ret:
234         return ret;
235 }
236
237 int rtlx_release(int index)
238 {
239         rtlx->channel[index].lx_state = RTLX_STATE_UNUSED;
240         return 0;
241 }
242
243 unsigned int rtlx_read_poll(int index, int can_sleep)
244 {
245         struct rtlx_channel *chan;
246
247         if (rtlx == NULL)
248                 return 0;
249
250         chan = &rtlx->channel[index];
251
252         /* data available to read? */
253         if (chan->lx_read == chan->lx_write) {
254                 if (can_sleep) {
255                         int ret = 0;
256
257                         __wait_event_interruptible(channel_wqs[index].lx_queue,
258                                                    chan->lx_read != chan->lx_write || sp_stopping,
259                                                    ret);
260                         if (ret)
261                                 return ret;
262
263                         if (sp_stopping)
264                                 return 0;
265                 } else
266                         return 0;
267         }
268
269         return (chan->lx_write + chan->buffer_size - chan->lx_read)
270                % chan->buffer_size;
271 }
272
273 static inline int write_spacefree(int read, int write, int size)
274 {
275         if (read == write) {
276                 /*
277                  * Never fill the buffer completely, so indexes are always
278                  * equal if empty and only empty, or !equal if data available
279                  */
280                 return size - 1;
281         }
282
283         return ((read + size - write) % size) - 1;
284 }
285
286 unsigned int rtlx_write_poll(int index)
287 {
288         struct rtlx_channel *chan = &rtlx->channel[index];
289         return write_spacefree(chan->rt_read, chan->rt_write, chan->buffer_size);
290 }
291
292 ssize_t rtlx_read(int index, void __user *buff, size_t count, int user)
293 {
294         size_t lx_write, fl = 0L;
295         struct rtlx_channel *lx;
296         unsigned long failed;
297
298         if (rtlx == NULL)
299                 return -ENOSYS;
300
301         lx = &rtlx->channel[index];
302
303         mutex_lock(&channel_wqs[index].mutex);
304         smp_rmb();
305         lx_write = lx->lx_write;
306
307         /* find out how much in total */
308         count = min(count,
309                      (size_t)(lx_write + lx->buffer_size - lx->lx_read)
310                      % lx->buffer_size);
311
312         /* then how much from the read pointer onwards */
313         fl = min(count, (size_t)lx->buffer_size - lx->lx_read);
314
315         failed = copy_to_user(buff, lx->lx_buffer + lx->lx_read, fl);
316         if (failed)
317                 goto out;
318
319         /* and if there is anything left at the beginning of the buffer */
320         if (count - fl)
321                 failed = copy_to_user(buff + fl, lx->lx_buffer, count - fl);
322
323 out:
324         count -= failed;
325
326         smp_wmb();
327         lx->lx_read = (lx->lx_read + count) % lx->buffer_size;
328         smp_wmb();
329         mutex_unlock(&channel_wqs[index].mutex);
330
331         return count;
332 }
333
334 ssize_t rtlx_write(int index, const void __user *buffer, size_t count, int user)
335 {
336         struct rtlx_channel *rt;
337         size_t rt_read;
338         size_t fl;
339
340         if (rtlx == NULL)
341                 return(-ENOSYS);
342
343         rt = &rtlx->channel[index];
344
345         mutex_lock(&channel_wqs[index].mutex);
346         smp_rmb();
347         rt_read = rt->rt_read;
348
349         /* total number of bytes to copy */
350         count = min(count,
351                     (size_t)write_spacefree(rt_read, rt->rt_write, rt->buffer_size));
352
353         /* first bit from write pointer to the end of the buffer, or count */
354         fl = min(count, (size_t) rt->buffer_size - rt->rt_write);
355
356         failed = copy_from_user(rt->rt_buffer + rt->rt_write, buffer, fl);
357         if (failed)
358                 goto out;
359
360         /* if there's any left copy to the beginning of the buffer */
361         if (count - fl) {
362                 failed = copy_from_user(rt->rt_buffer, buffer + fl, count - fl);
363         }
364
365 out:
366         count -= cailed;
367
368         smp_wmb();
369         rt->rt_write = (rt->rt_write + count) % rt->buffer_size;
370         smp_wmb();
371         mutex_unlock(&channel_wqs[index].mutex);
372
373         return count;
374 }
375
376
377 static int file_open(struct inode *inode, struct file *filp)
378 {
379         int minor = iminor(inode);
380
381         return rtlx_open(minor, (filp->f_flags & O_NONBLOCK) ? 0 : 1);
382 }
383
384 static int file_release(struct inode *inode, struct file *filp)
385 {
386         int minor = iminor(inode);
387
388         return rtlx_release(minor);
389 }
390
391 static unsigned int file_poll(struct file *file, poll_table * wait)
392 {
393         int minor;
394         unsigned int mask = 0;
395
396         minor = iminor(file->f_path.dentry->d_inode);
397
398         poll_wait(file, &channel_wqs[minor].rt_queue, wait);
399         poll_wait(file, &channel_wqs[minor].lx_queue, wait);
400
401         if (rtlx == NULL)
402                 return 0;
403
404         /* data available to read? */
405         if (rtlx_read_poll(minor, 0))
406                 mask |= POLLIN | POLLRDNORM;
407
408         /* space to write */
409         if (rtlx_write_poll(minor))
410                 mask |= POLLOUT | POLLWRNORM;
411
412         return mask;
413 }
414
415 static ssize_t file_read(struct file *file, char __user * buffer, size_t count,
416                          loff_t * ppos)
417 {
418         int minor = iminor(file->f_path.dentry->d_inode);
419
420         /* data available? */
421         if (!rtlx_read_poll(minor, (file->f_flags & O_NONBLOCK) ? 0 : 1)) {
422                 return 0;       // -EAGAIN makes cat whinge
423         }
424
425         return rtlx_read(minor, buffer, count);
426 }
427
428 static ssize_t file_write(struct file *file, const char __user * buffer,
429                           size_t count, loff_t * ppos)
430 {
431         int minor;
432         struct rtlx_channel *rt;
433
434         minor = iminor(file->f_path.dentry->d_inode);
435         rt = &rtlx->channel[minor];
436
437         /* any space left... */
438         if (!rtlx_write_poll(minor)) {
439                 int ret = 0;
440
441                 if (file->f_flags & O_NONBLOCK)
442                         return -EAGAIN;
443
444                 __wait_event_interruptible(channel_wqs[minor].rt_queue,
445                                            rtlx_write_poll(minor),
446                                            ret);
447                 if (ret)
448                         return ret;
449         }
450
451         return rtlx_write(minor, buffer, count);
452 }
453
454 static const struct file_operations rtlx_fops = {
455         .owner =   THIS_MODULE,
456         .open =    file_open,
457         .release = file_release,
458         .write =   file_write,
459         .read =    file_read,
460         .poll =    file_poll
461 };
462
463 static struct irqaction rtlx_irq = {
464         .handler        = rtlx_interrupt,
465         .flags          = IRQF_DISABLED,
466         .name           = "RTLX",
467 };
468
469 static int rtlx_irq_num = MIPS_CPU_IRQ_BASE + MIPS_CPU_RTLX_IRQ;
470
471 static char register_chrdev_failed[] __initdata =
472         KERN_ERR "rtlx_module_init: unable to register device\n";
473
474 static int rtlx_module_init(void)
475 {
476         struct device *dev;
477         int i, err;
478
479         major = register_chrdev(0, module_name, &rtlx_fops);
480         if (major < 0) {
481                 printk(register_chrdev_failed);
482                 return major;
483         }
484
485         /* initialise the wait queues */
486         for (i = 0; i < RTLX_CHANNELS; i++) {
487                 init_waitqueue_head(&channel_wqs[i].rt_queue);
488                 init_waitqueue_head(&channel_wqs[i].lx_queue);
489                 atomic_set(&channel_wqs[i].in_open, 0);
490                 mutex_init(&channel_wqs[i].mutex);
491
492                 dev = device_create(mt_class, NULL, MKDEV(major, i),
493                                     "%s%d", module_name, i);
494                 if (IS_ERR(dev)) {
495                         err = PTR_ERR(dev);
496                         goto out_chrdev;
497                 }
498         }
499
500         /* set up notifiers */
501         notify.start = starting;
502         notify.stop = stopping;
503         vpe_notify(RTLX_TARG_VPE, &notify);
504
505         if (cpu_has_vint)
506                 set_vi_handler(MIPS_CPU_RTLX_IRQ, rtlx_dispatch);
507
508         rtlx_irq.dev_id = rtlx;
509         setup_irq(rtlx_irq_num, &rtlx_irq);
510
511         return 0;
512
513 out_chrdev:
514         for (i = 0; i < RTLX_CHANNELS; i++)
515                 device_destroy(mt_class, MKDEV(major, i));
516
517         return err;
518 }
519
520 static void __exit rtlx_module_exit(void)
521 {
522         int i;
523
524         for (i = 0; i < RTLX_CHANNELS; i++)
525                 device_destroy(mt_class, MKDEV(major, i));
526
527         unregister_chrdev(major, module_name);
528 }
529
530 module_init(rtlx_module_init);
531 module_exit(rtlx_module_exit);
532
533 MODULE_DESCRIPTION("MIPS RTLX");
534 MODULE_AUTHOR("Elizabeth Oldham, MIPS Technologies, Inc.");
535 MODULE_LICENSE("GPL");