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
49static struct rtlx_info *rtlx;
50static int major;
51static char module_name[] = "rtlx";
52
53static 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
60static struct irqaction irq;
61static int irq_num;
62static struct vpe_notifications notify;
63static int sp_stopping = 0;
64
65extern void *vpe_get_shared(int index);
66
67static 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*/
76static 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
88static __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. */
112static 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 */
125static 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
138static 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
148int 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
228out_fail:
229	smp_mb();
230	atomic_dec(&channel_wqs[index].in_open);
231	smp_mb();
232
233out_ret:
234	return ret;
235}
236
237int rtlx_release(int index)
238{
239	rtlx->channel[index].lx_state = RTLX_STATE_UNUSED;
240	return 0;
241}
242
243unsigned 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
273static 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
286unsigned 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
292ssize_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
323out:
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
334ssize_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
366out:
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
378static 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
385static int file_release(struct inode *inode, struct file *filp)
386{
387	int minor = iminor(inode);
388
389	return rtlx_release(minor);
390}
391
392static 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
416static 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
429static 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
455static 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
464static struct irqaction rtlx_irq = {
465	.handler	= rtlx_interrupt,
466	.flags		= IRQF_DISABLED,
467	.name		= "RTLX",
468};
469
470static int rtlx_irq_num = MIPS_CPU_IRQ_BASE + MIPS_CPU_RTLX_IRQ;
471
472static char register_chrdev_failed[] __initdata =
473	KERN_ERR "rtlx_module_init: unable to register device\n";
474
475static 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
514out_chrdev:
515	for (i = 0; i < RTLX_CHANNELS; i++)
516		device_destroy(mt_class, MKDEV(major, i));
517
518	return err;
519}
520
521static 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
531module_init(rtlx_module_init);
532module_exit(rtlx_module_exit);
533
534MODULE_DESCRIPTION("MIPS RTLX");
535MODULE_AUTHOR("Elizabeth Oldham, MIPS Technologies, Inc.");
536MODULE_LICENSE("GPL");
537