rtlx.c 12.2 KB
Newer Older
1 2
/*
 * Copyright (C) 2005 MIPS Technologies, Inc.  All rights reserved.
R
Ralf Baechle 已提交
3
 * Copyright (C) 2005, 06 Ralf Baechle (ralf@linux-mips.org)
4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
 *
 *  This program is free software; you can distribute it and/or modify it
 *  under the terms of the GNU General Public License (Version 2) as
 *  published by the Free Software Foundation.
 *
 *  This program is distributed in the hope it will be useful, but WITHOUT
 *  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 *  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 *  for more details.
 *
 *  You should have received a copy of the GNU General Public License along
 *  with this program; if not, write to the Free Software Foundation, Inc.,
 *  59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
 *
 */

20
#include <linux/device.h>
21 22 23
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
24 25 26 27 28 29 30
#include <asm/uaccess.h>
#include <linux/list.h>
#include <linux/vmalloc.h>
#include <linux/elf.h>
#include <linux/seq_file.h>
#include <linux/syscalls.h>
#include <linux/moduleloader.h>
R
Ralf Baechle 已提交
31
#include <linux/interrupt.h>
32 33 34 35
#include <linux/poll.h>
#include <linux/sched.h>
#include <linux/wait.h>
#include <asm/mipsmtregs.h>
36
#include <asm/mips_mt.h>
37
#include <asm/cacheflush.h>
A
Arun Sharma 已提交
38
#include <linux/atomic.h>
39 40
#include <asm/cpu.h>
#include <asm/processor.h>
41 42
#include <asm/system.h>
#include <asm/vpe.h>
43 44
#include <asm/rtlx.h>

R
Ralf Baechle 已提交
45
static struct rtlx_info *rtlx;
46 47 48 49 50 51
static int major;
static char module_name[] = "rtlx";

static struct chan_waitqueues {
	wait_queue_head_t rt_queue;
	wait_queue_head_t lx_queue;
52
	atomic_t in_open;
53
	struct mutex mutex;
54 55
} channel_wqs[RTLX_CHANNELS];

56
static struct vpe_notifications notify;
57
static int sp_stopping;
58

59 60
extern void *vpe_get_shared(int index);

61
static void rtlx_dispatch(void)
62
{
63
	do_IRQ(MIPS_CPU_IRQ_BASE + MIPS_CPU_RTLX_IRQ);
64 65
}

66 67 68 69

/* Interrupt handler may be called before rtlx_init has otherwise had
   a chance to run.
*/
70
static irqreturn_t rtlx_interrupt(int irq, void *dev_id)
71
{
R
Ralf Baechle 已提交
72 73
	unsigned int vpeflags;
	unsigned long flags;
74
	int i;
75 76 77 78 79 80 81 82

	/* Ought not to be strictly necessary for SMTC builds */
	local_irq_save(flags);
	vpeflags = dvpe();
	set_c0_status(0x100 << MIPS_CPU_RTLX_IRQ);
	irq_enable_hazard();
	evpe(vpeflags);
	local_irq_restore(flags);
83 84

	for (i = 0; i < RTLX_CHANNELS; i++) {
85 86
			wake_up(&channel_wqs[i].lx_queue);
			wake_up(&channel_wqs[i].rt_queue);
87 88
	}

R
Ralf Baechle 已提交
89
	return IRQ_HANDLED;
90 91
}

92
static void __used dump_rtlx(void)
93 94 95
{
	int i;

96
	printk("id 0x%lx state %d\n", rtlx->id, rtlx->state);
97 98

	for (i = 0; i < RTLX_CHANNELS; i++) {
99
		struct rtlx_channel *chan = &rtlx->channel[i];
100

101 102
		printk(" rt_state %d lx_state %d buffer_size %d\n",
		       chan->rt_state, chan->lx_state, chan->buffer_size);
103

104 105
		printk(" rt_read %d rt_write %d\n",
		       chan->rt_read, chan->rt_write);
106

107 108 109 110 111 112 113 114 115 116 117 118
		printk(" lx_read %d lx_write %d\n",
		       chan->lx_read, chan->lx_write);

		printk(" rt_buffer <%s>\n", chan->rt_buffer);
		printk(" lx_buffer <%s>\n", chan->lx_buffer);
	}
}

