]> git.openfabrics.org - ~shefty/rdma-dev.git/blob - arch/mips/kernel/rtlx.c
[MIPS] Replace __attribute_used__ with __used
[~shefty/rdma-dev.git] / 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 void __used 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)
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)
335 {
336         struct rtlx_channel *rt;
337         unsigned long failed;
338         size_t rt_read;
339         size_t fl;
340
341         if (rtlx == NULL)
342                 return(-ENOSYS);
343
344         rt = &rtlx->channel[index];
345
346         mutex_lock(&channel_wqs[index].mutex);
347         smp_rmb();
348         rt_read = rt->rt_read;
349
350         /* total number of bytes to copy */
351         count = min(count,
352                     (size_t)write_spacefree(rt_read, rt->rt_write, rt->buffer_size));
353
354         /* first bit from write pointer to the end of the buffer, or count */
355         fl = min(count, (size_t) rt->buffer_size - rt->rt_write);
356
357         failed = copy_from_user(rt->rt_buffer + rt->rt_write, buffer, fl);
358         if (failed)
359                 goto out;
360
361         /* if there's any left copy to the beginning of the buffer */
362         if (count - fl) {
363                 failed = copy_from_user(rt->rt_buffer, buffer + fl, count - fl);
364         }
365
366 out:
367         count -= failed;
368
369         smp_wmb();
370         rt->rt_write = (rt->rt_write + count) % rt->buffer_size;
371         smp_wmb();
372         mutex_unlock(&channel_wqs[index].mutex);
373
374         return count;
375 }
376
377
378 static int file_open(struct inode *inode, struct file *filp)
379 {
380         int minor = iminor(inode);
381
382         return rtlx_open(minor, (filp->f_flags & O_NONBLOCK) ? 0 : 1);
383 }
384
385 static int file_release(struct inode *inode, struct file *filp)
386 {
387         int minor = iminor(inode);
388
389         return rtlx_release(minor);
390 }
391
392 static unsigned int file_poll(struct file *file, poll_table * wait)
393 {
394         int minor;
395         unsigned int mask = 0;
396
397         minor = iminor(file->f_path.dentry->d_inode);
398
399         poll_wait(file, &channel_wqs[minor].rt_queue, wait);
400         poll_wait(file, &channel_wqs[minor].lx_queue, wait);
401
402         if (rtlx == NULL)
403                 return 0;
404
405         /* data available to read? */
406         if (rtlx_read_poll(minor, 0))
407                 mask |= POLLIN | POLLRDNORM;
408
409         /* space to write */
410         if (rtlx_write_poll(minor))
411                 mask |= POLLOUT | POLLWRNORM;
412
413         return mask;
414 }
415
416 static ssize_t file_read(struct file *file, char __user * buffer, size_t count,
417                          loff_t * ppos)
418 {
419         int minor = iminor(file->f_path.dentry->d_inode);
420
421         /* data available? */
422         if (!rtlx_read_poll(minor, (file->f_flags & O_NONBLOCK) ? 0 : 1)) {
423                 return 0;       // -EAGAIN makes cat whinge
424         }
425
426         return rtlx_read(minor, buffer, count);
427 }
428
429 static ssize_t file_write(struct file *file, const char __user * buffer,
430                           size_t count, loff_t * ppos)
431 {
432         int minor;
433         struct rtlx_channel *rt;
434
435         minor = iminor(file->f_path.dentry->d_inode);
436         rt = &rtlx->channel[minor];
437
438         /* any space left... */
439         if (!rtlx_write_poll(minor)) {
440                 int ret = 0;
441
442                 if (file->f_flags & O_NONBLOCK)
443                         return -EAGAIN;
444
445                 __wait_event_interruptible(channel_wqs[minor].rt_queue,
446                                            rtlx_write_poll(minor),
447                                            ret);
448                 if (ret)
449                         return ret;
450         }
451
452         return rtlx_write(minor, buffer, count);
453 }
454
455 static const struct file_operations rtlx_fops = {
456         .owner =   THIS_MODULE,
457         .open =    file_open,
458         .release = file_release,
459         .write =   file_write,
460         .read =    file_read,
461         .poll =    file_poll
462 };
463
464 static struct irqaction rtlx_irq = {
465         .handler        = rtlx_interrupt,
466         .flags          = IRQF_DISABLED,
467         .name           = "RTLX",
468 };
469
470 static int rtlx_irq_num = MIPS_CPU_IRQ_BASE + MIPS_CPU_RTLX_IRQ;
471
472 static char register_chrdev_failed[] __initdata =
473         KERN_ERR "rtlx_module_init: unable to register device\n";
474
475 static int rtlx_module_init(void)
476 {
477         struct device *dev;
478         int i, err;
479
480         major = register_chrdev(0, module_name, &rtlx_fops);
481         if (major < 0) {
482                 printk(register_chrdev_failed);
483                 return major;
484         }
485
486         /* initialise the wait queues */
487         for (i = 0; i < RTLX_CHANNELS; i++) {
488                 init_waitqueue_head(&channel_wqs[i].rt_queue);
489                 init_waitqueue_head(&channel_wqs[i].lx_queue);
490                 atomic_set(&channel_wqs[i].in_open, 0);
491                 mutex_init(&channel_wqs[i].mutex);
492
493                 dev = device_create(mt_class, NULL, MKDEV(major, i),
494                                     "%s%d", module_name, i);
495                 if (IS_ERR(dev)) {
496                         err = PTR_ERR(dev);
497                         goto out_chrdev;
498                 }
499         }
500
501         /* set up notifiers */
502         notify.start = starting;
503         notify.stop = stopping;
504         vpe_notify(RTLX_TARG_VPE, &notify);
505
506         if (cpu_has_vint)
507                 set_vi_handler(MIPS_CPU_RTLX_IRQ, rtlx_dispatch);
508
509         rtlx_irq.dev_id = rtlx;
510         setup_irq(rtlx_irq_num, &rtlx_irq);
511
512         return 0;
513
514 out_chrdev:
515         for (i = 0; i < RTLX_CHANNELS; i++)
516                 device_destroy(mt_class, MKDEV(major, i));
517
518         return err;
519 }
520
521 static void __exit rtlx_module_exit(void)
522 {
523         int i;
524
525         for (i = 0; i < RTLX_CHANNELS; i++)
526                 device_destroy(mt_class, MKDEV(major, i));
527
528         unregister_chrdev(major, module_name);
529 }
530
531 module_init(rtlx_module_init);
532 module_exit(rtlx_module_exit);
533
534 MODULE_DESCRIPTION("MIPS RTLX");
535 MODULE_AUTHOR("Elizabeth Oldham, MIPS Technologies, Inc.");
536 MODULE_LICENSE("GPL");