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
  32 #include <asm/io.h>
  33 #include <asm/semaphore.h>
  34 #include <asm/spu.h>
  35 #include <asm/uaccess.h>
  36
  37 #include "spufs.h"
  38
  39 #define SPUFS_MMAP_4K (PAGE_SIZE == 0x1000)
  40
  41
  42 static int
  43 spufs_mem_open(struct inode *inode, struct file *file)
  44 {
  45         struct spufs_inode_info *i = SPUFS_I(inode);
  46         struct spu_context *ctx = i->i_ctx;
  47         file->private_data = ctx;
  48         file->f_mapping = inode->i_mapping;
  49         ctx->local_store = inode->i_mapping;
  50         return 0;
  51 }
  52
  53 static ssize_t
  54 spufs_mem_read(struct file *file, char __user *buffer,
  55                                 size_t size, loff_t *pos)
  56 {
  57         struct spu_context *ctx = file->private_data;
  58         char *local_store;
  59         int ret;
  60
  61         spu_acquire(ctx);
  62
  63         local_store = ctx->ops->get_ls(ctx);
  64         ret = simple_read_from_buffer(buffer, size, pos, local_store, LS_SIZE);
  65
  66         spu_release(ctx);
  67         return ret;
  68 }
  69
  70 static ssize_t
  71 spufs_mem_write(struct file *file, const char __user *buffer,
  72                                         size_t size, loff_t *pos)
  73 {
  74         struct spu_context *ctx = file->private_data;
  75         char *local_store;
  76         int ret;
  77
  78         size = min_t(ssize_t, LS_SIZE - *pos, size);
  79         if (size <= 0)
  80                 return -EFBIG;
  81         *pos += size;
  82
  83         spu_acquire(ctx);
  84
  85         local_store = ctx->ops->get_ls(ctx);
  86         ret = copy_from_user(local_store + *pos - size,
  87                              buffer, size) ? -EFAULT : size;
  88
  89         spu_release(ctx);
  90         return ret;
  91 }
  92
  93 static struct page *
  94 spufs_mem_mmap_nopage(struct vm_area_struct *vma,
  95                       unsigned long address, int *type)
  96 {
  97         struct page *page = NOPAGE_SIGBUS;
  98
  99         struct spu_context *ctx = vma->vm_file->private_data;
 100         unsigned long offset = address - vma->vm_start;
 101         offset += vma->vm_pgoff << PAGE_SHIFT;
 102
 103         spu_acquire(ctx);
 104
 105         if (ctx->state == SPU_STATE_SAVED) {
 106                 vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot)
 107                                         & ~(_PAGE_NO_CACHE | _PAGE_GUARDED));
 108                 page = vmalloc_to_page(ctx->csa.lscsa->ls + offset);
 109         } else {
 110                 vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot)
 111                                         | _PAGE_NO_CACHE | _PAGE_GUARDED);
 112                 page = pfn_to_page((ctx->spu->local_store_phys + offset)
 113                                    >> PAGE_SHIFT);
 114         }
 115         spu_release(ctx);
 116
 117         if (type)
 118                 *type = VM_FAULT_MINOR;
 119
 120         page_cache_get(page);
 121         return page;
 122 }
 123
 124 static struct vm_operations_struct spufs_mem_mmap_vmops = {
 125         .nopage = spufs_mem_mmap_nopage,
 126 };
 127
 128 static int
 129 spufs_mem_mmap(struct file *file, struct vm_area_struct *vma)
 130 {
 131         if (!(vma->vm_flags & VM_SHARED))
 132                 return -EINVAL;
 133
 134         /* FIXME: */
 135         vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot)
 136                                      | _PAGE_NO_CACHE);
 137
 138         vma->vm_ops = &spufs_mem_mmap_vmops;
 139         return 0;
 140 }
 141
 142 static struct file_operations spufs_mem_fops = {
 143         .open    = spufs_mem_open,
 144         .read    = spufs_mem_read,
 145         .write   = spufs_mem_write,
 146         .llseek  = generic_file_llseek,
 147         .mmap    = spufs_mem_mmap,
 148 };
 149
 150 static struct page *spufs_ps_nopage(struct vm_area_struct *vma,
 151                                     unsigned long address,
 152                                     int *type, unsigned long ps_offs,
 153                                     unsigned long ps_size)
 154 {
 155         struct page *page = NOPAGE_SIGBUS;
 156         int fault_type = VM_FAULT_SIGBUS;
 157         struct spu_context *ctx = vma->vm_file->private_data;
 158         unsigned long offset = address - vma->vm_start;
 159         unsigned long area;
 160         int ret;
 161
 162         offset += vma->vm_pgoff << PAGE_SHIFT;
 163         if (offset >= ps_size)
 164                 goto out;
 165
 166         ret = spu_acquire_runnable(ctx);
 167         if (ret)
 168                 goto out;
 169
 170         area = ctx->spu->problem_phys + ps_offs;
 171         page = pfn_to_page((area + offset) >> PAGE_SHIFT);
 172         fault_type = VM_FAULT_MINOR;
 173         page_cache_get(page);
 174
 175         spu_release(ctx);
 176
 177       out:
 178         if (type)
 179                 *type = fault_type;
 180
 181         return page;
 182 }
 183
 184 #if SPUFS_MMAP_4K
 185 static struct page *spufs_cntl_mmap_nopage(struct vm_area_struct *vma,
 186                                            unsigned long address, int *type)
 187 {
 188         return spufs_ps_nopage(vma, address, type, 0x4000, 0x1000);
 189 }
 190
 191 static struct vm_operations_struct spufs_cntl_mmap_vmops = {
 192         .nopage = spufs_cntl_mmap_nopage,
 193 };
 194
 195 /*
 196  * mmap support for problem state control area [0x4000 - 0x4fff].
 197  */
 198 static int spufs_cntl_mmap(struct file *file, struct vm_area_struct *vma)
 199 {
 200         if (!(vma->vm_flags & VM_SHARED))
 201                 return -EINVAL;
 202
 203         vma->vm_flags |= VM_RESERVED;
 204         vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot)
 205                                      | _PAGE_NO_CACHE | _PAGE_GUARDED);
 206
 207         vma->vm_ops = &spufs_cntl_mmap_vmops;
 208         return 0;
 209 }
 210 #else /* SPUFS_MMAP_4K */
 211 #define spufs_cntl_mmap NULL
 212 #endif /* !SPUFS_MMAP_4K */
 213
 214 static u64 spufs_cntl_get(void *data)
 215 {
 216         struct spu_context *ctx = data;
 217         u64 val;
 218
 219         spu_acquire(ctx);
 220         val = ctx->ops->status_read(ctx);
 221         spu_release(ctx);
 222
 223         return val;
 224 }
 225
 226 static void spufs_cntl_set(void *data, u64 val)
 227 {
 228         struct spu_context *ctx = data;
 229
 230         spu_acquire(ctx);
 231         ctx->ops->runcntl_write(ctx, val);
 232         spu_release(ctx);
 233 }
 234
 235 static int spufs_cntl_open(struct inode *inode, struct file *file)
 236 {
 237         struct spufs_inode_info *i = SPUFS_I(inode);
 238         struct spu_context *ctx = i->i_ctx;
 239
 240         file->private_data = ctx;
 241         file->f_mapping = inode->i_mapping;
 242         ctx->cntl = inode->i_mapping;
 243         return simple_attr_open(inode, file, spufs_cntl_get,
 244                                         spufs_cntl_set, "0x%08lx");
 245 }
 246
 247 static struct file_operations spufs_cntl_fops = {
 248         .open = spufs_cntl_open,
 249         .release = simple_attr_close,
 250         .read = simple_attr_read,
 251         .write = simple_attr_write,
 252         .mmap = spufs_cntl_mmap,
 253 };
 254
 255 static int
 256 spufs_regs_open(struct inode *inode, struct file *file)
 257 {
 258         struct spufs_inode_info *i = SPUFS_I(inode);
 259         file->private_data = i->i_ctx;
 260         return 0;
 261 }
 262
 263 static ssize_t
 264 spufs_regs_read(struct file *file, char __user *buffer,
 265                 size_t size, loff_t *pos)
 266 {
 267         struct spu_context *ctx = file->private_data;
 268         struct spu_lscsa *lscsa = ctx->csa.lscsa;
 269         int ret;
 270
 271         spu_acquire_saved(ctx);
 272
 273         ret = simple_read_from_buffer(buffer, size, pos,
 274                                       lscsa->gprs, sizeof lscsa->gprs);
 275
 276         spu_release(ctx);
 277         return ret;
 278 }
 279
 280 static ssize_t
 281 spufs_regs_write(struct file *file, const char __user *buffer,
 282                  size_t size, loff_t *pos)
 283 {
 284         struct spu_context *ctx = file->private_data;
 285         struct spu_lscsa *lscsa = ctx->csa.lscsa;
 286         int ret;
 287
 288         size = min_t(ssize_t, sizeof lscsa->gprs - *pos, size);
 289         if (size <= 0)
 290                 return -EFBIG;
 291         *pos += size;
 292
 293         spu_acquire_saved(ctx);
 294
 295         ret = copy_from_user(lscsa->gprs + *pos - size,
 296                              buffer, size) ? -EFAULT : size;
 297
 298         spu_release(ctx);
 299         return ret;
 300 }
 301
 302 static struct file_operations spufs_regs_fops = {
 303         .open    = spufs_regs_open,
 304         .read    = spufs_regs_read,
 305         .write   = spufs_regs_write,
 306         .llseek  = generic_file_llseek,
 307 };
 308
 309 static ssize_t
 310 spufs_fpcr_read(struct file *file, char __user * buffer,
 311                 size_t size, loff_t * pos)
 312 {
 313         struct spu_context *ctx = file->private_data;
 314         struct spu_lscsa *lscsa = ctx->csa.lscsa;
 315         int ret;
 316
 317         spu_acquire_saved(ctx);
 318
 319         ret = simple_read_from_buffer(buffer, size, pos,
 320                                       &lscsa->fpcr, sizeof(lscsa->fpcr));
 321
 322         spu_release(ctx);
 323         return ret;
 324 }
 325
 326 static ssize_t
 327 spufs_fpcr_write(struct file *file, const char __user * buffer,
 328                  size_t size, loff_t * pos)
 329 {
 330         struct spu_context *ctx = file->private_data;
 331         struct spu_lscsa *lscsa = ctx->csa.lscsa;
 332         int ret;
 333
 334         size = min_t(ssize_t, sizeof(lscsa->fpcr) - *pos, size);
 335         if (size <= 0)
 336                 return -EFBIG;
 337         *pos += size;
 338
 339         spu_acquire_saved(ctx);
 340
 341         ret = copy_from_user((char *)&lscsa->fpcr + *pos - size,
 342                              buffer, size) ? -EFAULT : size;
 343
 344         spu_release(ctx);
 345         return ret;
 346 }
 347
 348 static struct file_operations spufs_fpcr_fops = {
 349         .open = spufs_regs_open,
 350         .read = spufs_fpcr_read,
 351         .write = spufs_fpcr_write,
 352         .llseek = generic_file_llseek,
 353 };
 354
 355 /* generic open function for all pipe-like files */
 356 static int spufs_pipe_open(struct inode *inode, struct file *file)
 357 {
 358         struct spufs_inode_info *i = SPUFS_I(inode);
 359         file->private_data = i->i_ctx;
 360
 361         return nonseekable_open(inode, file);
 362 }
 363
 364 /*
 365  * Read as many bytes from the mailbox as possible, until
 366  * one of the conditions becomes true:
 367  *
 368  * - no more data available in the mailbox
 369  * - end of the user provided buffer
 370  * - end of the mapped area
 371  */
 372 static ssize_t spufs_mbox_read(struct file *file, char __user *buf,
 373                         size_t len, loff_t *pos)
 374 {
 375         struct spu_context *ctx = file->private_data;
 376         u32 mbox_data, __user *udata;
 377         ssize_t count;
 378
 379         if (len < 4)
 380                 return -EINVAL;
 381
 382         if (!access_ok(VERIFY_WRITE, buf, len))
 383                 return -EFAULT;
 384
 385         udata = (void __user *)buf;
 386
 387         spu_acquire(ctx);
 388         for (count = 0; (count + 4) <= len; count += 4, udata++) {
 389                 int ret;
 390                 ret = ctx->ops->mbox_read(ctx, &mbox_data);
 391                 if (ret == 0)
 392                         break;
 393
 394                 /*
 395                  * at the end of the mapped area, we can fault
 396                  * but still need to return the data we have
 397                  * read successfully so far.
 398                  */
 399                 ret = __put_user(mbox_data, udata);
 400                 if (ret) {
 401                         if (!count)
 402                                 count = -EFAULT;
 403                         break;
 404                 }
 405         }
 406         spu_release(ctx);
 407
 408         if (!count)
 409                 count = -EAGAIN;
 410
 411         return count;
 412 }
 413
 414 static struct file_operations spufs_mbox_fops = {
 415         .open   = spufs_pipe_open,
 416         .read   = spufs_mbox_read,
 417 };
 418
 419 static ssize_t spufs_mbox_stat_read(struct file *file, char __user *buf,
 420                         size_t len, loff_t *pos)
 421 {
 422         struct spu_context *ctx = file->private_data;
 423         u32 mbox_stat;
 424
 425         if (len < 4)
 426                 return -EINVAL;
 427
 428         spu_acquire(ctx);
 429
 430         mbox_stat = ctx->ops->mbox_stat_read(ctx) & 0xff;
 431
 432         spu_release(ctx);
 433
 434         if (copy_to_user(buf, &mbox_stat, sizeof mbox_stat))
 435                 return -EFAULT;
 436
 437         return 4;
 438 }
 439
 440 static struct file_operations spufs_mbox_stat_fops = {
 441         .open   = spufs_pipe_open,
 442         .read   = spufs_mbox_stat_read,
 443 };
 444
 445 /* low-level ibox access function */
 446 size_t spu_ibox_read(struct spu_context *ctx, u32 *data)
 447 {
 448         return ctx->ops->ibox_read(ctx, data);
 449 }
 450
 451 static int spufs_ibox_fasync(int fd, struct file *file, int on)
 452 {
 453         struct spu_context *ctx = file->private_data;
 454
 455         return fasync_helper(fd, file, on, &ctx->ibox_fasync);
 456 }
 457
 458 /* interrupt-level ibox callback function. */
 459 void spufs_ibox_callback(struct spu *spu)
 460 {
 461         struct spu_context *ctx = spu->ctx;
 462
 463         wake_up_all(&ctx->ibox_wq);
 464         kill_fasync(&ctx->ibox_fasync, SIGIO, POLLIN);
 465 }
 466
 467 /*
 468  * Read as many bytes from the interrupt mailbox as possible, until
 469  * one of the conditions becomes true:
 470  *
 471  * - no more data available in the mailbox
 472  * - end of the user provided buffer
 473  * - end of the mapped area
 474  *
 475  * If the file is opened without O_NONBLOCK, we wait here until
 476  * any data is available, but return when we have been able to
 477  * read something.
 478  */
 479 static ssize_t spufs_ibox_read(struct file *file, char __user *buf,
 480                         size_t len, loff_t *pos)
 481 {
 482         struct spu_context *ctx = file->private_data;
 483         u32 ibox_data, __user *udata;
 484         ssize_t count;
 485
 486         if (len < 4)
 487                 return -EINVAL;
 488
 489         if (!access_ok(VERIFY_WRITE, buf, len))
 490                 return -EFAULT;
 491
 492         udata = (void __user *)buf;
 493
 494         spu_acquire(ctx);
 495
 496         /* wait only for the first element */
 497         count = 0;
 498         if (file->f_flags & O_NONBLOCK) {
 499                 if (!spu_ibox_read(ctx, &ibox_data))
 500                         count = -EAGAIN;
 501         } else {
 502                 count = spufs_wait(ctx->ibox_wq, spu_ibox_read(ctx, &ibox_data));
 503         }
 504         if (count)
 505                 goto out;
 506
 507         /* if we can't write at all, return -EFAULT */
 508         count = __put_user(ibox_data, udata);
 509         if (count)
 510                 goto out;
 511
 512         for (count = 4, udata++; (count + 4) <= len; count += 4, udata++) {
 513                 int ret;
 514                 ret = ctx->ops->ibox_read(ctx, &ibox_data);
 515                 if (ret == 0)
 516                         break;
 517                 /*
 518                  * at the end of the mapped area, we can fault
 519                  * but still need to return the data we have
 520                  * read successfully so far.
 521                  */
 522                 ret = __put_user(ibox_data, udata);
 523                 if (ret)
 524                         break;
 525         }
 526
 527 out:
 528         spu_release(ctx);
 529
 530         return count;
 531 }
 532
 533 static unsigned int spufs_ibox_poll(struct file *file, poll_table *wait)
 534 {
 535         struct spu_context *ctx = file->private_data;
 536         unsigned int mask;
 537
 538         poll_wait(file, &ctx->ibox_wq, wait);
 539
 540         spu_acquire(ctx);
 541         mask = ctx->ops->mbox_stat_poll(ctx, POLLIN | POLLRDNORM);
 542         spu_release(ctx);
 543
 544         return mask;
 545 }
 546
 547 static struct file_operations spufs_ibox_fops = {
 548         .open   = spufs_pipe_open,
 549         .read   = spufs_ibox_read,
 550         .poll   = spufs_ibox_poll,
 551         .fasync = spufs_ibox_fasync,
 552 };
 553
 554 static ssize_t spufs_ibox_stat_read(struct file *file, char __user *buf,
 555                         size_t len, loff_t *pos)
 556 {
 557         struct spu_context *ctx = file->private_data;
 558         u32 ibox_stat;
 559
 560         if (len < 4)
 561                 return -EINVAL;
 562
 563         spu_acquire(ctx);
 564         ibox_stat = (ctx->ops->mbox_stat_read(ctx) >> 16) & 0xff;
 565         spu_release(ctx);
 566
 567         if (copy_to_user(buf, &ibox_stat, sizeof ibox_stat))
 568                 return -EFAULT;
 569
 570         return 4;
 571 }
 572
 573 static struct file_operations spufs_ibox_stat_fops = {
 574         .open   = spufs_pipe_open,
 575         .read   = spufs_ibox_stat_read,
 576 };
 577
 578 /* low-level mailbox write */
 579 size_t spu_wbox_write(struct spu_context *ctx, u32 data)
 580 {
 581         return ctx->ops->wbox_write(ctx, data);
 582 }
 583
 584 static int spufs_wbox_fasync(int fd, struct file *file, int on)
 585 {
 586         struct spu_context *ctx = file->private_data;
 587         int ret;
 588
 589         ret = fasync_helper(fd, file, on, &ctx->wbox_fasync);
 590
 591         return ret;
 592 }
 593
 594 /* interrupt-level wbox callback function. */
 595 void spufs_wbox_callback(struct spu *spu)
 596 {
 597         struct spu_context *ctx = spu->ctx;
 598
 599         wake_up_all(&ctx->wbox_wq);
 600         kill_fasync(&ctx->wbox_fasync, SIGIO, POLLOUT);
 601 }
 602
 603 /*
 604  * Write as many bytes to the interrupt mailbox as possible, until
 605  * one of the conditions becomes true:
 606  *
 607  * - the mailbox is full
 608  * - end of the user provided buffer
 609  * - end of the mapped area
 610  *
 611  * If the file is opened without O_NONBLOCK, we wait here until
 612  * space is availabyl, but return when we have been able to
 613  * write something.
 614  */
 615 static ssize_t spufs_wbox_write(struct file *file, const char __user *buf,
 616                         size_t len, loff_t *pos)
 617 {
 618         struct spu_context *ctx = file->private_data;
 619         u32 wbox_data, __user *udata;
 620         ssize_t count;
 621
 622         if (len < 4)
 623                 return -EINVAL;
 624
 625         udata = (void __user *)buf;
 626         if (!access_ok(VERIFY_READ, buf, len))
 627                 return -EFAULT;
 628
 629         if (__get_user(wbox_data, udata))
 630                 return -EFAULT;
 631
 632         spu_acquire(ctx);
 633
 634         /*
 635          * make sure we can at least write one element, by waiting
 636          * in case of !O_NONBLOCK
 637          */
 638         count = 0;
 639         if (file->f_flags & O_NONBLOCK) {
 640                 if (!spu_wbox_write(ctx, wbox_data))
 641                         count = -EAGAIN;
 642         } else {
 643                 count = spufs_wait(ctx->wbox_wq, spu_wbox_write(ctx, wbox_data));
 644         }
 645
 646         if (count)
 647                 goto out;
 648
 649         /* write aѕ much as possible */
 650         for (count = 4, udata++; (count + 4) <= len; count += 4, udata++) {
 651                 int ret;
 652                 ret = __get_user(wbox_data, udata);
 653                 if (ret)
 654                         break;
 655
 656                 ret = spu_wbox_write(ctx, wbox_data);
 657                 if (ret == 0)
 658                         break;
 659         }
 660
 661 out:
 662         spu_release(ctx);
 663         return count;
 664 }
 665
 666 static unsigned int spufs_wbox_poll(struct file *file, poll_table *wait)
 667 {
 668         struct spu_context *ctx = file->private_data;
 669         unsigned int mask;
 670
 671         poll_wait(file, &ctx->wbox_wq, wait);
 672
 673         spu_acquire(ctx);
 674         mask = ctx->ops->mbox_stat_poll(ctx, POLLOUT | POLLWRNORM);
 675         spu_release(ctx);
 676
 677         return mask;
 678 }
 679
 680 static struct file_operations spufs_wbox_fops = {
 681         .open   = spufs_pipe_open,
 682         .write  = spufs_wbox_write,
 683         .poll   = spufs_wbox_poll,
 684         .fasync = spufs_wbox_fasync,
 685 };
 686
 687 static ssize_t spufs_wbox_stat_read(struct file *file, char __user *buf,
 688                         size_t len, loff_t *pos)
 689 {
 690         struct spu_context *ctx = file->private_data;
 691         u32 wbox_stat;
 692
 693         if (len < 4)
 694                 return -EINVAL;
 695
 696         spu_acquire(ctx);
 697         wbox_stat = (ctx->ops->mbox_stat_read(ctx) >> 8) & 0xff;
 698         spu_release(ctx);
 699
 700         if (copy_to_user(buf, &wbox_stat, sizeof wbox_stat))
 701                 return -EFAULT;
 702
 703         return 4;
 704 }
 705
 706 static struct file_operations spufs_wbox_stat_fops = {
 707         .open   = spufs_pipe_open,
 708         .read   = spufs_wbox_stat_read,
 709 };
 710
 711 static int spufs_signal1_open(struct inode *inode, struct file *file)
 712 {
 713         struct spufs_inode_info *i = SPUFS_I(inode);
 714         struct spu_context *ctx = i->i_ctx;
 715         file->private_data = ctx;
 716         file->f_mapping = inode->i_mapping;
 717         ctx->signal1 = inode->i_mapping;
 718         return nonseekable_open(inode, file);
 719 }
 720
 721 static ssize_t spufs_signal1_read(struct file *file, char __user *buf,
 722                         size_t len, loff_t *pos)
 723 {
 724         struct spu_context *ctx = file->private_data;
 725         u32 data;
 726
 727         if (len < 4)
 728                 return -EINVAL;
 729
 730         spu_acquire(ctx);
 731         data = ctx->ops->signal1_read(ctx);
 732         spu_release(ctx);
 733
 734         if (copy_to_user(buf, &data, 4))
 735                 return -EFAULT;
 736
 737         return 4;
 738 }
 739
 740 static ssize_t spufs_signal1_write(struct file *file, const char __user *buf,
 741                         size_t len, loff_t *pos)
 742 {
 743         struct spu_context *ctx;
 744         u32 data;
 745
 746         ctx = file->private_data;
 747
 748         if (len < 4)
 749                 return -EINVAL;
 750
 751         if (copy_from_user(&data, buf, 4))
 752                 return -EFAULT;
 753
 754         spu_acquire(ctx);
 755         ctx->ops->signal1_write(ctx, data);
 756         spu_release(ctx);
 757
 758         return 4;
 759 }
 760
 761 static struct page *spufs_signal1_mmap_nopage(struct vm_area_struct *vma,
 762                                               unsigned long address, int *type)
 763 {
 764 #if PAGE_SIZE == 0x1000
 765         return spufs_ps_nopage(vma, address, type, 0x14000, 0x1000);
 766 #elif PAGE_SIZE == 0x10000
 767         /* For 64k pages, both signal1 and signal2 can be used to mmap the whole
 768          * signal 1 and 2 area
 769          */
 770         return spufs_ps_nopage(vma, address, type, 0x10000, 0x10000);
 771 #else
 772 #error unsupported page size
 773 #endif
 774 }
 775
 776 static struct vm_operations_struct spufs_signal1_mmap_vmops = {
 777         .nopage = spufs_signal1_mmap_nopage,
 778 };
 779
 780 static int spufs_signal1_mmap(struct file *file, struct vm_area_struct *vma)
 781 {
 782         if (!(vma->vm_flags & VM_SHARED))
 783                 return -EINVAL;
 784
 785         vma->vm_flags |= VM_RESERVED;
 786         vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot)
 787                                      | _PAGE_NO_CACHE | _PAGE_GUARDED);
 788
 789         vma->vm_ops = &spufs_signal1_mmap_vmops;
 790         return 0;
 791 }
 792
 793 static struct file_operations spufs_signal1_fops = {
 794         .open = spufs_signal1_open,
 795         .read = spufs_signal1_read,
 796         .write = spufs_signal1_write,
 797         .mmap = spufs_signal1_mmap,
 798 };
 799
 800 static int spufs_signal2_open(struct inode *inode, struct file *file)
 801 {
 802         struct spufs_inode_info *i = SPUFS_I(inode);
 803         struct spu_context *ctx = i->i_ctx;
 804         file->private_data = ctx;
 805         file->f_mapping = inode->i_mapping;
 806         ctx->signal2 = inode->i_mapping;
 807         return nonseekable_open(inode, file);
 808 }
 809
 810 static ssize_t spufs_signal2_read(struct file *file, char __user *buf,
 811                         size_t len, loff_t *pos)
 812 {
 813         struct spu_context *ctx;
 814         u32 data;
 815
 816         ctx = file->private_data;
 817
 818         if (len < 4)
 819                 return -EINVAL;
 820
 821         spu_acquire(ctx);
 822         data = ctx->ops->signal2_read(ctx);
 823         spu_release(ctx);
 824
 825         if (copy_to_user(buf, &data, 4))
 826                 return -EFAULT;
 827
 828         return 4;
 829 }
 830
 831 static ssize_t spufs_signal2_write(struct file *file, const char __user *buf,
 832                         size_t len, loff_t *pos)
 833 {
 834         struct spu_context *ctx;
 835         u32 data;
 836
 837         ctx = file->private_data;
 838
 839         if (len < 4)
 840                 return -EINVAL;
 841
 842         if (copy_from_user(&data, buf, 4))
 843                 return -EFAULT;
 844
 845         spu_acquire(ctx);
 846         ctx->ops->signal2_write(ctx, data);
 847         spu_release(ctx);
 848
 849         return 4;
 850 }
 851
 852 #if SPUFS_MMAP_4K
 853 static struct page *spufs_signal2_mmap_nopage(struct vm_area_struct *vma,
 854                                               unsigned long address, int *type)
 855 {
 856 #if PAGE_SIZE == 0x1000
 857         return spufs_ps_nopage(vma, address, type, 0x1c000, 0x1000);
 858 #elif PAGE_SIZE == 0x10000
 859         /* For 64k pages, both signal1 and signal2 can be used to mmap the whole
 860          * signal 1 and 2 area
 861          */
 862         return spufs_ps_nopage(vma, address, type, 0x10000, 0x10000);
 863 #else
 864 #error unsupported page size
 865 #endif
 866 }
 867
 868 static struct vm_operations_struct spufs_signal2_mmap_vmops = {
 869         .nopage = spufs_signal2_mmap_nopage,
 870 };
 871
 872 static int spufs_signal2_mmap(struct file *file, struct vm_area_struct *vma)
 873 {
 874         if (!(vma->vm_flags & VM_SHARED))
 875                 return -EINVAL;
 876
 877         /* FIXME: */
 878         vma->vm_flags |= VM_RESERVED;
 879         vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot)
 880                                      | _PAGE_NO_CACHE | _PAGE_GUARDED);
 881
 882         vma->vm_ops = &spufs_signal2_mmap_vmops;
 883         return 0;
 884 }
 885 #else /* SPUFS_MMAP_4K */
 886 #define spufs_signal2_mmap NULL
 887 #endif /* !SPUFS_MMAP_4K */
 888
 889 static struct file_operations spufs_signal2_fops = {
 890         .open = spufs_signal2_open,
 891         .read = spufs_signal2_read,
 892         .write = spufs_signal2_write,
 893         .mmap = spufs_signal2_mmap,
 894 };
 895
 896 static void spufs_signal1_type_set(void *data, u64 val)
 897 {
 898         struct spu_context *ctx = data;
 899
 900         spu_acquire(ctx);
 901         ctx->ops->signal1_type_set(ctx, val);
 902         spu_release(ctx);
 903 }
 904
 905 static u64 spufs_signal1_type_get(void *data)
 906 {
 907         struct spu_context *ctx = data;
 908         u64 ret;
 909
 910         spu_acquire(ctx);
 911         ret = ctx->ops->signal1_type_get(ctx);
 912         spu_release(ctx);
 913
 914         return ret;
 915 }
 916 DEFINE_SIMPLE_ATTRIBUTE(spufs_signal1_type, spufs_signal1_type_get,
 917                                         spufs_signal1_type_set, "%llu");
 918
 919 static void spufs_signal2_type_set(void *data, u64 val)
 920 {
 921         struct spu_context *ctx = data;
 922
 923         spu_acquire(ctx);
 924         ctx->ops->signal2_type_set(ctx, val);
 925         spu_release(ctx);
 926 }
 927
 928 static u64 spufs_signal2_type_get(void *data)
 929 {
 930         struct spu_context *ctx = data;
 931         u64 ret;
 932
 933         spu_acquire(ctx);
 934         ret = ctx->ops->signal2_type_get(ctx);
 935         spu_release(ctx);
 936
 937         return ret;
 938 }
 939 DEFINE_SIMPLE_ATTRIBUTE(spufs_signal2_type, spufs_signal2_type_get,
 940                                         spufs_signal2_type_set, "%llu");
 941
 942 #if SPUFS_MMAP_4K
 943 static struct page *spufs_mss_mmap_nopage(struct vm_area_struct *vma,
 944                                            unsigned long address, int *type)
 945 {
 946         return spufs_ps_nopage(vma, address, type, 0x0000, 0x1000);
 947 }
 948
 949 static struct vm_operations_struct spufs_mss_mmap_vmops = {
 950         .nopage = spufs_mss_mmap_nopage,
 951 };
 952
 953 /*
 954  * mmap support for problem state MFC DMA area [0x0000 - 0x0fff].
 955  */
 956 static int spufs_mss_mmap(struct file *file, struct vm_area_struct *vma)
 957 {
 958         if (!(vma->vm_flags & VM_SHARED))
 959                 return -EINVAL;
 960
 961         vma->vm_flags |= VM_RESERVED;
 962         vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot)
 963                                      | _PAGE_NO_CACHE | _PAGE_GUARDED);
 964
 965         vma->vm_ops = &spufs_mss_mmap_vmops;
 966         return 0;
 967 }
 968 #else /* SPUFS_MMAP_4K */
 969 #define spufs_mss_mmap NULL
 970 #endif /* !SPUFS_MMAP_4K */
 971
 972 static int spufs_mss_open(struct inode *inode, struct file *file)
 973 {
 974         struct spufs_inode_info *i = SPUFS_I(inode);
 975
 976         file->private_data = i->i_ctx;
 977         return nonseekable_open(inode, file);
 978 }
 979
 980 static struct file_operations spufs_mss_fops = {
 981         .open    = spufs_mss_open,
 982         .mmap    = spufs_mss_mmap,
 983 };
 984
 985 static struct page *spufs_psmap_mmap_nopage(struct vm_area_struct *vma,
 986                                            unsigned long address, int *type)
 987 {
 988         return spufs_ps_nopage(vma, address, type, 0x0000, 0x20000);
 989 }
 990
 991 static struct vm_operations_struct spufs_psmap_mmap_vmops = {
 992         .nopage = spufs_psmap_mmap_nopage,
 993 };
 994
 995 /*
 996  * mmap support for full problem state area [0x00000 - 0x1ffff].
 997  */
 998 static int spufs_psmap_mmap(struct file *file, struct vm_area_struct *vma)
 999 {
1000         if (!(vma->vm_flags & VM_SHARED))
1001                 return -EINVAL;
1002
1003         vma->vm_flags |= VM_RESERVED;
1004         vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot)
1005                                      | _PAGE_NO_CACHE | _PAGE_GUARDED);
1006
1007         vma->vm_ops = &spufs_psmap_mmap_vmops;
1008         return 0;
1009 }
1010
1011 static int spufs_psmap_open(struct inode *inode, struct file *file)
1012 {
1013         struct spufs_inode_info *i = SPUFS_I(inode);
1014
1015         file->private_data = i->i_ctx;
1016         return nonseekable_open(inode, file);
1017 }
1018
1019 static struct file_operations spufs_psmap_fops = {
1020         .open    = spufs_psmap_open,
1021         .mmap    = spufs_psmap_mmap,
1022 };
1023
1024
1025 #if SPUFS_MMAP_4K
1026 static struct page *spufs_mfc_mmap_nopage(struct vm_area_struct *vma,
1027                                            unsigned long address, int *type)
1028 {
1029         return spufs_ps_nopage(vma, address, type, 0x3000, 0x1000);
1030 }
1031
1032 static struct vm_operations_struct spufs_mfc_mmap_vmops = {
1033         .nopage = spufs_mfc_mmap_nopage,
1034 };
1035
1036 /*
1037  * mmap support for problem state MFC DMA area [0x0000 - 0x0fff].
1038  */
1039 static int spufs_mfc_mmap(struct file *file, struct vm_area_struct *vma)
1040 {
1041         if (!(vma->vm_flags & VM_SHARED))
1042                 return -EINVAL;
1043
1044         vma->vm_flags |= VM_RESERVED;
1045         vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot)
1046                                      | _PAGE_NO_CACHE | _PAGE_GUARDED);
1047
1048         vma->vm_ops = &spufs_mfc_mmap_vmops;
1049         return 0;
1050 }
1051 #else /* SPUFS_MMAP_4K */
1052 #define spufs_mfc_mmap NULL
1053 #endif /* !SPUFS_MMAP_4K */
1054
1055 static int spufs_mfc_open(struct inode *inode, struct file *file)
1056 {
1057         struct spufs_inode_info *i = SPUFS_I(inode);
1058         struct spu_context *ctx = i->i_ctx;
1059
1060         /* we don't want to deal with DMA into other processes */
1061         if (ctx->owner != current->mm)
1062                 return -EINVAL;
1063
1064         if (atomic_read(&inode->i_count) != 1)
1065                 return -EBUSY;
1066
1067         file->private_data = ctx;
1068         return nonseekable_open(inode, file);
1069 }
1070
1071 /* interrupt-level mfc callback function. */
1072 void spufs_mfc_callback(struct spu *spu)
1073 {
1074         struct spu_context *ctx = spu->ctx;
1075
1076         wake_up_all(&ctx->mfc_wq);
1077
1078         pr_debug("%s %s\n", __FUNCTION__, spu->name);
1079         if (ctx->mfc_fasync) {
1080                 u32 free_elements, tagstatus;
1081                 unsigned int mask;
1082
1083                 /* no need for spu_acquire in interrupt context */
1084                 free_elements = ctx->ops->get_mfc_free_elements(ctx);
1085                 tagstatus = ctx->ops->read_mfc_tagstatus(ctx);
1086
1087                 mask = 0;
1088                 if (free_elements & 0xffff)
1089                         mask |= POLLOUT;
1090                 if (tagstatus & ctx->tagwait)
1091                         mask |= POLLIN;
1092
1093                 kill_fasync(&ctx->mfc_fasync, SIGIO, mask);
1094         }
1095 }
1096
1097 static int spufs_read_mfc_tagstatus(struct spu_context *ctx, u32 *status)
1098 {
1099         /* See if there is one tag group is complete */
1100         /* FIXME we need locking around tagwait */
1101         *status = ctx->ops->read_mfc_tagstatus(ctx) & ctx->tagwait;
1102         ctx->tagwait &= ~*status;
1103         if (*status)
1104                 return 1;
1105
1106         /* enable interrupt waiting for any tag group,
1107            may silently fail if interrupts are already enabled */
1108         ctx->ops->set_mfc_query(ctx, ctx->tagwait, 1);
1109         return 0;
1110 }
1111
1112 static ssize_t spufs_mfc_read(struct file *file, char __user *buffer,
1113                         size_t size, loff_t *pos)
1114 {
1115         struct spu_context *ctx = file->private_data;
1116         int ret = -EINVAL;
1117         u32 status;
1118
1119         if (size != 4)
1120                 goto out;
1121
1122         spu_acquire(ctx);
1123         if (file->f_flags & O_NONBLOCK) {
1124                 status = ctx->ops->read_mfc_tagstatus(ctx);
1125                 if (!(status & ctx->tagwait))
1126                         ret = -EAGAIN;
1127                 else
1128                         ctx->tagwait &= ~status;
1129         } else {
1130                 ret = spufs_wait(ctx->mfc_wq,
1131                            spufs_read_mfc_tagstatus(ctx, &status));
1132         }
1133         spu_release(ctx);
1134
1135         if (ret)
1136                 goto out;
1137
1138         ret = 4;
1139         if (copy_to_user(buffer, &status, 4))
1140                 ret = -EFAULT;
1141
1142 out:
1143         return ret;
1144 }
1145
1146 static int spufs_check_valid_dma(struct mfc_dma_command *cmd)
1147 {
1148         pr_debug("queueing DMA %x %lx %x %x %x\n", cmd->lsa,
1149                  cmd->ea, cmd->size, cmd->tag, cmd->cmd);
1150
1151         switch (cmd->cmd) {
1152         case MFC_PUT_CMD:
1153         case MFC_PUTF_CMD:
1154         case MFC_PUTB_CMD:
1155         case MFC_GET_CMD:
1156         case MFC_GETF_CMD:
1157         case MFC_GETB_CMD:
1158                 break;
1159         default:
1160                 pr_debug("invalid DMA opcode %x\n", cmd->cmd);
1161                 return -EIO;
1162         }
1163
1164         if ((cmd->lsa & 0xf) != (cmd->ea &0xf)) {
1165                 pr_debug("invalid DMA alignment, ea %lx lsa %x\n",
1166                                 cmd->ea, cmd->lsa);
1167                 return -EIO;
1168         }
1169
1170         switch (cmd->size & 0xf) {
1171         case 1:
1172                 break;
1173         case 2:
1174                 if (cmd->lsa & 1)
1175                         goto error;
1176                 break;
1177         case 4:
1178                 if (cmd->lsa & 3)
1179                         goto error;
1180                 break;
1181         case 8:
1182                 if (cmd->lsa & 7)
1183                         goto error;
1184                 break;
1185         case 0:
1186                 if (cmd->lsa & 15)
1187                         goto error;
1188                 break;
1189         error:
1190         default:
1191                 pr_debug("invalid DMA alignment %x for size %x\n",
1192                         cmd->lsa & 0xf, cmd->size);
1193                 return -EIO;
1194         }
1195
1196         if (cmd->size > 16 * 1024) {
1197                 pr_debug("invalid DMA size %x\n", cmd->size);
1198                 return -EIO;
1199         }
1200
1201         if (cmd->tag & 0xfff0) {
1202                 /* we reserve the higher tag numbers for kernel use */
1203                 pr_debug("invalid DMA tag\n");
1204                 return -EIO;
1205         }
1206
1207         if (cmd->class) {
1208                 /* not supported in this version */
1209                 pr_debug("invalid DMA class\n");
1210                 return -EIO;
1211         }
1212
1213         return 0;
1214 }
1215
1216 static int spu_send_mfc_command(struct spu_context *ctx,
1217                                 struct mfc_dma_command cmd,
1218                                 int *error)
1219 {
1220         *error = ctx->ops->send_mfc_command(ctx, &cmd);
1221         if (*error == -EAGAIN) {
1222                 /* wait for any tag group to complete
1223                    so we have space for the new command */
1224                 ctx->ops->set_mfc_query(ctx, ctx->tagwait, 1);
1225                 /* try again, because the queue might be
1226                    empty again */
1227                 *error = ctx->ops->send_mfc_command(ctx, &cmd);
1228                 if (*error == -EAGAIN)
1229                         return 0;
1230         }
1231         return 1;
1232 }
1233
1234 static ssize_t spufs_mfc_write(struct file *file, const char __user *buffer,
1235                         size_t size, loff_t *pos)
1236 {
1237         struct spu_context *ctx = file->private_data;
1238         struct mfc_dma_command cmd;
1239         int ret = -EINVAL;
1240
1241         if (size != sizeof cmd)
1242                 goto out;
1243
1244         ret = -EFAULT;
1245         if (copy_from_user(&cmd, buffer, sizeof cmd))
1246                 goto out;
1247
1248         ret = spufs_check_valid_dma(&cmd);
1249         if (ret)
1250                 goto out;
1251
1252         spu_acquire_runnable(ctx);
1253         if (file->f_flags & O_NONBLOCK) {
1254                 ret = ctx->ops->send_mfc_command(ctx, &cmd);
1255         } else {
1256                 int status;
1257                 ret = spufs_wait(ctx->mfc_wq,
1258                                  spu_send_mfc_command(ctx, cmd, &status));
1259                 if (status)
1260                         ret = status;
1261         }
1262         spu_release(ctx);
1263
1264         if (ret)
1265                 goto out;
1266
1267         ctx->tagwait |= 1 << cmd.tag;
1268
1269 out:
1270         return ret;
1271 }
1272
1273 static unsigned int spufs_mfc_poll(struct file *file,poll_table *wait)
1274 {
1275         struct spu_context *ctx = file->private_data;
1276         u32 free_elements, tagstatus;
1277         unsigned int mask;
1278
1279         spu_acquire(ctx);
1280         ctx->ops->set_mfc_query(ctx, ctx->tagwait, 2);
1281         free_elements = ctx->ops->get_mfc_free_elements(ctx);
1282         tagstatus = ctx->ops->read_mfc_tagstatus(ctx);
1283         spu_release(ctx);
1284
1285         poll_wait(file, &ctx->mfc_wq, wait);
1286
1287         mask = 0;
1288         if (free_elements & 0xffff)
1289                 mask |= POLLOUT | POLLWRNORM;
1290         if (tagstatus & ctx->tagwait)
1291                 mask |= POLLIN | POLLRDNORM;
1292
1293         pr_debug("%s: free %d tagstatus %d tagwait %d\n", __FUNCTION__,
1294                 free_elements, tagstatus, ctx->tagwait);
1295
1296         return mask;
1297 }
1298
1299 static int spufs_mfc_flush(struct file *file, fl_owner_t id)
1300 {
1301         struct spu_context *ctx = file->private_data;
1302         int ret;
1303
1304         spu_acquire(ctx);
1305 #if 0
1306 /* this currently hangs */
1307         ret = spufs_wait(ctx->mfc_wq,
1308                          ctx->ops->set_mfc_query(ctx, ctx->tagwait, 2));
1309         if (ret)
1310                 goto out;
1311         ret = spufs_wait(ctx->mfc_wq,
1312                          ctx->ops->read_mfc_tagstatus(ctx) == ctx->tagwait);
1313 out:
1314 #else
1315         ret = 0;
1316 #endif
1317         spu_release(ctx);
1318
1319         return ret;
1320 }
1321
1322 static int spufs_mfc_fsync(struct file *file, struct dentry *dentry,
1323                            int datasync)
1324 {
1325         return spufs_mfc_flush(file, NULL);
1326 }
1327
1328 static int spufs_mfc_fasync(int fd, struct file *file, int on)
1329 {
1330         struct spu_context *ctx = file->private_data;
1331
1332         return fasync_helper(fd, file, on, &ctx->mfc_fasync);
1333 }
1334
1335 static struct file_operations spufs_mfc_fops = {
1336         .open    = spufs_mfc_open,
1337         .read    = spufs_mfc_read,
1338         .write   = spufs_mfc_write,
1339         .poll    = spufs_mfc_poll,
1340         .flush   = spufs_mfc_flush,
1341         .fsync   = spufs_mfc_fsync,
1342         .fasync  = spufs_mfc_fasync,
1343         .mmap    = spufs_mfc_mmap,
1344 };
1345
1346 static void spufs_npc_set(void *data, u64 val)
1347 {
1348         struct spu_context *ctx = data;
1349         spu_acquire(ctx);
1350         ctx->ops->npc_write(ctx, val);
1351         spu_release(ctx);
1352 }
1353
1354 static u64 spufs_npc_get(void *data)
1355 {
1356         struct spu_context *ctx = data;
1357         u64 ret;
1358         spu_acquire(ctx);
1359         ret = ctx->ops->npc_read(ctx);
1360         spu_release(ctx);
1361         return ret;
1362 }
1363 DEFINE_SIMPLE_ATTRIBUTE(spufs_npc_ops, spufs_npc_get, spufs_npc_set, "%llx\n")
1364
1365 static void spufs_decr_set(void *data, u64 val)
1366 {
1367         struct spu_context *ctx = data;
1368         struct spu_lscsa *lscsa = ctx->csa.lscsa;
1369         spu_acquire_saved(ctx);
1370         lscsa->decr.slot[0] = (u32) val;
1371         spu_release(ctx);
1372 }
1373
1374 static u64 spufs_decr_get(void *data)
1375 {
1376         struct spu_context *ctx = data;
1377         struct spu_lscsa *lscsa = ctx->csa.lscsa;
1378         u64 ret;
1379         spu_acquire_saved(ctx);
1380         ret = lscsa->decr.slot[0];
1381         spu_release(ctx);
1382         return ret;
1383 }
1384 DEFINE_SIMPLE_ATTRIBUTE(spufs_decr_ops, spufs_decr_get, spufs_decr_set,
1385                         "%llx\n")
1386
1387 static void spufs_decr_status_set(void *data, u64 val)
1388 {
1389         struct spu_context *ctx = data;
1390         struct spu_lscsa *lscsa = ctx->csa.lscsa;
1391         spu_acquire_saved(ctx);
1392         lscsa->decr_status.slot[0] = (u32) val;
1393         spu_release(ctx);
1394 }
1395
1396 static u64 spufs_decr_status_get(void *data)
1397 {
1398         struct spu_context *ctx = data;
1399         struct spu_lscsa *lscsa = ctx->csa.lscsa;
1400         u64 ret;
1401         spu_acquire_saved(ctx);
1402         ret = lscsa->decr_status.slot[0];
1403         spu_release(ctx);
1404         return ret;
1405 }
1406 DEFINE_SIMPLE_ATTRIBUTE(spufs_decr_status_ops, spufs_decr_status_get,
1407                         spufs_decr_status_set, "%llx\n")
1408
1409 static void spufs_spu_tag_mask_set(void *data, u64 val)
1410 {
1411         struct spu_context *ctx = data;
1412         struct spu_lscsa *lscsa = ctx->csa.lscsa;
1413         spu_acquire_saved(ctx);
1414         lscsa->tag_mask.slot[0] = (u32) val;
1415         spu_release(ctx);
1416 }
1417
1418 static u64 spufs_spu_tag_mask_get(void *data)
1419 {
1420         struct spu_context *ctx = data;
1421         struct spu_lscsa *lscsa = ctx->csa.lscsa;
1422         u64 ret;
1423         spu_acquire_saved(ctx);
1424         ret = lscsa->tag_mask.slot[0];
1425         spu_release(ctx);
1426         return ret;
1427 }
1428 DEFINE_SIMPLE_ATTRIBUTE(spufs_spu_tag_mask_ops, spufs_spu_tag_mask_get,
1429                         spufs_spu_tag_mask_set, "%llx\n")
1430
1431 static void spufs_event_mask_set(void *data, u64 val)
1432 {
1433         struct spu_context *ctx = data;
1434         struct spu_lscsa *lscsa = ctx->csa.lscsa;
1435         spu_acquire_saved(ctx);
1436         lscsa->event_mask.slot[0] = (u32) val;
1437         spu_release(ctx);
1438 }
1439
1440 static u64 spufs_event_mask_get(void *data)
1441 {
1442         struct spu_context *ctx = data;
1443         struct spu_lscsa *lscsa = ctx->csa.lscsa;
1444         u64 ret;
1445         spu_acquire_saved(ctx);
1446         ret = lscsa->event_mask.slot[0];
1447         spu_release(ctx);
1448         return ret;
1449 }
1450 DEFINE_SIMPLE_ATTRIBUTE(spufs_event_mask_ops, spufs_event_mask_get,
1451                         spufs_event_mask_set, "%llx\n")
1452
1453 static void spufs_srr0_set(void *data, u64 val)
1454 {
1455         struct spu_context *ctx = data;
1456         struct spu_lscsa *lscsa = ctx->csa.lscsa;
1457         spu_acquire_saved(ctx);
1458         lscsa->srr0.slot[0] = (u32) val;
1459         spu_release(ctx);
1460 }
1461
1462 static u64 spufs_srr0_get(void *data)
1463 {
1464         struct spu_context *ctx = data;
1465         struct spu_lscsa *lscsa = ctx->csa.lscsa;
1466         u64 ret;
1467         spu_acquire_saved(ctx);
1468         ret = lscsa->srr0.slot[0];
1469         spu_release(ctx);
1470         return ret;
1471 }
1472 DEFINE_SIMPLE_ATTRIBUTE(spufs_srr0_ops, spufs_srr0_get, spufs_srr0_set,
1473                         "%llx\n")
1474
1475 static u64 spufs_id_get(void *data)
1476 {
1477         struct spu_context *ctx = data;
1478         u64 num;
1479
1480         spu_acquire(ctx);
1481         if (ctx->state == SPU_STATE_RUNNABLE)
1482                 num = ctx->spu->number;
1483         else
1484                 num = (unsigned int)-1;
1485         spu_release(ctx);
1486
1487         return num;
1488 }
1489 DEFINE_SIMPLE_ATTRIBUTE(spufs_id_ops, spufs_id_get, NULL, "0x%llx\n")
1490
1491 static u64 spufs_object_id_get(void *data)
1492 {
1493         struct spu_context *ctx = data;
1494         return ctx->object_id;
1495 }
1496
1497 static void spufs_object_id_set(void *data, u64 id)
1498 {
1499         struct spu_context *ctx = data;
1500         ctx->object_id = id;
1501 }
1502
1503 DEFINE_SIMPLE_ATTRIBUTE(spufs_object_id_ops, spufs_object_id_get,
1504                 spufs_object_id_set, "0x%llx\n");
1505
1506 struct tree_descr spufs_dir_contents[] = {
1507         { "mem",  &spufs_mem_fops,  0666, },
1508         { "regs", &spufs_regs_fops,  0666, },
1509         { "mbox", &spufs_mbox_fops, 0444, },
1510         { "ibox", &spufs_ibox_fops, 0444, },
1511         { "wbox", &spufs_wbox_fops, 0222, },
1512         { "mbox_stat", &spufs_mbox_stat_fops, 0444, },
1513         { "ibox_stat", &spufs_ibox_stat_fops, 0444, },
1514         { "wbox_stat", &spufs_wbox_stat_fops, 0444, },
1515         { "signal1", &spufs_signal1_fops, 0666, },
1516         { "signal2", &spufs_signal2_fops, 0666, },
1517         { "signal1_type", &spufs_signal1_type, 0666, },
1518         { "signal2_type", &spufs_signal2_type, 0666, },
1519         { "mss", &spufs_mss_fops, 0666, },
1520         { "mfc", &spufs_mfc_fops, 0666, },
1521         { "cntl", &spufs_cntl_fops,  0666, },
1522         { "npc", &spufs_npc_ops, 0666, },
1523         { "fpcr", &spufs_fpcr_fops, 0666, },
1524         { "decr", &spufs_decr_ops, 0666, },
1525         { "decr_status", &spufs_decr_status_ops, 0666, },
1526         { "spu_tag_mask", &spufs_spu_tag_mask_ops, 0666, },
1527         { "event_mask", &spufs_event_mask_ops, 0666, },
1528         { "srr0", &spufs_srr0_ops, 0666, },
1529         { "psmap", &spufs_psmap_fops, 0666, },
1530         { "phys-id", &spufs_id_ops, 0666, },
1531         { "object-id", &spufs_object_id_ops, 0666, },
1532         {},
1533 };