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