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, ¬ify); 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