arch/powerpc/platforms/cell/spufs/file.c

   1 /*
   2  * SPU file system -- file contents
   3  *
   4  * (C) Copyright IBM Deutschland Entwicklung GmbH 2005
   5  *
   6  * Author: Arnd Bergmann <arndb@de.ibm.com>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2, or (at your option)
  11  * any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21  */
  22
  23 #undef DEBUG
  24
  25 #include <linux/fs.h>
  26 #include <linux/ioctl.h>
  27 #include <linux/export.h>
  28 #include <linux/pagemap.h>
  29 #include <linux/poll.h>
  30 #include <linux/ptrace.h>
  31 #include <linux/seq_file.h>
  32 #include <linux/slab.h>
  33
  34 #include <asm/io.h>
  35 #include <asm/time.h>
  36 #include <asm/spu.h>
  37 #include <asm/spu_info.h>
  38 #include <linux/uaccess.h>
  39
  40 #include "spufs.h"
  41 #include "sputrace.h"
  42
  43 #define SPUFS_MMAP_4K (PAGE_SIZE == 0x1000)
  44
  45 /* Simple attribute files */
  46 struct spufs_attr {
  47         int (*get)(void *, u64 *);
  48         int (*set)(void *, u64);
  49         char get_buf[24];       /* enough to store a u64 and "\n\0" */
  50         char set_buf[24];
  51         void *data;
  52         const char *fmt;        /* format for read operation */
  53         struct mutex mutex;     /* protects access to these buffers */
  54 };
  55
  56 static int spufs_attr_open(struct inode *inode, struct file *file,
  57                 int (*get)(void *, u64 *), int (*set)(void *, u64),
  58                 const char *fmt)
  59 {
  60         struct spufs_attr *attr;
  61
  62         attr = kmalloc(sizeof(*attr), GFP_KERNEL);
  63         if (!attr)
  64                 return -ENOMEM;
  65
  66         attr->get = get;
  67         attr->set = set;
  68         attr->data = inode->i_private;
  69         attr->fmt = fmt;
  70         mutex_init(&attr->mutex);
  71         file->private_data = attr;
  72
  73         return nonseekable_open(inode, file);
  74 }
  75
  76 static int spufs_attr_release(struct inode *inode, struct file *file)
  77 {
  78        kfree(file->private_data);
  79         return 0;
  80 }
  81
  82 static ssize_t spufs_attr_read(struct file *file, char __user *buf,
  83                 size_t len, loff_t *ppos)
  84 {
  85         struct spufs_attr *attr;
  86         size_t size;
  87         ssize_t ret;
  88
  89         attr = file->private_data;
  90         if (!attr->get)
  91                 return -EACCES;
  92
  93         ret = mutex_lock_interruptible(&attr->mutex);
  94         if (ret)
  95                 return ret;
  96
  97         if (*ppos) {            /* continued read */
  98                 size = strlen(attr->get_buf);
  99         } else {                /* first read */
 100                 u64 val;
 101                 ret = attr->get(attr->data, &val);
 102                 if (ret)
 103                         goto out;
 104
 105                 size = scnprintf(attr->get_buf, sizeof(attr->get_buf),
 106                                  attr->fmt, (unsigned long long)val);
 107         }
 108
 109         ret = simple_read_from_buffer(buf, len, ppos, attr->get_buf, size);
 110 out:
 111         mutex_unlock(&attr->mutex);
 112         return ret;
 113 }
 114
 115 static ssize_t spufs_attr_write(struct file *file, const char __user *buf,
 116                 size_t len, loff_t *ppos)
 117 {
 118         struct spufs_attr *attr;
 119         u64 val;
 120         size_t size;
 121         ssize_t ret;
 122
 123         attr = file->private_data;
 124         if (!attr->set)
 125                 return -EACCES;
 126
 127         ret = mutex_lock_interruptible(&attr->mutex);
 128         if (ret)
 129                 return ret;
 130
 131         ret = -EFAULT;
 132         size = min(sizeof(attr->set_buf) - 1, len);
 133         if (copy_from_user(attr->set_buf, buf, size))
 134                 goto out;
 135
 136         ret = len; /* claim we got the whole input */
 137         attr->set_buf[size] = '\0';
 138         val = simple_strtol(attr->set_buf, NULL, 0);
 139         attr->set(attr->data, val);
 140 out:
 141         mutex_unlock(&attr->mutex);
 142         return ret;
 143 }
 144
 145 #define DEFINE_SPUFS_SIMPLE_ATTRIBUTE(__fops, __get, __set, __fmt)      \
 146 static int __fops ## _open(struct inode *inode, struct file *file)      \
 147 {                                                                       \
 148         __simple_attr_check_format(__fmt, 0ull);                        \
 149         return spufs_attr_open(inode, file, __get, __set, __fmt);       \
 150 }                                                                       \
 151 static const struct file_operations __fops = {                          \
 152         .open    = __fops ## _open,                                     \
 153         .release = spufs_attr_release,                                  \
 154         .read    = spufs_attr_read,                                     \
 155         .write   = spufs_attr_write,                                    \
 156         .llseek  = generic_file_llseek,                                 \
 157 };
 158
 159
 160 static int
 161 spufs_mem_open(struct inode *inode, struct file *file)
 162 {
 163         struct spufs_inode_info *i = SPUFS_I(inode);
 164         struct spu_context *ctx = i->i_ctx;
 165
 166         mutex_lock(&ctx->mapping_lock);
 167         file->private_data = ctx;
 168         if (!i->i_openers++)
 169                 ctx->local_store = inode->i_mapping;
 170         mutex_unlock(&ctx->mapping_lock);
 171         return 0;
 172 }
 173
 174 static int
 175 spufs_mem_release(struct inode *inode, struct file *file)
 176 {
 177         struct spufs_inode_info *i = SPUFS_I(inode);
 178         struct spu_context *ctx = i->i_ctx;
 179
 180         mutex_lock(&ctx->mapping_lock);
 181         if (!--i->i_openers)
 182                 ctx->local_store = NULL;
 183         mutex_unlock(&ctx->mapping_lock);
 184         return 0;
 185 }
 186
 187 static ssize_t
 188 __spufs_mem_read(struct spu_context *ctx, char __user *buffer,
 189                         size_t size, loff_t *pos)
 190 {
 191         char *local_store = ctx->ops->get_ls(ctx);
 192         return simple_read_from_buffer(buffer, size, pos, local_store,
 193                                         LS_SIZE);
 194 }
 195
 196 static ssize_t
 197 spufs_mem_read(struct file *file, char __user *buffer,
 198                                 size_t size, loff_t *pos)
 199 {
 200         struct spu_context *ctx = file->private_data;
 201         ssize_t ret;
 202
 203         ret = spu_acquire(ctx);
 204         if (ret)
 205                 return ret;
 206         ret = __spufs_mem_read(ctx, buffer, size, pos);
 207         spu_release(ctx);
 208
 209         return ret;
 210 }
 211
 212 static ssize_t
 213 spufs_mem_write(struct file *file, const char __user *buffer,
 214                                         size_t size, loff_t *ppos)
 215 {
 216         struct spu_context *ctx = file->private_data;
 217         char *local_store;
 218         loff_t pos = *ppos;
 219         int ret;
 220
 221         if (pos > LS_SIZE)
 222                 return -EFBIG;
 223
 224         ret = spu_acquire(ctx);
 225         if (ret)
 226                 return ret;
 227
 228         local_store = ctx->ops->get_ls(ctx);
 229         size = simple_write_to_buffer(local_store, LS_SIZE, ppos, buffer, size);
 230         spu_release(ctx);
 231
 232         return size;
 233 }
 234
 235 static vm_fault_t
 236 spufs_mem_mmap_fault(struct vm_fault *vmf)
 237 {
 238         struct vm_area_struct *vma = vmf->vma;
 239         struct spu_context *ctx = vma->vm_file->private_data;
 240         unsigned long pfn, offset;
 241         vm_fault_t ret;
 242
 243         offset = vmf->pgoff << PAGE_SHIFT;
 244         if (offset >= LS_SIZE)
 245                 return VM_FAULT_SIGBUS;
 246
 247         pr_debug("spufs_mem_mmap_fault address=0x%lx, offset=0x%lx\n",
 248                         vmf->address, offset);
 249
 250         if (spu_acquire(ctx))
 251                 return VM_FAULT_NOPAGE;
 252
 253         if (ctx->state == SPU_STATE_SAVED) {
 254                 vma->vm_page_prot = pgprot_cached(vma->vm_page_prot);
 255                 pfn = vmalloc_to_pfn(ctx->csa.lscsa->ls + offset);
 256         } else {
 257                 vma->vm_page_prot = pgprot_noncached_wc(vma->vm_page_prot);
 258                 pfn = (ctx->spu->local_store_phys + offset) >> PAGE_SHIFT;
 259         }
 260         ret = vmf_insert_pfn(vma, vmf->address, pfn);
 261
 262         spu_release(ctx);
 263
 264         return ret;
 265 }
 266
 267 static int spufs_mem_mmap_access(struct vm_area_struct *vma,
 268                                 unsigned long address,
 269                                 void *buf, int len, int write)
 270 {
 271         struct spu_context *ctx = vma->vm_file->private_data;
 272         unsigned long offset = address - vma->vm_start;
 273         char *local_store;
 274
 275         if (write && !(vma->vm_flags & VM_WRITE))
 276                 return -EACCES;
 277         if (spu_acquire(ctx))
 278                 return -EINTR;
 279         if ((offset + len) > vma->vm_end)
 280                 len = vma->vm_end - offset;
 281         local_store = ctx->ops->get_ls(ctx);
 282         if (write)
 283                 memcpy_toio(local_store + offset, buf, len);
 284         else
 285                 memcpy_fromio(buf, local_store + offset, len);
 286         spu_release(ctx);
 287         return len;
 288 }
 289
 290 static const struct vm_operations_struct spufs_mem_mmap_vmops = {
 291         .fault = spufs_mem_mmap_fault,
 292         .access = spufs_mem_mmap_access,
 293 };
 294
 295 static int spufs_mem_mmap(struct file *file, struct vm_area_struct *vma)
 296 {
 297         if (!(vma->vm_flags & VM_SHARED))
 298                 return -EINVAL;
 299
 300         vma->vm_flags |= VM_IO | VM_PFNMAP;
 301         vma->vm_page_prot = pgprot_noncached_wc(vma->vm_page_prot);
 302
 303         vma->vm_ops = &spufs_mem_mmap_vmops;
 304         return 0;
 305 }
 306
 307 static const struct file_operations spufs_mem_fops = {
 308         .open                   = spufs_mem_open,
 309         .release                = spufs_mem_release,
 310         .read                   = spufs_mem_read,
 311         .write                  = spufs_mem_write,
 312         .llseek                 = generic_file_llseek,
 313         .mmap                   = spufs_mem_mmap,
 314 };
 315
 316 static vm_fault_t spufs_ps_fault(struct vm_fault *vmf,
 317                                     unsigned long ps_offs,
 318                                     unsigned long ps_size)
 319 {
 320         struct spu_context *ctx = vmf->vma->vm_file->private_data;
 321         unsigned long area, offset = vmf->pgoff << PAGE_SHIFT;
 322         int err = 0;
 323         vm_fault_t ret = VM_FAULT_NOPAGE;
 324
 325         spu_context_nospu_trace(spufs_ps_fault__enter, ctx);
 326
 327         if (offset >= ps_size)
 328                 return VM_FAULT_SIGBUS;
 329
 330         if (fatal_signal_pending(current))
 331                 return VM_FAULT_SIGBUS;
 332
 333         /*
 334          * Because we release the mmap_sem, the context may be destroyed while
 335          * we're in spu_wait. Grab an extra reference so it isn't destroyed
 336          * in the meantime.
 337          */
 338         get_spu_context(ctx);
 339
 340         /*
 341          * We have to wait for context to be loaded before we have
 342          * pages to hand out to the user, but we don't want to wait
 343          * with the mmap_sem held.
 344          * It is possible to drop the mmap_sem here, but then we need
 345          * to return VM_FAULT_NOPAGE because the mappings may have
 346          * hanged.
 347          */
 348         if (spu_acquire(ctx))
 349                 goto refault;
 350
 351         if (ctx->state == SPU_STATE_SAVED) {
 352                 up_read(&current->mm->mmap_sem);
 353                 spu_context_nospu_trace(spufs_ps_fault__sleep, ctx);
 354                 err = spufs_wait(ctx->run_wq, ctx->state == SPU_STATE_RUNNABLE);
 355                 spu_context_trace(spufs_ps_fault__wake, ctx, ctx->spu);
 356                 down_read(&current->mm->mmap_sem);
 357         } else {
 358                 area = ctx->spu->problem_phys + ps_offs;
 359                 ret = vmf_insert_pfn(vmf->vma, vmf->address,
 360                                 (area + offset) >> PAGE_SHIFT);
 361                 spu_context_trace(spufs_ps_fault__insert, ctx, ctx->spu);
 362         }
 363
 364         if (!err)
 365                 spu_release(ctx);
 366
 367 refault:
 368         put_spu_context(ctx);
 369         return ret;
 370 }
 371
 372 #if SPUFS_MMAP_4K
 373 static vm_fault_t spufs_cntl_mmap_fault(struct vm_fault *vmf)
 374 {
 375         return spufs_ps_fault(vmf, 0x4000, SPUFS_CNTL_MAP_SIZE);
 376 }
 377
 378 static const struct vm_operations_struct spufs_cntl_mmap_vmops = {
 379         .fault = spufs_cntl_mmap_fault,
 380 };
 381
 382 /*
 383  * mmap support for problem state control area [0x4000 - 0x4fff].
 384  */
 385 static int spufs_cntl_mmap(struct file *file, struct vm_area_struct *vma)
 386 {
 387         if (!(vma->vm_flags & VM_SHARED))
 388                 return -EINVAL;
 389
 390         vma->vm_flags |= VM_IO | VM_PFNMAP;
 391         vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
 392
 393         vma->vm_ops = &spufs_cntl_mmap_vmops;
 394         return 0;
 395 }
 396 #else /* SPUFS_MMAP_4K */
 397 #define spufs_cntl_mmap NULL
 398 #endif /* !SPUFS_MMAP_4K */
 399
 400 static int spufs_cntl_get(void *data, u64 *val)
 401 {
 402         struct spu_context *ctx = data;
 403         int ret;
 404
 405         ret = spu_acquire(ctx);
 406         if (ret)
 407                 return ret;
 408         *val = ctx->ops->status_read(ctx);
 409         spu_release(ctx);
 410
 411         return 0;
 412 }
 413
 414 static int spufs_cntl_set(void *data, u64 val)
 415 {
 416         struct spu_context *ctx = data;
 417         int ret;
 418
 419         ret = spu_acquire(ctx);
 420         if (ret)
 421                 return ret;
 422         ctx->ops->runcntl_write(ctx, val);
 423         spu_release(ctx);
 424
 425         return 0;
 426 }
 427
 428 static int spufs_cntl_open(struct inode *inode, struct file *file)
 429 {
 430         struct spufs_inode_info *i = SPUFS_I(inode);
 431         struct spu_context *ctx = i->i_ctx;
 432
 433         mutex_lock(&ctx->mapping_lock);
 434         file->private_data = ctx;
 435         if (!i->i_openers++)
 436                 ctx->cntl = inode->i_mapping;
 437         mutex_unlock(&ctx->mapping_lock);
 438         return simple_attr_open(inode, file, spufs_cntl_get,
 439                                         spufs_cntl_set, "0x%08lx");
 440 }
 441
 442 static int
 443 spufs_cntl_release(struct inode *inode, struct file *file)
 444 {
 445         struct spufs_inode_info *i = SPUFS_I(inode);
 446         struct spu_context *ctx = i->i_ctx;
 447
 448         simple_attr_release(inode, file);
 449
 450         mutex_lock(&ctx->mapping_lock);
 451         if (!--i->i_openers)
 452                 ctx->cntl = NULL;
 453         mutex_unlock(&ctx->mapping_lock);
 454         return 0;
 455 }
 456
 457 static const struct file_operations spufs_cntl_fops = {
 458         .open = spufs_cntl_open,
 459         .release = spufs_cntl_release,
 460         .read = simple_attr_read,
 461         .write = simple_attr_write,
 462         .llseek = generic_file_llseek,
 463         .mmap = spufs_cntl_mmap,
 464 };
 465
 466 static int
 467 spufs_regs_open(struct inode *inode, struct file *file)
 468 {
 469         struct spufs_inode_info *i = SPUFS_I(inode);
 470         file->private_data = i->i_ctx;
 471         return 0;
 472 }
 473
 474 static ssize_t
 475 __spufs_regs_read(struct spu_context *ctx, char __user *buffer,
 476                         size_t size, loff_t *pos)
 477 {
 478         struct spu_lscsa *lscsa = ctx->csa.lscsa;
 479         return simple_read_from_buffer(buffer, size, pos,
 480                                       lscsa->gprs, sizeof lscsa->gprs);
 481 }
 482
 483 static ssize_t
 484 spufs_regs_read(struct file *file, char __user *buffer,
 485                 size_t size, loff_t *pos)
 486 {
 487         int ret;
 488         struct spu_context *ctx = file->private_data;
 489
 490         /* pre-check for file position: if we'd return EOF, there's no point
 491          * causing a deschedule */
 492         if (*pos >= sizeof(ctx->csa.lscsa->gprs))
 493                 return 0;
 494
 495         ret = spu_acquire_saved(ctx);
 496         if (ret)
 497                 return ret;
 498         ret = __spufs_regs_read(ctx, buffer, size, pos);
 499         spu_release_saved(ctx);
 500         return ret;
 501 }
 502
 503 static ssize_t
 504 spufs_regs_write(struct file *file, const char __user *buffer,
 505                  size_t size, loff_t *pos)
 506 {
 507         struct spu_context *ctx = file->private_data;
 508         struct spu_lscsa *lscsa = ctx->csa.lscsa;
 509         int ret;
 510
 511         if (*pos >= sizeof(lscsa->gprs))
 512                 return -EFBIG;
 513
 514         ret = spu_acquire_saved(ctx);
 515         if (ret)
 516                 return ret;
 517
 518         size = simple_write_to_buffer(lscsa->gprs, sizeof(lscsa->gprs), pos,
 519                                         buffer, size);
 520
 521         spu_release_saved(ctx);
 522         return size;
 523 }
 524
 525 static const struct file_operations spufs_regs_fops = {
 526         .open    = spufs_regs_open,
 527         .read    = spufs_regs_read,
 528         .write   = spufs_regs_write,
 529         .llseek  = generic_file_llseek,
 530 };
 531
 532 static ssize_t
 533 __spufs_fpcr_read(struct spu_context *ctx, char __user * buffer,
 534                         size_t size, loff_t * pos)
 535 {
 536         struct spu_lscsa *lscsa = ctx->csa.lscsa;
 537         return simple_read_from_buffer(buffer, size, pos,
 538                                       &lscsa->fpcr, sizeof(lscsa->fpcr));
 539 }
 540
 541 static ssize_t
 542 spufs_fpcr_read(struct file *file, char __user * buffer,
 543                 size_t size, loff_t * pos)
 544 {
 545         int ret;
 546         struct spu_context *ctx = file->private_data;
 547
 548         ret = spu_acquire_saved(ctx);
 549         if (ret)
 550                 return ret;
 551         ret = __spufs_fpcr_read(ctx, buffer, size, pos);
 552         spu_release_saved(ctx);
 553         return ret;
 554 }
 555
 556 static ssize_t
 557 spufs_fpcr_write(struct file *file, const char __user * buffer,
 558                  size_t size, loff_t * pos)
 559 {
 560         struct spu_context *ctx = file->private_data;
 561         struct spu_lscsa *lscsa = ctx->csa.lscsa;
 562         int ret;
 563
 564         if (*pos >= sizeof(lscsa->fpcr))
 565                 return -EFBIG;
 566
 567         ret = spu_acquire_saved(ctx);
 568         if (ret)
 569                 return ret;
 570
 571         size = simple_write_to_buffer(&lscsa->fpcr, sizeof(lscsa->fpcr), pos,
 572                                         buffer, size);
 573
 574         spu_release_saved(ctx);
 575         return size;
 576 }
 577
 578 static const struct file_operations spufs_fpcr_fops = {
 579         .open = spufs_regs_open,
 580         .read = spufs_fpcr_read,
 581         .write = spufs_fpcr_write,
 582         .llseek = generic_file_llseek,
 583 };
 584
 585 /* generic open function for all pipe-like files */
 586 static int spufs_pipe_open(struct inode *inode, struct file *file)
 587 {
 588         struct spufs_inode_info *i = SPUFS_I(inode);
 589         file->private_data = i->i_ctx;
 590
 591         return nonseekable_open(inode, file);
 592 }
 593
 594 /*
 595  * Read as many bytes from the mailbox as possible, until
 596  * one of the conditions becomes true:
 597  *
 598  * - no more data available in the mailbox
 599  * - end of the user provided buffer
 600  * - end of the mapped area
 601  */
 602 static ssize_t spufs_mbox_read(struct file *file, char __user *buf,
 603                         size_t len, loff_t *pos)
 604 {
 605         struct spu_context *ctx = file->private_data;
 606         u32 mbox_data, __user *udata;
 607         ssize_t count;
 608
 609         if (len < 4)
 610                 return -EINVAL;
 611
 612         if (!access_ok(VERIFY_WRITE, buf, len))
 613                 return -EFAULT;
 614
 615         udata = (void __user *)buf;
 616
 617         count = spu_acquire(ctx);
 618         if (count)
 619                 return count;
 620
 621         for (count = 0; (count + 4) <= len; count += 4, udata++) {
 622                 int ret;
 623                 ret = ctx->ops->mbox_read(ctx, &mbox_data);
 624                 if (ret == 0)
 625                         break;
 626
 627                 /*
 628                  * at the end of the mapped area, we can fault
 629                  * but still need to return the data we have
 630                  * read successfully so far.
 631                  */
 632                 ret = __put_user(mbox_data, udata);
 633                 if (ret) {
 634                         if (!count)
 635                                 count = -EFAULT;
 636                         break;
 637                 }
 638         }
 639         spu_release(ctx);
 640
 641         if (!count)
 642                 count = -EAGAIN;
 643
 644         return count;
 645 }
 646
 647 static const struct file_operations spufs_mbox_fops = {
 648         .open   = spufs_pipe_open,
 649         .read   = spufs_mbox_read,
 650         .llseek = no_llseek,
 651 };
 652
 653 static ssize_t spufs_mbox_stat_read(struct file *file, char __user *buf,
 654                         size_t len, loff_t *pos)
 655 {
 656         struct spu_context *ctx = file->private_data;
 657         ssize_t ret;
 658         u32 mbox_stat;
 659
 660         if (len < 4)
 661                 return -EINVAL;
 662
 663         ret = spu_acquire(ctx);
 664         if (ret)
 665                 return ret;
 666
 667         mbox_stat = ctx->ops->mbox_stat_read(ctx) & 0xff;
 668
 669         spu_release(ctx);
 670
 671         if (copy_to_user(buf, &mbox_stat, sizeof mbox_stat))
 672                 return -EFAULT;
 673
 674         return 4;
 675 }
 676
 677 static const struct file_operations spufs_mbox_stat_fops = {
 678         .open   = spufs_pipe_open,
 679         .read   = spufs_mbox_stat_read,
 680         .llseek = no_llseek,
 681 };
 682
 683 /* low-level ibox access function */
 684 size_t spu_ibox_read(struct spu_context *ctx, u32 *data)
 685 {
 686         return ctx->ops->ibox_read(ctx, data);
 687 }
 688
 689 /* interrupt-level ibox callback function. */
 690 void spufs_ibox_callback(struct spu *spu)
 691 {
 692         struct spu_context *ctx = spu->ctx;
 693
 694         if (ctx)
 695                 wake_up_all(&ctx->ibox_wq);
 696 }
 697
 698 /*
 699  * Read as many bytes from the interrupt mailbox as possible, until
 700  * one of the conditions becomes true:
 701  *
 702  * - no more data available in the mailbox
 703  * - end of the user provided buffer
 704  * - end of the mapped area
 705  *
 706  * If the file is opened without O_NONBLOCK, we wait here until
 707  * any data is available, but return when we have been able to
 708  * read something.
 709  */
 710 static ssize_t spufs_ibox_read(struct file *file, char __user *buf,
 711                         size_t len, loff_t *pos)
 712 {
 713         struct spu_context *ctx = file->private_data;
 714         u32 ibox_data, __user *udata;
 715         ssize_t count;
 716
 717         if (len < 4)
 718                 return -EINVAL;
 719
 720         if (!access_ok(VERIFY_WRITE, buf, len))
 721                 return -EFAULT;
 722
 723         udata = (void __user *)buf;
 724
 725         count = spu_acquire(ctx);
 726         if (count)
 727                 goto out;
 728
 729         /* wait only for the first element */
 730         count = 0;
 731         if (file->f_flags & O_NONBLOCK) {
 732                 if (!spu_ibox_read(ctx, &ibox_data)) {
 733                         count = -EAGAIN;
 734                         goto out_unlock;
 735                 }
 736         } else {
 737                 count = spufs_wait(ctx->ibox_wq, spu_ibox_read(ctx, &ibox_data));
 738                 if (count)
 739                         goto out;
 740         }
 741
 742         /* if we can't write at all, return -EFAULT */
 743         count = __put_user(ibox_data, udata);
 744         if (count)
 745                 goto out_unlock;
 746
 747         for (count = 4, udata++; (count + 4) <= len; count += 4, udata++) {
 748                 int ret;
 749                 ret = ctx->ops->ibox_read(ctx, &ibox_data);
 750                 if (ret == 0)
 751                         break;
 752                 /*
 753                  * at the end of the mapped area, we can fault
 754                  * but still need to return the data we have
 755                  * read successfully so far.
 756                  */
 757                 ret = __put_user(ibox_data, udata);
 758                 if (ret)
 759                         break;
 760         }
 761
 762 out_unlock:
 763         spu_release(ctx);
 764 out:
 765         return count;
 766 }
 767
 768 static __poll_t spufs_ibox_poll(struct file *file, poll_table *wait)
 769 {
 770         struct spu_context *ctx = file->private_data;
 771         __poll_t mask;
 772
 773         poll_wait(file, &ctx->ibox_wq, wait);
 774
 775         /*
 776          * For now keep this uninterruptible and also ignore the rule
 777          * that poll should not sleep.  Will be fixed later.
 778          */
 779         mutex_lock(&ctx->state_mutex);
 780         mask = ctx->ops->mbox_stat_poll(ctx, EPOLLIN | EPOLLRDNORM);
 781         spu_release(ctx);
 782
 783         return mask;
 784 }
 785
 786 static const struct file_operations spufs_ibox_fops = {
 787         .open   = spufs_pipe_open,
 788         .read   = spufs_ibox_read,
 789         .poll   = spufs_ibox_poll,
 790         .llseek = no_llseek,
 791 };
 792
 793 static ssize_t spufs_ibox_stat_read(struct file *file, char __user *buf,
 794                         size_t len, loff_t *pos)
 795 {
 796         struct spu_context *ctx = file->private_data;
 797         ssize_t ret;
 798         u32 ibox_stat;
 799
 800         if (len < 4)
 801                 return -EINVAL;
 802
 803         ret = spu_acquire(ctx);
 804         if (ret)
 805                 return ret;
 806         ibox_stat = (ctx->ops->mbox_stat_read(ctx) >> 16) & 0xff;
 807         spu_release(ctx);
 808
 809         if (copy_to_user(buf, &ibox_stat, sizeof ibox_stat))
 810                 return -EFAULT;
 811
 812         return 4;
 813 }
 814
 815 static const struct file_operations spufs_ibox_stat_fops = {
 816         .open   = spufs_pipe_open,
 817         .read   = spufs_ibox_stat_read,
 818         .llseek = no_llseek,
 819 };
 820
 821 /* low-level mailbox write */
 822 size_t spu_wbox_write(struct spu_context *ctx, u32 data)
 823 {
 824         return ctx->ops->wbox_write(ctx, data);
 825 }
 826
 827 /* interrupt-level wbox callback function. */
 828 void spufs_wbox_callback(struct spu *spu)
 829 {
 830         struct spu_context *ctx = spu->ctx;
 831
 832         if (ctx)
 833                 wake_up_all(&ctx->wbox_wq);
 834 }
 835
 836 /*
 837  * Write as many bytes to the interrupt mailbox as possible, until
 838  * one of the conditions becomes true:
 839  *
 840  * - the mailbox is full
 841  * - end of the user provided buffer
 842  * - end of the mapped area
 843  *
 844  * If the file is opened without O_NONBLOCK, we wait here until
 845  * space is available, but return when we have been able to
 846  * write something.
 847  */
 848 static ssize_t spufs_wbox_write(struct file *file, const char __user *buf,
 849                         size_t len, loff_t *pos)
 850 {
 851         struct spu_context *ctx = file->private_data;
 852         u32 wbox_data, __user *udata;
 853         ssize_t count;
 854
 855         if (len < 4)
 856                 return -EINVAL;
 857
 858         udata = (void __user *)buf;
 859         if (!access_ok(VERIFY_READ, buf, len))
 860                 return -EFAULT;
 861
 862         if (__get_user(wbox_data, udata))
 863                 return -EFAULT;
 864
 865         count = spu_acquire(ctx);
 866         if (count)
 867                 goto out;
 868
 869         /*
 870          * make sure we can at least write one element, by waiting
 871          * in case of !O_NONBLOCK
 872          */
 873         count = 0;
 874         if (file->f_flags & O_NONBLOCK) {
 875                 if (!spu_wbox_write(ctx, wbox_data)) {
 876                         count = -EAGAIN;
 877                         goto out_unlock;
 878                 }
 879         } else {
 880                 count = spufs_wait(ctx->wbox_wq, spu_wbox_write(ctx, wbox_data));
 881                 if (count)
 882                         goto out;
 883         }
 884
 885
 886         /* write as much as possible */
 887         for (count = 4, udata++; (count + 4) <= len; count += 4, udata++) {
 888                 int ret;
 889                 ret = __get_user(wbox_data, udata);
 890                 if (ret)
 891                         break;
 892
 893                 ret = spu_wbox_write(ctx, wbox_data);
 894                 if (ret == 0)
 895                         break;
 896         }
 897
 898 out_unlock:
 899         spu_release(ctx);
 900 out:
 901         return count;
 902 }
 903
 904 static __poll_t spufs_wbox_poll(struct file *file, poll_table *wait)
 905 {
 906         struct spu_context *ctx = file->private_data;
 907         __poll_t mask;
 908
 909         poll_wait(file, &ctx->wbox_wq, wait);
 910
 911         /*
 912          * For now keep this uninterruptible and also ignore the rule
 913          * that poll should not sleep.  Will be fixed later.
 914          */
 915         mutex_lock(&ctx->state_mutex);
 916         mask = ctx->ops->mbox_stat_poll(ctx, EPOLLOUT | EPOLLWRNORM);
 917         spu_release(ctx);
 918
 919         return mask;
 920 }
 921
 922 static const struct file_operations spufs_wbox_fops = {
 923         .open   = spufs_pipe_open,
 924         .write  = spufs_wbox_write,
 925         .poll   = spufs_wbox_poll,
 926         .llseek = no_llseek,
 927 };
 928
 929 static ssize_t spufs_wbox_stat_read(struct file *file, char __user *buf,
 930                         size_t len, loff_t *pos)
 931 {
 932         struct spu_context *ctx = file->private_data;
 933         ssize_t ret;
 934         u32 wbox_stat;
 935
 936         if (len < 4)
 937                 return -EINVAL;
 938
 939         ret = spu_acquire(ctx);
 940         if (ret)
 941                 return ret;
 942         wbox_stat = (ctx->ops->mbox_stat_read(ctx) >> 8) & 0xff;
 943         spu_release(ctx);
 944
 945         if (copy_to_user(buf, &wbox_stat, sizeof wbox_stat))
 946                 return -EFAULT;
 947
 948         return 4;
 949 }
 950
 951 static const struct file_operations spufs_wbox_stat_fops = {
 952         .open   = spufs_pipe_open,
 953         .read   = spufs_wbox_stat_read,
 954         .llseek = no_llseek,
 955 };
 956
 957 static int spufs_signal1_open(struct inode *inode, struct file *file)
 958 {
 959         struct spufs_inode_info *i = SPUFS_I(inode);
 960         struct spu_context *ctx = i->i_ctx;
 961
 962         mutex_lock(&ctx->mapping_lock);
 963         file->private_data = ctx;
 964         if (!i->i_openers++)
 965                 ctx->signal1 = inode->i_mapping;
 966         mutex_unlock(&ctx->mapping_lock);
 967         return nonseekable_open(inode, file);
 968 }
 969
 970 static int
 971 spufs_signal1_release(struct inode *inode, struct file *file)
 972 {
 973         struct spufs_inode_info *i = SPUFS_I(inode);
 974         struct spu_context *ctx = i->i_ctx;
 975
 976         mutex_lock(&ctx->mapping_lock);
 977         if (!--i->i_openers)
 978                 ctx->signal1 = NULL;
 979         mutex_unlock(&ctx->mapping_lock);
 980         return 0;
 981 }
 982
 983 static ssize_t __spufs_signal1_read(struct spu_context *ctx, char __user *buf,
 984                         size_t len, loff_t *pos)
 985 {
 986         int ret = 0;
 987         u32 data;
 988
 989         if (len < 4)
 990                 return -EINVAL;
 991
 992         if (ctx->csa.spu_chnlcnt_RW[3]) {
 993                 data = ctx->csa.spu_chnldata_RW[3];
 994                 ret = 4;
 995         }
 996
 997         if (!ret)
 998                 goto out;
 999
1000         if (copy_to_user(buf, &data, 4))
1001                 return -EFAULT;
1002
1003 out:
1004         return ret;
1005 }
1006
1007 static ssize_t spufs_signal1_read(struct file *file, char __user *buf,
1008                         size_t len, loff_t *pos)
1009 {
1010         int ret;
1011         struct spu_context *ctx = file->private_data;
1012
1013         ret = spu_acquire_saved(ctx);
1014         if (ret)
1015                 return ret;
1016         ret = __spufs_signal1_read(ctx, buf, len, pos);
1017         spu_release_saved(ctx);
1018
1019         return ret;
1020 }
1021
1022 static ssize_t spufs_signal1_write(struct file *file, const char __user *buf,
1023                         size_t len, loff_t *pos)
1024 {
1025         struct spu_context *ctx;
1026         ssize_t ret;
1027         u32 data;
1028
1029         ctx = file->private_data;
1030
1031         if (len < 4)
1032                 return -EINVAL;
1033
1034         if (copy_from_user(&data, buf, 4))
1035                 return -EFAULT;
1036
1037         ret = spu_acquire(ctx);
1038         if (ret)
1039                 return ret;
1040         ctx->ops->signal1_write(ctx, data);
1041         spu_release(ctx);
1042
1043         return 4;
1044 }
1045
1046 static vm_fault_t
1047 spufs_signal1_mmap_fault(struct vm_fault *vmf)
1048 {
1049 #if SPUFS_SIGNAL_MAP_SIZE == 0x1000
1050         return spufs_ps_fault(vmf, 0x14000, SPUFS_SIGNAL_MAP_SIZE);
1051 #elif SPUFS_SIGNAL_MAP_SIZE == 0x10000
1052         /* For 64k pages, both signal1 and signal2 can be used to mmap the whole
1053          * signal 1 and 2 area
1054          */
1055         return spufs_ps_fault(vmf, 0x10000, SPUFS_SIGNAL_MAP_SIZE);
1056 #else
1057 #error unsupported page size
1058 #endif
1059 }
1060
1061 static const struct vm_operations_struct spufs_signal1_mmap_vmops = {
1062         .fault = spufs_signal1_mmap_fault,
1063 };
1064
1065 static int spufs_signal1_mmap(struct file *file, struct vm_area_struct *vma)
1066 {
1067         if (!(vma->vm_flags & VM_SHARED))
1068                 return -EINVAL;
1069
1070         vma->vm_flags |= VM_IO | VM_PFNMAP;
1071         vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
1072
1073         vma->vm_ops = &spufs_signal1_mmap_vmops;
1074         return 0;
1075 }
1076
1077 static const struct file_operations spufs_signal1_fops = {
1078         .open = spufs_signal1_open,
1079         .release = spufs_signal1_release,
1080         .read = spufs_signal1_read,
1081         .write = spufs_signal1_write,
1082         .mmap = spufs_signal1_mmap,
1083         .llseek = no_llseek,
1084 };
1085
1086 static const struct file_operations spufs_signal1_nosched_fops = {
1087         .open = spufs_signal1_open,
1088         .release = spufs_signal1_release,
1089         .write = spufs_signal1_write,
1090         .mmap = spufs_signal1_mmap,
1091         .llseek = no_llseek,
1092 };
1093
1094 static int spufs_signal2_open(struct inode *inode, struct file *file)
1095 {
1096         struct spufs_inode_info *i = SPUFS_I(inode);
1097         struct spu_context *ctx = i->i_ctx;
1098
1099         mutex_lock(&ctx->mapping_lock);
1100         file->private_data = ctx;
1101         if (!i->i_openers++)
1102                 ctx->signal2 = inode->i_mapping;
1103         mutex_unlock(&ctx->mapping_lock);
1104         return nonseekable_open(inode, file);
1105 }
1106
1107 static int
1108 spufs_signal2_release(struct inode *inode, struct file *file)
1109 {
1110         struct spufs_inode_info *i = SPUFS_I(inode);
1111         struct spu_context *ctx = i->i_ctx;
1112
1113         mutex_lock(&ctx->mapping_lock);
1114         if (!--i->i_openers)
1115                 ctx->signal2 = NULL;
1116         mutex_unlock(&ctx->mapping_lock);
1117         return 0;
1118 }
1119
1120 static ssize_t __spufs_signal2_read(struct spu_context *ctx, char __user *buf,
1121                         size_t len, loff_t *pos)
1122 {
1123         int ret = 0;
1124         u32 data;
1125
1126         if (len < 4)
1127                 return -EINVAL;
1128
1129         if (ctx->csa.spu_chnlcnt_RW[4]) {
1130                 data =  ctx->csa.spu_chnldata_RW[4];
1131                 ret = 4;
1132         }
1133
1134         if (!ret)
1135                 goto out;
1136
1137         if (copy_to_user(buf, &data, 4))
1138                 return -EFAULT;
1139
1140 out:
1141         return ret;
1142 }
1143
1144 static ssize_t spufs_signal2_read(struct file *file, char __user *buf,
1145                         size_t len, loff_t *pos)
1146 {
1147         struct spu_context *ctx = file->private_data;
1148         int ret;
1149
1150         ret = spu_acquire_saved(ctx);
1151         if (ret)
1152                 return ret;
1153         ret = __spufs_signal2_read(ctx, buf, len, pos);
1154         spu_release_saved(ctx);
1155
1156         return ret;
1157 }
1158
1159 static ssize_t spufs_signal2_write(struct file *file, const char __user *buf,
1160                         size_t len, loff_t *pos)
1161 {
1162         struct spu_context *ctx;
1163         ssize_t ret;
1164         u32 data;
1165
1166         ctx = file->private_data;
1167
1168         if (len < 4)
1169                 return -EINVAL;
1170
1171         if (copy_from_user(&data, buf, 4))
1172                 return -EFAULT;
1173
1174         ret = spu_acquire(ctx);
1175         if (ret)
1176                 return ret;
1177         ctx->ops->signal2_write(ctx, data);
1178         spu_release(ctx);
1179
1180         return 4;
1181 }
1182
1183 #if SPUFS_MMAP_4K
1184 static vm_fault_t
1185 spufs_signal2_mmap_fault(struct vm_fault *vmf)
1186 {
1187 #if SPUFS_SIGNAL_MAP_SIZE == 0x1000
1188         return spufs_ps_fault(vmf, 0x1c000, SPUFS_SIGNAL_MAP_SIZE);
1189 #elif SPUFS_SIGNAL_MAP_SIZE == 0x10000
1190         /* For 64k pages, both signal1 and signal2 can be used to mmap the whole
1191          * signal 1 and 2 area
1192          */
1193         return spufs_ps_fault(vmf, 0x10000, SPUFS_SIGNAL_MAP_SIZE);
1194 #else
1195 #error unsupported page size
1196 #endif
1197 }
1198
1199 static const struct vm_operations_struct spufs_signal2_mmap_vmops = {
1200         .fault = spufs_signal2_mmap_fault,
1201 };
1202
1203 static int spufs_signal2_mmap(struct file *file, struct vm_area_struct *vma)
1204 {
1205         if (!(vma->vm_flags & VM_SHARED))
1206                 return -EINVAL;
1207
1208         vma->vm_flags |= VM_IO | VM_PFNMAP;
1209         vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
1210
1211         vma->vm_ops = &spufs_signal2_mmap_vmops;
1212         return 0;
1213 }
1214 #else /* SPUFS_MMAP_4K */
1215 #define spufs_signal2_mmap NULL
1216 #endif /* !SPUFS_MMAP_4K */
1217
1218 static const struct file_operations spufs_signal2_fops = {
1219         .open = spufs_signal2_open,
1220         .release = spufs_signal2_release,
1221         .read = spufs_signal2_read,
1222         .write = spufs_signal2_write,
1223         .mmap = spufs_signal2_mmap,
1224         .llseek = no_llseek,
1225 };
1226
1227 static const struct file_operations spufs_signal2_nosched_fops = {
1228         .open = spufs_signal2_open,
1229         .release = spufs_signal2_release,
1230         .write = spufs_signal2_write,
1231         .mmap = spufs_signal2_mmap,
1232         .llseek = no_llseek,
1233 };
1234
1235 /*
1236  * This is a wrapper around DEFINE_SIMPLE_ATTRIBUTE which does the
1237  * work of acquiring (or not) the SPU context before calling through
1238  * to the actual get routine. The set routine is called directly.
1239  */
1240 #define SPU_ATTR_NOACQUIRE      0
1241 #define SPU_ATTR_ACQUIRE        1
1242 #define SPU_ATTR_ACQUIRE_SAVED  2
1243
1244 #define DEFINE_SPUFS_ATTRIBUTE(__name, __get, __set, __fmt, __acquire)  \
1245 static int __##__get(void *data, u64 *val)                              \
1246 {                                                                       \
1247         struct spu_context *ctx = data;                                 \
1248         int ret = 0;                                                    \
1249                                                                         \
1250         if (__acquire == SPU_ATTR_ACQUIRE) {                            \
1251                 ret = spu_acquire(ctx);                                 \
1252                 if (ret)                                                \
1253                         return ret;                                     \
1254                 *val = __get(ctx);                                      \
1255                 spu_release(ctx);                                       \
1256         } else if (__acquire == SPU_ATTR_ACQUIRE_SAVED) {               \
1257                 ret = spu_acquire_saved(ctx);                           \
1258                 if (ret)                                                \
1259                         return ret;                                     \
1260                 *val = __get(ctx);                                      \
1261                 spu_release_saved(ctx);                                 \
1262         } else                                                          \
1263                 *val = __get(ctx);                                      \
1264                                                                         \
1265         return 0;                                                       \
1266 }                                                                       \
1267 DEFINE_SPUFS_SIMPLE_ATTRIBUTE(__name, __##__get, __set, __fmt);
1268
1269 static int spufs_signal1_type_set(void *data, u64 val)
1270 {
1271         struct spu_context *ctx = data;
1272         int ret;
1273
1274         ret = spu_acquire(ctx);
1275         if (ret)
1276                 return ret;
1277         ctx->ops->signal1_type_set(ctx, val);
1278         spu_release(ctx);
1279
1280         return 0;
1281 }
1282
1283 static u64 spufs_signal1_type_get(struct spu_context *ctx)
1284 {
1285         return ctx->ops->signal1_type_get(ctx);
1286 }
1287 DEFINE_SPUFS_ATTRIBUTE(spufs_signal1_type, spufs_signal1_type_get,
1288                        spufs_signal1_type_set, "%llu\n", SPU_ATTR_ACQUIRE);
1289
1290
1291 static int spufs_signal2_type_set(void *data, u64 val)
1292 {
1293         struct spu_context *ctx = data;
1294         int ret;
1295
1296         ret = spu_acquire(ctx);
1297         if (ret)
1298                 return ret;
1299         ctx->ops->signal2_type_set(ctx, val);
1300         spu_release(ctx);
1301
1302         return 0;
1303 }
1304
1305 static u64 spufs_signal2_type_get(struct spu_context *ctx)
1306 {
1307         return ctx->ops->signal2_type_get(ctx);
1308 }
1309 DEFINE_SPUFS_ATTRIBUTE(spufs_signal2_type, spufs_signal2_type_get,
1310                        spufs_signal2_type_set, "%llu\n", SPU_ATTR_ACQUIRE);
1311
1312 #if SPUFS_MMAP_4K
1313 static vm_fault_t
1314 spufs_mss_mmap_fault(struct vm_fault *vmf)
1315 {
1316         return spufs_ps_fault(vmf, 0x0000, SPUFS_MSS_MAP_SIZE);
1317 }
1318
1319 static const struct vm_operations_struct spufs_mss_mmap_vmops = {
1320         .fault = spufs_mss_mmap_fault,
1321 };
1322
1323 /*
1324  * mmap support for problem state MFC DMA area [0x0000 - 0x0fff].
1325  */
1326 static int spufs_mss_mmap(struct file *file, struct vm_area_struct *vma)
1327 {
1328         if (!(vma->vm_flags & VM_SHARED))
1329                 return -EINVAL;
1330
1331         vma->vm_flags |= VM_IO | VM_PFNMAP;
1332         vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
1333
1334         vma->vm_ops = &spufs_mss_mmap_vmops;
1335         return 0;
1336 }
1337 #else /* SPUFS_MMAP_4K */
1338 #define spufs_mss_mmap NULL
1339 #endif /* !SPUFS_MMAP_4K */
1340
1341 static int spufs_mss_open(struct inode *inode, struct file *file)
1342 {
1343         struct spufs_inode_info *i = SPUFS_I(inode);
1344         struct spu_context *ctx = i->i_ctx;
1345
1346         file->private_data = i->i_ctx;
1347
1348         mutex_lock(&ctx->mapping_lock);
1349         if (!i->i_openers++)
1350                 ctx->mss = inode->i_mapping;
1351         mutex_unlock(&ctx->mapping_lock);
1352         return nonseekable_open(inode, file);
1353 }
1354
1355 static int
1356 spufs_mss_release(struct inode *inode, struct file *file)
1357 {
1358         struct spufs_inode_info *i = SPUFS_I(inode);
1359         struct spu_context *ctx = i->i_ctx;
1360
1361         mutex_lock(&ctx->mapping_lock);
1362         if (!--i->i_openers)
1363                 ctx->mss = NULL;
1364         mutex_unlock(&ctx->mapping_lock);
1365         return 0;
1366 }
1367
1368 static const struct file_operations spufs_mss_fops = {
1369         .open    = spufs_mss_open,
1370         .release = spufs_mss_release,
1371         .mmap    = spufs_mss_mmap,
1372         .llseek  = no_llseek,
1373 };
1374
1375 static vm_fault_t
1376 spufs_psmap_mmap_fault(struct vm_fault *vmf)
1377 {
1378         return spufs_ps_fault(vmf, 0x0000, SPUFS_PS_MAP_SIZE);
1379 }
1380
1381 static const struct vm_operations_struct spufs_psmap_mmap_vmops = {
1382         .fault = spufs_psmap_mmap_fault,
1383 };
1384
1385 /*
1386  * mmap support for full problem state area [0x00000 - 0x1ffff].
1387  */
1388 static int spufs_psmap_mmap(struct file *file, struct vm_area_struct *vma)
1389 {
1390         if (!(vma->vm_flags & VM_SHARED))
1391                 return -EINVAL;
1392
1393         vma->vm_flags |= VM_IO | VM_PFNMAP;
1394         vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
1395
1396         vma->vm_ops = &spufs_psmap_mmap_vmops;
1397         return 0;
1398 }
1399
1400 static int spufs_psmap_open(struct inode *inode, struct file *file)
1401 {
1402         struct spufs_inode_info *i = SPUFS_I(inode);
1403         struct spu_context *ctx = i->i_ctx;
1404
1405         mutex_lock(&ctx->mapping_lock);
1406         file->private_data = i->i_ctx;
1407         if (!i->i_openers++)
1408                 ctx->psmap = inode->i_mapping;
1409         mutex_unlock(&ctx->mapping_lock);
1410         return nonseekable_open(inode, file);
1411 }
1412
1413 static int
1414 spufs_psmap_release(struct inode *inode, struct file *file)
1415 {
1416         struct spufs_inode_info *i = SPUFS_I(inode);
1417         struct spu_context *ctx = i->i_ctx;
1418
1419         mutex_lock(&ctx->mapping_lock);
1420         if (!--i->i_openers)
1421                 ctx->psmap = NULL;
1422         mutex_unlock(&ctx->mapping_lock);
1423         return 0;
1424 }
1425
1426 static const struct file_operations spufs_psmap_fops = {
1427         .open    = spufs_psmap_open,
1428         .release = spufs_psmap_release,
1429         .mmap    = spufs_psmap_mmap,
1430         .llseek  = no_llseek,
1431 };
1432
1433
1434 #if SPUFS_MMAP_4K
1435 static vm_fault_t
1436 spufs_mfc_mmap_fault(struct vm_fault *vmf)
1437 {
1438         return spufs_ps_fault(vmf, 0x3000, SPUFS_MFC_MAP_SIZE);
1439 }
1440
1441 static const struct vm_operations_struct spufs_mfc_mmap_vmops = {
1442         .fault = spufs_mfc_mmap_fault,
1443 };
1444
1445 /*
1446  * mmap support for problem state MFC DMA area [0x0000 - 0x0fff].
1447  */
1448 static int spufs_mfc_mmap(struct file *file, struct vm_area_struct *vma)
1449 {
1450         if (!(vma->vm_flags & VM_SHARED))
1451                 return -EINVAL;
1452
1453         vma->vm_flags |= VM_IO | VM_PFNMAP;
1454         vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
1455
1456         vma->vm_ops = &spufs_mfc_mmap_vmops;
1457         return 0;
1458 }
1459 #else /* SPUFS_MMAP_4K */
1460 #define spufs_mfc_mmap NULL
1461 #endif /* !SPUFS_MMAP_4K */
1462
1463 static int spufs_mfc_open(struct inode *inode, struct file *file)
1464 {
1465         struct spufs_inode_info *i = SPUFS_I(inode);
1466         struct spu_context *ctx = i->i_ctx;
1467
1468         /* we don't want to deal with DMA into other processes */
1469         if (ctx->owner != current->mm)
1470                 return -EINVAL;
1471
1472         if (atomic_read(&inode->i_count) != 1)
1473                 return -EBUSY;
1474
1475         mutex_lock(&ctx->mapping_lock);
1476         file->private_data = ctx;
1477         if (!i->i_openers++)
1478                 ctx->mfc = inode->i_mapping;
1479         mutex_unlock(&ctx->mapping_lock);
1480         return nonseekable_open(inode, file);
1481 }
1482
1483 static int
1484 spufs_mfc_release(struct inode *inode, struct file *file)
1485 {
1486         struct spufs_inode_info *i = SPUFS_I(inode);
1487         struct spu_context *ctx = i->i_ctx;
1488
1489         mutex_lock(&ctx->mapping_lock);
1490         if (!--i->i_openers)
1491                 ctx->mfc = NULL;
1492         mutex_unlock(&ctx->mapping_lock);
1493         return 0;
1494 }
1495
1496 /* interrupt-level mfc callback function. */
1497 void spufs_mfc_callback(struct spu *spu)
1498 {
1499         struct spu_context *ctx = spu->ctx;
1500
1501         if (ctx)
1502                 wake_up_all(&ctx->mfc_wq);
1503 }
1504
1505 static int spufs_read_mfc_tagstatus(struct spu_context *ctx, u32 *status)
1506 {
1507         /* See if there is one tag group is complete */
1508         /* FIXME we need locking around tagwait */
1509         *status = ctx->ops->read_mfc_tagstatus(ctx) & ctx->tagwait;
1510         ctx->tagwait &= ~*status;
1511         if (*status)
1512                 return 1;
1513
1514         /* enable interrupt waiting for any tag group,
1515            may silently fail if interrupts are already enabled */
1516         ctx->ops->set_mfc_query(ctx, ctx->tagwait, 1);
1517         return 0;
1518 }
1519
1520 static ssize_t spufs_mfc_read(struct file *file, char __user *buffer,
1521                         size_t size, loff_t *pos)
1522 {
1523         struct spu_context *ctx = file->private_data;
1524         int ret = -EINVAL;
1525         u32 status;
1526
1527         if (size != 4)
1528                 goto out;
1529
1530         ret = spu_acquire(ctx);
1531         if (ret)
1532                 return ret;
1533
1534         ret = -EINVAL;
1535         if (file->f_flags & O_NONBLOCK) {
1536                 status = ctx->ops->read_mfc_tagstatus(ctx);
1537                 if (!(status & ctx->tagwait))
1538                         ret = -EAGAIN;
1539                 else
1540                         /* XXX(hch): shouldn't we clear ret here? */
1541                         ctx->tagwait &= ~status;
1542         } else {
1543                 ret = spufs_wait(ctx->mfc_wq,
1544                            spufs_read_mfc_tagstatus(ctx, &status));
1545                 if (ret)
1546                         goto out;
1547         }
1548         spu_release(ctx);
1549
1550         ret = 4;
1551         if (copy_to_user(buffer, &status, 4))
1552                 ret = -EFAULT;
1553
1554 out:
1555         return ret;
1556 }
1557
1558 static int spufs_check_valid_dma(struct mfc_dma_command *cmd)
1559 {
1560         pr_debug("queueing DMA %x %llx %x %x %x\n", cmd->lsa,
1561                  cmd->ea, cmd->size, cmd->tag, cmd->cmd);
1562
1563         switch (cmd->cmd) {
1564         case MFC_PUT_CMD:
1565         case MFC_PUTF_CMD:
1566         case MFC_PUTB_CMD:
1567         case MFC_GET_CMD:
1568         case MFC_GETF_CMD:
1569         case MFC_GETB_CMD:
1570                 break;
1571         default:
1572                 pr_debug("invalid DMA opcode %x\n", cmd->cmd);
1573                 return -EIO;
1574         }
1575
1576         if ((cmd->lsa & 0xf) != (cmd->ea &0xf)) {
1577                 pr_debug("invalid DMA alignment, ea %llx lsa %x\n",
1578                                 cmd->ea, cmd->lsa);
1579                 return -EIO;
1580         }
1581
1582         switch (cmd->size & 0xf) {
1583         case 1:
1584                 break;
1585         case 2:
1586                 if (cmd->lsa & 1)
1587                         goto error;
1588                 break;
1589         case 4:
1590                 if (cmd->lsa & 3)
1591                         goto error;
1592                 break;
1593         case 8:
1594                 if (cmd->lsa & 7)
1595                         goto error;
1596                 break;
1597         case 0:
1598                 if (cmd->lsa & 15)
1599                         goto error;
1600                 break;
1601         error:
1602         default:
1603                 pr_debug("invalid DMA alignment %x for size %x\n",
1604                         cmd->lsa & 0xf, cmd->size);
1605                 return -EIO;
1606         }
1607
1608         if (cmd->size > 16 * 1024) {
1609                 pr_debug("invalid DMA size %x\n", cmd->size);
1610                 return -EIO;
1611         }
1612
1613         if (cmd->tag & 0xfff0) {
1614                 /* we reserve the higher tag numbers for kernel use */
1615                 pr_debug("invalid DMA tag\n");
1616                 return -EIO;
1617         }
1618
1619         if (cmd->class) {
1620                 /* not supported in this version */
1621                 pr_debug("invalid DMA class\n");
1622                 return -EIO;
1623         }
1624
1625         return 0;
1626 }
1627
1628 static int spu_send_mfc_command(struct spu_context *ctx,
1629                                 struct mfc_dma_command cmd,
1630                                 int *error)
1631 {
1632         *error = ctx->ops->send_mfc_command(ctx, &cmd);
1633         if (*error == -EAGAIN) {
1634                 /* wait for any tag group to complete
1635                    so we have space for the new command */
1636                 ctx->ops->set_mfc_query(ctx, ctx->tagwait, 1);
1637                 /* try again, because the queue might be
1638                    empty again */
1639                 *error = ctx->ops->send_mfc_command(ctx, &cmd);
1640                 if (*error == -EAGAIN)
1641                         return 0;
1642         }
1643         return 1;
1644 }
1645
1646 static ssize_t spufs_mfc_write(struct file *file, const char __user *buffer,
1647                         size_t size, loff_t *pos)
1648 {
1649         struct spu_context *ctx = file->private_data;
1650         struct mfc_dma_command cmd;
1651         int ret = -EINVAL;
1652
1653         if (size != sizeof cmd)
1654                 goto out;
1655
1656         ret = -EFAULT;
1657         if (copy_from_user(&cmd, buffer, sizeof cmd))
1658                 goto out;
1659
1660         ret = spufs_check_valid_dma(&cmd);
1661         if (ret)
1662                 goto out;
1663
1664         ret = spu_acquire(ctx);
1665         if (ret)
1666                 goto out;
1667
1668         ret = spufs_wait(ctx->run_wq, ctx->state == SPU_STATE_RUNNABLE);
1669         if (ret)
1670                 goto out;
1671
1672         if (file->f_flags & O_NONBLOCK) {
1673                 ret = ctx->ops->send_mfc_command(ctx, &cmd);
1674         } else {
1675                 int status;
1676                 ret = spufs_wait(ctx->mfc_wq,
1677                                  spu_send_mfc_command(ctx, cmd, &status));
1678                 if (ret)
1679                         goto out;
1680                 if (status)
1681                         ret = status;
1682         }
1683
1684         if (ret)
1685                 goto out_unlock;
1686
1687         ctx->tagwait |= 1 << cmd.tag;
1688         ret = size;
1689
1690 out_unlock:
1691         spu_release(ctx);
1692 out:
1693         return ret;
1694 }
1695
1696 static __poll_t spufs_mfc_poll(struct file *file,poll_table *wait)
1697 {
1698         struct spu_context *ctx = file->private_data;
1699         u32 free_elements, tagstatus;
1700         __poll_t mask;
1701
1702         poll_wait(file, &ctx->mfc_wq, wait);
1703
1704         /*
1705          * For now keep this uninterruptible and also ignore the rule
1706          * that poll should not sleep.  Will be fixed later.
1707          */
1708         mutex_lock(&ctx->state_mutex);
1709         ctx->ops->set_mfc_query(ctx, ctx->tagwait, 2);
1710         free_elements = ctx->ops->get_mfc_free_elements(ctx);
1711         tagstatus = ctx->ops->read_mfc_tagstatus(ctx);
1712         spu_release(ctx);
1713
1714         mask = 0;
1715         if (free_elements & 0xffff)
1716                 mask |= EPOLLOUT | EPOLLWRNORM;
1717         if (tagstatus & ctx->tagwait)
1718                 mask |= EPOLLIN | EPOLLRDNORM;
1719
1720         pr_debug("%s: free %d tagstatus %d tagwait %d\n", __func__,
1721                 free_elements, tagstatus, ctx->tagwait);
1722
1723         return mask;
1724 }
1725
1726 static int spufs_mfc_flush(struct file *file, fl_owner_t id)
1727 {
1728         struct spu_context *ctx = file->private_data;
1729         int ret;
1730
1731         ret = spu_acquire(ctx);
1732         if (ret)
1733                 goto out;
1734 #if 0
1735 /* this currently hangs */
1736         ret = spufs_wait(ctx->mfc_wq,
1737                          ctx->ops->set_mfc_query(ctx, ctx->tagwait, 2));
1738         if (ret)
1739                 goto out;
1740         ret = spufs_wait(ctx->mfc_wq,
1741                          ctx->ops->read_mfc_tagstatus(ctx) == ctx->tagwait);
1742         if (ret)
1743                 goto out;
1744 #else
1745         ret = 0;
1746 #endif
1747         spu_release(ctx);
1748 out:
1749         return ret;
1750 }
1751
1752 static int spufs_mfc_fsync(struct file *file, loff_t start, loff_t end, int datasync)
1753 {
1754         struct inode *inode = file_inode(file);
1755         int err = file_write_and_wait_range(file, start, end);
1756         if (!err) {
1757                 inode_lock(inode);
1758                 err = spufs_mfc_flush(file, NULL);
1759                 inode_unlock(inode);
1760         }
1761         return err;
1762 }
1763
1764 static const struct file_operations spufs_mfc_fops = {
1765         .open    = spufs_mfc_open,
1766         .release = spufs_mfc_release,
1767         .read    = spufs_mfc_read,
1768         .write   = spufs_mfc_write,
1769         .poll    = spufs_mfc_poll,
1770         .flush   = spufs_mfc_flush,
1771         .fsync   = spufs_mfc_fsync,
1772         .mmap    = spufs_mfc_mmap,
1773         .llseek  = no_llseek,
1774 };
1775
1776 static int spufs_npc_set(void *data, u64 val)
1777 {
1778         struct spu_context *ctx = data;
1779         int ret;
1780
1781         ret = spu_acquire(ctx);
1782         if (ret)
1783                 return ret;
1784         ctx->ops->npc_write(ctx, val);
1785         spu_release(ctx);
1786
1787         return 0;
1788 }
1789
1790 static u64 spufs_npc_get(struct spu_context *ctx)
1791 {
1792         return ctx->ops->npc_read(ctx);
1793 }
1794 DEFINE_SPUFS_ATTRIBUTE(spufs_npc_ops, spufs_npc_get, spufs_npc_set,
1795                        "0x%llx\n", SPU_ATTR_ACQUIRE);
1796
1797 static int spufs_decr_set(void *data, u64 val)
1798 {
1799         struct spu_context *ctx = data;
1800         struct spu_lscsa *lscsa = ctx->csa.lscsa;
1801         int ret;
1802
1803         ret = spu_acquire_saved(ctx);
1804         if (ret)
1805                 return ret;
1806         lscsa->decr.slot[0] = (u32) val;
1807         spu_release_saved(ctx);
1808
1809         return 0;
1810 }
1811
1812 static u64 spufs_decr_get(struct spu_context *ctx)
1813 {
1814         struct spu_lscsa *lscsa = ctx->csa.lscsa;
1815         return lscsa->decr.slot[0];
1816 }
1817 DEFINE_SPUFS_ATTRIBUTE(spufs_decr_ops, spufs_decr_get, spufs_decr_set,
1818                        "0x%llx\n", SPU_ATTR_ACQUIRE_SAVED);
1819
1820 static int spufs_decr_status_set(void *data, u64 val)
1821 {
1822         struct spu_context *ctx = data;
1823         int ret;
1824
1825         ret = spu_acquire_saved(ctx);
1826         if (ret)
1827                 return ret;
1828         if (val)
1829                 ctx->csa.priv2.mfc_control_RW |= MFC_CNTL_DECREMENTER_RUNNING;
1830         else
1831                 ctx->csa.priv2.mfc_control_RW &= ~MFC_CNTL_DECREMENTER_RUNNING;
1832         spu_release_saved(ctx);
1833
1834         return 0;
1835 }
1836
1837 static u64 spufs_decr_status_get(struct spu_context *ctx)
1838 {
1839         if (ctx->csa.priv2.mfc_control_RW & MFC_CNTL_DECREMENTER_RUNNING)
1840                 return SPU_DECR_STATUS_RUNNING;
1841         else
1842                 return 0;
1843 }
1844 DEFINE_SPUFS_ATTRIBUTE(spufs_decr_status_ops, spufs_decr_status_get,
1845                        spufs_decr_status_set, "0x%llx\n",
1846                        SPU_ATTR_ACQUIRE_SAVED);
1847
1848 static int spufs_event_mask_set(void *data, u64 val)
1849 {
1850         struct spu_context *ctx = data;
1851         struct spu_lscsa *lscsa = ctx->csa.lscsa;
1852         int ret;
1853
1854         ret = spu_acquire_saved(ctx);
1855         if (ret)
1856                 return ret;
1857         lscsa->event_mask.slot[0] = (u32) val;
1858         spu_release_saved(ctx);
1859
1860         return 0;
1861 }
1862
1863 static u64 spufs_event_mask_get(struct spu_context *ctx)
1864 {
1865         struct spu_lscsa *lscsa = ctx->csa.lscsa;
1866         return lscsa->event_mask.slot[0];
1867 }
1868
1869 DEFINE_SPUFS_ATTRIBUTE(spufs_event_mask_ops, spufs_event_mask_get,
1870                        spufs_event_mask_set, "0x%llx\n",
1871                        SPU_ATTR_ACQUIRE_SAVED);
1872
1873 static u64 spufs_event_status_get(struct spu_context *ctx)
1874 {
1875         struct spu_state *state = &ctx->csa;
1876         u64 stat;
1877         stat = state->spu_chnlcnt_RW[0];
1878         if (stat)
1879                 return state->spu_chnldata_RW[0];
1880         return 0;
1881 }
1882 DEFINE_SPUFS_ATTRIBUTE(spufs_event_status_ops, spufs_event_status_get,
1883                        NULL, "0x%llx\n", SPU_ATTR_ACQUIRE_SAVED)
1884
1885 static int spufs_srr0_set(void *data, u64 val)
1886 {
1887         struct spu_context *ctx = data;
1888         struct spu_lscsa *lscsa = ctx->csa.lscsa;
1889         int ret;
1890
1891         ret = spu_acquire_saved(ctx);
1892         if (ret)
1893                 return ret;
1894         lscsa->srr0.slot[0] = (u32) val;
1895         spu_release_saved(ctx);
1896
1897         return 0;
1898 }
1899
1900 static u64 spufs_srr0_get(struct spu_context *ctx)
1901 {
1902         struct spu_lscsa *lscsa = ctx->csa.lscsa;
1903         return lscsa->srr0.slot[0];
1904 }
1905 DEFINE_SPUFS_ATTRIBUTE(spufs_srr0_ops, spufs_srr0_get, spufs_srr0_set,
1906                        "0x%llx\n", SPU_ATTR_ACQUIRE_SAVED)
1907
1908 static u64 spufs_id_get(struct spu_context *ctx)
1909 {
1910         u64 num;
1911
1912         if (ctx->state == SPU_STATE_RUNNABLE)
1913                 num = ctx->spu->number;
1914         else
1915                 num = (unsigned int)-1;
1916
1917         return num;
1918 }
1919 DEFINE_SPUFS_ATTRIBUTE(spufs_id_ops, spufs_id_get, NULL, "0x%llx\n",
1920                        SPU_ATTR_ACQUIRE)
1921
1922 static u64 spufs_object_id_get(struct spu_context *ctx)
1923 {
1924         /* FIXME: Should there really be no locking here? */
1925         return ctx->object_id;
1926 }
1927
1928 static int spufs_object_id_set(void *data, u64 id)
1929 {
1930         struct spu_context *ctx = data;
1931         ctx->object_id = id;
1932
1933         return 0;
1934 }
1935
1936 DEFINE_SPUFS_ATTRIBUTE(spufs_object_id_ops, spufs_object_id_get,
1937                        spufs_object_id_set, "0x%llx\n", SPU_ATTR_NOACQUIRE);
1938
1939 static u64 spufs_lslr_get(struct spu_context *ctx)
1940 {
1941         return ctx->csa.priv2.spu_lslr_RW;
1942 }
1943 DEFINE_SPUFS_ATTRIBUTE(spufs_lslr_ops, spufs_lslr_get, NULL, "0x%llx\n",
1944                        SPU_ATTR_ACQUIRE_SAVED);
1945
1946 static int spufs_info_open(struct inode *inode, struct file *file)
1947 {
1948         struct spufs_inode_info *i = SPUFS_I(inode);
1949         struct spu_context *ctx = i->i_ctx;
1950         file->private_data = ctx;
1951         return 0;
1952 }
1953
1954 static int spufs_caps_show(struct seq_file *s, void *private)
1955 {
1956         struct spu_context *ctx = s->private;
1957
1958         if (!(ctx->flags & SPU_CREATE_NOSCHED))
1959                 seq_puts(s, "sched\n");
1960         if (!(ctx->flags & SPU_CREATE_ISOLATE))
1961                 seq_puts(s, "step\n");
1962         return 0;
1963 }
1964
1965 static int spufs_caps_open(struct inode *inode, struct file *file)
1966 {
1967         return single_open(file, spufs_caps_show, SPUFS_I(inode)->i_ctx);
1968 }
1969
1970 static const struct file_operations spufs_caps_fops = {
1971         .open           = spufs_caps_open,
1972         .read           = seq_read,
1973         .llseek         = seq_lseek,
1974         .release        = single_release,
1975 };
1976
1977 static ssize_t __spufs_mbox_info_read(struct spu_context *ctx,
1978                         char __user *buf, size_t len, loff_t *pos)
1979 {
1980         u32 data;
1981
1982         /* EOF if there's no entry in the mbox */
1983         if (!(ctx->csa.prob.mb_stat_R & 0x0000ff))
1984                 return 0;
1985
1986         data = ctx->csa.prob.pu_mb_R;
1987
1988         return simple_read_from_buffer(buf, len, pos, &data, sizeof data);
1989 }
1990
1991 static ssize_t spufs_mbox_info_read(struct file *file, char __user *buf,
1992                                    size_t len, loff_t *pos)
1993 {
1994         struct spu_context *ctx = file->private_data;
1995         u32 stat, data;
1996         int ret;
1997
1998         if (!access_ok(VERIFY_WRITE, buf, len))
1999                 return -EFAULT;
2000
2001         ret = spu_acquire_saved(ctx);
2002         if (ret)
2003                 return ret;
2004         spin_lock(&ctx->csa.register_lock);
2005         stat = ctx->csa.prob.mb_stat_R;
2006         data = ctx->csa.prob.pu_mb_R;
2007         spin_unlock(&ctx->csa.register_lock);
2008         spu_release_saved(ctx);
2009
2010         /* EOF if there's no entry in the mbox */
2011         if (!(stat & 0x0000ff))
2012                 return 0;
2013
2014         return simple_read_from_buffer(buf, len, pos, &data, sizeof(data));
2015 }
2016
2017 static const struct file_operations spufs_mbox_info_fops = {
2018         .open = spufs_info_open,
2019         .read = spufs_mbox_info_read,
2020         .llseek  = generic_file_llseek,
2021 };
2022
2023 static ssize_t __spufs_ibox_info_read(struct spu_context *ctx,
2024                                 char __user *buf, size_t len, loff_t *pos)
2025 {
2026         u32 data;
2027
2028         /* EOF if there's no entry in the ibox */
2029         if (!(ctx->csa.prob.mb_stat_R & 0xff0000))
2030                 return 0;
2031
2032         data = ctx->csa.priv2.puint_mb_R;
2033
2034         return simple_read_from_buffer(buf, len, pos, &data, sizeof data);
2035 }
2036
2037 static ssize_t spufs_ibox_info_read(struct file *file, char __user *buf,
2038                                    size_t len, loff_t *pos)
2039 {
2040         struct spu_context *ctx = file->private_data;
2041         u32 stat, data;
2042         int ret;
2043
2044         if (!access_ok(VERIFY_WRITE, buf, len))
2045                 return -EFAULT;
2046
2047         ret = spu_acquire_saved(ctx);
2048         if (ret)
2049                 return ret;
2050         spin_lock(&ctx->csa.register_lock);
2051         stat = ctx->csa.prob.mb_stat_R;
2052         data = ctx->csa.priv2.puint_mb_R;
2053         spin_unlock(&ctx->csa.register_lock);
2054         spu_release_saved(ctx);
2055
2056         /* EOF if there's no entry in the ibox */
2057         if (!(stat & 0xff0000))
2058                 return 0;
2059
2060         return simple_read_from_buffer(buf, len, pos, &data, sizeof(data));
2061 }
2062
2063 static const struct file_operations spufs_ibox_info_fops = {
2064         .open = spufs_info_open,
2065         .read = spufs_ibox_info_read,
2066         .llseek  = generic_file_llseek,
2067 };
2068
2069 static size_t spufs_wbox_info_cnt(struct spu_context *ctx)
2070 {
2071         return (4 - ((ctx->csa.prob.mb_stat_R & 0x00ff00) >> 8)) * sizeof(u32);
2072 }
2073
2074 static ssize_t __spufs_wbox_info_read(struct spu_context *ctx,
2075                         char __user *buf, size_t len, loff_t *pos)
2076 {
2077         int i, cnt;
2078         u32 data[4];
2079         u32 wbox_stat;
2080
2081         wbox_stat = ctx->csa.prob.mb_stat_R;
2082         cnt = spufs_wbox_info_cnt(ctx);
2083         for (i = 0; i < cnt; i++) {
2084                 data[i] = ctx->csa.spu_mailbox_data[i];
2085         }
2086
2087         return simple_read_from_buffer(buf, len, pos, &data,
2088                                 cnt * sizeof(u32));
2089 }
2090
2091 static ssize_t spufs_wbox_info_read(struct file *file, char __user *buf,
2092                                    size_t len, loff_t *pos)
2093 {
2094         struct spu_context *ctx = file->private_data;
2095         u32 data[ARRAY_SIZE(ctx->csa.spu_mailbox_data)];
2096         int ret, count;
2097
2098         if (!access_ok(VERIFY_WRITE, buf, len))
2099                 return -EFAULT;
2100
2101         ret = spu_acquire_saved(ctx);
2102         if (ret)
2103                 return ret;
2104         spin_lock(&ctx->csa.register_lock);
2105         count = spufs_wbox_info_cnt(ctx);
2106         memcpy(&data, &ctx->csa.spu_mailbox_data, sizeof(data));
2107         spin_unlock(&ctx->csa.register_lock);
2108         spu_release_saved(ctx);
2109
2110         return simple_read_from_buffer(buf, len, pos, &data,
2111                                 count * sizeof(u32));
2112 }
2113
2114 static const struct file_operations spufs_wbox_info_fops = {
2115         .open = spufs_info_open,
2116         .read = spufs_wbox_info_read,
2117         .llseek  = generic_file_llseek,
2118 };
2119
2120 static void spufs_get_dma_info(struct spu_context *ctx,
2121                 struct spu_dma_info *info)
2122 {
2123         int i;
2124
2125         info->dma_info_type = ctx->csa.priv2.spu_tag_status_query_RW;
2126         info->dma_info_mask = ctx->csa.lscsa->tag_mask.slot[0];
2127         info->dma_info_status = ctx->csa.spu_chnldata_RW[24];
2128         info->dma_info_stall_and_notify = ctx->csa.spu_chnldata_RW[25];
2129         info->dma_info_atomic_command_status = ctx->csa.spu_chnldata_RW[27];
2130         for (i = 0; i < 16; i++) {
2131                 struct mfc_cq_sr *qp = &info->dma_info_command_data[i];
2132                 struct mfc_cq_sr *spuqp = &ctx->csa.priv2.spuq[i];
2133
2134                 qp->mfc_cq_data0_RW = spuqp->mfc_cq_data0_RW;
2135                 qp->mfc_cq_data1_RW = spuqp->mfc_cq_data1_RW;
2136                 qp->mfc_cq_data2_RW = spuqp->mfc_cq_data2_RW;
2137                 qp->mfc_cq_data3_RW = spuqp->mfc_cq_data3_RW;
2138         }
2139 }
2140
2141 static ssize_t __spufs_dma_info_read(struct spu_context *ctx,
2142                         char __user *buf, size_t len, loff_t *pos)
2143 {
2144         struct spu_dma_info info;
2145
2146         spufs_get_dma_info(ctx, &info);
2147
2148         return simple_read_from_buffer(buf, len, pos, &info,
2149                                 sizeof info);
2150 }
2151
2152 static ssize_t spufs_dma_info_read(struct file *file, char __user *buf,
2153                               size_t len, loff_t *pos)
2154 {
2155         struct spu_context *ctx = file->private_data;
2156         struct spu_dma_info info;
2157         int ret;
2158
2159         if (!access_ok(VERIFY_WRITE, buf, len))
2160                 return -EFAULT;
2161
2162         ret = spu_acquire_saved(ctx);
2163         if (ret)
2164                 return ret;
2165         spin_lock(&ctx->csa.register_lock);
2166         spufs_get_dma_info(ctx, &info);
2167         spin_unlock(&ctx->csa.register_lock);
2168         spu_release_saved(ctx);
2169
2170         return simple_read_from_buffer(buf, len, pos, &info,
2171                                 sizeof(info));
2172 }
2173
2174 static const struct file_operations spufs_dma_info_fops = {
2175         .open = spufs_info_open,
2176         .read = spufs_dma_info_read,
2177         .llseek = no_llseek,
2178 };
2179
2180 static void spufs_get_proxydma_info(struct spu_context *ctx,
2181                 struct spu_proxydma_info *info)
2182 {
2183         int i;
2184
2185         info->proxydma_info_type = ctx->csa.prob.dma_querytype_RW;
2186         info->proxydma_info_mask = ctx->csa.prob.dma_querymask_RW;
2187         info->proxydma_info_status = ctx->csa.prob.dma_tagstatus_R;
2188
2189         for (i = 0; i < 8; i++) {
2190                 struct mfc_cq_sr *qp = &info->proxydma_info_command_data[i];
2191                 struct mfc_cq_sr *puqp = &ctx->csa.priv2.puq[i];
2192
2193                 qp->mfc_cq_data0_RW = puqp->mfc_cq_data0_RW;
2194                 qp->mfc_cq_data1_RW = puqp->mfc_cq_data1_RW;
2195                 qp->mfc_cq_data2_RW = puqp->mfc_cq_data2_RW;
2196                 qp->mfc_cq_data3_RW = puqp->mfc_cq_data3_RW;
2197         }
2198 }
2199
2200 static ssize_t __spufs_proxydma_info_read(struct spu_context *ctx,
2201                         char __user *buf, size_t len, loff_t *pos)
2202 {
2203         struct spu_proxydma_info info;
2204         int ret = sizeof info;
2205
2206         if (len < ret)
2207                 return -EINVAL;
2208
2209         if (!access_ok(VERIFY_WRITE, buf, len))
2210                 return -EFAULT;
2211
2212         spufs_get_proxydma_info(ctx, &info);
2213
2214         return simple_read_from_buffer(buf, len, pos, &info,
2215                                 sizeof info);
2216 }
2217
2218 static ssize_t spufs_proxydma_info_read(struct file *file, char __user *buf,
2219                                    size_t len, loff_t *pos)
2220 {
2221         struct spu_context *ctx = file->private_data;
2222         struct spu_proxydma_info info;
2223         int ret;
2224
2225         ret = spu_acquire_saved(ctx);
2226         if (ret)
2227                 return ret;
2228         spin_lock(&ctx->csa.register_lock);
2229         spufs_get_proxydma_info(ctx, &info);
2230         spin_unlock(&ctx->csa.register_lock);
2231         spu_release_saved(ctx);
2232
2233         return simple_read_from_buffer(buf, len, pos, &info,
2234                                 sizeof(info));
2235 }
2236
2237 static const struct file_operations spufs_proxydma_info_fops = {
2238         .open = spufs_info_open,
2239         .read = spufs_proxydma_info_read,
2240         .llseek = no_llseek,
2241 };
2242
2243 static int spufs_show_tid(struct seq_file *s, void *private)
2244 {
2245         struct spu_context *ctx = s->private;
2246
2247         seq_printf(s, "%d\n", ctx->tid);
2248         return 0;
2249 }
2250
2251 static int spufs_tid_open(struct inode *inode, struct file *file)
2252 {
2253         return single_open(file, spufs_show_tid, SPUFS_I(inode)->i_ctx);
2254 }
2255
2256 static const struct file_operations spufs_tid_fops = {
2257         .open           = spufs_tid_open,
2258         .read           = seq_read,
2259         .llseek         = seq_lseek,
2260         .release        = single_release,
2261 };
2262
2263 static const char *ctx_state_names[] = {
2264         "user", "system", "iowait", "loaded"
2265 };
2266
2267 static unsigned long long spufs_acct_time(struct spu_context *ctx,
2268                 enum spu_utilization_state state)
2269 {
2270         unsigned long long time = ctx->stats.times[state];
2271
2272         /*
2273          * In general, utilization statistics are updated by the controlling
2274          * thread as the spu context moves through various well defined
2275          * state transitions, but if the context is lazily loaded its
2276          * utilization statistics are not updated as the controlling thread
2277          * is not tightly coupled with the execution of the spu context.  We
2278          * calculate and apply the time delta from the last recorded state
2279          * of the spu context.
2280          */
2281         if (ctx->spu && ctx->stats.util_state == state) {
2282                 time += ktime_get_ns() - ctx->stats.tstamp;
2283         }
2284
2285         return time / NSEC_PER_MSEC;
2286 }
2287
2288 static unsigned long long spufs_slb_flts(struct spu_context *ctx)
2289 {
2290         unsigned long long slb_flts = ctx->stats.slb_flt;
2291
2292         if (ctx->state == SPU_STATE_RUNNABLE) {
2293                 slb_flts += (ctx->spu->stats.slb_flt -
2294                              ctx->stats.slb_flt_base);
2295         }
2296
2297         return slb_flts;
2298 }
2299
2300 static unsigned long long spufs_class2_intrs(struct spu_context *ctx)
2301 {
2302         unsigned long long class2_intrs = ctx->stats.class2_intr;
2303
2304         if (ctx->state == SPU_STATE_RUNNABLE) {
2305                 class2_intrs += (ctx->spu->stats.class2_intr -
2306                                  ctx->stats.class2_intr_base);
2307         }
2308
2309         return class2_intrs;
2310 }
2311
2312
2313 static int spufs_show_stat(struct seq_file *s, void *private)
2314 {
2315         struct spu_context *ctx = s->private;
2316         int ret;
2317
2318         ret = spu_acquire(ctx);
2319         if (ret)
2320                 return ret;
2321
2322         seq_printf(s, "%s %llu %llu %llu %llu "
2323                       "%llu %llu %llu %llu %llu %llu %llu %llu\n",
2324                 ctx_state_names[ctx->stats.util_state],
2325                 spufs_acct_time(ctx, SPU_UTIL_USER),
2326                 spufs_acct_time(ctx, SPU_UTIL_SYSTEM),
2327                 spufs_acct_time(ctx, SPU_UTIL_IOWAIT),
2328                 spufs_acct_time(ctx, SPU_UTIL_IDLE_LOADED),
2329                 ctx->stats.vol_ctx_switch,
2330                 ctx->stats.invol_ctx_switch,
2331                 spufs_slb_flts(ctx),
2332                 ctx->stats.hash_flt,
2333                 ctx->stats.min_flt,
2334                 ctx->stats.maj_flt,
2335                 spufs_class2_intrs(ctx),
2336                 ctx->stats.libassist);
2337         spu_release(ctx);
2338         return 0;
2339 }
2340
2341 static int spufs_stat_open(struct inode *inode, struct file *file)
2342 {
2343         return single_open(file, spufs_show_stat, SPUFS_I(inode)->i_ctx);
2344 }
2345
2346 static const struct file_operations spufs_stat_fops = {
2347         .open           = spufs_stat_open,
2348         .read           = seq_read,
2349         .llseek         = seq_lseek,
2350         .release        = single_release,
2351 };
2352
2353 static inline int spufs_switch_log_used(struct spu_context *ctx)
2354 {
2355         return (ctx->switch_log->head - ctx->switch_log->tail) %
2356                 SWITCH_LOG_BUFSIZE;
2357 }
2358
2359 static inline int spufs_switch_log_avail(struct spu_context *ctx)
2360 {
2361         return SWITCH_LOG_BUFSIZE - spufs_switch_log_used(ctx);
2362 }
2363
2364 static int spufs_switch_log_open(struct inode *inode, struct file *file)
2365 {
2366         struct spu_context *ctx = SPUFS_I(inode)->i_ctx;
2367         int rc;
2368
2369         rc = spu_acquire(ctx);
2370         if (rc)
2371                 return rc;
2372
2373         if (ctx->switch_log) {
2374                 rc = -EBUSY;
2375                 goto out;
2376         }
2377
2378         ctx->switch_log = kmalloc(sizeof(struct switch_log) +
2379                 SWITCH_LOG_BUFSIZE * sizeof(struct switch_log_entry),
2380                 GFP_KERNEL);
2381
2382         if (!ctx->switch_log) {
2383                 rc = -ENOMEM;
2384                 goto out;
2385         }
2386
2387         ctx->switch_log->head = ctx->switch_log->tail = 0;
2388         init_waitqueue_head(&ctx->switch_log->wait);
2389         rc = 0;
2390
2391 out:
2392         spu_release(ctx);
2393         return rc;
2394 }
2395
2396 static int spufs_switch_log_release(struct inode *inode, struct file *file)
2397 {
2398         struct spu_context *ctx = SPUFS_I(inode)->i_ctx;
2399         int rc;
2400
2401         rc = spu_acquire(ctx);
2402         if (rc)
2403                 return rc;
2404
2405         kfree(ctx->switch_log);
2406         ctx->switch_log = NULL;
2407         spu_release(ctx);
2408
2409         return 0;
2410 }
2411
2412 static int switch_log_sprint(struct spu_context *ctx, char *tbuf, int n)
2413 {
2414         struct switch_log_entry *p;
2415
2416         p = ctx->switch_log->log + ctx->switch_log->tail % SWITCH_LOG_BUFSIZE;
2417
2418         return snprintf(tbuf, n, "%llu.%09u %d %u %u %llu\n",
2419                         (unsigned long long) p->tstamp.tv_sec,
2420                         (unsigned int) p->tstamp.tv_nsec,
2421                         p->spu_id,
2422                         (unsigned int) p->type,
2423                         (unsigned int) p->val,
2424                         (unsigned long long) p->timebase);
2425 }
2426
2427 static ssize_t spufs_switch_log_read(struct file *file, char __user *buf,
2428                              size_t len, loff_t *ppos)
2429 {
2430         struct inode *inode = file_inode(file);
2431         struct spu_context *ctx = SPUFS_I(inode)->i_ctx;
2432         int error = 0, cnt = 0;
2433
2434         if (!buf)
2435                 return -EINVAL;
2436
2437         error = spu_acquire(ctx);
2438         if (error)
2439                 return error;
2440
2441         while (cnt < len) {
2442                 char tbuf[128];
2443                 int width;
2444
2445                 if (spufs_switch_log_used(ctx) == 0) {
2446                         if (cnt > 0) {
2447                                 /* If there's data ready to go, we can
2448                                  * just return straight away */
2449                                 break;
2450
2451                         } else if (file->f_flags & O_NONBLOCK) {
2452                                 error = -EAGAIN;
2453                                 break;
2454
2455                         } else {
2456                                 /* spufs_wait will drop the mutex and
2457                                  * re-acquire, but since we're in read(), the
2458                                  * file cannot be _released (and so
2459                                  * ctx->switch_log is stable).
2460                                  */
2461                                 error = spufs_wait(ctx->switch_log->wait,
2462                                                 spufs_switch_log_used(ctx) > 0);
2463
2464                                 /* On error, spufs_wait returns without the
2465                                  * state mutex held */
2466                                 if (error)
2467                                         return error;
2468
2469                                 /* We may have had entries read from underneath
2470                                  * us while we dropped the mutex in spufs_wait,
2471                                  * so re-check */
2472                                 if (spufs_switch_log_used(ctx) == 0)
2473                                         continue;
2474                         }
2475                 }
2476
2477                 width = switch_log_sprint(ctx, tbuf, sizeof(tbuf));
2478                 if (width < len)
2479                         ctx->switch_log->tail =
2480                                 (ctx->switch_log->tail + 1) %
2481                                  SWITCH_LOG_BUFSIZE;
2482                 else
2483                         /* If the record is greater than space available return
2484                          * partial buffer (so far) */
2485                         break;
2486
2487                 error = copy_to_user(buf + cnt, tbuf, width);
2488                 if (error)
2489                         break;
2490                 cnt += width;
2491         }
2492
2493         spu_release(ctx);
2494
2495         return cnt == 0 ? error : cnt;
2496 }
2497
2498 static __poll_t spufs_switch_log_poll(struct file *file, poll_table *wait)
2499 {
2500         struct inode *inode = file_inode(file);
2501         struct spu_context *ctx = SPUFS_I(inode)->i_ctx;
2502         __poll_t mask = 0;
2503         int rc;
2504
2505         poll_wait(file, &ctx->switch_log->wait, wait);
2506
2507         rc = spu_acquire(ctx);
2508         if (rc)
2509                 return rc;
2510
2511         if (spufs_switch_log_used(ctx) > 0)
2512                 mask |= EPOLLIN;
2513
2514         spu_release(ctx);
2515
2516         return mask;
2517 }
2518
2519 static const struct file_operations spufs_switch_log_fops = {
2520         .open           = spufs_switch_log_open,
2521         .read           = spufs_switch_log_read,
2522         .poll           = spufs_switch_log_poll,
2523         .release        = spufs_switch_log_release,
2524         .llseek         = no_llseek,
2525 };
2526
2527 /**
2528  * Log a context switch event to a switch log reader.
2529  *
2530  * Must be called with ctx->state_mutex held.
2531  */
2532 void spu_switch_log_notify(struct spu *spu, struct spu_context *ctx,
2533                 u32 type, u32 val)
2534 {
2535         if (!ctx->switch_log)
2536                 return;
2537
2538         if (spufs_switch_log_avail(ctx) > 1) {
2539                 struct switch_log_entry *p;
2540
2541                 p = ctx->switch_log->log + ctx->switch_log->head;
2542                 ktime_get_ts64(&p->tstamp);
2543                 p->timebase = get_tb();
2544                 p->spu_id = spu ? spu->number : -1;
2545                 p->type = type;
2546                 p->val = val;
2547
2548                 ctx->switch_log->head =
2549                         (ctx->switch_log->head + 1) % SWITCH_LOG_BUFSIZE;
2550         }
2551
2552         wake_up(&ctx->switch_log->wait);
2553 }
2554
2555 static int spufs_show_ctx(struct seq_file *s, void *private)
2556 {
2557         struct spu_context *ctx = s->private;
2558         u64 mfc_control_RW;
2559
2560         mutex_lock(&ctx->state_mutex);
2561         if (ctx->spu) {
2562                 struct spu *spu = ctx->spu;
2563                 struct spu_priv2 __iomem *priv2 = spu->priv2;
2564
2565                 spin_lock_irq(&spu->register_lock);
2566                 mfc_control_RW = in_be64(&priv2->mfc_control_RW);
2567                 spin_unlock_irq(&spu->register_lock);
2568         } else {
2569                 struct spu_state *csa = &ctx->csa;
2570
2571                 mfc_control_RW = csa->priv2.mfc_control_RW;
2572         }
2573
2574         seq_printf(s, "%c flgs(%lx) sflgs(%lx) pri(%d) ts(%d) spu(%02d)"
2575                 " %c %llx %llx %llx %llx %x %x\n",
2576                 ctx->state == SPU_STATE_SAVED ? 'S' : 'R',
2577                 ctx->flags,
2578                 ctx->sched_flags,
2579                 ctx->prio,
2580                 ctx->time_slice,
2581                 ctx->spu ? ctx->spu->number : -1,
2582                 !list_empty(&ctx->rq) ? 'q' : ' ',
2583                 ctx->csa.class_0_pending,
2584                 ctx->csa.class_0_dar,
2585                 ctx->csa.class_1_dsisr,
2586                 mfc_control_RW,
2587                 ctx->ops->runcntl_read(ctx),
2588                 ctx->ops->status_read(ctx));
2589
2590         mutex_unlock(&ctx->state_mutex);
2591
2592         return 0;
2593 }
2594
2595 static int spufs_ctx_open(struct inode *inode, struct file *file)
2596 {
2597         return single_open(file, spufs_show_ctx, SPUFS_I(inode)->i_ctx);
2598 }
2599
2600 static const struct file_operations spufs_ctx_fops = {
2601         .open           = spufs_ctx_open,
2602         .read           = seq_read,
2603         .llseek         = seq_lseek,
2604         .release        = single_release,
2605 };
2606
2607 const struct spufs_tree_descr spufs_dir_contents[] = {
2608         { "capabilities", &spufs_caps_fops, 0444, },
2609         { "mem",  &spufs_mem_fops,  0666, LS_SIZE, },
2610         { "regs", &spufs_regs_fops,  0666, sizeof(struct spu_reg128[128]), },
2611         { "mbox", &spufs_mbox_fops, 0444, },
2612         { "ibox", &spufs_ibox_fops, 0444, },
2613         { "wbox", &spufs_wbox_fops, 0222, },
2614         { "mbox_stat", &spufs_mbox_stat_fops, 0444, sizeof(u32), },
2615         { "ibox_stat", &spufs_ibox_stat_fops, 0444, sizeof(u32), },
2616         { "wbox_stat", &spufs_wbox_stat_fops, 0444, sizeof(u32), },
2617         { "signal1", &spufs_signal1_fops, 0666, },
2618         { "signal2", &spufs_signal2_fops, 0666, },
2619         { "signal1_type", &spufs_signal1_type, 0666, },
2620         { "signal2_type", &spufs_signal2_type, 0666, },
2621         { "cntl", &spufs_cntl_fops,  0666, },
2622         { "fpcr", &spufs_fpcr_fops, 0666, sizeof(struct spu_reg128), },
2623         { "lslr", &spufs_lslr_ops, 0444, },
2624         { "mfc", &spufs_mfc_fops, 0666, },
2625         { "mss", &spufs_mss_fops, 0666, },
2626         { "npc", &spufs_npc_ops, 0666, },
2627         { "srr0", &spufs_srr0_ops, 0666, },
2628         { "decr", &spufs_decr_ops, 0666, },
2629         { "decr_status", &spufs_decr_status_ops, 0666, },
2630         { "event_mask", &spufs_event_mask_ops, 0666, },
2631         { "event_status", &spufs_event_status_ops, 0444, },
2632         { "psmap", &spufs_psmap_fops, 0666, SPUFS_PS_MAP_SIZE, },
2633         { "phys-id", &spufs_id_ops, 0666, },
2634         { "object-id", &spufs_object_id_ops, 0666, },
2635         { "mbox_info", &spufs_mbox_info_fops, 0444, sizeof(u32), },
2636         { "ibox_info", &spufs_ibox_info_fops, 0444, sizeof(u32), },
2637         { "wbox_info", &spufs_wbox_info_fops, 0444, sizeof(u32), },
2638         { "dma_info", &spufs_dma_info_fops, 0444,
2639                 sizeof(struct spu_dma_info), },
2640         { "proxydma_info", &spufs_proxydma_info_fops, 0444,
2641                 sizeof(struct spu_proxydma_info)},
2642         { "tid", &spufs_tid_fops, 0444, },
2643         { "stat", &spufs_stat_fops, 0444, },
2644         { "switch_log", &spufs_switch_log_fops, 0444 },
2645         {},
2646 };
2647
2648 const struct spufs_tree_descr spufs_dir_nosched_contents[] = {
2649         { "capabilities", &spufs_caps_fops, 0444, },
2650         { "mem",  &spufs_mem_fops,  0666, LS_SIZE, },
2651         { "mbox", &spufs_mbox_fops, 0444, },
2652         { "ibox", &spufs_ibox_fops, 0444, },
2653         { "wbox", &spufs_wbox_fops, 0222, },
2654         { "mbox_stat", &spufs_mbox_stat_fops, 0444, sizeof(u32), },
2655         { "ibox_stat", &spufs_ibox_stat_fops, 0444, sizeof(u32), },
2656         { "wbox_stat", &spufs_wbox_stat_fops, 0444, sizeof(u32), },
2657         { "signal1", &spufs_signal1_nosched_fops, 0222, },
2658         { "signal2", &spufs_signal2_nosched_fops, 0222, },
2659         { "signal1_type", &spufs_signal1_type, 0666, },
2660         { "signal2_type", &spufs_signal2_type, 0666, },
2661         { "mss", &spufs_mss_fops, 0666, },
2662         { "mfc", &spufs_mfc_fops, 0666, },
2663         { "cntl", &spufs_cntl_fops,  0666, },
2664         { "npc", &spufs_npc_ops, 0666, },
2665         { "psmap", &spufs_psmap_fops, 0666, SPUFS_PS_MAP_SIZE, },
2666         { "phys-id", &spufs_id_ops, 0666, },
2667         { "object-id", &spufs_object_id_ops, 0666, },
2668         { "tid", &spufs_tid_fops, 0444, },
2669         { "stat", &spufs_stat_fops, 0444, },
2670         {},
2671 };
2672
2673 const struct spufs_tree_descr spufs_dir_debug_contents[] = {
2674         { ".ctx", &spufs_ctx_fops, 0444, },
2675         {},
2676 };
2677
2678 const struct spufs_coredump_reader spufs_coredump_read[] = {
2679         { "regs", __spufs_regs_read, NULL, sizeof(struct spu_reg128[128])},
2680         { "fpcr", __spufs_fpcr_read, NULL, sizeof(struct spu_reg128) },
2681         { "lslr", NULL, spufs_lslr_get, 19 },
2682         { "decr", NULL, spufs_decr_get, 19 },
2683         { "decr_status", NULL, spufs_decr_status_get, 19 },
2684         { "mem", __spufs_mem_read, NULL, LS_SIZE, },
2685         { "signal1", __spufs_signal1_read, NULL, sizeof(u32) },
2686         { "signal1_type", NULL, spufs_signal1_type_get, 19 },
2687         { "signal2", __spufs_signal2_read, NULL, sizeof(u32) },
2688         { "signal2_type", NULL, spufs_signal2_type_get, 19 },
2689         { "event_mask", NULL, spufs_event_mask_get, 19 },
2690         { "event_status", NULL, spufs_event_status_get, 19 },
2691         { "mbox_info", __spufs_mbox_info_read, NULL, sizeof(u32) },
2692         { "ibox_info", __spufs_ibox_info_read, NULL, sizeof(u32) },
2693         { "wbox_info", __spufs_wbox_info_read, NULL, 4 * sizeof(u32)},
2694         { "dma_info", __spufs_dma_info_read, NULL, sizeof(struct spu_dma_info)},
2695         { "proxydma_info", __spufs_proxydma_info_read,
2696                            NULL, sizeof(struct spu_proxydma_info)},
2697         { "object-id", NULL, spufs_object_id_get, 19 },
2698         { "npc", NULL, spufs_npc_get, 19 },
2699         { NULL },
2700 };