/* call when we have the address of the shared structure from the SP side. */
static int rtlx_init(struct rtlx_info *rtlxi)
{
	if (rtlxi->id != RTLX_ID) {
119 120
		printk(KERN_ERR "no valid RTLX id at 0x%p 0x%lx\n",
			rtlxi, rtlxi->id);
121 122
		return -ENOEXEC;
	}
123 124

	rtlx = rtlxi;
R
Ralf Baechle 已提交
125 126

	return 0;
127 128
}

129 130
/* notifications */
static void starting(int vpe)
131
{
132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154
	int i;
	sp_stopping = 0;

	/* force a reload of rtlx */
	rtlx=NULL;

	/* wake up any sleeping rtlx_open's */
	for (i = 0; i < RTLX_CHANNELS; i++)
		wake_up_interruptible(&channel_wqs[i].lx_queue);
}

static void stopping(int vpe)
{
	int i;

	sp_stopping = 1;
	for (i = 0; i < RTLX_CHANNELS; i++)
		wake_up_interruptible(&channel_wqs[i].lx_queue);
}


int rtlx_open(int index, int can_sleep)
{
155
	struct rtlx_info **p;
156
	struct rtlx_channel *chan;
157
	enum rtlx_state state;
158
	int ret = 0;
159

160 161 162 163 164
	if (index >= RTLX_CHANNELS) {
		printk(KERN_DEBUG "rtlx_open index out of range\n");
		return -ENOSYS;
	}

165 166 167 168 169
	if (atomic_inc_return(&channel_wqs[index].in_open) > 1) {
		printk(KERN_DEBUG "rtlx_open channel %d already opened\n",
		       index);
		ret = -EBUSY;
		goto out_fail;
170 171
	}

172
	if (rtlx == NULL) {
173
		if( (p = vpe_get_shared(tclimit)) == NULL) {
174 175 176 177
		    if (can_sleep) {
			__wait_event_interruptible(channel_wqs[index].lx_queue,
				(p = vpe_get_shared(tclimit)), ret);
			if (ret)
178
				goto out_fail;
179 180 181 182 183 184
		    } else {
			printk(KERN_DEBUG "No SP program loaded, and device "
					"opened with O_NONBLOCK\n");
			ret = -ENOSYS;
			goto out_fail;
		    }
185 186
		}

187
		smp_rmb();
188
		if (*p == NULL) {
189
			if (can_sleep) {
190 191 192
				DEFINE_WAIT(wait);

				for (;;) {
193 194 195
					prepare_to_wait(
						&channel_wqs[index].lx_queue,
						&wait, TASK_INTERRUPTIBLE);
196 197 198 199 200 201 202 203
					smp_rmb();
					if (*p != NULL)
						break;
					if (!signal_pending(current)) {
						schedule();
						continue;
					}
					ret = -ERESTARTSYS;
204
					goto out_fail;
205 206
				}
				finish_wait(&channel_wqs[index].lx_queue, &wait);
207
			} else {
208
				pr_err(" *vpe_get_shared is NULL. "
209
				       "Has an SP program been loaded?\n");
210 211
				ret = -ENOSYS;
				goto out_fail;
212 213 214 215
			}
		}

		if ((unsigned int)*p < KSEG0) {
216 217 218
			printk(KERN_WARNING "vpe_get_shared returned an "
			       "invalid pointer maybe an error code %d\n",
			       (int)*p);
219 220
			ret = -ENOSYS;
			goto out_fail;
221 222
		}

223 224
		if ((ret = rtlx_init(*p)) < 0)
			goto out_ret;
225 226
	}

227
	chan = &rtlx->channel[index];
228

229 230 231 232 233
	state = xchg(&chan->lx_state, RTLX_STATE_OPENED);
	if (state == RTLX_STATE_OPENED) {
		ret = -EBUSY;
		goto out_fail;
	}
234 235

out_fail:
236 237 238
	smp_mb();
	atomic_dec(&channel_wqs[index].in_open);
	smp_mb();
239

240
out_ret:
241
	return ret;
242 243
}

