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