git.oblomov.eu Git - linux-2.6/blob - 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/spu_info.h>
  36 #include <asm/uaccess.h>
  37
  38 #include "spufs.h"
  39
  40 #define SPUFS_MMAP_4K (PAGE_SIZE == 0x1000)
  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         ctx->local_store = inode->i_mapping;
  49         smp_wmb();
  50         return 0;
  51 }
  52
  53 static ssize_t
  54 __spufs_mem_read(struct spu_context *ctx, char __user *buffer,
  55                         size_t size, loff_t *pos)
  56 {
  57         char *local_store = ctx->ops->get_ls(ctx);
  58         return simple_read_from_buffer(buffer, size, pos, local_store,
  59                                         LS_SIZE);
  60 }
  61
  62 static ssize_t
  63 spufs_mem_read(struct file *file, char __user *buffer,
  64                                 size_t size, loff_t *pos)
  65 {
  66         struct spu_context *ctx = file->private_data;
  67         ssize_t ret;
  68
  69         spu_acquire(ctx);
  70         ret = __spufs_mem_read(ctx, buffer, size, pos);
  71         spu_release(ctx);
  72         return ret;
  73 }
  74
  75 static ssize_t
  76 spufs_mem_write(struct file *file, const char __user *buffer,
  77                                         size_t size, loff_t *ppos)
  78 {
  79         struct spu_context *ctx = file->private_data;
  80         char *local_store;
  81         loff_t pos = *ppos;
  82         int ret;
  83
  84         if (pos < 0)
  85                 return -EINVAL;
  86         if (pos > LS_SIZE)
  87                 return -EFBIG;
  88         if (size > LS_SIZE - pos)
  89                 size = LS_SIZE - pos;
  90
  91         spu_acquire(ctx);
  92         local_store = ctx->ops->get_ls(ctx);
  93         ret = copy_from_user(local_store + pos, buffer, size);
  94         spu_release(ctx);
  95
  96         if (ret)
  97                 return -EFAULT;
  98         *ppos = pos + size;
  99         return size;
 100 }
 101
 102 static unsigned long spufs_mem_mmap_nopfn(struct vm_area_struct *vma,
 103                                           unsigned long address)
 104 {
 105         struct spu_context *ctx = vma->vm_file->private_data;
 106         unsigned long pfn, offset = address - vma->vm_start;
 107
 108         offset += vma->vm_pgoff << PAGE_SHIFT;
 109
 110         if (offset >= LS_SIZE)
 111                 return NOPFN_SIGBUS;
 112
 113         spu_acquire(ctx);
 114
 115         if (ctx->state == SPU_STATE_SAVED) {
 116                 vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot)
 117                                                         & ~_PAGE_NO_CACHE);
 118                 pfn = vmalloc_to_pfn(ctx->csa.lscsa->ls + offset);
 119         } else {
 120                 vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot)
 121                                              | _PAGE_NO_CACHE);
 122                 pfn = (ctx->spu->local_store_phys + offset) >> PAGE_SHIFT;
 123         }
 124         vm_insert_pfn(vma, address, pfn);
 125
 126         spu_release(ctx);
 127
 128         return NOPFN_REFAULT;
 129 }
 130
 131
 132 static struct vm_operations_struct spufs_mem_mmap_vmops = {
 133         .nopfn = spufs_mem_mmap_nopfn,
 134 };
 135
 136 static int
 137 spufs_mem_mmap(struct file *file, struct vm_area_struct *vma)
 138 {
 139         if (!(vma->vm_flags & VM_SHARED))
 140                 return -EINVAL;
 141
 142         vma->vm_flags |= VM_IO | VM_PFNMAP;
 143         vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot)
 144                                      | _PAGE_NO_CACHE);
 145
 146         vma->vm_ops = &spufs_mem_mmap_vmops;
 147         return 0;
 148 }
 149
 150 static const struct file_operations spufs_mem_fops = {
 151         .open    = spufs_mem_open,
 152         .read    = spufs_mem_read,
 153         .write   = spufs_mem_write,
 154         .llseek  = generic_file_llseek,
 155         .mmap    = spufs_mem_mmap,
 156 };
 157
 158 static unsigned long spufs_ps_nopfn(struct vm_area_struct *vma,
 159                                     unsigned long address,
 160                                     unsigned long ps_offs,
 161                                     unsigned long ps_size)
 162 {
 163         struct spu_context *ctx = vma->vm_file->private_data;
 164         unsigned long area, offset = address - vma->vm_start;
 165         int ret;
 166
 167         offset += vma->vm_pgoff << PAGE_SHIFT;
 168         if (offset >= ps_size)
 169                 return NOPFN_SIGBUS;
 170
 171         /* error here usually means a signal.. we might want to test
 172          * the error code more precisely though
 173          */
 174         ret = spu_acquire_runnable(ctx, 0);
 175         if (ret)
 176                 return NOPFN_REFAULT;
 177
 178         area = ctx->spu->problem_phys + ps_offs;
 179         vm_insert_pfn(vma, address, (area + offset) >> PAGE_SHIFT);
 180         spu_release(ctx);
 181
 182         return NOPFN_REFAULT;
 183 }
 184
 185 #if SPUFS_MMAP_4K
 186 static unsigned long spufs_cntl_mmap_nopfn(struct vm_area_struct *vma,
 187                                            unsigned long address)
 188 {
 189         return spufs_ps_nopfn(vma, address, 0x4000, 0x1000);
 190 }
 191
 192 static struct vm_operations_struct spufs_cntl_mmap_vmops = {
 193         .nopfn = spufs_cntl_mmap_nopfn,
 194 };
 195
 196 /*
 197  * mmap support for problem state control area [0x4000 - 0x4fff].
 198  */
 199 static int spufs_cntl_mmap(struct file *file, struct vm_area_struct *vma)
 200 {
 201         if (!(vma->vm_flags & VM_SHARED))
 202                 return -EINVAL;
 203
 204         vma->vm_flags |= VM_IO | VM_PFNMAP;
 205         vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot)
 206                                      | _PAGE_NO_CACHE | _PAGE_GUARDED);
 207
 208         vma->vm_ops = &spufs_cntl_mmap_vmops;
 209         return 0;
 210 }
 211 #else /* SPUFS_MMAP_4K */
 212 #define spufs_cntl_mmap NULL
 213 #endif /* !SPUFS_MMAP_4K */
 214
 215 static u64 spufs_cntl_get(void *data)
 216 {
 217         struct spu_context *ctx = data;
 218         u64 val;
 219
 220         spu_acquire(ctx);
 221         val = ctx->ops->status_read(ctx);
 222         spu_release(ctx);
 223
 224         return val;
 225 }
 226
 227 static void spufs_cntl_set(void *data, u64 val)
 228 {
 229         struct spu_context *ctx = data;
 230
 231         spu_acquire(ctx);
 232         ctx->ops->runcntl_write(ctx, val);
 233         spu_release(ctx);
 234 }
 235
 236 static int spufs_cntl_open(struct inode *inode, struct file *file)
 237 {
 238         struct spufs_inode_info *i = SPUFS_I(inode);
 239         struct spu_context *ctx = i->i_ctx;
 240
 241         file->private_data = ctx;
 242         ctx->cntl = inode->i_mapping;
 243         smp_wmb();
 244         return simple_attr_open(inode, file, spufs_cntl_get,
 245                                         spufs_cntl_set, "0x%08lx");
 246 }
 247
 248 static const struct file_operations spufs_cntl_fops = {
 249         .open = spufs_cntl_open,
 250         .release = simple_attr_close,
 251         .read = simple_attr_read,
 252         .write = simple_attr_write,
 253         .mmap = spufs_cntl_mmap,
 254 };
 255
 256 static int
 257 spufs_regs_open(struct inode *inode, struct file *file)
 258 {
 259         struct spufs_inode_info *i = SPUFS_I(inode);
 260         file->private_data = i->i_ctx;
 261         return 0;
 262 }
 263
 264 static ssize_t
 265 __spufs_regs_read(struct spu_context *ctx, char __user *buffer,
 266                         size_t size, loff_t *pos)
 267 {
 268         struct spu_lscsa *lscsa = ctx->csa.lscsa;
 269         return simple_read_from_buffer(buffer, size, pos,
 270                                       lscsa->gprs, sizeof lscsa->gprs);
 271 }
 272
 273 static ssize_t
 274 spufs_regs_read(struct file *file, char __user *buffer,
 275                 size_t size, loff_t *pos)
 276 {
 277         int ret;
 278         struct spu_context *ctx = file->private_data;
 279
 280         spu_acquire_saved(ctx);
 281         ret = __spufs_regs_read(ctx, buffer, size, pos);
 282         spu_release(ctx);
 283         return ret;
 284 }
 285
 286 static ssize_t
 287 spufs_regs_write(struct file *file, const char __user *buffer,
 288                  size_t size, loff_t *pos)
 289 {
 290         struct spu_context *ctx = file->private_data;
 291         struct spu_lscsa *lscsa = ctx->csa.lscsa;
 292         int ret;
 293
 294         size = min_t(ssize_t, sizeof lscsa->gprs - *pos, size);
 295         if (size <= 0)
 296                 return -EFBIG;
 297         *pos += size;
 298
 299         spu_acquire_saved(ctx);
 300
 301         ret = copy_from_user(lscsa->gprs + *pos - size,
 302                              buffer, size) ? -EFAULT : size;
 303
 304         spu_release(ctx);
 305         return ret;
 306 }
 307
 308 static const struct file_operations spufs_regs_fops = {
 309         .open    = spufs_regs_open,
 310         .read    = spufs_regs_read,
 311         .write   = spufs_regs_write,
 312         .llseek  = generic_file_llseek,
 313 };
 314
 315 static ssize_t
 316 __spufs_fpcr_read(struct spu_context *ctx, char __user * buffer,
 317                         size_t size, loff_t * pos)
 318 {
 319         struct spu_lscsa *lscsa = ctx->csa.lscsa;
 320         return simple_read_from_buffer(buffer, size, pos,
 321                                       &lscsa->fpcr, sizeof(lscsa->fpcr));
 322 }
 323
 324 static ssize_t
 325 spufs_fpcr_read(struct file *file, char __user * buffer,
 326                 size_t size, loff_t * pos)
 327 {
 328         int ret;
 329         struct spu_context *ctx = file->private_data;
 330
 331         spu_acquire_saved(ctx);
 332         ret = __spufs_fpcr_read(ctx, buffer, size, pos);
 333         spu_release(ctx);
 334         return ret;
 335 }
 336
 337 static ssize_t
 338 spufs_fpcr_write(struct file *file, const char __user * buffer,
 339                  size_t size, loff_t * pos)
 340 {
 341         struct spu_context *ctx = file->private_data;
 342         struct spu_lscsa *lscsa = ctx->csa.lscsa;
 343         int ret;
 344
 345         size = min_t(ssize_t, sizeof(lscsa->fpcr) - *pos, size);
 346         if (size <= 0)
 347                 return -EFBIG;
 348         *pos += size;
 349
 350         spu_acquire_saved(ctx);
 351
 352         ret = copy_from_user((char *)&lscsa->fpcr + *pos - size,
 353                              buffer, size) ? -EFAULT : size;
 354
 355         spu_release(ctx);
 356         return ret;
 357 }
 358
 359 static const struct file_operations spufs_fpcr_fops = {
 360         .open = spufs_regs_open,
 361         .read = spufs_fpcr_read,
 362         .write = spufs_fpcr_write,
 363         .llseek = generic_file_llseek,
 364 };
 365
 366 /* generic open function for all pipe-like files */
 367 static int spufs_pipe_open(struct inode *inode, struct file *file)
 368 {
 369         struct spufs_inode_info *i = SPUFS_I(inode);
 370         file->private_data = i->i_ctx;
 371
 372         return nonseekable_open(inode, file);
 373 }
 374
 375 /*
 376  * Read as many bytes from the mailbox as possible, until
 377  * one of the conditions becomes true:
 378  *
 379  * - no more data available in the mailbox
 380  * - end of the user provided buffer
 381  * - end of the mapped area
 382  */
 383 static ssize_t spufs_mbox_read(struct file *file, char __user *buf,
 384                         size_t len, loff_t *pos)
 385 {
 386         struct spu_context *ctx = file->private_data;
 387         u32 mbox_data, __user *udata;
 388         ssize_t count;
 389
 390         if (len < 4)
 391                 return -EINVAL;
 392
 393         if (!access_ok(VERIFY_WRITE, buf, len))
 394                 return -EFAULT;
 395
 396         udata = (void __user *)buf;
 397
 398         spu_acquire(ctx);
 399         for (count = 0; (count + 4) <= len; count += 4, udata++) {
 400                 int ret;
 401                 ret = ctx->ops->mbox_read(ctx, &mbox_data);
 402                 if (ret == 0)
 403                         break;
 404
 405                 /*
 406                  * at the end of the mapped area, we can fault
 407                  * but still need to return the data we have
 408                  * read successfully so far.
 409                  */
 410                 ret = __put_user(mbox_data, udata);
 411                 if (ret) {
 412                         if (!count)
 413                                 count = -EFAULT;
 414                         break;
 415                 }
 416         }
 417         spu_release(ctx);
 418
 419         if (!count)
 420                 count = -EAGAIN;
 421
 422         return count;
 423 }
 424
 425 static const struct file_operations spufs_mbox_fops = {
 426         .open   = spufs_pipe_open,
 427         .read   = spufs_mbox_read,
 428 };
 429
 430 static ssize_t spufs_mbox_stat_read(struct file *file, char __user *buf,
 431                         size_t len, loff_t *pos)
 432 {
 433         struct spu_context *ctx = file->private_data;
 434         u32 mbox_stat;
 435
 436         if (len < 4)
 437                 return -EINVAL;
 438
 439         spu_acquire(ctx);
 440
 441         mbox_stat = ctx->ops->mbox_stat_read(ctx) & 0xff;
 442
 443         spu_release(ctx);
 444
 445         if (copy_to_user(buf, &mbox_stat, sizeof mbox_stat))
 446                 return -EFAULT;
 447
 448         return 4;
 449 }
 450
 451 static const struct file_operations spufs_mbox_stat_fops = {
 452         .open   = spufs_pipe_open,
 453         .read   = spufs_mbox_stat_read,
 454 };
 455
 456 /* low-level ibox access function */
 457 size_t spu_ibox_read(struct spu_context *ctx, u32 *data)
 458 {
 459         return ctx->ops->ibox_read(ctx, data);
 460 }
 461
 462 static int spufs_ibox_fasync(int fd, struct file *file, int on)
 463 {
 464         struct spu_context *ctx = file->private_data;
 465
 466         return fasync_helper(fd, file, on, &ctx->ibox_fasync);
 467 }
 468
 469 /* interrupt-level ibox callback function. */
 470 void spufs_ibox_callback(struct spu *spu)
 471 {
 472         struct spu_context *ctx = spu->ctx;
 473
 474         wake_up_all(&ctx->ibox_wq);
 475         kill_fasync(&ctx->ibox_fasync, SIGIO, POLLIN);
 476 }
 477
 478 /*
 479  * Read as many bytes from the interrupt mailbox as possible, until
 480  * one of the conditions becomes true:
 481  *
 482  * - no more data available in the mailbox
 483  * - end of the user provided buffer
 484  * - end of the mapped area
 485  *
 486  * If the file is opened without O_NONBLOCK, we wait here until
 487  * any data is available, but return when we have been able to
 488  * read something.
 489  */
 490 static ssize_t spufs_ibox_read(struct file *file, char __user *buf,
 491                         size_t len, loff_t *pos)
 492 {
 493         struct spu_context *ctx = file->private_data;
 494         u32 ibox_data, __user *udata;
 495         ssize_t count;
 496
 497         if (len < 4)
 498                 return -EINVAL;
 499
 500         if (!access_ok(VERIFY_WRITE, buf, len))
 501                 return -EFAULT;
 502
 503         udata = (void __user *)buf;
 504
 505         spu_acquire(ctx);
 506
 507         /* wait only for the first element */
 508         count = 0;
 509         if (file->f_flags & O_NONBLOCK) {
 510                 if (!spu_ibox_read(ctx, &ibox_data))
 511                         count = -EAGAIN;
 512         } else {
 513                 count = spufs_wait(ctx->ibox_wq, spu_ibox_read(ctx, &ibox_data));
 514         }
 515         if (count)
 516                 goto out;
 517
 518         /* if we can't write at all, return -EFAULT */
 519         count = __put_user(ibox_data, udata);
 520         if (count)
 521                 goto out;
 522
 523         for (count = 4, udata++; (count + 4) <= len; count += 4, udata++) {
 524                 int ret;
 525                 ret = ctx->ops->ibox_read(ctx, &ibox_data);
 526                 if (ret == 0)
 527                         break;
 528                 /*
 529                  * at the end of the mapped area, we can fault
 530                  * but still need to return the data we have
 531                  * read successfully so far.
 532                  */
 533                 ret = __put_user(ibox_data, udata);
 534                 if (ret)
 535                         break;
 536         }
 537
 538 out:
 539         spu_release(ctx);
 540
 541         return count;
 542 }
 543
 544 static unsigned int spufs_ibox_poll(struct file *file, poll_table *wait)
 545 {
 546         struct spu_context *ctx = file->private_data;
 547         unsigned int mask;
 548
 549         poll_wait(file, &ctx->ibox_wq, wait);
 550
 551         spu_acquire(ctx);
 552         mask = ctx->ops->mbox_stat_poll(ctx, POLLIN | POLLRDNORM);
 553         spu_release(ctx);
 554
 555         return mask;
 556 }
 557
 558 static const struct file_operations spufs_ibox_fops = {
 559         .open   = spufs_pipe_open,
 560         .read   = spufs_ibox_read,
 561         .poll   = spufs_ibox_poll,
 562         .fasync = spufs_ibox_fasync,
 563 };
 564
 565 static ssize_t spufs_ibox_stat_read(struct file *file, char __user *buf,
 566                         size_t len, loff_t *pos)
 567 {
 568         struct spu_context *ctx = file->private_data;
 569         u32 ibox_stat;
 570
 571         if (len < 4)
 572                 return -EINVAL;
 573
 574         spu_acquire(ctx);
 575         ibox_stat = (ctx->ops->mbox_stat_read(ctx) >> 16) & 0xff;
 576         spu_release(ctx);
 577
 578         if (copy_to_user(buf, &ibox_stat, sizeof ibox_stat))
 579                 return -EFAULT;
 580
 581         return 4;
 582 }
 583
 584 static const struct file_operations spufs_ibox_stat_fops = {
 585         .open   = spufs_pipe_open,
 586         .read   = spufs_ibox_stat_read,
 587 };
 588
 589 /* low-level mailbox write */
 590 size_t spu_wbox_write(struct spu_context *ctx, u32 data)
 591 {
 592         return ctx->ops->wbox_write(ctx, data);
 593 }
 594
 595 static int spufs_wbox_fasync(int fd, struct file *file, int on)
 596 {
 597         struct spu_context *ctx = file->private_data;
 598         int ret;
 599
 600         ret = fasync_helper(fd, file, on, &ctx->wbox_fasync);
 601
 602         return ret;
 603 }
 604
 605 /* interrupt-level wbox callback function. */
 606 void spufs_wbox_callback(struct spu *spu)
 607 {
 608         struct spu_context *ctx = spu->ctx;
 609
 610         wake_up_all(&ctx->wbox_wq);
 611         kill_fasync(&ctx->wbox_fasync, SIGIO, POLLOUT);
 612 }
 613
 614 /*
 615  * Write as many bytes to the interrupt mailbox as possible, until
 616  * one of the conditions becomes true:
 617  *
 618  * - the mailbox is full
 619  * - end of the user provided buffer
 620  * - end of the mapped area
 621  *
 622  * If the file is opened without O_NONBLOCK, we wait here until
 623  * space is availabyl, but return when we have been able to
 624  * write something.
 625  */
 626 static ssize_t spufs_wbox_write(struct file *file, const char __user *buf,
 627                         size_t len, loff_t *pos)
 628 {
 629         struct spu_context *ctx = file->private_data;
 630         u32 wbox_data, __user *udata;
 631         ssize_t count;
 632
 633         if (len < 4)
 634                 return -EINVAL;
 635
 636         udata = (void __user *)buf;
 637         if (!access_ok(VERIFY_READ, buf, len))
 638                 return -EFAULT;
 639
 640         if (__get_user(wbox_data, udata))
 641                 return -EFAULT;
 642
 643         spu_acquire(ctx);
 644
 645         /*
 646          * make sure we can at least write one element, by waiting
 647          * in case of !O_NONBLOCK
 648          */
 649         count = 0;
 650         if (file->f_flags & O_NONBLOCK) {
 651                 if (!spu_wbox_write(ctx, wbox_data))
 652                         count = -EAGAIN;
 653         } else {
 654                 count = spufs_wait(ctx->wbox_wq, spu_wbox_write(ctx, wbox_data));
 655         }
 656
 657         if (count)
 658                 goto out;
 659
 660         /* write aѕ much as possible */
 661         for (count = 4, udata++; (count + 4) <= len; count += 4, udata++) {
 662                 int ret;
 663                 ret = __get_user(wbox_data, udata);
 664                 if (ret)
 665                         break;
 666
 667                 ret = spu_wbox_write(ctx, wbox_data);
 668                 if (ret == 0)
 669                         break;
 670         }
 671
 672 out:
 673         spu_release(ctx);
 674         return count;
 675 }
 676
 677 static unsigned int spufs_wbox_poll(struct file *file, poll_table *wait)
 678 {
 679         struct spu_context *ctx = file->private_data;
 680         unsigned int mask;
 681
 682         poll_wait(file, &ctx->wbox_wq, wait);
 683
 684         spu_acquire(ctx);
 685         mask = ctx->ops->mbox_stat_poll(ctx, POLLOUT | POLLWRNORM);
 686         spu_release(ctx);
 687
 688         return mask;
 689 }
 690
 691 static const struct file_operations spufs_wbox_fops = {
 692         .open   = spufs_pipe_open,
 693         .write  = spufs_wbox_write,
 694         .poll   = spufs_wbox_poll,
 695         .fasync = spufs_wbox_fasync,
 696 };
 697
 698 static ssize_t spufs_wbox_stat_read(struct file *file, char __user *buf,
 699                         size_t len, loff_t *pos)
 700 {
 701         struct spu_context *ctx = file->private_data;
 702         u32 wbox_stat;
 703
 704         if (len < 4)
 705                 return -EINVAL;
 706
 707         spu_acquire(ctx);
 708         wbox_stat = (ctx->ops->mbox_stat_read(ctx) >> 8) & 0xff;
 709         spu_release(ctx);
 710
 711         if (copy_to_user(buf, &wbox_stat, sizeof wbox_stat))
 712                 return -EFAULT;
 713
 714         return 4;
 715 }
 716
 717 static const struct file_operations spufs_wbox_stat_fops = {
 718         .open   = spufs_pipe_open,
 719         .read   = spufs_wbox_stat_read,
 720 };
 721
 722 static int spufs_signal1_open(struct inode *inode, struct file *file)
 723 {
 724         struct spufs_inode_info *i = SPUFS_I(inode);
 725         struct spu_context *ctx = i->i_ctx;
 726         file->private_data = ctx;
 727         ctx->signal1 = inode->i_mapping;
 728         smp_wmb();
 729         return nonseekable_open(inode, file);
 730 }
 731
 732 static ssize_t __spufs_signal1_read(struct spu_context *ctx, char __user *buf,
 733                         size_t len, loff_t *pos)
 734 {
 735         int ret = 0;
 736         u32 data;
 737
 738         if (len < 4)
 739                 return -EINVAL;
 740
 741         if (ctx->csa.spu_chnlcnt_RW[3]) {
 742                 data = ctx->csa.spu_chnldata_RW[3];
 743                 ret = 4;
 744         }
 745
 746         if (!ret)
 747                 goto out;
 748
 749         if (copy_to_user(buf, &data, 4))
 750                 return -EFAULT;
 751
 752 out:
 753         return ret;
 754 }
 755
 756 static ssize_t spufs_signal1_read(struct file *file, char __user *buf,
 757                         size_t len, loff_t *pos)
 758 {
 759         int ret;
 760         struct spu_context *ctx = file->private_data;
 761
 762         spu_acquire_saved(ctx);
 763         ret = __spufs_signal1_read(ctx, buf, len, pos);
 764         spu_release(ctx);
 765
 766         return ret;
 767 }
 768
 769 static ssize_t spufs_signal1_write(struct file *file, const char __user *buf,
 770                         size_t len, loff_t *pos)
 771 {
 772         struct spu_context *ctx;
 773         u32 data;
 774
 775         ctx = file->private_data;
 776
 777         if (len < 4)
 778                 return -EINVAL;
 779
 780         if (copy_from_user(&data, buf, 4))
 781                 return -EFAULT;
 782
 783         spu_acquire(ctx);
 784         ctx->ops->signal1_write(ctx, data);
 785         spu_release(ctx);
 786
 787         return 4;
 788 }
 789
 790 static unsigned long spufs_signal1_mmap_nopfn(struct vm_area_struct *vma,
 791                                               unsigned long address)
 792 {
 793 #if PAGE_SIZE == 0x1000
 794         return spufs_ps_nopfn(vma, address, 0x14000, 0x1000);
 795 #elif PAGE_SIZE == 0x10000
 796         /* For 64k pages, both signal1 and signal2 can be used to mmap the whole
 797          * signal 1 and 2 area
 798          */
 799         return spufs_ps_nopfn(vma, address, 0x10000, 0x10000);
 800 #else
 801 #error unsupported page size
 802 #endif
 803 }
 804
 805 static struct vm_operations_struct spufs_signal1_mmap_vmops = {
 806         .nopfn = spufs_signal1_mmap_nopfn,
 807 };
 808
 809 static int spufs_signal1_mmap(struct file *file, struct vm_area_struct *vma)
 810 {
 811         if (!(vma->vm_flags & VM_SHARED))
 812                 return -EINVAL;
 813
 814         vma->vm_flags |= VM_IO | VM_PFNMAP;
 815         vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot)
 816                                      | _PAGE_NO_CACHE | _PAGE_GUARDED);
 817
 818         vma->vm_ops = &spufs_signal1_mmap_vmops;
 819         return 0;
 820 }
 821
 822 static const struct file_operations spufs_signal1_fops = {
 823         .open = spufs_signal1_open,
 824         .read = spufs_signal1_read,
 825         .write = spufs_signal1_write,
 826         .mmap = spufs_signal1_mmap,
 827 };
 828
 829 static int spufs_signal2_open(struct inode *inode, struct file *file)
 830 {
 831         struct spufs_inode_info *i = SPUFS_I(inode);
 832         struct spu_context *ctx = i->i_ctx;
 833         file->private_data = ctx;
 834         ctx->signal2 = inode->i_mapping;
 835         smp_wmb();
 836         return nonseekable_open(inode, file);
 837 }
 838
 839 static ssize_t __spufs_signal2_read(struct spu_context *ctx, char __user *buf,
 840                         size_t len, loff_t *pos)
 841 {
 842         int ret = 0;
 843         u32 data;
 844
 845         if (len < 4)
 846                 return -EINVAL;
 847
 848         if (ctx->csa.spu_chnlcnt_RW[4]) {
 849                 data =  ctx->csa.spu_chnldata_RW[4];
 850                 ret = 4;
 851         }
 852
 853         if (!ret)
 854                 goto out;
 855
 856         if (copy_to_user(buf, &data, 4))
 857                 return -EFAULT;
 858
 859 out:
 860         return ret;
 861 }
 862
 863 static ssize_t spufs_signal2_read(struct file *file, char __user *buf,
 864                         size_t len, loff_t *pos)
 865 {
 866         struct spu_context *ctx = file->private_data;
 867         int ret;
 868
 869         spu_acquire_saved(ctx);
 870         ret = __spufs_signal2_read(ctx, buf, len, pos);
 871         spu_release(ctx);
 872
 873         return ret;
 874 }
 875
 876 static ssize_t spufs_signal2_write(struct file *file, const char __user *buf,
 877                         size_t len, loff_t *pos)
 878 {
 879         struct spu_context *ctx;
 880         u32 data;
 881
 882         ctx = file->private_data;
 883
 884         if (len < 4)
 885                 return -EINVAL;
 886
 887         if (copy_from_user(&data, buf, 4))
 888                 return -EFAULT;
 889
 890         spu_acquire(ctx);
 891         ctx->ops->signal2_write(ctx, data);
 892         spu_release(ctx);
 893
 894         return 4;
 895 }
 896
 897 #if SPUFS_MMAP_4K
 898 static unsigned long spufs_signal2_mmap_nopfn(struct vm_area_struct *vma,
 899                                               unsigned long address)
 900 {
 901 #if PAGE_SIZE == 0x1000
 902         return spufs_ps_nopfn(vma, address, 0x1c000, 0x1000);
 903 #elif PAGE_SIZE == 0x10000
 904         /* For 64k pages, both signal1 and signal2 can be used to mmap the whole
 905          * signal 1 and 2 area
 906          */
 907         return spufs_ps_nopfn(vma, address, 0x10000, 0x10000);
 908 #else
 909 #error unsupported page size
 910 #endif
 911 }
 912
 913 static struct vm_operations_struct spufs_signal2_mmap_vmops = {
 914         .nopfn = spufs_signal2_mmap_nopfn,
 915 };
 916
 917 static int spufs_signal2_mmap(struct file *file, struct vm_area_struct *vma)
 918 {
 919         if (!(vma->vm_flags & VM_SHARED))
 920                 return -EINVAL;
 921
 922         vma->vm_flags |= VM_IO | VM_PFNMAP;
 923         vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot)
 924                                      | _PAGE_NO_CACHE | _PAGE_GUARDED);
 925
 926         vma->vm_ops = &spufs_signal2_mmap_vmops;
 927         return 0;
 928 }
 929 #else /* SPUFS_MMAP_4K */
 930 #define spufs_signal2_mmap NULL
 931 #endif /* !SPUFS_MMAP_4K */
 932
 933 static const struct file_operations spufs_signal2_fops = {
 934         .open = spufs_signal2_open,
 935         .read = spufs_signal2_read,
 936         .write = spufs_signal2_write,
 937         .mmap = spufs_signal2_mmap,
 938 };
 939
 940 static void spufs_signal1_type_set(void *data, u64 val)
 941 {
 942         struct spu_context *ctx = data;
 943
 944         spu_acquire(ctx);
 945         ctx->ops->signal1_type_set(ctx, val);
 946         spu_release(ctx);
 947 }
 948
 949 static u64 __spufs_signal1_type_get(void *data)
 950 {
 951         struct spu_context *ctx = data;
 952         return ctx->ops->signal1_type_get(ctx);
 953 }
 954
 955 static u64 spufs_signal1_type_get(void *data)
 956 {
 957         struct spu_context *ctx = data;
 958         u64 ret;
 959
 960         spu_acquire(ctx);
 961         ret = __spufs_signal1_type_get(data);
 962         spu_release(ctx);
 963
 964         return ret;
 965 }
 966 DEFINE_SIMPLE_ATTRIBUTE(spufs_signal1_type, spufs_signal1_type_get,
 967                                         spufs_signal1_type_set, "%llu");
 968
 969 static void spufs_signal2_type_set(void *data, u64 val)
 970 {
 971         struct spu_context *ctx = data;
 972
 973         spu_acquire(ctx);
 974         ctx->ops->signal2_type_set(ctx, val);
 975         spu_release(ctx);
 976 }
 977
 978 static u64 __spufs_signal2_type_get(void *data)
 979 {
 980         struct spu_context *ctx = data;
 981         return ctx->ops->signal2_type_get(ctx);
 982 }
 983
 984 static u64 spufs_signal2_type_get(void *data)
 985 {
 986         struct spu_context *ctx = data;
 987         u64 ret;
 988
 989         spu_acquire(ctx);
 990         ret = __spufs_signal2_type_get(data);
 991         spu_release(ctx);
 992
 993         return ret;
 994 }
 995 DEFINE_SIMPLE_ATTRIBUTE(spufs_signal2_type, spufs_signal2_type_get,
 996                                         spufs_signal2_type_set, "%llu");
 997
 998 #if SPUFS_MMAP_4K
 999 static unsigned long spufs_mss_mmap_nopfn(struct vm_area_struct *vma,
1000                                           unsigned long address)
1001 {
1002         return spufs_ps_nopfn(vma, address, 0x0000, 0x1000);
1003 }
1004
1005 static struct vm_operations_struct spufs_mss_mmap_vmops = {
1006         .nopfn = spufs_mss_mmap_nopfn,
1007 };
1008
1009 /*
1010  * mmap support for problem state MFC DMA area [0x0000 - 0x0fff].
1011  */
1012 static int spufs_mss_mmap(struct file *file, struct vm_area_struct *vma)
1013 {
1014         if (!(vma->vm_flags & VM_SHARED))
1015                 return -EINVAL;
1016
1017         vma->vm_flags |= VM_IO | VM_PFNMAP;
1018         vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot)
1019                                      | _PAGE_NO_CACHE | _PAGE_GUARDED);
1020
1021         vma->vm_ops = &spufs_mss_mmap_vmops;
1022         return 0;
1023 }
1024 #else /* SPUFS_MMAP_4K */
1025 #define spufs_mss_mmap NULL
1026 #endif /* !SPUFS_MMAP_4K */
1027
1028 static int spufs_mss_open(struct inode *inode, struct file *file)
1029 {
1030         struct spufs_inode_info *i = SPUFS_I(inode);
1031         struct spu_context *ctx = i->i_ctx;
1032
1033         file->private_data = i->i_ctx;
1034         ctx->mss = inode->i_mapping;
1035         smp_wmb();
1036         return nonseekable_open(inode, file);
1037 }
1038
1039 static const struct file_operations spufs_mss_fops = {
1040         .open    = spufs_mss_open,
1041         .mmap    = spufs_mss_mmap,
1042 };
1043
1044 static unsigned long spufs_psmap_mmap_nopfn(struct vm_area_struct *vma,
1045                                             unsigned long address)
1046 {
1047         return spufs_ps_nopfn(vma, address, 0x0000, 0x20000);
1048 }
1049
1050 static struct vm_operations_struct spufs_psmap_mmap_vmops = {
1051         .nopfn = spufs_psmap_mmap_nopfn,
1052 };
1053
1054 /*
1055  * mmap support for full problem state area [0x00000 - 0x1ffff].
1056  */
1057 static int spufs_psmap_mmap(struct file *file, struct vm_area_struct *vma)
1058 {
1059         if (!(vma->vm_flags & VM_SHARED))
1060                 return -EINVAL;
1061
1062         vma->vm_flags |= VM_IO | VM_PFNMAP;
1063         vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot)
1064                                      | _PAGE_NO_CACHE | _PAGE_GUARDED);
1065
1066         vma->vm_ops = &spufs_psmap_mmap_vmops;
1067         return 0;
1068 }
1069
1070 static int spufs_psmap_open(struct inode *inode, struct file *file)
1071 {
1072         struct spufs_inode_info *i = SPUFS_I(inode);
1073         struct spu_context *ctx = i->i_ctx;
1074
1075         file->private_data = i->i_ctx;
1076         ctx->psmap = inode->i_mapping;
1077         smp_wmb();
1078         return nonseekable_open(inode, file);
1079 }
1080
1081 static const struct file_operations spufs_psmap_fops = {
1082         .open    = spufs_psmap_open,
1083         .mmap    = spufs_psmap_mmap,
1084 };
1085
1086
1087 #if SPUFS_MMAP_4K
1088 static unsigned long spufs_mfc_mmap_nopfn(struct vm_area_struct *vma,
1089                                           unsigned long address)
1090 {
1091         return spufs_ps_nopfn(vma, address, 0x3000, 0x1000);
1092 }
1093
1094 static struct vm_operations_struct spufs_mfc_mmap_vmops = {
1095         .nopfn = spufs_mfc_mmap_nopfn,
1096 };
1097
1098 /*
1099  * mmap support for problem state MFC DMA area [0x0000 - 0x0fff].
1100  */
1101 static int spufs_mfc_mmap(struct file *file, struct vm_area_struct *vma)
1102 {
1103         if (!(vma->vm_flags & VM_SHARED))
1104                 return -EINVAL;
1105
1106         vma->vm_flags |= VM_IO | VM_PFNMAP;
1107         vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot)
1108                                      | _PAGE_NO_CACHE | _PAGE_GUARDED);
1109
1110         vma->vm_ops = &spufs_mfc_mmap_vmops;
1111         return 0;
1112 }
1113 #else /* SPUFS_MMAP_4K */
1114 #define spufs_mfc_mmap NULL
1115 #endif /* !SPUFS_MMAP_4K */
1116
1117 static int spufs_mfc_open(struct inode *inode, struct file *file)
1118 {
1119         struct spufs_inode_info *i = SPUFS_I(inode);
1120         struct spu_context *ctx = i->i_ctx;
1121
1122         /* we don't want to deal with DMA into other processes */
1123         if (ctx->owner != current->mm)
1124                 return -EINVAL;
1125
1126         if (atomic_read(&inode->i_count) != 1)
1127                 return -EBUSY;
1128
1129         file->private_data = ctx;
1130         ctx->mfc = inode->i_mapping;
1131         smp_wmb();
1132         return nonseekable_open(inode, file);
1133 }
1134
1135 /* interrupt-level mfc callback function. */
1136 void spufs_mfc_callback(struct spu *spu)
1137 {
1138         struct spu_context *ctx = spu->ctx;
1139
1140         wake_up_all(&ctx->mfc_wq);
1141
1142         pr_debug("%s %s\n", __FUNCTION__, spu->name);
1143         if (ctx->mfc_fasync) {
1144                 u32 free_elements, tagstatus;
1145                 unsigned int mask;
1146
1147                 /* no need for spu_acquire in interrupt context */
1148                 free_elements = ctx->ops->get_mfc_free_elements(ctx);
1149                 tagstatus = ctx->ops->read_mfc_tagstatus(ctx);
1150
1151                 mask = 0;
1152                 if (free_elements & 0xffff)
1153                         mask |= POLLOUT;
1154                 if (tagstatus & ctx->tagwait)
1155                         mask |= POLLIN;
1156
1157                 kill_fasync(&ctx->mfc_fasync, SIGIO, mask);
1158         }
1159 }
1160
1161 static int spufs_read_mfc_tagstatus(struct spu_context *ctx, u32 *status)
1162 {
1163         /* See if there is one tag group is complete */
1164         /* FIXME we need locking around tagwait */
1165         *status = ctx->ops->read_mfc_tagstatus(ctx) & ctx->tagwait;
1166         ctx->tagwait &= ~*status;
1167         if (*status)
1168                 return 1;
1169
1170         /* enable interrupt waiting for any tag group,
1171            may silently fail if interrupts are already enabled */
1172         ctx->ops->set_mfc_query(ctx, ctx->tagwait, 1);
1173         return 0;
1174 }
1175
1176 static ssize_t spufs_mfc_read(struct file *file, char __user *buffer,
1177                         size_t size, loff_t *pos)
1178 {
1179         struct spu_context *ctx = file->private_data;
1180         int ret = -EINVAL;
1181         u32 status;
1182
1183         if (size != 4)
1184                 goto out;
1185
1186         spu_acquire(ctx);
1187         if (file->f_flags & O_NONBLOCK) {
1188                 status = ctx->ops->read_mfc_tagstatus(ctx);
1189                 if (!(status & ctx->tagwait))
1190                         ret = -EAGAIN;
1191                 else
1192                         ctx->tagwait &= ~status;
1193         } else {
1194                 ret = spufs_wait(ctx->mfc_wq,
1195                            spufs_read_mfc_tagstatus(ctx, &status));
1196         }
1197         spu_release(ctx);
1198
1199         if (ret)
1200                 goto out;
1201
1202         ret = 4;
1203         if (copy_to_user(buffer, &status, 4))
1204                 ret = -EFAULT;
1205
1206 out:
1207         return ret;
1208 }
1209
1210 static int spufs_check_valid_dma(struct mfc_dma_command *cmd)
1211 {
1212         pr_debug("queueing DMA %x %lx %x %x %x\n", cmd->lsa,
1213                  cmd->ea, cmd->size, cmd->tag, cmd->cmd);
1214
1215         switch (cmd->cmd) {
1216         case MFC_PUT_CMD:
1217         case MFC_PUTF_CMD:
1218         case MFC_PUTB_CMD:
1219         case MFC_GET_CMD:
1220         case MFC_GETF_CMD:
1221         case MFC_GETB_CMD:
1222                 break;
1223         default:
1224                 pr_debug("invalid DMA opcode %x\n", cmd->cmd);
1225                 return -EIO;
1226         }
1227
1228         if ((cmd->lsa & 0xf) != (cmd->ea &0xf)) {
1229                 pr_debug("invalid DMA alignment, ea %lx lsa %x\n",
1230                                 cmd->ea, cmd->lsa);
1231                 return -EIO;
1232         }
1233
1234         switch (cmd->size & 0xf) {
1235         case 1:
1236                 break;
1237         case 2:
1238                 if (cmd->lsa & 1)
1239                         goto error;
1240                 break;
1241         case 4:
1242                 if (cmd->lsa & 3)
1243                         goto error;
1244                 break;
1245         case 8:
1246                 if (cmd->lsa & 7)
1247                         goto error;
1248                 break;
1249         case 0:
1250                 if (cmd->lsa & 15)
1251                         goto error;
1252                 break;
1253         error:
1254         default:
1255                 pr_debug("invalid DMA alignment %x for size %x\n",
1256                         cmd->lsa & 0xf, cmd->size);
1257                 return -EIO;
1258         }
1259
1260         if (cmd->size > 16 * 1024) {
1261                 pr_debug("invalid DMA size %x\n", cmd->size);
1262                 return -EIO;
1263         }
1264
1265         if (cmd->tag & 0xfff0) {
1266                 /* we reserve the higher tag numbers for kernel use */
1267                 pr_debug("invalid DMA tag\n");
1268                 return -EIO;
1269         }
1270
1271         if (cmd->class) {
1272                 /* not supported in this version */
1273                 pr_debug("invalid DMA class\n");
1274                 return -EIO;
1275         }
1276
1277         return 0;
1278 }
1279
1280 static int spu_send_mfc_command(struct spu_context *ctx,
1281                                 struct mfc_dma_command cmd,
1282                                 int *error)
1283 {
1284         *error = ctx->ops->send_mfc_command(ctx, &cmd);
1285         if (*error == -EAGAIN) {
1286                 /* wait for any tag group to complete
1287                    so we have space for the new command */
1288                 ctx->ops->set_mfc_query(ctx, ctx->tagwait, 1);
1289                 /* try again, because the queue might be
1290                    empty again */
1291                 *error = ctx->ops->send_mfc_command(ctx, &cmd);
1292                 if (*error == -EAGAIN)
1293                         return 0;
1294         }
1295         return 1;
1296 }
1297
1298 static ssize_t spufs_mfc_write(struct file *file, const char __user *buffer,
1299                         size_t size, loff_t *pos)
1300 {
1301         struct spu_context *ctx = file->private_data;
1302         struct mfc_dma_command cmd;
1303         int ret = -EINVAL;
1304
1305         if (size != sizeof cmd)
1306                 goto out;
1307
1308         ret = -EFAULT;
1309         if (copy_from_user(&cmd, buffer, sizeof cmd))
1310                 goto out;
1311
1312         ret = spufs_check_valid_dma(&cmd);
1313         if (ret)
1314                 goto out;
1315
1316         spu_acquire_runnable(ctx, 0);
1317         if (file->f_flags & O_NONBLOCK) {
1318                 ret = ctx->ops->send_mfc_command(ctx, &cmd);
1319         } else {
1320                 int status;
1321                 ret = spufs_wait(ctx->mfc_wq,
1322                                  spu_send_mfc_command(ctx, cmd, &status));
1323                 if (status)
1324                         ret = status;
1325         }
1326         spu_release(ctx);
1327
1328         if (ret)
1329                 goto out;
1330
1331         ctx->tagwait |= 1 << cmd.tag;
1332         ret = size;
1333
1334 out:
1335         return ret;
1336 }
1337
1338 static unsigned int spufs_mfc_poll(struct file *file,poll_table *wait)
1339 {
1340         struct spu_context *ctx = file->private_data;
1341         u32 free_elements, tagstatus;
1342         unsigned int mask;
1343
1344         spu_acquire(ctx);
1345         ctx->ops->set_mfc_query(ctx, ctx->tagwait, 2);
1346         free_elements = ctx->ops->get_mfc_free_elements(ctx);
1347         tagstatus = ctx->ops->read_mfc_tagstatus(ctx);
1348         spu_release(ctx);
1349
1350         poll_wait(file, &ctx->mfc_wq, wait);
1351
1352         mask = 0;
1353         if (free_elements & 0xffff)
1354                 mask |= POLLOUT | POLLWRNORM;
1355         if (tagstatus & ctx->tagwait)
1356                 mask |= POLLIN | POLLRDNORM;
1357
1358         pr_debug("%s: free %d tagstatus %d tagwait %d\n", __FUNCTION__,
1359                 free_elements, tagstatus, ctx->tagwait);
1360
1361         return mask;
1362 }
1363
1364 static int spufs_mfc_flush(struct file *file, fl_owner_t id)
1365 {
1366         struct spu_context *ctx = file->private_data;
1367         int ret;
1368
1369         spu_acquire(ctx);
1370 #if 0
1371 /* this currently hangs */
1372         ret = spufs_wait(ctx->mfc_wq,
1373                          ctx->ops->set_mfc_query(ctx, ctx->tagwait, 2));
1374         if (ret)
1375                 goto out;
1376         ret = spufs_wait(ctx->mfc_wq,
1377                          ctx->ops->read_mfc_tagstatus(ctx) == ctx->tagwait);
1378 out:
1379 #else
1380         ret = 0;
1381 #endif
1382         spu_release(ctx);
1383
1384         return ret;
1385 }
1386
1387 static int spufs_mfc_fsync(struct file *file, struct dentry *dentry,
1388                            int datasync)
1389 {
1390         return spufs_mfc_flush(file, NULL);
1391 }
1392
1393 static int spufs_mfc_fasync(int fd, struct file *file, int on)
1394 {
1395         struct spu_context *ctx = file->private_data;
1396
1397         return fasync_helper(fd, file, on, &ctx->mfc_fasync);
1398 }
1399
1400 static const struct file_operations spufs_mfc_fops = {
1401         .open    = spufs_mfc_open,
1402         .read    = spufs_mfc_read,
1403         .write   = spufs_mfc_write,
1404         .poll    = spufs_mfc_poll,
1405         .flush   = spufs_mfc_flush,
1406         .fsync   = spufs_mfc_fsync,
1407         .fasync  = spufs_mfc_fasync,
1408         .mmap    = spufs_mfc_mmap,
1409 };
1410
1411 static void spufs_npc_set(void *data, u64 val)
1412 {
1413         struct spu_context *ctx = data;
1414         spu_acquire(ctx);
1415         ctx->ops->npc_write(ctx, val);
1416         spu_release(ctx);
1417 }
1418
1419 static u64 spufs_npc_get(void *data)
1420 {
1421         struct spu_context *ctx = data;
1422         u64 ret;
1423         spu_acquire(ctx);
1424         ret = ctx->ops->npc_read(ctx);
1425         spu_release(ctx);
1426         return ret;
1427 }
1428 DEFINE_SIMPLE_ATTRIBUTE(spufs_npc_ops, spufs_npc_get, spufs_npc_set,
1429                         "0x%llx\n")
1430
1431 static void spufs_decr_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->decr.slot[0] = (u32) val;
1437         spu_release(ctx);
1438 }
1439
1440 static u64 __spufs_decr_get(void *data)
1441 {
1442         struct spu_context *ctx = data;
1443         struct spu_lscsa *lscsa = ctx->csa.lscsa;
1444         return lscsa->decr.slot[0];
1445 }
1446
1447 static u64 spufs_decr_get(void *data)
1448 {
1449         struct spu_context *ctx = data;
1450         u64 ret;
1451         spu_acquire_saved(ctx);
1452         ret = __spufs_decr_get(data);
1453         spu_release(ctx);
1454         return ret;
1455 }
1456 DEFINE_SIMPLE_ATTRIBUTE(spufs_decr_ops, spufs_decr_get, spufs_decr_set,
1457                         "0x%llx\n")
1458
1459 static void spufs_decr_status_set(void *data, u64 val)
1460 {
1461         struct spu_context *ctx = data;
1462         struct spu_lscsa *lscsa = ctx->csa.lscsa;
1463         spu_acquire_saved(ctx);
1464         lscsa->decr_status.slot[0] = (u32) val;
1465         spu_release(ctx);
1466 }
1467
1468 static u64 __spufs_decr_status_get(void *data)
1469 {
1470         struct spu_context *ctx = data;
1471         struct spu_lscsa *lscsa = ctx->csa.lscsa;
1472         return lscsa->decr_status.slot[0];
1473 }
1474
1475 static u64 spufs_decr_status_get(void *data)
1476 {
1477         struct spu_context *ctx = data;
1478         u64 ret;
1479         spu_acquire_saved(ctx);
1480         ret = __spufs_decr_status_get(data);
1481         spu_release(ctx);
1482         return ret;
1483 }
1484 DEFINE_SIMPLE_ATTRIBUTE(spufs_decr_status_ops, spufs_decr_status_get,
1485                         spufs_decr_status_set, "0x%llx\n")
1486
1487 static void spufs_event_mask_set(void *data, u64 val)
1488 {
1489         struct spu_context *ctx = data;
1490         struct spu_lscsa *lscsa = ctx->csa.lscsa;
1491         spu_acquire_saved(ctx);
1492         lscsa->event_mask.slot[0] = (u32) val;
1493         spu_release(ctx);
1494 }
1495
1496 static u64 __spufs_event_mask_get(void *data)
1497 {
1498         struct spu_context *ctx = data;
1499         struct spu_lscsa *lscsa = ctx->csa.lscsa;
1500         return lscsa->event_mask.slot[0];
1501 }
1502
1503 static u64 spufs_event_mask_get(void *data)
1504 {
1505         struct spu_context *ctx = data;
1506         u64 ret;
1507         spu_acquire_saved(ctx);
1508         ret = __spufs_event_mask_get(data);
1509         spu_release(ctx);
1510         return ret;
1511 }
1512 DEFINE_SIMPLE_ATTRIBUTE(spufs_event_mask_ops, spufs_event_mask_get,
1513                         spufs_event_mask_set, "0x%llx\n")
1514
1515 static u64 __spufs_event_status_get(void *data)
1516 {
1517         struct spu_context *ctx = data;
1518         struct spu_state *state = &ctx->csa;
1519         u64 stat;
1520         stat = state->spu_chnlcnt_RW[0];
1521         if (stat)
1522                 return state->spu_chnldata_RW[0];
1523         return 0;
1524 }
1525
1526 static u64 spufs_event_status_get(void *data)
1527 {
1528         struct spu_context *ctx = data;
1529         u64 ret = 0;
1530
1531         spu_acquire_saved(ctx);
1532         ret = __spufs_event_status_get(data);
1533         spu_release(ctx);
1534         return ret;
1535 }
1536 DEFINE_SIMPLE_ATTRIBUTE(spufs_event_status_ops, spufs_event_status_get,
1537                         NULL, "0x%llx\n")
1538
1539 static void spufs_srr0_set(void *data, u64 val)
1540 {
1541         struct spu_context *ctx = data;
1542         struct spu_lscsa *lscsa = ctx->csa.lscsa;
1543         spu_acquire_saved(ctx);
1544         lscsa->srr0.slot[0] = (u32) val;
1545         spu_release(ctx);
1546 }
1547
1548 static u64 spufs_srr0_get(void *data)
1549 {
1550         struct spu_context *ctx = data;
1551         struct spu_lscsa *lscsa = ctx->csa.lscsa;
1552         u64 ret;
1553         spu_acquire_saved(ctx);
1554         ret = lscsa->srr0.slot[0];
1555         spu_release(ctx);
1556         return ret;
1557 }
1558 DEFINE_SIMPLE_ATTRIBUTE(spufs_srr0_ops, spufs_srr0_get, spufs_srr0_set,
1559                         "0x%llx\n")
1560
1561 static u64 spufs_id_get(void *data)
1562 {
1563         struct spu_context *ctx = data;
1564         u64 num;
1565
1566         spu_acquire(ctx);
1567         if (ctx->state == SPU_STATE_RUNNABLE)
1568                 num = ctx->spu->number;
1569         else
1570                 num = (unsigned int)-1;
1571         spu_release(ctx);
1572
1573         return num;
1574 }
1575 DEFINE_SIMPLE_ATTRIBUTE(spufs_id_ops, spufs_id_get, NULL, "0x%llx\n")
1576
1577 static u64 __spufs_object_id_get(void *data)
1578 {
1579         struct spu_context *ctx = data;
1580         return ctx->object_id;
1581 }
1582
1583 static u64 spufs_object_id_get(void *data)
1584 {
1585         /* FIXME: Should there really be no locking here? */
1586         return __spufs_object_id_get(data);
1587 }
1588
1589 static void spufs_object_id_set(void *data, u64 id)
1590 {
1591         struct spu_context *ctx = data;
1592         ctx->object_id = id;
1593 }
1594
1595 DEFINE_SIMPLE_ATTRIBUTE(spufs_object_id_ops, spufs_object_id_get,
1596                 spufs_object_id_set, "0x%llx\n");
1597
1598 static u64 __spufs_lslr_get(void *data)
1599 {
1600         struct spu_context *ctx = data;
1601         return ctx->csa.priv2.spu_lslr_RW;
1602 }
1603
1604 static u64 spufs_lslr_get(void *data)
1605 {
1606         struct spu_context *ctx = data;
1607         u64 ret;
1608
1609         spu_acquire_saved(ctx);
1610         ret = __spufs_lslr_get(data);
1611         spu_release(ctx);
1612
1613         return ret;
1614 }
1615 DEFINE_SIMPLE_ATTRIBUTE(spufs_lslr_ops, spufs_lslr_get, NULL, "0x%llx\n")
1616
1617 static int spufs_info_open(struct inode *inode, struct file *file)
1618 {
1619         struct spufs_inode_info *i = SPUFS_I(inode);
1620         struct spu_context *ctx = i->i_ctx;
1621         file->private_data = ctx;
1622         return 0;
1623 }
1624
1625 static ssize_t __spufs_mbox_info_read(struct spu_context *ctx,
1626                         char __user *buf, size_t len, loff_t *pos)
1627 {
1628         u32 mbox_stat;
1629         u32 data;
1630
1631         mbox_stat = ctx->csa.prob.mb_stat_R;
1632         if (mbox_stat & 0x0000ff) {
1633                 data = ctx->csa.prob.pu_mb_R;
1634         }
1635
1636         return simple_read_from_buffer(buf, len, pos, &data, sizeof data);
1637 }
1638
1639 static ssize_t spufs_mbox_info_read(struct file *file, char __user *buf,
1640                                    size_t len, loff_t *pos)
1641 {
1642         int ret;
1643         struct spu_context *ctx = file->private_data;
1644
1645         if (!access_ok(VERIFY_WRITE, buf, len))
1646                 return -EFAULT;
1647
1648         spu_acquire_saved(ctx);
1649         spin_lock(&ctx->csa.register_lock);
1650         ret = __spufs_mbox_info_read(ctx, buf, len, pos);
1651         spin_unlock(&ctx->csa.register_lock);
1652         spu_release(ctx);
1653
1654         return ret;
1655 }
1656
1657 static const struct file_operations spufs_mbox_info_fops = {
1658         .open = spufs_info_open,
1659         .read = spufs_mbox_info_read,
1660         .llseek  = generic_file_llseek,
1661 };
1662
1663 static ssize_t __spufs_ibox_info_read(struct spu_context *ctx,
1664                                 char __user *buf, size_t len, loff_t *pos)
1665 {
1666         u32 ibox_stat;
1667         u32 data;
1668
1669         ibox_stat = ctx->csa.prob.mb_stat_R;
1670         if (ibox_stat & 0xff0000) {
1671                 data = ctx->csa.priv2.puint_mb_R;
1672         }
1673
1674         return simple_read_from_buffer(buf, len, pos, &data, sizeof data);
1675 }
1676
1677 static ssize_t spufs_ibox_info_read(struct file *file, char __user *buf,
1678                                    size_t len, loff_t *pos)
1679 {
1680         struct spu_context *ctx = file->private_data;
1681         int ret;
1682
1683         if (!access_ok(VERIFY_WRITE, buf, len))
1684                 return -EFAULT;
1685
1686         spu_acquire_saved(ctx);
1687         spin_lock(&ctx->csa.register_lock);
1688         ret = __spufs_ibox_info_read(ctx, buf, len, pos);
1689         spin_unlock(&ctx->csa.register_lock);
1690         spu_release(ctx);
1691
1692         return ret;
1693 }
1694
1695 static const struct file_operations spufs_ibox_info_fops = {
1696         .open = spufs_info_open,
1697         .read = spufs_ibox_info_read,
1698         .llseek  = generic_file_llseek,
1699 };
1700
1701 static ssize_t __spufs_wbox_info_read(struct spu_context *ctx,
1702                         char __user *buf, size_t len, loff_t *pos)
1703 {
1704         int i, cnt;
1705         u32 data[4];
1706         u32 wbox_stat;
1707
1708         wbox_stat = ctx->csa.prob.mb_stat_R;
1709         cnt = 4 - ((wbox_stat & 0x00ff00) >> 8);
1710         for (i = 0; i < cnt; i++) {
1711                 data[i] = ctx->csa.spu_mailbox_data[i];
1712         }
1713
1714         return simple_read_from_buffer(buf, len, pos, &data,
1715                                 cnt * sizeof(u32));
1716 }
1717
1718 static ssize_t spufs_wbox_info_read(struct file *file, char __user *buf,
1719                                    size_t len, loff_t *pos)
1720 {
1721         struct spu_context *ctx = file->private_data;
1722         int ret;
1723
1724         if (!access_ok(VERIFY_WRITE, buf, len))
1725                 return -EFAULT;
1726
1727         spu_acquire_saved(ctx);
1728         spin_lock(&ctx->csa.register_lock);
1729         ret = __spufs_wbox_info_read(ctx, buf, len, pos);
1730         spin_unlock(&ctx->csa.register_lock);
1731         spu_release(ctx);
1732
1733         return ret;
1734 }
1735
1736 static const struct file_operations spufs_wbox_info_fops = {
1737         .open = spufs_info_open,
1738         .read = spufs_wbox_info_read,
1739         .llseek  = generic_file_llseek,
1740 };
1741
1742 static ssize_t __spufs_dma_info_read(struct spu_context *ctx,
1743                         char __user *buf, size_t len, loff_t *pos)
1744 {
1745         struct spu_dma_info info;
1746         struct mfc_cq_sr *qp, *spuqp;
1747         int i;
1748
1749         info.dma_info_type = ctx->csa.priv2.spu_tag_status_query_RW;
1750         info.dma_info_mask = ctx->csa.lscsa->tag_mask.slot[0];
1751         info.dma_info_status = ctx->csa.spu_chnldata_RW[24];
1752         info.dma_info_stall_and_notify = ctx->csa.spu_chnldata_RW[25];
1753         info.dma_info_atomic_command_status = ctx->csa.spu_chnldata_RW[27];
1754         for (i = 0; i < 16; i++) {
1755                 qp = &info.dma_info_command_data[i];
1756                 spuqp = &ctx->csa.priv2.spuq[i];
1757
1758                 qp->mfc_cq_data0_RW = spuqp->mfc_cq_data0_RW;
1759                 qp->mfc_cq_data1_RW = spuqp->mfc_cq_data1_RW;
1760                 qp->mfc_cq_data2_RW = spuqp->mfc_cq_data2_RW;
1761                 qp->mfc_cq_data3_RW = spuqp->mfc_cq_data3_RW;
1762         }
1763
1764         return simple_read_from_buffer(buf, len, pos, &info,
1765                                 sizeof info);
1766 }
1767
1768 static ssize_t spufs_dma_info_read(struct file *file, char __user *buf,
1769                               size_t len, loff_t *pos)
1770 {
1771         struct spu_context *ctx = file->private_data;
1772         int ret;
1773
1774         if (!access_ok(VERIFY_WRITE, buf, len))
1775                 return -EFAULT;
1776
1777         spu_acquire_saved(ctx);
1778         spin_lock(&ctx->csa.register_lock);
1779         ret = __spufs_dma_info_read(ctx, buf, len, pos);
1780         spin_unlock(&ctx->csa.register_lock);
1781         spu_release(ctx);
1782
1783         return ret;
1784 }
1785
1786 static const struct file_operations spufs_dma_info_fops = {
1787         .open = spufs_info_open,
1788         .read = spufs_dma_info_read,
1789 };
1790
1791 static ssize_t __spufs_proxydma_info_read(struct spu_context *ctx,
1792                         char __user *buf, size_t len, loff_t *pos)
1793 {
1794         struct spu_proxydma_info info;
1795         struct mfc_cq_sr *qp, *puqp;
1796         int ret = sizeof info;
1797         int i;
1798
1799         if (len < ret)
1800                 return -EINVAL;
1801
1802         if (!access_ok(VERIFY_WRITE, buf, len))
1803                 return -EFAULT;
1804
1805         info.proxydma_info_type = ctx->csa.prob.dma_querytype_RW;
1806         info.proxydma_info_mask = ctx->csa.prob.dma_querymask_RW;
1807         info.proxydma_info_status = ctx->csa.prob.dma_tagstatus_R;
1808         for (i = 0; i < 8; i++) {
1809                 qp = &info.proxydma_info_command_data[i];
1810                 puqp = &ctx->csa.priv2.puq[i];
1811
1812                 qp->mfc_cq_data0_RW = puqp->mfc_cq_data0_RW;
1813                 qp->mfc_cq_data1_RW = puqp->mfc_cq_data1_RW;
1814                 qp->mfc_cq_data2_RW = puqp->mfc_cq_data2_RW;
1815                 qp->mfc_cq_data3_RW = puqp->mfc_cq_data3_RW;
1816         }
1817
1818         return simple_read_from_buffer(buf, len, pos, &info,
1819                                 sizeof info);
1820 }
1821
1822 static ssize_t spufs_proxydma_info_read(struct file *file, char __user *buf,
1823                                    size_t len, loff_t *pos)
1824 {
1825         struct spu_context *ctx = file->private_data;
1826         int ret;
1827
1828         spu_acquire_saved(ctx);
1829         spin_lock(&ctx->csa.register_lock);
1830         ret = __spufs_proxydma_info_read(ctx, buf, len, pos);
1831         spin_unlock(&ctx->csa.register_lock);
1832         spu_release(ctx);
1833
1834         return ret;
1835 }
1836
1837 static const struct file_operations spufs_proxydma_info_fops = {
1838         .open = spufs_info_open,
1839         .read = spufs_proxydma_info_read,
1840 };
1841
1842 struct tree_descr spufs_dir_contents[] = {
1843         { "mem",  &spufs_mem_fops,  0666, },
1844         { "regs", &spufs_regs_fops,  0666, },
1845         { "mbox", &spufs_mbox_fops, 0444, },
1846         { "ibox", &spufs_ibox_fops, 0444, },
1847         { "wbox", &spufs_wbox_fops, 0222, },
1848         { "mbox_stat", &spufs_mbox_stat_fops, 0444, },
1849         { "ibox_stat", &spufs_ibox_stat_fops, 0444, },
1850         { "wbox_stat", &spufs_wbox_stat_fops, 0444, },
1851         { "signal1", &spufs_signal1_fops, 0666, },
1852         { "signal2", &spufs_signal2_fops, 0666, },
1853         { "signal1_type", &spufs_signal1_type, 0666, },
1854         { "signal2_type", &spufs_signal2_type, 0666, },
1855         { "cntl", &spufs_cntl_fops,  0666, },
1856         { "fpcr", &spufs_fpcr_fops, 0666, },
1857         { "lslr", &spufs_lslr_ops, 0444, },
1858         { "mfc", &spufs_mfc_fops, 0666, },
1859         { "mss", &spufs_mss_fops, 0666, },
1860         { "npc", &spufs_npc_ops, 0666, },
1861         { "srr0", &spufs_srr0_ops, 0666, },
1862         { "decr", &spufs_decr_ops, 0666, },
1863         { "decr_status", &spufs_decr_status_ops, 0666, },
1864         { "event_mask", &spufs_event_mask_ops, 0666, },
1865         { "event_status", &spufs_event_status_ops, 0444, },
1866         { "psmap", &spufs_psmap_fops, 0666, },
1867         { "phys-id", &spufs_id_ops, 0666, },
1868         { "object-id", &spufs_object_id_ops, 0666, },
1869         { "mbox_info", &spufs_mbox_info_fops, 0444, },
1870         { "ibox_info", &spufs_ibox_info_fops, 0444, },
1871         { "wbox_info", &spufs_wbox_info_fops, 0444, },
1872         { "dma_info", &spufs_dma_info_fops, 0444, },
1873         { "proxydma_info", &spufs_proxydma_info_fops, 0444, },
1874         {},
1875 };
1876
1877 struct tree_descr spufs_dir_nosched_contents[] = {
1878         { "mem",  &spufs_mem_fops,  0666, },
1879         { "mbox", &spufs_mbox_fops, 0444, },
1880         { "ibox", &spufs_ibox_fops, 0444, },
1881         { "wbox", &spufs_wbox_fops, 0222, },
1882         { "mbox_stat", &spufs_mbox_stat_fops, 0444, },
1883         { "ibox_stat", &spufs_ibox_stat_fops, 0444, },
1884         { "wbox_stat", &spufs_wbox_stat_fops, 0444, },
1885         { "signal1", &spufs_signal1_fops, 0666, },
1886         { "signal2", &spufs_signal2_fops, 0666, },
1887         { "signal1_type", &spufs_signal1_type, 0666, },
1888         { "signal2_type", &spufs_signal2_type, 0666, },
1889         { "mss", &spufs_mss_fops, 0666, },
1890         { "mfc", &spufs_mfc_fops, 0666, },
1891         { "cntl", &spufs_cntl_fops,  0666, },
1892         { "npc", &spufs_npc_ops, 0666, },
1893         { "psmap", &spufs_psmap_fops, 0666, },
1894         { "phys-id", &spufs_id_ops, 0666, },
1895         { "object-id", &spufs_object_id_ops, 0666, },
1896         {},
1897 };
1898
1899 struct spufs_coredump_reader spufs_coredump_read[] = {
1900         { "regs", __spufs_regs_read, NULL, 128 * 16 },
1901         { "fpcr", __spufs_fpcr_read, NULL, 16 },
1902         { "lslr", NULL, __spufs_lslr_get, 11 },
1903         { "decr", NULL, __spufs_decr_get, 11 },
1904         { "decr_status", NULL, __spufs_decr_status_get, 11 },
1905         { "mem", __spufs_mem_read, NULL, 256 * 1024, },
1906         { "signal1", __spufs_signal1_read, NULL, 4 },
1907         { "signal1_type", NULL, __spufs_signal1_type_get, 2 },
1908         { "signal2", __spufs_signal2_read, NULL, 4 },
1909         { "signal2_type", NULL, __spufs_signal2_type_get, 2 },
1910         { "event_mask", NULL, __spufs_event_mask_get, 8 },
1911         { "event_status", NULL, __spufs_event_status_get, 8 },
1912         { "mbox_info", __spufs_mbox_info_read, NULL, 4 },
1913         { "ibox_info", __spufs_ibox_info_read, NULL, 4 },
1914         { "wbox_info", __spufs_wbox_info_read, NULL, 16 },
1915         { "dma_info", __spufs_dma_info_read, NULL, 69 * 8 },
1916         { "proxydma_info", __spufs_proxydma_info_read, NULL, 35 * 8 },
1917         { "object-id", NULL, __spufs_object_id_get, 19 },
1918         { },
1919 };
1920 int spufs_coredump_num_notes = ARRAY_SIZE(spufs_coredump_read) - 1;
1921