244
int rtlx_release(int index)
245
{
246 247 248 249
	if (rtlx == NULL) {
		pr_err("rtlx_release() with null rtlx\n");
		return 0;
	}
250
	rtlx->channel[index].lx_state = RTLX_STATE_UNUSED;
R
Ralf Baechle 已提交
251
	return 0;
252 253
}

254
unsigned int rtlx_read_poll(int index, int can_sleep)
255
{
256
 	struct rtlx_channel *chan;
257

258 259
 	if (rtlx == NULL)
 		return 0;
260

261
 	chan = &rtlx->channel[index];
262 263

	/* data available to read? */
264 265
	if (chan->lx_read == chan->lx_write) {
		if (can_sleep) {
266
			int ret = 0;
267

268
			__wait_event_interruptible(channel_wqs[index].lx_queue,
269 270
				(chan->lx_read != chan->lx_write) ||
				sp_stopping, ret);
271 272
			if (ret)
				return ret;
273

274 275 276
			if (sp_stopping)
				return 0;
		} else
277 278 279 280 281
			return 0;
	}

	return (chan->lx_write + chan->buffer_size - chan->lx_read)
	       % chan->buffer_size;
282 283
}

284
static inline int write_spacefree(int read, int write, int size)
285
{
286 287 288 289 290 291 292
	if (read == write) {
		/*
		 * Never fill the buffer completely, so indexes are always
		 * equal if empty and only empty, or !equal if data available
		 */
		return size - 1;
	}
293

294 295
	return ((read + size - write) % size) - 1;
}
296

297 298 299
unsigned int rtlx_write_poll(int index)
{
	struct rtlx_channel *chan = &rtlx->channel[index];
300 301 302

	return write_spacefree(chan->rt_read, chan->rt_write,
				chan->buffer_size);
303
}
304

305
ssize_t rtlx_read(int index, void __user *buff, size_t count)
306
{
307
	size_t lx_write, fl = 0L;
308
	struct rtlx_channel *lx;
309
	unsigned long failed;
310

311 312 313 314
	if (rtlx == NULL)
		return -ENOSYS;

	lx = &rtlx->channel[index];
315

316
	mutex_lock(&channel_wqs[index].mutex);
317 318 319
	smp_rmb();
	lx_write = lx->lx_write;

320
	/* find out how much in total */
R
Ralf Baechle 已提交
321
	count = min(count,
322
		     (size_t)(lx_write + lx->buffer_size - lx->lx_read)
323
		     % lx->buffer_size);
324 325

	/* then how much from the read pointer onwards */
326
	fl = min(count, (size_t)lx->buffer_size - lx->lx_read);
327

328 329 330
	failed = copy_to_user(buff, lx->lx_buffer + lx->lx_read, fl);
	if (failed)
		goto out;
331 332

	/* and if there is anything left at the beginning of the buffer */
333
	if (count - fl)
334 335 336 337
		failed = copy_to_user(buff + fl, lx->lx_buffer, count - fl);

out:
	count -= failed;
338

339 340 341
	smp_wmb();
	lx->lx_read = (lx->lx_read + count) % lx->buffer_size;
	smp_wmb();
342
	mutex_unlock(&channel_wqs[index].mutex);
343

R
Ralf Baechle 已提交
344
	return count;
345 346
}

