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 static struct rtlx_info *rtlx; 48 static int major; 49 static char module_name[] = "rtlx"; 50 51 static struct chan_waitqueues { 52 wait_queue_head_t rt_queue; 53 wait_queue_head_t lx_queue; 54 atomic_t in_open; 55 struct mutex mutex; 56 } channel_wqs[RTLX_CHANNELS]; 57 58 static struct vpe_notifications notify; 59 static int sp_stopping; 60 61 extern void *vpe_get_shared(int index); 62 63 static void rtlx_dispatch(void) 64 { 65 do_IRQ(MIPS_CPU_IRQ_BASE + MIPS_CPU_RTLX_IRQ); 66 } 67 68 69 /* Interrupt handler may be called before rtlx_init has otherwise had 70 a chance to run. 71 */ 72 static irqreturn_t rtlx_interrupt(int irq, void *dev_id) 73 { 74 unsigned int vpeflags; 75 unsigned long flags; 76 int i; 77 78 /* Ought not to be strictly necessary for SMTC builds */ 79 local_irq_save(flags); 80 vpeflags = dvpe(); 81 set_c0_status(0x100 << MIPS_CPU_RTLX_IRQ); 82 irq_enable_hazard(); 83 evpe(vpeflags); 84 local_irq_restore(flags); 85 86 for (i = 0; i < RTLX_CHANNELS; i++) { 87 wake_up(&channel_wqs[i].lx_queue); 88 wake_up(&channel_wqs[i].rt_queue); 89 } 90 91 return IRQ_HANDLED; 92 } 93 94 static void __used dump_rtlx(void) 95 { 96 int i; 97 98 printk("id 0x%lx state %d\n", rtlx->id, rtlx->state); 99 100 for (i = 0; i < RTLX_CHANNELS; i++) { 101 struct rtlx_channel *chan = &rtlx->channel[i]; 102 103 printk(" rt_state %d lx_state %d buffer_size %d\n", 104 chan->rt_state, chan->lx_state, chan->buffer_size); 105 106 printk(" rt_read %d rt_write %d\n", 107 chan->rt_read, chan->rt_write); 108 109 printk(" lx_read %d lx_write %d\n", 110 chan->lx_read, chan->lx_write); 111 112 printk(" rt_buffer <%s>\n", chan->rt_buffer); 113 printk(" lx_buffer <%s>\n", chan->lx_buffer); 114 } 115 } 116 117 /* call when we have the address of the shared structure from the SP side. */ 118 static int rtlx_init(struct rtlx_info *rtlxi) 119 { 120 if (rtlxi->id != RTLX_ID) { 121 printk(KERN_ERR "no valid RTLX id at 0x%p 0x%lx\n", 122 rtlxi, rtlxi->id); 123 return -ENOEXEC; 124 } 125 126 rtlx = rtlxi; 127 128 return 0; 129 } 130 131 /* notifications */ 132 static void starting(int vpe) 133 { 134 int i; 135 sp_stopping = 0; 136 137 /* force a reload of rtlx */ 138 rtlx=NULL; 139 140 /* wake up any sleeping rtlx_open's */ 141 for (i = 0; i < RTLX_CHANNELS; i++) 142 wake_up_interruptible(&channel_wqs[i].lx_queue); 143 } 144 145 static void stopping(int vpe) 146 { 147 int i; 148 149 sp_stopping = 1; 150 for (i = 0; i < RTLX_CHANNELS; i++) 151 wake_up_interruptible(&channel_wqs[i].lx_queue); 152 } 153 154 155 int rtlx_open(int index, int can_sleep) 156 { 157 struct rtlx_info **p; 158 struct rtlx_channel *chan; 159 enum rtlx_state state; 160 int ret = 0; 161 162 if (index >= RTLX_CHANNELS) { 163 printk(KERN_DEBUG "rtlx_open index out of range\n"); 164 return -ENOSYS; 165 } 166 167 if (atomic_inc_return(&channel_wqs[index].in_open) > 1) { 168 printk(KERN_DEBUG "rtlx_open channel %d already opened\n", 169 index); 170 ret = -EBUSY; 171 goto out_fail; 172 } 173 174 if (rtlx == NULL) { 175 if( (p = vpe_get_shared(tclimit)) == NULL) { 176 if (can_sleep) { 177 __wait_event_interruptible(channel_wqs[index].lx_queue, 178 (p = vpe_get_shared(tclimit)), ret); 179 if (ret) 180 goto out_fail; 181 } else { 182 printk(KERN_DEBUG "No SP program loaded, and device " 183 "opened with O_NONBLOCK\n"); 184 ret = -ENOSYS; 185 goto out_fail; 186 } 187 } 188 189 smp_rmb(); 190 if (*p == NULL) { 191 if (can_sleep) { 192 DEFINE_WAIT(wait); 193 194 for (;;) { 195 prepare_to_wait( 196 &channel_wqs[index].lx_queue, 197 &wait, TASK_INTERRUPTIBLE); 198 smp_rmb(); 199 if (*p != NULL) 200 break; 201 if (!signal_pending(current)) { 202 schedule(); 203 continue; 204 } 205 ret = -ERESTARTSYS; 206 goto out_fail; 207 } 208 finish_wait(&channel_wqs[index].lx_queue, &wait); 209 } else { 210 pr_err(" *vpe_get_shared is NULL. " 211 "Has an SP program been loaded?\n"); 212 ret = -ENOSYS; 213 goto out_fail; 214 } 215 } 216 217 if ((unsigned int)*p < KSEG0) { 218 printk(KERN_WARNING "vpe_get_shared returned an " 219 "invalid pointer maybe an error code %d\n", 220 (int)*p); 221 ret = -ENOSYS; 222 goto out_fail; 223 } 224 225 if ((ret = rtlx_init(*p)) < 0) 226 goto out_ret; 227 } 228 229 chan = &rtlx->channel[index]; 230 231 state = xchg(&chan->lx_state, RTLX_STATE_OPENED); 232 if (state == RTLX_STATE_OPENED) { 233 ret = -EBUSY; 234 goto out_fail; 235 } 236 237 out_fail: 238 smp_mb(); 239 atomic_dec(&channel_wqs[index].in_open); 240 smp_mb(); 241 242 out_ret: 243 return ret; 244 } 245 246 int rtlx_release(int index) 247 { 248 if (rtlx == NULL) { 249 pr_err("rtlx_release() with null rtlx\n"); 250 return 0; 251 } 252 rtlx->channel[index].lx_state = RTLX_STATE_UNUSED; 253 return 0; 254 } 255 256 unsigned int rtlx_read_poll(int index, int can_sleep) 257 { 258 struct rtlx_channel *chan; 259 260 if (rtlx == NULL) 261 return 0; 262 263 chan = &rtlx->channel[index]; 264 265 /* data available to read? */ 266 if (chan->lx_read == chan->lx_write) { 267 if (can_sleep) { 268 int ret = 0; 269 270 __wait_event_interruptible(channel_wqs[index].lx_queue, 271 (chan->lx_read != chan->lx_write) || 272 sp_stopping, ret); 273 if (ret) 274 return ret; 275 276 if (sp_stopping) 277 return 0; 278 } else 279 return 0; 280 } 281 282 return (chan->lx_write + chan->buffer_size - chan->lx_read) 283 % chan->buffer_size; 284 } 285 286 static inline int write_spacefree(int read, int write, int size) 287 { 288 if (read == write) { 289 /* 290 * Never fill the buffer completely, so indexes are always 291 * equal if empty and only empty, or !equal if data available 292 */ 293 return size - 1; 294 } 295 296 return ((read + size - write) % size) - 1; 297 } 298 299 unsigned int rtlx_write_poll(int index) 300 { 301 struct rtlx_channel *chan = &rtlx->channel[index]; 302 303 return write_spacefree(chan->rt_read, chan->rt_write, 304 chan->buffer_size); 305 } 306 307 ssize_t rtlx_read(int index, void __user *buff, size_t count) 308 { 309 size_t lx_write, fl = 0L; 310 struct rtlx_channel *lx; 311 unsigned long failed; 312 313 if (rtlx == NULL) 314 return -ENOSYS; 315 316 lx = &rtlx->channel[index]; 317 318 mutex_lock(&channel_wqs[index].mutex); 319 smp_rmb(); 320 lx_write = lx->lx_write; 321 322 /* find out how much in total */ 323 count = min(count, 324 (size_t)(lx_write + lx->buffer_size - lx->lx_read) 325 % lx->buffer_size); 326 327 /* then how much from the read pointer onwards */ 328 fl = min(count, (size_t)lx->buffer_size - lx->lx_read); 329 330 failed = copy_to_user(buff, lx->lx_buffer + lx->lx_read, fl); 331 if (failed) 332 goto out; 333 334 /* and if there is anything left at the beginning of the buffer */ 335 if (count - fl) 336 failed = copy_to_user(buff + fl, lx->lx_buffer, count - fl); 337 338 out: 339 count -= failed; 340 341 smp_wmb(); 342 lx->lx_read = (lx->lx_read + count) % lx->buffer_size; 343 smp_wmb(); 344 mutex_unlock(&channel_wqs[index].mutex); 345 346 return count; 347 } 348 349 ssize_t rtlx_write(int index, const void __user *buffer, size_t count) 350 { 351 struct rtlx_channel *rt; 352 unsigned long failed; 353 size_t rt_read; 354 size_t fl; 355 356 if (rtlx == NULL) 357 return(-ENOSYS); 358 359 rt = &rtlx->channel[index]; 360 361 mutex_lock(&channel_wqs[index].mutex); 362 smp_rmb(); 363 rt_read = rt->rt_read; 364 365 /* total number of bytes to copy */ 366 count = min(count, (size_t)write_spacefree(rt_read, rt->rt_write, 367 rt->buffer_size)); 368 369 /* first bit from write pointer to the end of the buffer, or count */ 370 fl = min(count, (size_t) rt->buffer_size - rt->rt_write); 371 372 failed = copy_from_user(rt->rt_buffer + rt->rt_write, buffer, fl); 373 if (failed) 374 goto out; 375 376 /* if there's any left copy to the beginning of the buffer */ 377 if (count - fl) { 378 failed = copy_from_user(rt->rt_buffer, buffer + fl, count - fl); 379 } 380 381 out: 382 count -= failed; 383 384 smp_wmb(); 385 rt->rt_write = (rt->rt_write + count) % rt->buffer_size; 386 smp_wmb(); 387 mutex_unlock(&channel_wqs[index].mutex); 388 389 return count; 390 } 391 392 393 static int file_open(struct inode *inode, struct file *filp) 394 { 395 return rtlx_open(iminor(inode), (filp->f_flags & O_NONBLOCK) ? 0 : 1); 396 } 397 398 static int file_release(struct inode *inode, struct file *filp) 399 { 400 return rtlx_release(iminor(inode)); 401 } 402 403 static unsigned int file_poll(struct file *file, poll_table * wait) 404 { 405 int minor; 406 unsigned int mask = 0; 407 408 minor = iminor(file->f_path.dentry->d_inode); 409 410 poll_wait(file, &channel_wqs[minor].rt_queue, wait); 411 poll_wait(file, &channel_wqs[minor].lx_queue, wait); 412 413 if (rtlx == NULL) 414 return 0; 415 416 /* data available to read? */ 417 if (rtlx_read_poll(minor, 0)) 418 mask |= POLLIN | POLLRDNORM; 419 420 /* space to write */ 421 if (rtlx_write_poll(minor)) 422 mask |= POLLOUT | POLLWRNORM; 423 424 return mask; 425 } 426 427 static ssize_t file_read(struct file *file, char __user * buffer, size_t count, 428 loff_t * ppos) 429 { 430 int minor = iminor(file->f_path.dentry->d_inode); 431 432 /* data available? */ 433 if (!rtlx_read_poll(minor, (file->f_flags & O_NONBLOCK) ? 0 : 1)) { 434 return 0; // -EAGAIN makes cat whinge 435 } 436 437 return rtlx_read(minor, buffer, count); 438 } 439 440 static ssize_t file_write(struct file *file, const char __user * buffer, 441 size_t count, loff_t * ppos) 442 { 443 int minor; 444 struct rtlx_channel *rt; 445 446 minor = iminor(file->f_path.dentry->d_inode); 447 rt = &rtlx->channel[minor]; 448 449 /* any space left... */ 450 if (!rtlx_write_poll(minor)) { 451 int ret = 0; 452 453 if (file->f_flags & O_NONBLOCK) 454 return -EAGAIN; 455 456 __wait_event_interruptible(channel_wqs[minor].rt_queue, 457 rtlx_write_poll(minor), 458 ret); 459 if (ret) 460 return ret; 461 } 462 463 return rtlx_write(minor, buffer, count); 464 } 465 466 static const struct file_operations rtlx_fops = { 467 .owner = THIS_MODULE, 468 .open = file_open, 469 .release = file_release, 470 .write = file_write, 471 .read = file_read, 472 .poll = file_poll 473 }; 474 475 static struct irqaction rtlx_irq = { 476 .handler = rtlx_interrupt, 477 .flags = IRQF_DISABLED, 478 .name = "RTLX", 479 }; 480 481 static int rtlx_irq_num = MIPS_CPU_IRQ_BASE + MIPS_CPU_RTLX_IRQ; 482 483 static char register_chrdev_failed[] __initdata = 484 KERN_ERR "rtlx_module_init: unable to register device\n"; 485 486 static int __init rtlx_module_init(void) 487 { 488 struct device *dev; 489 int i, err; 490 491 if (!cpu_has_mipsmt) { 492 printk("VPE loader: not a MIPS MT capable processor\n"); 493 return -ENODEV; 494 } 495 496 if (tclimit == 0) { 497 printk(KERN_WARNING "No TCs reserved for AP/SP, not " 498 "initializing RTLX.\nPass maxtcs=<n> argument as kernel " 499 "argument\n"); 500 501 return -ENODEV; 502 } 503 504 major = register_chrdev(0, module_name, &rtlx_fops); 505 if (major < 0) { 506 printk(register_chrdev_failed); 507 return major; 508 } 509 510 /* initialise the wait queues */ 511 for (i = 0; i < RTLX_CHANNELS; i++) { 512 init_waitqueue_head(&channel_wqs[i].rt_queue); 513 init_waitqueue_head(&channel_wqs[i].lx_queue); 514 atomic_set(&channel_wqs[i].in_open, 0); 515 mutex_init(&channel_wqs[i].mutex); 516 517 dev = device_create(mt_class, NULL, MKDEV(major, i), NULL, 518 "%s%d", module_name, i); 519 if (IS_ERR(dev)) { 520 err = PTR_ERR(dev); 521 goto out_chrdev; 522 } 523 } 524 525 /* set up notifiers */ 526 notify.start = starting; 527 notify.stop = stopping; 528 vpe_notify(tclimit, ¬ify); 529 530 if (cpu_has_vint) 531 set_vi_handler(MIPS_CPU_RTLX_IRQ, rtlx_dispatch); 532 else { 533 pr_err("APRP RTLX init on non-vectored-interrupt processor\n"); 534 err = -ENODEV; 535 goto out_chrdev; 536 } 537 538 rtlx_irq.dev_id = rtlx; 539 setup_irq(rtlx_irq_num, &rtlx_irq); 540 541 return 0; 542 543 out_chrdev: 544 for (i = 0; i < RTLX_CHANNELS; i++) 545 device_destroy(mt_class, MKDEV(major, i)); 546 547 return err; 548 } 549 550 static void __exit rtlx_module_exit(void) 551 { 552 int i; 553 554 for (i = 0; i < RTLX_CHANNELS; i++) 555 device_destroy(mt_class, MKDEV(major, i)); 556 557 unregister_chrdev(major, module_name); 558 } 559 560 module_init(rtlx_module_init); 561 module_exit(rtlx_module_exit); 562 563 MODULE_DESCRIPTION("MIPS RTLX"); 564 MODULE_AUTHOR("Elizabeth Oldham, MIPS Technologies, Inc."); 565 MODULE_LICENSE("GPL"); 566