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