347
ssize_t rtlx_write(int index, const void __user *buffer, size_t count)
348 349
{
	struct rtlx_channel *rt;
350
	unsigned long failed;
351
	size_t rt_read;
352 353 354 355 356 357 358
	size_t fl;

	if (rtlx == NULL)
		return(-ENOSYS);

	rt = &rtlx->channel[index];

359
	mutex_lock(&channel_wqs[index].mutex);
360 361 362
	smp_rmb();
	rt_read = rt->rt_read;

363
	/* total number of bytes to copy */
364 365
	count = min(count, (size_t)write_spacefree(rt_read, rt->rt_write,
							rt->buffer_size));
366 367 368 369

	/* first bit from write pointer to the end of the buffer, or count */
	fl = min(count, (size_t) rt->buffer_size - rt->rt_write);

370 371 372
	failed = copy_from_user(rt->rt_buffer + rt->rt_write, buffer, fl);
	if (failed)
		goto out;
373 374

	/* if there's any left copy to the beginning of the buffer */
375 376 377 378 379
	if (count - fl) {
		failed = copy_from_user(rt->rt_buffer, buffer + fl, count - fl);
	}

out:
380
	count -= failed;
381

382 383 384
	smp_wmb();
	rt->rt_write = (rt->rt_write + count) % rt->buffer_size;
	smp_wmb();
385
	mutex_unlock(&channel_wqs[index].mutex);
386

387
	return count;
388 389 390 391 392
}


static int file_open(struct inode *inode, struct file *filp)
{
R
Ralf Baechle 已提交
393
	return rtlx_open(iminor(inode), (filp->f_flags & O_NONBLOCK) ? 0 : 1);
394 395 396 397
}

static int file_release(struct inode *inode, struct file *filp)
{
R
Ralf Baechle 已提交
398
	return rtlx_release(iminor(inode));
399 400 401 402 403 404 405
}

static unsigned int file_poll(struct file *file, poll_table * wait)
{
	int minor;
	unsigned int mask = 0;

J
Josef Sipek 已提交
406
	minor = iminor(file->f_path.dentry->d_inode);
407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427

	poll_wait(file, &channel_wqs[minor].rt_queue, wait);
	poll_wait(file, &channel_wqs[minor].lx_queue, wait);

	if (rtlx == NULL)
		return 0;

	/* data available to read? */
	if (rtlx_read_poll(minor, 0))
		mask |= POLLIN | POLLRDNORM;

	/* space to write */
	if (rtlx_write_poll(minor))
		mask |= POLLOUT | POLLWRNORM;

	return mask;
}

static ssize_t file_read(struct file *file, char __user * buffer, size_t count,
			 loff_t * ppos)
{
J
Josef Sipek 已提交
428
	int minor = iminor(file->f_path.dentry->d_inode);
429 430 431 432 433 434

	/* data available? */
	if (!rtlx_read_poll(minor, (file->f_flags & O_NONBLOCK) ? 0 : 1)) {
		return 0;	// -EAGAIN makes cat whinge
	}

435
	return rtlx_read(minor, buffer, count);
436 437 438
}

static ssize_t file_write(struct file *file, const char __user * buffer,
439 440 441 442 443
			  size_t count, loff_t * ppos)
{
	int minor;
	struct rtlx_channel *rt;

J
Josef Sipek 已提交
444
	minor = iminor(file->f_path.dentry->d_inode);
445 446 447
	rt = &rtlx->channel[minor];

	/* any space left... */
448
	if (!rtlx_write_poll(minor)) {
449
		int ret = 0;
450 451

		if (file->f_flags & O_NONBLOCK)
R
Ralf Baechle 已提交
452
			return -EAGAIN;
453

454 455 456 457 458
		__wait_event_interruptible(channel_wqs[minor].rt_queue,
		                           rtlx_write_poll(minor),
		                           ret);
		if (ret)
			return ret;
459 460
	}

461
	return rtlx_write(minor, buffer, count);
462 463
}

