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