464
static const struct file_operations rtlx_fops = {
465 466 467 468 469
	.owner =   THIS_MODULE,
	.open =    file_open,
	.release = file_release,
	.write =   file_write,
	.read =    file_read,
470 471
	.poll =    file_poll,
	.llseek =  noop_llseek,
472 473
};

474 475 476 477 478
static struct irqaction rtlx_irq = {
	.handler	= rtlx_interrupt,
	.name		= "RTLX",
};

479
static int rtlx_irq_num = MIPS_CPU_IRQ_BASE + MIPS_CPU_RTLX_IRQ;
480

R
Ralf Baechle 已提交
481 482 483
static char register_chrdev_failed[] __initdata =
	KERN_ERR "rtlx_module_init: unable to register device\n";

R
Ralf Baechle 已提交
484
static int __init rtlx_module_init(void)
485
{
486 487
	struct device *dev;
	int i, err;
488

489 490 491 492 493 494 495 496 497 498 499 500 501
	if (!cpu_has_mipsmt) {
		printk("VPE loader: not a MIPS MT capable processor\n");
		return -ENODEV;
	}

	if (tclimit == 0) {
		printk(KERN_WARNING "No TCs reserved for AP/SP, not "
		       "initializing RTLX.\nPass maxtcs=<n> argument as kernel "
		       "argument\n");

		return -ENODEV;
	}

R
Ralf Baechle 已提交
502 503 504 505
	major = register_chrdev(0, module_name, &rtlx_fops);
	if (major < 0) {
		printk(register_chrdev_failed);
		return major;
506 507
	}

508 509 510 511
	/* initialise the wait queues */
	for (i = 0; i < RTLX_CHANNELS; i++) {
		init_waitqueue_head(&channel_wqs[i].rt_queue);
		init_waitqueue_head(&channel_wqs[i].lx_queue);
512
		atomic_set(&channel_wqs[i].in_open, 0);
513
		mutex_init(&channel_wqs[i].mutex);
514

515 516
		dev = device_create(mt_class, NULL, MKDEV(major, i), NULL,
				    "%s%d", module_name, i);
517 518 519 520
		if (IS_ERR(dev)) {
			err = PTR_ERR(dev);
			goto out_chrdev;
		}
521 522 523 524 525
	}

	/* set up notifiers */
	notify.start = starting;
	notify.stop = stopping;
526
	vpe_notify(tclimit, &notify);
527 528 529

	if (cpu_has_vint)
		set_vi_handler(MIPS_CPU_RTLX_IRQ, rtlx_dispatch);
530 531 532 533 534
	else {
		pr_err("APRP RTLX init on non-vectored-interrupt processor\n");
		err = -ENODEV;
		goto out_chrdev;
	}
535 536 537 538

	rtlx_irq.dev_id = rtlx;
	setup_irq(rtlx_irq_num, &rtlx_irq);

R
Ralf Baechle 已提交
539
	return 0;
540 541 542 543 544 545

out_chrdev:
	for (i = 0; i < RTLX_CHANNELS; i++)
		device_destroy(mt_class, MKDEV(major, i));

	return err;
546 547
}

R
Ralf Baechle 已提交
548
static void __exit rtlx_module_exit(void)
549
{
550 551 552 553 554
	int i;

	for (i = 0; i < RTLX_CHANNELS; i++)
		device_destroy(mt_class, MKDEV(major, i));

555 556 557 558 559
	unregister_chrdev(major, module_name);
}

module_init(rtlx_module_init);
module_exit(rtlx_module_exit);
R
Ralf Baechle 已提交
560

561
MODULE_DESCRIPTION("MIPS RTLX");
562
MODULE_AUTHOR("Elizabeth Oldham, MIPS Technologies, Inc.");
563
MODULE_LICENSE("GPL");