167207b96SArnd Bergmann /* 267207b96SArnd Bergmann * SPU file system -- file contents 367207b96SArnd Bergmann * 467207b96SArnd Bergmann * (C) Copyright IBM Deutschland Entwicklung GmbH 2005 567207b96SArnd Bergmann * 667207b96SArnd Bergmann * Author: Arnd Bergmann <arndb@de.ibm.com> 767207b96SArnd Bergmann * 867207b96SArnd Bergmann * This program is free software; you can redistribute it and/or modify 967207b96SArnd Bergmann * it under the terms of the GNU General Public License as published by 1067207b96SArnd Bergmann * the Free Software Foundation; either version 2, or (at your option) 1167207b96SArnd Bergmann * any later version. 1267207b96SArnd Bergmann * 1367207b96SArnd Bergmann * This program is distributed in the hope that it will be useful, 1467207b96SArnd Bergmann * but WITHOUT ANY WARRANTY; without even the implied warranty of 1567207b96SArnd Bergmann * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 1667207b96SArnd Bergmann * GNU General Public License for more details. 1767207b96SArnd Bergmann * 1867207b96SArnd Bergmann * You should have received a copy of the GNU General Public License 1967207b96SArnd Bergmann * along with this program; if not, write to the Free Software 2067207b96SArnd Bergmann * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 2167207b96SArnd Bergmann */ 2267207b96SArnd Bergmann 23a33a7d73SArnd Bergmann #undef DEBUG 24a33a7d73SArnd Bergmann 2567207b96SArnd Bergmann #include <linux/fs.h> 2667207b96SArnd Bergmann #include <linux/ioctl.h> 274b16f8e2SPaul Gortmaker #include <linux/export.h> 28d88cfffaSArnd Bergmann #include <linux/pagemap.h> 2967207b96SArnd Bergmann #include <linux/poll.h> 305110459fSArnd Bergmann #include <linux/ptrace.h> 31cbe709c1SBenjamin Herrenschmidt #include <linux/seq_file.h> 325a0e3ad6STejun Heo #include <linux/slab.h> 3367207b96SArnd Bergmann 3467207b96SArnd Bergmann #include <asm/io.h> 35dfe1e09fSFUJITA Tomonori #include <asm/time.h> 3667207b96SArnd Bergmann #include <asm/spu.h> 37b9e3bd77SDwayne Grant McConnell #include <asm/spu_info.h> 387c0f6ba6SLinus Torvalds #include <linux/uaccess.h> 3967207b96SArnd Bergmann 4067207b96SArnd Bergmann #include "spufs.h" 41ae142e0cSChristoph Hellwig #include "sputrace.h" 4267207b96SArnd Bergmann 4327d5bf2aSBenjamin Herrenschmidt #define SPUFS_MMAP_4K (PAGE_SIZE == 0x1000) 4427d5bf2aSBenjamin Herrenschmidt 45197b1a82SChristoph Hellwig /* Simple attribute files */ 46197b1a82SChristoph Hellwig struct spufs_attr { 47197b1a82SChristoph Hellwig int (*get)(void *, u64 *); 48197b1a82SChristoph Hellwig int (*set)(void *, u64); 49197b1a82SChristoph Hellwig char get_buf[24]; /* enough to store a u64 and "\n\0" */ 50197b1a82SChristoph Hellwig char set_buf[24]; 51197b1a82SChristoph Hellwig void *data; 52197b1a82SChristoph Hellwig const char *fmt; /* format for read operation */ 53197b1a82SChristoph Hellwig struct mutex mutex; /* protects access to these buffers */ 54197b1a82SChristoph Hellwig }; 55197b1a82SChristoph Hellwig 56197b1a82SChristoph Hellwig static int spufs_attr_open(struct inode *inode, struct file *file, 57197b1a82SChristoph Hellwig int (*get)(void *, u64 *), int (*set)(void *, u64), 58197b1a82SChristoph Hellwig const char *fmt) 59197b1a82SChristoph Hellwig { 60197b1a82SChristoph Hellwig struct spufs_attr *attr; 61197b1a82SChristoph Hellwig 62197b1a82SChristoph Hellwig attr = kmalloc(sizeof(*attr), GFP_KERNEL); 63197b1a82SChristoph Hellwig if (!attr) 64197b1a82SChristoph Hellwig return -ENOMEM; 65197b1a82SChristoph Hellwig 66197b1a82SChristoph Hellwig attr->get = get; 67197b1a82SChristoph Hellwig attr->set = set; 68197b1a82SChristoph Hellwig attr->data = inode->i_private; 69197b1a82SChristoph Hellwig attr->fmt = fmt; 70197b1a82SChristoph Hellwig mutex_init(&attr->mutex); 71197b1a82SChristoph Hellwig file->private_data = attr; 72197b1a82SChristoph Hellwig 73197b1a82SChristoph Hellwig return nonseekable_open(inode, file); 74197b1a82SChristoph Hellwig } 75197b1a82SChristoph Hellwig 76197b1a82SChristoph Hellwig static int spufs_attr_release(struct inode *inode, struct file *file) 77197b1a82SChristoph Hellwig { 78197b1a82SChristoph Hellwig kfree(file->private_data); 79197b1a82SChristoph Hellwig return 0; 80197b1a82SChristoph Hellwig } 81197b1a82SChristoph Hellwig 82197b1a82SChristoph Hellwig static ssize_t spufs_attr_read(struct file *file, char __user *buf, 83197b1a82SChristoph Hellwig size_t len, loff_t *ppos) 84197b1a82SChristoph Hellwig { 85197b1a82SChristoph Hellwig struct spufs_attr *attr; 86197b1a82SChristoph Hellwig size_t size; 87197b1a82SChristoph Hellwig ssize_t ret; 88197b1a82SChristoph Hellwig 89197b1a82SChristoph Hellwig attr = file->private_data; 90197b1a82SChristoph Hellwig if (!attr->get) 91197b1a82SChristoph Hellwig return -EACCES; 92197b1a82SChristoph Hellwig 93197b1a82SChristoph Hellwig ret = mutex_lock_interruptible(&attr->mutex); 94197b1a82SChristoph Hellwig if (ret) 95197b1a82SChristoph Hellwig return ret; 96197b1a82SChristoph Hellwig 97197b1a82SChristoph Hellwig if (*ppos) { /* continued read */ 98197b1a82SChristoph Hellwig size = strlen(attr->get_buf); 99197b1a82SChristoph Hellwig } else { /* first read */ 100197b1a82SChristoph Hellwig u64 val; 101197b1a82SChristoph Hellwig ret = attr->get(attr->data, &val); 102197b1a82SChristoph Hellwig if (ret) 103197b1a82SChristoph Hellwig goto out; 104197b1a82SChristoph Hellwig 105197b1a82SChristoph Hellwig size = scnprintf(attr->get_buf, sizeof(attr->get_buf), 106197b1a82SChristoph Hellwig attr->fmt, (unsigned long long)val); 107197b1a82SChristoph Hellwig } 108197b1a82SChristoph Hellwig 109197b1a82SChristoph Hellwig ret = simple_read_from_buffer(buf, len, ppos, attr->get_buf, size); 110197b1a82SChristoph Hellwig out: 111197b1a82SChristoph Hellwig mutex_unlock(&attr->mutex); 112197b1a82SChristoph Hellwig return ret; 113197b1a82SChristoph Hellwig } 114197b1a82SChristoph Hellwig 115197b1a82SChristoph Hellwig static ssize_t spufs_attr_write(struct file *file, const char __user *buf, 116197b1a82SChristoph Hellwig size_t len, loff_t *ppos) 117197b1a82SChristoph Hellwig { 118197b1a82SChristoph Hellwig struct spufs_attr *attr; 119197b1a82SChristoph Hellwig u64 val; 120197b1a82SChristoph Hellwig size_t size; 121197b1a82SChristoph Hellwig ssize_t ret; 122197b1a82SChristoph Hellwig 123197b1a82SChristoph Hellwig attr = file->private_data; 124197b1a82SChristoph Hellwig if (!attr->set) 125197b1a82SChristoph Hellwig return -EACCES; 126197b1a82SChristoph Hellwig 127197b1a82SChristoph Hellwig ret = mutex_lock_interruptible(&attr->mutex); 128197b1a82SChristoph Hellwig if (ret) 129197b1a82SChristoph Hellwig return ret; 130197b1a82SChristoph Hellwig 131197b1a82SChristoph Hellwig ret = -EFAULT; 132197b1a82SChristoph Hellwig size = min(sizeof(attr->set_buf) - 1, len); 133197b1a82SChristoph Hellwig if (copy_from_user(attr->set_buf, buf, size)) 134197b1a82SChristoph Hellwig goto out; 135197b1a82SChristoph Hellwig 136197b1a82SChristoph Hellwig ret = len; /* claim we got the whole input */ 137197b1a82SChristoph Hellwig attr->set_buf[size] = '\0'; 138197b1a82SChristoph Hellwig val = simple_strtol(attr->set_buf, NULL, 0); 139197b1a82SChristoph Hellwig attr->set(attr->data, val); 140197b1a82SChristoph Hellwig out: 141197b1a82SChristoph Hellwig mutex_unlock(&attr->mutex); 142197b1a82SChristoph Hellwig return ret; 143197b1a82SChristoph Hellwig } 144197b1a82SChristoph Hellwig 145197b1a82SChristoph Hellwig #define DEFINE_SPUFS_SIMPLE_ATTRIBUTE(__fops, __get, __set, __fmt) \ 146197b1a82SChristoph Hellwig static int __fops ## _open(struct inode *inode, struct file *file) \ 147197b1a82SChristoph Hellwig { \ 148197b1a82SChristoph Hellwig __simple_attr_check_format(__fmt, 0ull); \ 149197b1a82SChristoph Hellwig return spufs_attr_open(inode, file, __get, __set, __fmt); \ 150197b1a82SChristoph Hellwig } \ 151828c0950SAlexey Dobriyan static const struct file_operations __fops = { \ 152197b1a82SChristoph Hellwig .open = __fops ## _open, \ 153197b1a82SChristoph Hellwig .release = spufs_attr_release, \ 154197b1a82SChristoph Hellwig .read = spufs_attr_read, \ 155197b1a82SChristoph Hellwig .write = spufs_attr_write, \ 156fc15351dSArnd Bergmann .llseek = generic_file_llseek, \ 157197b1a82SChristoph Hellwig }; 158197b1a82SChristoph Hellwig 159cbe709c1SBenjamin Herrenschmidt 16067207b96SArnd Bergmann static int 16167207b96SArnd Bergmann spufs_mem_open(struct inode *inode, struct file *file) 16267207b96SArnd Bergmann { 16367207b96SArnd Bergmann struct spufs_inode_info *i = SPUFS_I(inode); 1646df10a82SMark Nutter struct spu_context *ctx = i->i_ctx; 16543c2bbd9SChristoph Hellwig 16647d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 1676df10a82SMark Nutter file->private_data = ctx; 16843c2bbd9SChristoph Hellwig if (!i->i_openers++) 1696df10a82SMark Nutter ctx->local_store = inode->i_mapping; 17047d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 17143c2bbd9SChristoph Hellwig return 0; 17243c2bbd9SChristoph Hellwig } 17343c2bbd9SChristoph Hellwig 17443c2bbd9SChristoph Hellwig static int 17543c2bbd9SChristoph Hellwig spufs_mem_release(struct inode *inode, struct file *file) 17643c2bbd9SChristoph Hellwig { 17743c2bbd9SChristoph Hellwig struct spufs_inode_info *i = SPUFS_I(inode); 17843c2bbd9SChristoph Hellwig struct spu_context *ctx = i->i_ctx; 17943c2bbd9SChristoph Hellwig 18047d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 18143c2bbd9SChristoph Hellwig if (!--i->i_openers) 18243c2bbd9SChristoph Hellwig ctx->local_store = NULL; 18347d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 18467207b96SArnd Bergmann return 0; 18567207b96SArnd Bergmann } 18667207b96SArnd Bergmann 18767207b96SArnd Bergmann static ssize_t 188bf1ab978SDwayne Grant McConnell __spufs_mem_read(struct spu_context *ctx, char __user *buffer, 189bf1ab978SDwayne Grant McConnell size_t size, loff_t *pos) 190bf1ab978SDwayne Grant McConnell { 191bf1ab978SDwayne Grant McConnell char *local_store = ctx->ops->get_ls(ctx); 192bf1ab978SDwayne Grant McConnell return simple_read_from_buffer(buffer, size, pos, local_store, 193bf1ab978SDwayne Grant McConnell LS_SIZE); 194bf1ab978SDwayne Grant McConnell } 195bf1ab978SDwayne Grant McConnell 196bf1ab978SDwayne Grant McConnell static ssize_t 19767207b96SArnd Bergmann spufs_mem_read(struct file *file, char __user *buffer, 19867207b96SArnd Bergmann size_t size, loff_t *pos) 19967207b96SArnd Bergmann { 200bf1ab978SDwayne Grant McConnell struct spu_context *ctx = file->private_data; 201aa0ed2bdSArnd Bergmann ssize_t ret; 20267207b96SArnd Bergmann 203c9101bdbSChristoph Hellwig ret = spu_acquire(ctx); 204c9101bdbSChristoph Hellwig if (ret) 205c9101bdbSChristoph Hellwig return ret; 206bf1ab978SDwayne Grant McConnell ret = __spufs_mem_read(ctx, buffer, size, pos); 2078b3d6663SArnd Bergmann spu_release(ctx); 208c9101bdbSChristoph Hellwig 20967207b96SArnd Bergmann return ret; 21067207b96SArnd Bergmann } 21167207b96SArnd Bergmann 21267207b96SArnd Bergmann static ssize_t 21367207b96SArnd Bergmann spufs_mem_write(struct file *file, const char __user *buffer, 214aa0ed2bdSArnd Bergmann size_t size, loff_t *ppos) 21567207b96SArnd Bergmann { 21667207b96SArnd Bergmann struct spu_context *ctx = file->private_data; 2178b3d6663SArnd Bergmann char *local_store; 218aa0ed2bdSArnd Bergmann loff_t pos = *ppos; 2198b3d6663SArnd Bergmann int ret; 22067207b96SArnd Bergmann 221aa0ed2bdSArnd Bergmann if (pos > LS_SIZE) 22267207b96SArnd Bergmann return -EFBIG; 2238b3d6663SArnd Bergmann 224c9101bdbSChristoph Hellwig ret = spu_acquire(ctx); 225c9101bdbSChristoph Hellwig if (ret) 226c9101bdbSChristoph Hellwig return ret; 227c9101bdbSChristoph Hellwig 2288b3d6663SArnd Bergmann local_store = ctx->ops->get_ls(ctx); 22963c3b9d7SAkinobu Mita size = simple_write_to_buffer(local_store, LS_SIZE, ppos, buffer, size); 2308b3d6663SArnd Bergmann spu_release(ctx); 231aa0ed2bdSArnd Bergmann 232aa0ed2bdSArnd Bergmann return size; 23367207b96SArnd Bergmann } 23467207b96SArnd Bergmann 235b1e2270fSNick Piggin static int 236b1e2270fSNick Piggin spufs_mem_mmap_fault(struct vm_area_struct *vma, struct vm_fault *vmf) 2378b3d6663SArnd Bergmann { 2388b3d6663SArnd Bergmann struct spu_context *ctx = vma->vm_file->private_data; 239b1e2270fSNick Piggin unsigned long pfn, offset; 240b1e2270fSNick Piggin 241b1e2270fSNick Piggin offset = vmf->pgoff << PAGE_SHIFT; 242128b8546SMasato Noguchi if (offset >= LS_SIZE) 243b1e2270fSNick Piggin return VM_FAULT_SIGBUS; 244128b8546SMasato Noguchi 245b1e2270fSNick Piggin pr_debug("spufs_mem_mmap_fault address=0x%lx, offset=0x%lx\n", 2461a29d85eSJan Kara vmf->address, offset); 247f1fa74f4SBenjamin Herrenschmidt 248c9101bdbSChristoph Hellwig if (spu_acquire(ctx)) 249b1e2270fSNick Piggin return VM_FAULT_NOPAGE; 2508b3d6663SArnd Bergmann 251ac91cb8dSArnd Bergmann if (ctx->state == SPU_STATE_SAVED) { 25264b3d0e8SBenjamin Herrenschmidt vma->vm_page_prot = pgprot_cached(vma->vm_page_prot); 25378bde53eSBenjamin Herrenschmidt pfn = vmalloc_to_pfn(ctx->csa.lscsa->ls + offset); 254ac91cb8dSArnd Bergmann } else { 25564b3d0e8SBenjamin Herrenschmidt vma->vm_page_prot = pgprot_noncached_wc(vma->vm_page_prot); 25678bde53eSBenjamin Herrenschmidt pfn = (ctx->spu->local_store_phys + offset) >> PAGE_SHIFT; 257ac91cb8dSArnd Bergmann } 2581a29d85eSJan Kara vm_insert_pfn(vma, vmf->address, pfn); 25978bde53eSBenjamin Herrenschmidt 2608b3d6663SArnd Bergmann spu_release(ctx); 2618b3d6663SArnd Bergmann 262b1e2270fSNick Piggin return VM_FAULT_NOPAGE; 2638b3d6663SArnd Bergmann } 2648b3d6663SArnd Bergmann 265a352894dSBenjamin Herrenschmidt static int spufs_mem_mmap_access(struct vm_area_struct *vma, 266a352894dSBenjamin Herrenschmidt unsigned long address, 267a352894dSBenjamin Herrenschmidt void *buf, int len, int write) 268a352894dSBenjamin Herrenschmidt { 269a352894dSBenjamin Herrenschmidt struct spu_context *ctx = vma->vm_file->private_data; 270a352894dSBenjamin Herrenschmidt unsigned long offset = address - vma->vm_start; 271a352894dSBenjamin Herrenschmidt char *local_store; 272a352894dSBenjamin Herrenschmidt 273a352894dSBenjamin Herrenschmidt if (write && !(vma->vm_flags & VM_WRITE)) 274a352894dSBenjamin Herrenschmidt return -EACCES; 275a352894dSBenjamin Herrenschmidt if (spu_acquire(ctx)) 276a352894dSBenjamin Herrenschmidt return -EINTR; 277a352894dSBenjamin Herrenschmidt if ((offset + len) > vma->vm_end) 278a352894dSBenjamin Herrenschmidt len = vma->vm_end - offset; 279a352894dSBenjamin Herrenschmidt local_store = ctx->ops->get_ls(ctx); 280a352894dSBenjamin Herrenschmidt if (write) 281a352894dSBenjamin Herrenschmidt memcpy_toio(local_store + offset, buf, len); 282a352894dSBenjamin Herrenschmidt else 283a352894dSBenjamin Herrenschmidt memcpy_fromio(buf, local_store + offset, len); 284a352894dSBenjamin Herrenschmidt spu_release(ctx); 285a352894dSBenjamin Herrenschmidt return len; 286a352894dSBenjamin Herrenschmidt } 28778bde53eSBenjamin Herrenschmidt 288f0f37e2fSAlexey Dobriyan static const struct vm_operations_struct spufs_mem_mmap_vmops = { 289b1e2270fSNick Piggin .fault = spufs_mem_mmap_fault, 290a352894dSBenjamin Herrenschmidt .access = spufs_mem_mmap_access, 2918b3d6663SArnd Bergmann }; 2928b3d6663SArnd Bergmann 293f1fa74f4SBenjamin Herrenschmidt static int spufs_mem_mmap(struct file *file, struct vm_area_struct *vma) 29467207b96SArnd Bergmann { 2958b3d6663SArnd Bergmann if (!(vma->vm_flags & VM_SHARED)) 2968b3d6663SArnd Bergmann return -EINVAL; 29767207b96SArnd Bergmann 29878bde53eSBenjamin Herrenschmidt vma->vm_flags |= VM_IO | VM_PFNMAP; 29964b3d0e8SBenjamin Herrenschmidt vma->vm_page_prot = pgprot_noncached_wc(vma->vm_page_prot); 3008b3d6663SArnd Bergmann 3018b3d6663SArnd Bergmann vma->vm_ops = &spufs_mem_mmap_vmops; 30267207b96SArnd Bergmann return 0; 30367207b96SArnd Bergmann } 30467207b96SArnd Bergmann 3055dfe4c96SArjan van de Ven static const struct file_operations spufs_mem_fops = { 30667207b96SArnd Bergmann .open = spufs_mem_open, 307ce92987bSChristoph Hellwig .release = spufs_mem_release, 30867207b96SArnd Bergmann .read = spufs_mem_read, 30967207b96SArnd Bergmann .write = spufs_mem_write, 3108b3d6663SArnd Bergmann .llseek = generic_file_llseek, 31167207b96SArnd Bergmann .mmap = spufs_mem_mmap, 3128b3d6663SArnd Bergmann }; 3138b3d6663SArnd Bergmann 314b1e2270fSNick Piggin static int spufs_ps_fault(struct vm_area_struct *vma, 315b1e2270fSNick Piggin struct vm_fault *vmf, 31678bde53eSBenjamin Herrenschmidt unsigned long ps_offs, 31727d5bf2aSBenjamin Herrenschmidt unsigned long ps_size) 3186df10a82SMark Nutter { 3196df10a82SMark Nutter struct spu_context *ctx = vma->vm_file->private_data; 320b1e2270fSNick Piggin unsigned long area, offset = vmf->pgoff << PAGE_SHIFT; 321eebead5bSChristoph Hellwig int ret = 0; 3226df10a82SMark Nutter 323b1e2270fSNick Piggin spu_context_nospu_trace(spufs_ps_fault__enter, ctx); 324038200cfSChristoph Hellwig 32527d5bf2aSBenjamin Herrenschmidt if (offset >= ps_size) 326b1e2270fSNick Piggin return VM_FAULT_SIGBUS; 3276df10a82SMark Nutter 32860657263SJeremy Kerr if (fatal_signal_pending(current)) 32960657263SJeremy Kerr return VM_FAULT_SIGBUS; 33060657263SJeremy Kerr 33133bfd7a7SArnd Bergmann /* 332d5883137SJeremy Kerr * Because we release the mmap_sem, the context may be destroyed while 333d5883137SJeremy Kerr * we're in spu_wait. Grab an extra reference so it isn't destroyed 334d5883137SJeremy Kerr * in the meantime. 335d5883137SJeremy Kerr */ 336d5883137SJeremy Kerr get_spu_context(ctx); 337d5883137SJeremy Kerr 338d5883137SJeremy Kerr /* 33933bfd7a7SArnd Bergmann * We have to wait for context to be loaded before we have 34033bfd7a7SArnd Bergmann * pages to hand out to the user, but we don't want to wait 34133bfd7a7SArnd Bergmann * with the mmap_sem held. 34233bfd7a7SArnd Bergmann * It is possible to drop the mmap_sem here, but then we need 343b1e2270fSNick Piggin * to return VM_FAULT_NOPAGE because the mappings may have 34433bfd7a7SArnd Bergmann * hanged. 34578bde53eSBenjamin Herrenschmidt */ 346c9101bdbSChristoph Hellwig if (spu_acquire(ctx)) 347d5883137SJeremy Kerr goto refault; 348c9101bdbSChristoph Hellwig 34933bfd7a7SArnd Bergmann if (ctx->state == SPU_STATE_SAVED) { 35033bfd7a7SArnd Bergmann up_read(¤t->mm->mmap_sem); 351b1e2270fSNick Piggin spu_context_nospu_trace(spufs_ps_fault__sleep, ctx); 352eebead5bSChristoph Hellwig ret = spufs_wait(ctx->run_wq, ctx->state == SPU_STATE_RUNNABLE); 353b1e2270fSNick Piggin spu_context_trace(spufs_ps_fault__wake, ctx, ctx->spu); 35433bfd7a7SArnd Bergmann down_read(¤t->mm->mmap_sem); 355c9101bdbSChristoph Hellwig } else { 3566df10a82SMark Nutter area = ctx->spu->problem_phys + ps_offs; 3571a29d85eSJan Kara vm_insert_pfn(vma, vmf->address, (area + offset) >> PAGE_SHIFT); 358b1e2270fSNick Piggin spu_context_trace(spufs_ps_fault__insert, ctx, ctx->spu); 359c9101bdbSChristoph Hellwig } 36033bfd7a7SArnd Bergmann 361eebead5bSChristoph Hellwig if (!ret) 3626df10a82SMark Nutter spu_release(ctx); 363d5883137SJeremy Kerr 364d5883137SJeremy Kerr refault: 365d5883137SJeremy Kerr put_spu_context(ctx); 366b1e2270fSNick Piggin return VM_FAULT_NOPAGE; 3676df10a82SMark Nutter } 3686df10a82SMark Nutter 36927d5bf2aSBenjamin Herrenschmidt #if SPUFS_MMAP_4K 370b1e2270fSNick Piggin static int spufs_cntl_mmap_fault(struct vm_area_struct *vma, 371b1e2270fSNick Piggin struct vm_fault *vmf) 3726df10a82SMark Nutter { 37387ff6090SJeremy Kerr return spufs_ps_fault(vma, vmf, 0x4000, SPUFS_CNTL_MAP_SIZE); 3746df10a82SMark Nutter } 3756df10a82SMark Nutter 376f0f37e2fSAlexey Dobriyan static const struct vm_operations_struct spufs_cntl_mmap_vmops = { 377b1e2270fSNick Piggin .fault = spufs_cntl_mmap_fault, 3786df10a82SMark Nutter }; 3796df10a82SMark Nutter 3806df10a82SMark Nutter /* 3816df10a82SMark Nutter * mmap support for problem state control area [0x4000 - 0x4fff]. 3826df10a82SMark Nutter */ 3836df10a82SMark Nutter static int spufs_cntl_mmap(struct file *file, struct vm_area_struct *vma) 3846df10a82SMark Nutter { 3856df10a82SMark Nutter if (!(vma->vm_flags & VM_SHARED)) 3866df10a82SMark Nutter return -EINVAL; 3876df10a82SMark Nutter 38878bde53eSBenjamin Herrenschmidt vma->vm_flags |= VM_IO | VM_PFNMAP; 38964b3d0e8SBenjamin Herrenschmidt vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot); 3906df10a82SMark Nutter 3916df10a82SMark Nutter vma->vm_ops = &spufs_cntl_mmap_vmops; 3926df10a82SMark Nutter return 0; 3936df10a82SMark Nutter } 39427d5bf2aSBenjamin Herrenschmidt #else /* SPUFS_MMAP_4K */ 39527d5bf2aSBenjamin Herrenschmidt #define spufs_cntl_mmap NULL 39627d5bf2aSBenjamin Herrenschmidt #endif /* !SPUFS_MMAP_4K */ 3976df10a82SMark Nutter 398197b1a82SChristoph Hellwig static int spufs_cntl_get(void *data, u64 *val) 399e1dbff2bSArnd Bergmann { 400e1dbff2bSArnd Bergmann struct spu_context *ctx = data; 401c9101bdbSChristoph Hellwig int ret; 402e1dbff2bSArnd Bergmann 403c9101bdbSChristoph Hellwig ret = spu_acquire(ctx); 404c9101bdbSChristoph Hellwig if (ret) 405c9101bdbSChristoph Hellwig return ret; 406197b1a82SChristoph Hellwig *val = ctx->ops->status_read(ctx); 407e1dbff2bSArnd Bergmann spu_release(ctx); 408e1dbff2bSArnd Bergmann 409197b1a82SChristoph Hellwig return 0; 410e1dbff2bSArnd Bergmann } 411e1dbff2bSArnd Bergmann 412197b1a82SChristoph Hellwig static int spufs_cntl_set(void *data, u64 val) 413e1dbff2bSArnd Bergmann { 414e1dbff2bSArnd Bergmann struct spu_context *ctx = data; 415c9101bdbSChristoph Hellwig int ret; 416e1dbff2bSArnd Bergmann 417c9101bdbSChristoph Hellwig ret = spu_acquire(ctx); 418c9101bdbSChristoph Hellwig if (ret) 419c9101bdbSChristoph Hellwig return ret; 420e1dbff2bSArnd Bergmann ctx->ops->runcntl_write(ctx, val); 421e1dbff2bSArnd Bergmann spu_release(ctx); 422197b1a82SChristoph Hellwig 423197b1a82SChristoph Hellwig return 0; 424e1dbff2bSArnd Bergmann } 425e1dbff2bSArnd Bergmann 4266df10a82SMark Nutter static int spufs_cntl_open(struct inode *inode, struct file *file) 4276df10a82SMark Nutter { 4286df10a82SMark Nutter struct spufs_inode_info *i = SPUFS_I(inode); 4296df10a82SMark Nutter struct spu_context *ctx = i->i_ctx; 4306df10a82SMark Nutter 43147d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 4326df10a82SMark Nutter file->private_data = ctx; 43343c2bbd9SChristoph Hellwig if (!i->i_openers++) 4346df10a82SMark Nutter ctx->cntl = inode->i_mapping; 43547d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 4368b88b099SChristoph Hellwig return simple_attr_open(inode, file, spufs_cntl_get, 437e1dbff2bSArnd Bergmann spufs_cntl_set, "0x%08lx"); 4386df10a82SMark Nutter } 4396df10a82SMark Nutter 44043c2bbd9SChristoph Hellwig static int 44143c2bbd9SChristoph Hellwig spufs_cntl_release(struct inode *inode, struct file *file) 44243c2bbd9SChristoph Hellwig { 44343c2bbd9SChristoph Hellwig struct spufs_inode_info *i = SPUFS_I(inode); 44443c2bbd9SChristoph Hellwig struct spu_context *ctx = i->i_ctx; 44543c2bbd9SChristoph Hellwig 44674bedc4dSChristoph Hellwig simple_attr_release(inode, file); 44743c2bbd9SChristoph Hellwig 44847d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 44943c2bbd9SChristoph Hellwig if (!--i->i_openers) 45043c2bbd9SChristoph Hellwig ctx->cntl = NULL; 45147d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 45243c2bbd9SChristoph Hellwig return 0; 45343c2bbd9SChristoph Hellwig } 45443c2bbd9SChristoph Hellwig 4555dfe4c96SArjan van de Ven static const struct file_operations spufs_cntl_fops = { 4566df10a82SMark Nutter .open = spufs_cntl_open, 45743c2bbd9SChristoph Hellwig .release = spufs_cntl_release, 4588b88b099SChristoph Hellwig .read = simple_attr_read, 4598b88b099SChristoph Hellwig .write = simple_attr_write, 460fc15351dSArnd Bergmann .llseek = generic_file_llseek, 4616df10a82SMark Nutter .mmap = spufs_cntl_mmap, 4626df10a82SMark Nutter }; 4636df10a82SMark Nutter 4648b3d6663SArnd Bergmann static int 4658b3d6663SArnd Bergmann spufs_regs_open(struct inode *inode, struct file *file) 4668b3d6663SArnd Bergmann { 4678b3d6663SArnd Bergmann struct spufs_inode_info *i = SPUFS_I(inode); 4688b3d6663SArnd Bergmann file->private_data = i->i_ctx; 4698b3d6663SArnd Bergmann return 0; 4708b3d6663SArnd Bergmann } 4718b3d6663SArnd Bergmann 4728b3d6663SArnd Bergmann static ssize_t 473bf1ab978SDwayne Grant McConnell __spufs_regs_read(struct spu_context *ctx, char __user *buffer, 474bf1ab978SDwayne Grant McConnell size_t size, loff_t *pos) 475bf1ab978SDwayne Grant McConnell { 476bf1ab978SDwayne Grant McConnell struct spu_lscsa *lscsa = ctx->csa.lscsa; 477bf1ab978SDwayne Grant McConnell return simple_read_from_buffer(buffer, size, pos, 478bf1ab978SDwayne Grant McConnell lscsa->gprs, sizeof lscsa->gprs); 479bf1ab978SDwayne Grant McConnell } 480bf1ab978SDwayne Grant McConnell 481bf1ab978SDwayne Grant McConnell static ssize_t 4828b3d6663SArnd Bergmann spufs_regs_read(struct file *file, char __user *buffer, 4838b3d6663SArnd Bergmann size_t size, loff_t *pos) 4848b3d6663SArnd Bergmann { 4858b3d6663SArnd Bergmann int ret; 486bf1ab978SDwayne Grant McConnell struct spu_context *ctx = file->private_data; 4878b3d6663SArnd Bergmann 488f027faa2SJeremy Kerr /* pre-check for file position: if we'd return EOF, there's no point 489f027faa2SJeremy Kerr * causing a deschedule */ 490f027faa2SJeremy Kerr if (*pos >= sizeof(ctx->csa.lscsa->gprs)) 491f027faa2SJeremy Kerr return 0; 492f027faa2SJeremy Kerr 493c9101bdbSChristoph Hellwig ret = spu_acquire_saved(ctx); 494c9101bdbSChristoph Hellwig if (ret) 495c9101bdbSChristoph Hellwig return ret; 496bf1ab978SDwayne Grant McConnell ret = __spufs_regs_read(ctx, buffer, size, pos); 49727b1ea09SChristoph Hellwig spu_release_saved(ctx); 4988b3d6663SArnd Bergmann return ret; 4998b3d6663SArnd Bergmann } 5008b3d6663SArnd Bergmann 5018b3d6663SArnd Bergmann static ssize_t 5028b3d6663SArnd Bergmann spufs_regs_write(struct file *file, const char __user *buffer, 5038b3d6663SArnd Bergmann size_t size, loff_t *pos) 5048b3d6663SArnd Bergmann { 5058b3d6663SArnd Bergmann struct spu_context *ctx = file->private_data; 5068b3d6663SArnd Bergmann struct spu_lscsa *lscsa = ctx->csa.lscsa; 5078b3d6663SArnd Bergmann int ret; 5088b3d6663SArnd Bergmann 509d219889bSJeremy Kerr if (*pos >= sizeof(lscsa->gprs)) 5108b3d6663SArnd Bergmann return -EFBIG; 511d219889bSJeremy Kerr 512c9101bdbSChristoph Hellwig ret = spu_acquire_saved(ctx); 513c9101bdbSChristoph Hellwig if (ret) 514c9101bdbSChristoph Hellwig return ret; 5158b3d6663SArnd Bergmann 51663c3b9d7SAkinobu Mita size = simple_write_to_buffer(lscsa->gprs, sizeof(lscsa->gprs), pos, 51763c3b9d7SAkinobu Mita buffer, size); 5188b3d6663SArnd Bergmann 51927b1ea09SChristoph Hellwig spu_release_saved(ctx); 52063c3b9d7SAkinobu Mita return size; 5218b3d6663SArnd Bergmann } 5228b3d6663SArnd Bergmann 5235dfe4c96SArjan van de Ven static const struct file_operations spufs_regs_fops = { 5248b3d6663SArnd Bergmann .open = spufs_regs_open, 5258b3d6663SArnd Bergmann .read = spufs_regs_read, 5268b3d6663SArnd Bergmann .write = spufs_regs_write, 5278b3d6663SArnd Bergmann .llseek = generic_file_llseek, 5288b3d6663SArnd Bergmann }; 5298b3d6663SArnd Bergmann 5308b3d6663SArnd Bergmann static ssize_t 531bf1ab978SDwayne Grant McConnell __spufs_fpcr_read(struct spu_context *ctx, char __user * buffer, 532bf1ab978SDwayne Grant McConnell size_t size, loff_t * pos) 533bf1ab978SDwayne Grant McConnell { 534bf1ab978SDwayne Grant McConnell struct spu_lscsa *lscsa = ctx->csa.lscsa; 535bf1ab978SDwayne Grant McConnell return simple_read_from_buffer(buffer, size, pos, 536bf1ab978SDwayne Grant McConnell &lscsa->fpcr, sizeof(lscsa->fpcr)); 537bf1ab978SDwayne Grant McConnell } 538bf1ab978SDwayne Grant McConnell 539bf1ab978SDwayne Grant McConnell static ssize_t 5408b3d6663SArnd Bergmann spufs_fpcr_read(struct file *file, char __user * buffer, 5418b3d6663SArnd Bergmann size_t size, loff_t * pos) 5428b3d6663SArnd Bergmann { 5438b3d6663SArnd Bergmann int ret; 544bf1ab978SDwayne Grant McConnell struct spu_context *ctx = file->private_data; 5458b3d6663SArnd Bergmann 546c9101bdbSChristoph Hellwig ret = spu_acquire_saved(ctx); 547c9101bdbSChristoph Hellwig if (ret) 548c9101bdbSChristoph Hellwig return ret; 549bf1ab978SDwayne Grant McConnell ret = __spufs_fpcr_read(ctx, buffer, size, pos); 55027b1ea09SChristoph Hellwig spu_release_saved(ctx); 5518b3d6663SArnd Bergmann return ret; 5528b3d6663SArnd Bergmann } 5538b3d6663SArnd Bergmann 5548b3d6663SArnd Bergmann static ssize_t 5558b3d6663SArnd Bergmann spufs_fpcr_write(struct file *file, const char __user * buffer, 5568b3d6663SArnd Bergmann size_t size, loff_t * pos) 5578b3d6663SArnd Bergmann { 5588b3d6663SArnd Bergmann struct spu_context *ctx = file->private_data; 5598b3d6663SArnd Bergmann struct spu_lscsa *lscsa = ctx->csa.lscsa; 5608b3d6663SArnd Bergmann int ret; 5618b3d6663SArnd Bergmann 562d219889bSJeremy Kerr if (*pos >= sizeof(lscsa->fpcr)) 5638b3d6663SArnd Bergmann return -EFBIG; 564c9101bdbSChristoph Hellwig 565c9101bdbSChristoph Hellwig ret = spu_acquire_saved(ctx); 566c9101bdbSChristoph Hellwig if (ret) 567c9101bdbSChristoph Hellwig return ret; 568c9101bdbSChristoph Hellwig 56963c3b9d7SAkinobu Mita size = simple_write_to_buffer(&lscsa->fpcr, sizeof(lscsa->fpcr), pos, 57063c3b9d7SAkinobu Mita buffer, size); 5718b3d6663SArnd Bergmann 57227b1ea09SChristoph Hellwig spu_release_saved(ctx); 57363c3b9d7SAkinobu Mita return size; 5748b3d6663SArnd Bergmann } 5758b3d6663SArnd Bergmann 5765dfe4c96SArjan van de Ven static const struct file_operations spufs_fpcr_fops = { 5778b3d6663SArnd Bergmann .open = spufs_regs_open, 5788b3d6663SArnd Bergmann .read = spufs_fpcr_read, 5798b3d6663SArnd Bergmann .write = spufs_fpcr_write, 58067207b96SArnd Bergmann .llseek = generic_file_llseek, 58167207b96SArnd Bergmann }; 58267207b96SArnd Bergmann 58367207b96SArnd Bergmann /* generic open function for all pipe-like files */ 58467207b96SArnd Bergmann static int spufs_pipe_open(struct inode *inode, struct file *file) 58567207b96SArnd Bergmann { 58667207b96SArnd Bergmann struct spufs_inode_info *i = SPUFS_I(inode); 58767207b96SArnd Bergmann file->private_data = i->i_ctx; 58867207b96SArnd Bergmann 58967207b96SArnd Bergmann return nonseekable_open(inode, file); 59067207b96SArnd Bergmann } 59167207b96SArnd Bergmann 592cdcc89bbSArnd Bergmann /* 593cdcc89bbSArnd Bergmann * Read as many bytes from the mailbox as possible, until 594cdcc89bbSArnd Bergmann * one of the conditions becomes true: 595cdcc89bbSArnd Bergmann * 596cdcc89bbSArnd Bergmann * - no more data available in the mailbox 597cdcc89bbSArnd Bergmann * - end of the user provided buffer 598cdcc89bbSArnd Bergmann * - end of the mapped area 599cdcc89bbSArnd Bergmann */ 60067207b96SArnd Bergmann static ssize_t spufs_mbox_read(struct file *file, char __user *buf, 60167207b96SArnd Bergmann size_t len, loff_t *pos) 60267207b96SArnd Bergmann { 6038b3d6663SArnd Bergmann struct spu_context *ctx = file->private_data; 604cdcc89bbSArnd Bergmann u32 mbox_data, __user *udata; 605cdcc89bbSArnd Bergmann ssize_t count; 60667207b96SArnd Bergmann 60767207b96SArnd Bergmann if (len < 4) 60867207b96SArnd Bergmann return -EINVAL; 60967207b96SArnd Bergmann 610cdcc89bbSArnd Bergmann if (!access_ok(VERIFY_WRITE, buf, len)) 61167207b96SArnd Bergmann return -EFAULT; 61267207b96SArnd Bergmann 613cdcc89bbSArnd Bergmann udata = (void __user *)buf; 614cdcc89bbSArnd Bergmann 615c9101bdbSChristoph Hellwig count = spu_acquire(ctx); 616c9101bdbSChristoph Hellwig if (count) 617c9101bdbSChristoph Hellwig return count; 618c9101bdbSChristoph Hellwig 619274cef5eSArnd Bergmann for (count = 0; (count + 4) <= len; count += 4, udata++) { 620cdcc89bbSArnd Bergmann int ret; 621cdcc89bbSArnd Bergmann ret = ctx->ops->mbox_read(ctx, &mbox_data); 622cdcc89bbSArnd Bergmann if (ret == 0) 623cdcc89bbSArnd Bergmann break; 624cdcc89bbSArnd Bergmann 625cdcc89bbSArnd Bergmann /* 626cdcc89bbSArnd Bergmann * at the end of the mapped area, we can fault 627cdcc89bbSArnd Bergmann * but still need to return the data we have 628cdcc89bbSArnd Bergmann * read successfully so far. 629cdcc89bbSArnd Bergmann */ 630cdcc89bbSArnd Bergmann ret = __put_user(mbox_data, udata); 631cdcc89bbSArnd Bergmann if (ret) { 632cdcc89bbSArnd Bergmann if (!count) 633cdcc89bbSArnd Bergmann count = -EFAULT; 634cdcc89bbSArnd Bergmann break; 635cdcc89bbSArnd Bergmann } 636cdcc89bbSArnd Bergmann } 637cdcc89bbSArnd Bergmann spu_release(ctx); 638cdcc89bbSArnd Bergmann 639cdcc89bbSArnd Bergmann if (!count) 640cdcc89bbSArnd Bergmann count = -EAGAIN; 641cdcc89bbSArnd Bergmann 642cdcc89bbSArnd Bergmann return count; 64367207b96SArnd Bergmann } 64467207b96SArnd Bergmann 6455dfe4c96SArjan van de Ven static const struct file_operations spufs_mbox_fops = { 64667207b96SArnd Bergmann .open = spufs_pipe_open, 64767207b96SArnd Bergmann .read = spufs_mbox_read, 648fc15351dSArnd Bergmann .llseek = no_llseek, 64967207b96SArnd Bergmann }; 65067207b96SArnd Bergmann 65167207b96SArnd Bergmann static ssize_t spufs_mbox_stat_read(struct file *file, char __user *buf, 65267207b96SArnd Bergmann size_t len, loff_t *pos) 65367207b96SArnd Bergmann { 6548b3d6663SArnd Bergmann struct spu_context *ctx = file->private_data; 655c9101bdbSChristoph Hellwig ssize_t ret; 65667207b96SArnd Bergmann u32 mbox_stat; 65767207b96SArnd Bergmann 65867207b96SArnd Bergmann if (len < 4) 65967207b96SArnd Bergmann return -EINVAL; 66067207b96SArnd Bergmann 661c9101bdbSChristoph Hellwig ret = spu_acquire(ctx); 662c9101bdbSChristoph Hellwig if (ret) 663c9101bdbSChristoph Hellwig return ret; 6648b3d6663SArnd Bergmann 6658b3d6663SArnd Bergmann mbox_stat = ctx->ops->mbox_stat_read(ctx) & 0xff; 6668b3d6663SArnd Bergmann 6678b3d6663SArnd Bergmann spu_release(ctx); 66867207b96SArnd Bergmann 66967207b96SArnd Bergmann if (copy_to_user(buf, &mbox_stat, sizeof mbox_stat)) 67067207b96SArnd Bergmann return -EFAULT; 67167207b96SArnd Bergmann 67267207b96SArnd Bergmann return 4; 67367207b96SArnd Bergmann } 67467207b96SArnd Bergmann 6755dfe4c96SArjan van de Ven static const struct file_operations spufs_mbox_stat_fops = { 67667207b96SArnd Bergmann .open = spufs_pipe_open, 67767207b96SArnd Bergmann .read = spufs_mbox_stat_read, 678fc15351dSArnd Bergmann .llseek = no_llseek, 67967207b96SArnd Bergmann }; 68067207b96SArnd Bergmann 68167207b96SArnd Bergmann /* low-level ibox access function */ 6828b3d6663SArnd Bergmann size_t spu_ibox_read(struct spu_context *ctx, u32 *data) 68367207b96SArnd Bergmann { 6848b3d6663SArnd Bergmann return ctx->ops->ibox_read(ctx, data); 68567207b96SArnd Bergmann } 68667207b96SArnd Bergmann 6878b3d6663SArnd Bergmann /* interrupt-level ibox callback function. */ 6888b3d6663SArnd Bergmann void spufs_ibox_callback(struct spu *spu) 6898b3d6663SArnd Bergmann { 6908b3d6663SArnd Bergmann struct spu_context *ctx = spu->ctx; 6918b3d6663SArnd Bergmann 6927d7be3aaSAl Viro if (ctx) 6938b3d6663SArnd Bergmann wake_up_all(&ctx->ibox_wq); 69467207b96SArnd Bergmann } 69567207b96SArnd Bergmann 696cdcc89bbSArnd Bergmann /* 697cdcc89bbSArnd Bergmann * Read as many bytes from the interrupt mailbox as possible, until 698cdcc89bbSArnd Bergmann * one of the conditions becomes true: 699cdcc89bbSArnd Bergmann * 700cdcc89bbSArnd Bergmann * - no more data available in the mailbox 701cdcc89bbSArnd Bergmann * - end of the user provided buffer 702cdcc89bbSArnd Bergmann * - end of the mapped area 703cdcc89bbSArnd Bergmann * 704cdcc89bbSArnd Bergmann * If the file is opened without O_NONBLOCK, we wait here until 705cdcc89bbSArnd Bergmann * any data is available, but return when we have been able to 706cdcc89bbSArnd Bergmann * read something. 707cdcc89bbSArnd Bergmann */ 70867207b96SArnd Bergmann static ssize_t spufs_ibox_read(struct file *file, char __user *buf, 70967207b96SArnd Bergmann size_t len, loff_t *pos) 71067207b96SArnd Bergmann { 7118b3d6663SArnd Bergmann struct spu_context *ctx = file->private_data; 712cdcc89bbSArnd Bergmann u32 ibox_data, __user *udata; 713cdcc89bbSArnd Bergmann ssize_t count; 71467207b96SArnd Bergmann 71567207b96SArnd Bergmann if (len < 4) 71667207b96SArnd Bergmann return -EINVAL; 71767207b96SArnd Bergmann 718cdcc89bbSArnd Bergmann if (!access_ok(VERIFY_WRITE, buf, len)) 719cdcc89bbSArnd Bergmann return -EFAULT; 720cdcc89bbSArnd Bergmann 721cdcc89bbSArnd Bergmann udata = (void __user *)buf; 722cdcc89bbSArnd Bergmann 723c9101bdbSChristoph Hellwig count = spu_acquire(ctx); 724c9101bdbSChristoph Hellwig if (count) 725eebead5bSChristoph Hellwig goto out; 72667207b96SArnd Bergmann 727cdcc89bbSArnd Bergmann /* wait only for the first element */ 728cdcc89bbSArnd Bergmann count = 0; 72967207b96SArnd Bergmann if (file->f_flags & O_NONBLOCK) { 730eebead5bSChristoph Hellwig if (!spu_ibox_read(ctx, &ibox_data)) { 731cdcc89bbSArnd Bergmann count = -EAGAIN; 732eebead5bSChristoph Hellwig goto out_unlock; 733eebead5bSChristoph Hellwig } 73467207b96SArnd Bergmann } else { 735cdcc89bbSArnd Bergmann count = spufs_wait(ctx->ibox_wq, spu_ibox_read(ctx, &ibox_data)); 736cdcc89bbSArnd Bergmann if (count) 737cdcc89bbSArnd Bergmann goto out; 738eebead5bSChristoph Hellwig } 739cdcc89bbSArnd Bergmann 740cdcc89bbSArnd Bergmann /* if we can't write at all, return -EFAULT */ 741cdcc89bbSArnd Bergmann count = __put_user(ibox_data, udata); 742cdcc89bbSArnd Bergmann if (count) 743eebead5bSChristoph Hellwig goto out_unlock; 744cdcc89bbSArnd Bergmann 745cdcc89bbSArnd Bergmann for (count = 4, udata++; (count + 4) <= len; count += 4, udata++) { 746cdcc89bbSArnd Bergmann int ret; 747cdcc89bbSArnd Bergmann ret = ctx->ops->ibox_read(ctx, &ibox_data); 748cdcc89bbSArnd Bergmann if (ret == 0) 749cdcc89bbSArnd Bergmann break; 750cdcc89bbSArnd Bergmann /* 751cdcc89bbSArnd Bergmann * at the end of the mapped area, we can fault 752cdcc89bbSArnd Bergmann * but still need to return the data we have 753cdcc89bbSArnd Bergmann * read successfully so far. 754cdcc89bbSArnd Bergmann */ 755cdcc89bbSArnd Bergmann ret = __put_user(ibox_data, udata); 756cdcc89bbSArnd Bergmann if (ret) 757cdcc89bbSArnd Bergmann break; 75867207b96SArnd Bergmann } 75967207b96SArnd Bergmann 760eebead5bSChristoph Hellwig out_unlock: 7618b3d6663SArnd Bergmann spu_release(ctx); 762eebead5bSChristoph Hellwig out: 763cdcc89bbSArnd Bergmann return count; 76467207b96SArnd Bergmann } 76567207b96SArnd Bergmann 76667207b96SArnd Bergmann static unsigned int spufs_ibox_poll(struct file *file, poll_table *wait) 76767207b96SArnd Bergmann { 7688b3d6663SArnd Bergmann struct spu_context *ctx = file->private_data; 76967207b96SArnd Bergmann unsigned int mask; 77067207b96SArnd Bergmann 7718b3d6663SArnd Bergmann poll_wait(file, &ctx->ibox_wq, wait); 77267207b96SArnd Bergmann 773c9101bdbSChristoph Hellwig /* 774c9101bdbSChristoph Hellwig * For now keep this uninterruptible and also ignore the rule 775c9101bdbSChristoph Hellwig * that poll should not sleep. Will be fixed later. 776c9101bdbSChristoph Hellwig */ 777c9101bdbSChristoph Hellwig mutex_lock(&ctx->state_mutex); 7783a843d7cSArnd Bergmann mask = ctx->ops->mbox_stat_poll(ctx, POLLIN | POLLRDNORM); 7793a843d7cSArnd Bergmann spu_release(ctx); 78067207b96SArnd Bergmann 78167207b96SArnd Bergmann return mask; 78267207b96SArnd Bergmann } 78367207b96SArnd Bergmann 7845dfe4c96SArjan van de Ven static const struct file_operations spufs_ibox_fops = { 78567207b96SArnd Bergmann .open = spufs_pipe_open, 78667207b96SArnd Bergmann .read = spufs_ibox_read, 78767207b96SArnd Bergmann .poll = spufs_ibox_poll, 788fc15351dSArnd Bergmann .llseek = no_llseek, 78967207b96SArnd Bergmann }; 79067207b96SArnd Bergmann 79167207b96SArnd Bergmann static ssize_t spufs_ibox_stat_read(struct file *file, char __user *buf, 79267207b96SArnd Bergmann size_t len, loff_t *pos) 79367207b96SArnd Bergmann { 7948b3d6663SArnd Bergmann struct spu_context *ctx = file->private_data; 795c9101bdbSChristoph Hellwig ssize_t ret; 79667207b96SArnd Bergmann u32 ibox_stat; 79767207b96SArnd Bergmann 79867207b96SArnd Bergmann if (len < 4) 79967207b96SArnd Bergmann return -EINVAL; 80067207b96SArnd Bergmann 801c9101bdbSChristoph Hellwig ret = spu_acquire(ctx); 802c9101bdbSChristoph Hellwig if (ret) 803c9101bdbSChristoph Hellwig return ret; 8048b3d6663SArnd Bergmann ibox_stat = (ctx->ops->mbox_stat_read(ctx) >> 16) & 0xff; 8058b3d6663SArnd Bergmann spu_release(ctx); 80667207b96SArnd Bergmann 80767207b96SArnd Bergmann if (copy_to_user(buf, &ibox_stat, sizeof ibox_stat)) 80867207b96SArnd Bergmann return -EFAULT; 80967207b96SArnd Bergmann 81067207b96SArnd Bergmann return 4; 81167207b96SArnd Bergmann } 81267207b96SArnd Bergmann 8135dfe4c96SArjan van de Ven static const struct file_operations spufs_ibox_stat_fops = { 81467207b96SArnd Bergmann .open = spufs_pipe_open, 81567207b96SArnd Bergmann .read = spufs_ibox_stat_read, 816fc15351dSArnd Bergmann .llseek = no_llseek, 81767207b96SArnd Bergmann }; 81867207b96SArnd Bergmann 81967207b96SArnd Bergmann /* low-level mailbox write */ 8208b3d6663SArnd Bergmann size_t spu_wbox_write(struct spu_context *ctx, u32 data) 82167207b96SArnd Bergmann { 8228b3d6663SArnd Bergmann return ctx->ops->wbox_write(ctx, data); 82367207b96SArnd Bergmann } 82467207b96SArnd Bergmann 8258b3d6663SArnd Bergmann /* interrupt-level wbox callback function. */ 8268b3d6663SArnd Bergmann void spufs_wbox_callback(struct spu *spu) 8278b3d6663SArnd Bergmann { 8288b3d6663SArnd Bergmann struct spu_context *ctx = spu->ctx; 8298b3d6663SArnd Bergmann 8307d7be3aaSAl Viro if (ctx) 8318b3d6663SArnd Bergmann wake_up_all(&ctx->wbox_wq); 83267207b96SArnd Bergmann } 83367207b96SArnd Bergmann 834cdcc89bbSArnd Bergmann /* 835cdcc89bbSArnd Bergmann * Write as many bytes to the interrupt mailbox as possible, until 836cdcc89bbSArnd Bergmann * one of the conditions becomes true: 837cdcc89bbSArnd Bergmann * 838cdcc89bbSArnd Bergmann * - the mailbox is full 839cdcc89bbSArnd Bergmann * - end of the user provided buffer 840cdcc89bbSArnd Bergmann * - end of the mapped area 841cdcc89bbSArnd Bergmann * 842cdcc89bbSArnd Bergmann * If the file is opened without O_NONBLOCK, we wait here until 843027dfac6SMichael Ellerman * space is available, but return when we have been able to 844cdcc89bbSArnd Bergmann * write something. 845cdcc89bbSArnd Bergmann */ 84667207b96SArnd Bergmann static ssize_t spufs_wbox_write(struct file *file, const char __user *buf, 84767207b96SArnd Bergmann size_t len, loff_t *pos) 84867207b96SArnd Bergmann { 8498b3d6663SArnd Bergmann struct spu_context *ctx = file->private_data; 850cdcc89bbSArnd Bergmann u32 wbox_data, __user *udata; 851cdcc89bbSArnd Bergmann ssize_t count; 85267207b96SArnd Bergmann 85367207b96SArnd Bergmann if (len < 4) 85467207b96SArnd Bergmann return -EINVAL; 85567207b96SArnd Bergmann 856cdcc89bbSArnd Bergmann udata = (void __user *)buf; 857cdcc89bbSArnd Bergmann if (!access_ok(VERIFY_READ, buf, len)) 858cdcc89bbSArnd Bergmann return -EFAULT; 859cdcc89bbSArnd Bergmann 860cdcc89bbSArnd Bergmann if (__get_user(wbox_data, udata)) 86167207b96SArnd Bergmann return -EFAULT; 86267207b96SArnd Bergmann 863c9101bdbSChristoph Hellwig count = spu_acquire(ctx); 864c9101bdbSChristoph Hellwig if (count) 865eebead5bSChristoph Hellwig goto out; 8668b3d6663SArnd Bergmann 867cdcc89bbSArnd Bergmann /* 868cdcc89bbSArnd Bergmann * make sure we can at least write one element, by waiting 869cdcc89bbSArnd Bergmann * in case of !O_NONBLOCK 870cdcc89bbSArnd Bergmann */ 871cdcc89bbSArnd Bergmann count = 0; 87267207b96SArnd Bergmann if (file->f_flags & O_NONBLOCK) { 873eebead5bSChristoph Hellwig if (!spu_wbox_write(ctx, wbox_data)) { 874cdcc89bbSArnd Bergmann count = -EAGAIN; 875eebead5bSChristoph Hellwig goto out_unlock; 876eebead5bSChristoph Hellwig } 87767207b96SArnd Bergmann } else { 878cdcc89bbSArnd Bergmann count = spufs_wait(ctx->wbox_wq, spu_wbox_write(ctx, wbox_data)); 879cdcc89bbSArnd Bergmann if (count) 880cdcc89bbSArnd Bergmann goto out; 881eebead5bSChristoph Hellwig } 882eebead5bSChristoph Hellwig 8838b3d6663SArnd Bergmann 88496de0e25SJan Engelhardt /* write as much as possible */ 885cdcc89bbSArnd Bergmann for (count = 4, udata++; (count + 4) <= len; count += 4, udata++) { 886cdcc89bbSArnd Bergmann int ret; 887cdcc89bbSArnd Bergmann ret = __get_user(wbox_data, udata); 888cdcc89bbSArnd Bergmann if (ret) 889cdcc89bbSArnd Bergmann break; 890cdcc89bbSArnd Bergmann 891cdcc89bbSArnd Bergmann ret = spu_wbox_write(ctx, wbox_data); 892cdcc89bbSArnd Bergmann if (ret == 0) 893cdcc89bbSArnd Bergmann break; 894cdcc89bbSArnd Bergmann } 895cdcc89bbSArnd Bergmann 896eebead5bSChristoph Hellwig out_unlock: 897cdcc89bbSArnd Bergmann spu_release(ctx); 898eebead5bSChristoph Hellwig out: 899cdcc89bbSArnd Bergmann return count; 90067207b96SArnd Bergmann } 90167207b96SArnd Bergmann 90267207b96SArnd Bergmann static unsigned int spufs_wbox_poll(struct file *file, poll_table *wait) 90367207b96SArnd Bergmann { 9048b3d6663SArnd Bergmann struct spu_context *ctx = file->private_data; 90567207b96SArnd Bergmann unsigned int mask; 90667207b96SArnd Bergmann 9078b3d6663SArnd Bergmann poll_wait(file, &ctx->wbox_wq, wait); 90867207b96SArnd Bergmann 909c9101bdbSChristoph Hellwig /* 910c9101bdbSChristoph Hellwig * For now keep this uninterruptible and also ignore the rule 911c9101bdbSChristoph Hellwig * that poll should not sleep. Will be fixed later. 912c9101bdbSChristoph Hellwig */ 913c9101bdbSChristoph Hellwig mutex_lock(&ctx->state_mutex); 9143a843d7cSArnd Bergmann mask = ctx->ops->mbox_stat_poll(ctx, POLLOUT | POLLWRNORM); 9153a843d7cSArnd Bergmann spu_release(ctx); 91667207b96SArnd Bergmann 91767207b96SArnd Bergmann return mask; 91867207b96SArnd Bergmann } 91967207b96SArnd Bergmann 9205dfe4c96SArjan van de Ven static const struct file_operations spufs_wbox_fops = { 92167207b96SArnd Bergmann .open = spufs_pipe_open, 92267207b96SArnd Bergmann .write = spufs_wbox_write, 92367207b96SArnd Bergmann .poll = spufs_wbox_poll, 924fc15351dSArnd Bergmann .llseek = no_llseek, 92567207b96SArnd Bergmann }; 92667207b96SArnd Bergmann 92767207b96SArnd Bergmann static ssize_t spufs_wbox_stat_read(struct file *file, char __user *buf, 92867207b96SArnd Bergmann size_t len, loff_t *pos) 92967207b96SArnd Bergmann { 9308b3d6663SArnd Bergmann struct spu_context *ctx = file->private_data; 931c9101bdbSChristoph Hellwig ssize_t ret; 93267207b96SArnd Bergmann u32 wbox_stat; 93367207b96SArnd Bergmann 93467207b96SArnd Bergmann if (len < 4) 93567207b96SArnd Bergmann return -EINVAL; 93667207b96SArnd Bergmann 937c9101bdbSChristoph Hellwig ret = spu_acquire(ctx); 938c9101bdbSChristoph Hellwig if (ret) 939c9101bdbSChristoph Hellwig return ret; 9408b3d6663SArnd Bergmann wbox_stat = (ctx->ops->mbox_stat_read(ctx) >> 8) & 0xff; 9418b3d6663SArnd Bergmann spu_release(ctx); 94267207b96SArnd Bergmann 94367207b96SArnd Bergmann if (copy_to_user(buf, &wbox_stat, sizeof wbox_stat)) 94467207b96SArnd Bergmann return -EFAULT; 94567207b96SArnd Bergmann 94667207b96SArnd Bergmann return 4; 94767207b96SArnd Bergmann } 94867207b96SArnd Bergmann 9495dfe4c96SArjan van de Ven static const struct file_operations spufs_wbox_stat_fops = { 95067207b96SArnd Bergmann .open = spufs_pipe_open, 95167207b96SArnd Bergmann .read = spufs_wbox_stat_read, 952fc15351dSArnd Bergmann .llseek = no_llseek, 95367207b96SArnd Bergmann }; 95467207b96SArnd Bergmann 9556df10a82SMark Nutter static int spufs_signal1_open(struct inode *inode, struct file *file) 9566df10a82SMark Nutter { 9576df10a82SMark Nutter struct spufs_inode_info *i = SPUFS_I(inode); 9586df10a82SMark Nutter struct spu_context *ctx = i->i_ctx; 95943c2bbd9SChristoph Hellwig 96047d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 9616df10a82SMark Nutter file->private_data = ctx; 96243c2bbd9SChristoph Hellwig if (!i->i_openers++) 9636df10a82SMark Nutter ctx->signal1 = inode->i_mapping; 96447d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 9656df10a82SMark Nutter return nonseekable_open(inode, file); 9666df10a82SMark Nutter } 9676df10a82SMark Nutter 96843c2bbd9SChristoph Hellwig static int 96943c2bbd9SChristoph Hellwig spufs_signal1_release(struct inode *inode, struct file *file) 97043c2bbd9SChristoph Hellwig { 97143c2bbd9SChristoph Hellwig struct spufs_inode_info *i = SPUFS_I(inode); 97243c2bbd9SChristoph Hellwig struct spu_context *ctx = i->i_ctx; 97343c2bbd9SChristoph Hellwig 97447d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 97543c2bbd9SChristoph Hellwig if (!--i->i_openers) 97643c2bbd9SChristoph Hellwig ctx->signal1 = NULL; 97747d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 97843c2bbd9SChristoph Hellwig return 0; 97943c2bbd9SChristoph Hellwig } 98043c2bbd9SChristoph Hellwig 981bf1ab978SDwayne Grant McConnell static ssize_t __spufs_signal1_read(struct spu_context *ctx, char __user *buf, 98267207b96SArnd Bergmann size_t len, loff_t *pos) 98367207b96SArnd Bergmann { 98417f88cebSDwayne Grant McConnell int ret = 0; 98567207b96SArnd Bergmann u32 data; 98667207b96SArnd Bergmann 98767207b96SArnd Bergmann if (len < 4) 98867207b96SArnd Bergmann return -EINVAL; 98967207b96SArnd Bergmann 99017f88cebSDwayne Grant McConnell if (ctx->csa.spu_chnlcnt_RW[3]) { 99117f88cebSDwayne Grant McConnell data = ctx->csa.spu_chnldata_RW[3]; 99217f88cebSDwayne Grant McConnell ret = 4; 99317f88cebSDwayne Grant McConnell } 9948b3d6663SArnd Bergmann 99517f88cebSDwayne Grant McConnell if (!ret) 99617f88cebSDwayne Grant McConnell goto out; 99717f88cebSDwayne Grant McConnell 99867207b96SArnd Bergmann if (copy_to_user(buf, &data, 4)) 99967207b96SArnd Bergmann return -EFAULT; 100067207b96SArnd Bergmann 100117f88cebSDwayne Grant McConnell out: 100217f88cebSDwayne Grant McConnell return ret; 100367207b96SArnd Bergmann } 100467207b96SArnd Bergmann 1005bf1ab978SDwayne Grant McConnell static ssize_t spufs_signal1_read(struct file *file, char __user *buf, 1006bf1ab978SDwayne Grant McConnell size_t len, loff_t *pos) 1007bf1ab978SDwayne Grant McConnell { 1008bf1ab978SDwayne Grant McConnell int ret; 1009bf1ab978SDwayne Grant McConnell struct spu_context *ctx = file->private_data; 1010bf1ab978SDwayne Grant McConnell 1011c9101bdbSChristoph Hellwig ret = spu_acquire_saved(ctx); 1012c9101bdbSChristoph Hellwig if (ret) 1013c9101bdbSChristoph Hellwig return ret; 1014bf1ab978SDwayne Grant McConnell ret = __spufs_signal1_read(ctx, buf, len, pos); 101527b1ea09SChristoph Hellwig spu_release_saved(ctx); 1016bf1ab978SDwayne Grant McConnell 1017bf1ab978SDwayne Grant McConnell return ret; 1018bf1ab978SDwayne Grant McConnell } 1019bf1ab978SDwayne Grant McConnell 102067207b96SArnd Bergmann static ssize_t spufs_signal1_write(struct file *file, const char __user *buf, 102167207b96SArnd Bergmann size_t len, loff_t *pos) 102267207b96SArnd Bergmann { 102367207b96SArnd Bergmann struct spu_context *ctx; 1024c9101bdbSChristoph Hellwig ssize_t ret; 102567207b96SArnd Bergmann u32 data; 102667207b96SArnd Bergmann 102767207b96SArnd Bergmann ctx = file->private_data; 102867207b96SArnd Bergmann 102967207b96SArnd Bergmann if (len < 4) 103067207b96SArnd Bergmann return -EINVAL; 103167207b96SArnd Bergmann 103267207b96SArnd Bergmann if (copy_from_user(&data, buf, 4)) 103367207b96SArnd Bergmann return -EFAULT; 103467207b96SArnd Bergmann 1035c9101bdbSChristoph Hellwig ret = spu_acquire(ctx); 1036c9101bdbSChristoph Hellwig if (ret) 1037c9101bdbSChristoph Hellwig return ret; 10388b3d6663SArnd Bergmann ctx->ops->signal1_write(ctx, data); 10398b3d6663SArnd Bergmann spu_release(ctx); 104067207b96SArnd Bergmann 104167207b96SArnd Bergmann return 4; 104267207b96SArnd Bergmann } 104367207b96SArnd Bergmann 1044b1e2270fSNick Piggin static int 1045b1e2270fSNick Piggin spufs_signal1_mmap_fault(struct vm_area_struct *vma, struct vm_fault *vmf) 10466df10a82SMark Nutter { 104787ff6090SJeremy Kerr #if SPUFS_SIGNAL_MAP_SIZE == 0x1000 104887ff6090SJeremy Kerr return spufs_ps_fault(vma, vmf, 0x14000, SPUFS_SIGNAL_MAP_SIZE); 104987ff6090SJeremy Kerr #elif SPUFS_SIGNAL_MAP_SIZE == 0x10000 105027d5bf2aSBenjamin Herrenschmidt /* For 64k pages, both signal1 and signal2 can be used to mmap the whole 105127d5bf2aSBenjamin Herrenschmidt * signal 1 and 2 area 105227d5bf2aSBenjamin Herrenschmidt */ 105387ff6090SJeremy Kerr return spufs_ps_fault(vma, vmf, 0x10000, SPUFS_SIGNAL_MAP_SIZE); 105427d5bf2aSBenjamin Herrenschmidt #else 105527d5bf2aSBenjamin Herrenschmidt #error unsupported page size 105627d5bf2aSBenjamin Herrenschmidt #endif 10576df10a82SMark Nutter } 10586df10a82SMark Nutter 1059f0f37e2fSAlexey Dobriyan static const struct vm_operations_struct spufs_signal1_mmap_vmops = { 1060b1e2270fSNick Piggin .fault = spufs_signal1_mmap_fault, 10616df10a82SMark Nutter }; 10626df10a82SMark Nutter 10636df10a82SMark Nutter static int spufs_signal1_mmap(struct file *file, struct vm_area_struct *vma) 10646df10a82SMark Nutter { 10656df10a82SMark Nutter if (!(vma->vm_flags & VM_SHARED)) 10666df10a82SMark Nutter return -EINVAL; 10676df10a82SMark Nutter 106878bde53eSBenjamin Herrenschmidt vma->vm_flags |= VM_IO | VM_PFNMAP; 106964b3d0e8SBenjamin Herrenschmidt vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot); 10706df10a82SMark Nutter 10716df10a82SMark Nutter vma->vm_ops = &spufs_signal1_mmap_vmops; 10726df10a82SMark Nutter return 0; 10736df10a82SMark Nutter } 10746df10a82SMark Nutter 10755dfe4c96SArjan van de Ven static const struct file_operations spufs_signal1_fops = { 10766df10a82SMark Nutter .open = spufs_signal1_open, 107743c2bbd9SChristoph Hellwig .release = spufs_signal1_release, 107867207b96SArnd Bergmann .read = spufs_signal1_read, 107967207b96SArnd Bergmann .write = spufs_signal1_write, 10806df10a82SMark Nutter .mmap = spufs_signal1_mmap, 1081fc15351dSArnd Bergmann .llseek = no_llseek, 108267207b96SArnd Bergmann }; 108367207b96SArnd Bergmann 1084d054b36fSJeremy Kerr static const struct file_operations spufs_signal1_nosched_fops = { 1085d054b36fSJeremy Kerr .open = spufs_signal1_open, 1086d054b36fSJeremy Kerr .release = spufs_signal1_release, 1087d054b36fSJeremy Kerr .write = spufs_signal1_write, 1088d054b36fSJeremy Kerr .mmap = spufs_signal1_mmap, 1089fc15351dSArnd Bergmann .llseek = no_llseek, 1090d054b36fSJeremy Kerr }; 1091d054b36fSJeremy Kerr 10926df10a82SMark Nutter static int spufs_signal2_open(struct inode *inode, struct file *file) 10936df10a82SMark Nutter { 10946df10a82SMark Nutter struct spufs_inode_info *i = SPUFS_I(inode); 10956df10a82SMark Nutter struct spu_context *ctx = i->i_ctx; 109643c2bbd9SChristoph Hellwig 109747d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 10986df10a82SMark Nutter file->private_data = ctx; 109943c2bbd9SChristoph Hellwig if (!i->i_openers++) 11006df10a82SMark Nutter ctx->signal2 = inode->i_mapping; 110147d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 11026df10a82SMark Nutter return nonseekable_open(inode, file); 11036df10a82SMark Nutter } 11046df10a82SMark Nutter 110543c2bbd9SChristoph Hellwig static int 110643c2bbd9SChristoph Hellwig spufs_signal2_release(struct inode *inode, struct file *file) 110743c2bbd9SChristoph Hellwig { 110843c2bbd9SChristoph Hellwig struct spufs_inode_info *i = SPUFS_I(inode); 110943c2bbd9SChristoph Hellwig struct spu_context *ctx = i->i_ctx; 111043c2bbd9SChristoph Hellwig 111147d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 111243c2bbd9SChristoph Hellwig if (!--i->i_openers) 111343c2bbd9SChristoph Hellwig ctx->signal2 = NULL; 111447d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 111543c2bbd9SChristoph Hellwig return 0; 111643c2bbd9SChristoph Hellwig } 111743c2bbd9SChristoph Hellwig 1118bf1ab978SDwayne Grant McConnell static ssize_t __spufs_signal2_read(struct spu_context *ctx, char __user *buf, 111967207b96SArnd Bergmann size_t len, loff_t *pos) 112067207b96SArnd Bergmann { 112117f88cebSDwayne Grant McConnell int ret = 0; 112267207b96SArnd Bergmann u32 data; 112367207b96SArnd Bergmann 112467207b96SArnd Bergmann if (len < 4) 112567207b96SArnd Bergmann return -EINVAL; 112667207b96SArnd Bergmann 112717f88cebSDwayne Grant McConnell if (ctx->csa.spu_chnlcnt_RW[4]) { 112817f88cebSDwayne Grant McConnell data = ctx->csa.spu_chnldata_RW[4]; 112917f88cebSDwayne Grant McConnell ret = 4; 113017f88cebSDwayne Grant McConnell } 11318b3d6663SArnd Bergmann 113217f88cebSDwayne Grant McConnell if (!ret) 113317f88cebSDwayne Grant McConnell goto out; 113417f88cebSDwayne Grant McConnell 113567207b96SArnd Bergmann if (copy_to_user(buf, &data, 4)) 113667207b96SArnd Bergmann return -EFAULT; 113767207b96SArnd Bergmann 113817f88cebSDwayne Grant McConnell out: 1139bf1ab978SDwayne Grant McConnell return ret; 1140bf1ab978SDwayne Grant McConnell } 1141bf1ab978SDwayne Grant McConnell 1142bf1ab978SDwayne Grant McConnell static ssize_t spufs_signal2_read(struct file *file, char __user *buf, 1143bf1ab978SDwayne Grant McConnell size_t len, loff_t *pos) 1144bf1ab978SDwayne Grant McConnell { 1145bf1ab978SDwayne Grant McConnell struct spu_context *ctx = file->private_data; 1146bf1ab978SDwayne Grant McConnell int ret; 1147bf1ab978SDwayne Grant McConnell 1148c9101bdbSChristoph Hellwig ret = spu_acquire_saved(ctx); 1149c9101bdbSChristoph Hellwig if (ret) 1150c9101bdbSChristoph Hellwig return ret; 1151bf1ab978SDwayne Grant McConnell ret = __spufs_signal2_read(ctx, buf, len, pos); 115227b1ea09SChristoph Hellwig spu_release_saved(ctx); 1153bf1ab978SDwayne Grant McConnell 1154bf1ab978SDwayne Grant McConnell return ret; 115567207b96SArnd Bergmann } 115667207b96SArnd Bergmann 115767207b96SArnd Bergmann static ssize_t spufs_signal2_write(struct file *file, const char __user *buf, 115867207b96SArnd Bergmann size_t len, loff_t *pos) 115967207b96SArnd Bergmann { 116067207b96SArnd Bergmann struct spu_context *ctx; 1161c9101bdbSChristoph Hellwig ssize_t ret; 116267207b96SArnd Bergmann u32 data; 116367207b96SArnd Bergmann 116467207b96SArnd Bergmann ctx = file->private_data; 116567207b96SArnd Bergmann 116667207b96SArnd Bergmann if (len < 4) 116767207b96SArnd Bergmann return -EINVAL; 116867207b96SArnd Bergmann 116967207b96SArnd Bergmann if (copy_from_user(&data, buf, 4)) 117067207b96SArnd Bergmann return -EFAULT; 117167207b96SArnd Bergmann 1172c9101bdbSChristoph Hellwig ret = spu_acquire(ctx); 1173c9101bdbSChristoph Hellwig if (ret) 1174c9101bdbSChristoph Hellwig return ret; 11758b3d6663SArnd Bergmann ctx->ops->signal2_write(ctx, data); 11768b3d6663SArnd Bergmann spu_release(ctx); 117767207b96SArnd Bergmann 117867207b96SArnd Bergmann return 4; 117967207b96SArnd Bergmann } 118067207b96SArnd Bergmann 118127d5bf2aSBenjamin Herrenschmidt #if SPUFS_MMAP_4K 1182b1e2270fSNick Piggin static int 1183b1e2270fSNick Piggin spufs_signal2_mmap_fault(struct vm_area_struct *vma, struct vm_fault *vmf) 11846df10a82SMark Nutter { 118587ff6090SJeremy Kerr #if SPUFS_SIGNAL_MAP_SIZE == 0x1000 118687ff6090SJeremy Kerr return spufs_ps_fault(vma, vmf, 0x1c000, SPUFS_SIGNAL_MAP_SIZE); 118787ff6090SJeremy Kerr #elif SPUFS_SIGNAL_MAP_SIZE == 0x10000 118827d5bf2aSBenjamin Herrenschmidt /* For 64k pages, both signal1 and signal2 can be used to mmap the whole 118927d5bf2aSBenjamin Herrenschmidt * signal 1 and 2 area 119027d5bf2aSBenjamin Herrenschmidt */ 119187ff6090SJeremy Kerr return spufs_ps_fault(vma, vmf, 0x10000, SPUFS_SIGNAL_MAP_SIZE); 119227d5bf2aSBenjamin Herrenschmidt #else 119327d5bf2aSBenjamin Herrenschmidt #error unsupported page size 119427d5bf2aSBenjamin Herrenschmidt #endif 11956df10a82SMark Nutter } 11966df10a82SMark Nutter 1197f0f37e2fSAlexey Dobriyan static const struct vm_operations_struct spufs_signal2_mmap_vmops = { 1198b1e2270fSNick Piggin .fault = spufs_signal2_mmap_fault, 11996df10a82SMark Nutter }; 12006df10a82SMark Nutter 12016df10a82SMark Nutter static int spufs_signal2_mmap(struct file *file, struct vm_area_struct *vma) 12026df10a82SMark Nutter { 12036df10a82SMark Nutter if (!(vma->vm_flags & VM_SHARED)) 12046df10a82SMark Nutter return -EINVAL; 12056df10a82SMark Nutter 120678bde53eSBenjamin Herrenschmidt vma->vm_flags |= VM_IO | VM_PFNMAP; 120764b3d0e8SBenjamin Herrenschmidt vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot); 12086df10a82SMark Nutter 12096df10a82SMark Nutter vma->vm_ops = &spufs_signal2_mmap_vmops; 12106df10a82SMark Nutter return 0; 12116df10a82SMark Nutter } 121227d5bf2aSBenjamin Herrenschmidt #else /* SPUFS_MMAP_4K */ 121327d5bf2aSBenjamin Herrenschmidt #define spufs_signal2_mmap NULL 121427d5bf2aSBenjamin Herrenschmidt #endif /* !SPUFS_MMAP_4K */ 12156df10a82SMark Nutter 12165dfe4c96SArjan van de Ven static const struct file_operations spufs_signal2_fops = { 12176df10a82SMark Nutter .open = spufs_signal2_open, 121843c2bbd9SChristoph Hellwig .release = spufs_signal2_release, 121967207b96SArnd Bergmann .read = spufs_signal2_read, 122067207b96SArnd Bergmann .write = spufs_signal2_write, 12216df10a82SMark Nutter .mmap = spufs_signal2_mmap, 1222fc15351dSArnd Bergmann .llseek = no_llseek, 122367207b96SArnd Bergmann }; 122467207b96SArnd Bergmann 1225d054b36fSJeremy Kerr static const struct file_operations spufs_signal2_nosched_fops = { 1226d054b36fSJeremy Kerr .open = spufs_signal2_open, 1227d054b36fSJeremy Kerr .release = spufs_signal2_release, 1228d054b36fSJeremy Kerr .write = spufs_signal2_write, 1229d054b36fSJeremy Kerr .mmap = spufs_signal2_mmap, 1230fc15351dSArnd Bergmann .llseek = no_llseek, 1231d054b36fSJeremy Kerr }; 1232d054b36fSJeremy Kerr 1233104f0cc2SMichael Ellerman /* 1234104f0cc2SMichael Ellerman * This is a wrapper around DEFINE_SIMPLE_ATTRIBUTE which does the 1235104f0cc2SMichael Ellerman * work of acquiring (or not) the SPU context before calling through 1236104f0cc2SMichael Ellerman * to the actual get routine. The set routine is called directly. 1237104f0cc2SMichael Ellerman */ 1238104f0cc2SMichael Ellerman #define SPU_ATTR_NOACQUIRE 0 1239104f0cc2SMichael Ellerman #define SPU_ATTR_ACQUIRE 1 1240104f0cc2SMichael Ellerman #define SPU_ATTR_ACQUIRE_SAVED 2 1241104f0cc2SMichael Ellerman 1242104f0cc2SMichael Ellerman #define DEFINE_SPUFS_ATTRIBUTE(__name, __get, __set, __fmt, __acquire) \ 1243197b1a82SChristoph Hellwig static int __##__get(void *data, u64 *val) \ 1244104f0cc2SMichael Ellerman { \ 1245104f0cc2SMichael Ellerman struct spu_context *ctx = data; \ 1246c9101bdbSChristoph Hellwig int ret = 0; \ 1247104f0cc2SMichael Ellerman \ 1248104f0cc2SMichael Ellerman if (__acquire == SPU_ATTR_ACQUIRE) { \ 1249c9101bdbSChristoph Hellwig ret = spu_acquire(ctx); \ 1250c9101bdbSChristoph Hellwig if (ret) \ 1251c9101bdbSChristoph Hellwig return ret; \ 1252197b1a82SChristoph Hellwig *val = __get(ctx); \ 1253104f0cc2SMichael Ellerman spu_release(ctx); \ 1254104f0cc2SMichael Ellerman } else if (__acquire == SPU_ATTR_ACQUIRE_SAVED) { \ 1255c9101bdbSChristoph Hellwig ret = spu_acquire_saved(ctx); \ 1256c9101bdbSChristoph Hellwig if (ret) \ 1257c9101bdbSChristoph Hellwig return ret; \ 1258197b1a82SChristoph Hellwig *val = __get(ctx); \ 1259104f0cc2SMichael Ellerman spu_release_saved(ctx); \ 1260104f0cc2SMichael Ellerman } else \ 1261197b1a82SChristoph Hellwig *val = __get(ctx); \ 1262104f0cc2SMichael Ellerman \ 1263197b1a82SChristoph Hellwig return 0; \ 1264104f0cc2SMichael Ellerman } \ 1265197b1a82SChristoph Hellwig DEFINE_SPUFS_SIMPLE_ATTRIBUTE(__name, __##__get, __set, __fmt); 1266104f0cc2SMichael Ellerman 1267197b1a82SChristoph Hellwig static int spufs_signal1_type_set(void *data, u64 val) 126867207b96SArnd Bergmann { 126967207b96SArnd Bergmann struct spu_context *ctx = data; 1270c9101bdbSChristoph Hellwig int ret; 127167207b96SArnd Bergmann 1272c9101bdbSChristoph Hellwig ret = spu_acquire(ctx); 1273c9101bdbSChristoph Hellwig if (ret) 1274c9101bdbSChristoph Hellwig return ret; 12758b3d6663SArnd Bergmann ctx->ops->signal1_type_set(ctx, val); 12768b3d6663SArnd Bergmann spu_release(ctx); 1277197b1a82SChristoph Hellwig 1278197b1a82SChristoph Hellwig return 0; 127967207b96SArnd Bergmann } 128067207b96SArnd Bergmann 1281104f0cc2SMichael Ellerman static u64 spufs_signal1_type_get(struct spu_context *ctx) 1282bf1ab978SDwayne Grant McConnell { 1283bf1ab978SDwayne Grant McConnell return ctx->ops->signal1_type_get(ctx); 1284bf1ab978SDwayne Grant McConnell } 1285104f0cc2SMichael Ellerman DEFINE_SPUFS_ATTRIBUTE(spufs_signal1_type, spufs_signal1_type_get, 1286af8b44e0SJeremy Kerr spufs_signal1_type_set, "%llu\n", SPU_ATTR_ACQUIRE); 1287bf1ab978SDwayne Grant McConnell 128867207b96SArnd Bergmann 1289197b1a82SChristoph Hellwig static int spufs_signal2_type_set(void *data, u64 val) 129067207b96SArnd Bergmann { 129167207b96SArnd Bergmann struct spu_context *ctx = data; 1292c9101bdbSChristoph Hellwig int ret; 129367207b96SArnd Bergmann 1294c9101bdbSChristoph Hellwig ret = spu_acquire(ctx); 1295c9101bdbSChristoph Hellwig if (ret) 1296c9101bdbSChristoph Hellwig return ret; 12978b3d6663SArnd Bergmann ctx->ops->signal2_type_set(ctx, val); 12988b3d6663SArnd Bergmann spu_release(ctx); 1299197b1a82SChristoph Hellwig 1300197b1a82SChristoph Hellwig return 0; 130167207b96SArnd Bergmann } 130267207b96SArnd Bergmann 1303104f0cc2SMichael Ellerman static u64 spufs_signal2_type_get(struct spu_context *ctx) 1304bf1ab978SDwayne Grant McConnell { 1305bf1ab978SDwayne Grant McConnell return ctx->ops->signal2_type_get(ctx); 1306bf1ab978SDwayne Grant McConnell } 1307104f0cc2SMichael Ellerman DEFINE_SPUFS_ATTRIBUTE(spufs_signal2_type, spufs_signal2_type_get, 1308af8b44e0SJeremy Kerr spufs_signal2_type_set, "%llu\n", SPU_ATTR_ACQUIRE); 130967207b96SArnd Bergmann 131027d5bf2aSBenjamin Herrenschmidt #if SPUFS_MMAP_4K 1311b1e2270fSNick Piggin static int 1312b1e2270fSNick Piggin spufs_mss_mmap_fault(struct vm_area_struct *vma, struct vm_fault *vmf) 1313d9379c4bSarnd@arndb.de { 131487ff6090SJeremy Kerr return spufs_ps_fault(vma, vmf, 0x0000, SPUFS_MSS_MAP_SIZE); 1315d9379c4bSarnd@arndb.de } 1316d9379c4bSarnd@arndb.de 1317f0f37e2fSAlexey Dobriyan static const struct vm_operations_struct spufs_mss_mmap_vmops = { 1318b1e2270fSNick Piggin .fault = spufs_mss_mmap_fault, 1319d9379c4bSarnd@arndb.de }; 1320d9379c4bSarnd@arndb.de 1321d9379c4bSarnd@arndb.de /* 1322d9379c4bSarnd@arndb.de * mmap support for problem state MFC DMA area [0x0000 - 0x0fff]. 1323d9379c4bSarnd@arndb.de */ 1324d9379c4bSarnd@arndb.de static int spufs_mss_mmap(struct file *file, struct vm_area_struct *vma) 1325d9379c4bSarnd@arndb.de { 1326d9379c4bSarnd@arndb.de if (!(vma->vm_flags & VM_SHARED)) 1327d9379c4bSarnd@arndb.de return -EINVAL; 1328d9379c4bSarnd@arndb.de 132978bde53eSBenjamin Herrenschmidt vma->vm_flags |= VM_IO | VM_PFNMAP; 133064b3d0e8SBenjamin Herrenschmidt vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot); 1331d9379c4bSarnd@arndb.de 1332d9379c4bSarnd@arndb.de vma->vm_ops = &spufs_mss_mmap_vmops; 1333d9379c4bSarnd@arndb.de return 0; 1334d9379c4bSarnd@arndb.de } 133527d5bf2aSBenjamin Herrenschmidt #else /* SPUFS_MMAP_4K */ 133627d5bf2aSBenjamin Herrenschmidt #define spufs_mss_mmap NULL 133727d5bf2aSBenjamin Herrenschmidt #endif /* !SPUFS_MMAP_4K */ 1338d9379c4bSarnd@arndb.de 1339d9379c4bSarnd@arndb.de static int spufs_mss_open(struct inode *inode, struct file *file) 1340d9379c4bSarnd@arndb.de { 1341d9379c4bSarnd@arndb.de struct spufs_inode_info *i = SPUFS_I(inode); 134217e0e270SBenjamin Herrenschmidt struct spu_context *ctx = i->i_ctx; 1343d9379c4bSarnd@arndb.de 1344d9379c4bSarnd@arndb.de file->private_data = i->i_ctx; 134543c2bbd9SChristoph Hellwig 134647d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 134743c2bbd9SChristoph Hellwig if (!i->i_openers++) 134817e0e270SBenjamin Herrenschmidt ctx->mss = inode->i_mapping; 134947d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 1350d9379c4bSarnd@arndb.de return nonseekable_open(inode, file); 1351d9379c4bSarnd@arndb.de } 1352d9379c4bSarnd@arndb.de 135343c2bbd9SChristoph Hellwig static int 135443c2bbd9SChristoph Hellwig spufs_mss_release(struct inode *inode, struct file *file) 135543c2bbd9SChristoph Hellwig { 135643c2bbd9SChristoph Hellwig struct spufs_inode_info *i = SPUFS_I(inode); 135743c2bbd9SChristoph Hellwig struct spu_context *ctx = i->i_ctx; 135843c2bbd9SChristoph Hellwig 135947d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 136043c2bbd9SChristoph Hellwig if (!--i->i_openers) 136143c2bbd9SChristoph Hellwig ctx->mss = NULL; 136247d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 136343c2bbd9SChristoph Hellwig return 0; 136443c2bbd9SChristoph Hellwig } 136543c2bbd9SChristoph Hellwig 13665dfe4c96SArjan van de Ven static const struct file_operations spufs_mss_fops = { 1367d9379c4bSarnd@arndb.de .open = spufs_mss_open, 136843c2bbd9SChristoph Hellwig .release = spufs_mss_release, 1369d9379c4bSarnd@arndb.de .mmap = spufs_mss_mmap, 1370fc15351dSArnd Bergmann .llseek = no_llseek, 137127d5bf2aSBenjamin Herrenschmidt }; 137227d5bf2aSBenjamin Herrenschmidt 1373b1e2270fSNick Piggin static int 1374b1e2270fSNick Piggin spufs_psmap_mmap_fault(struct vm_area_struct *vma, struct vm_fault *vmf) 137527d5bf2aSBenjamin Herrenschmidt { 137687ff6090SJeremy Kerr return spufs_ps_fault(vma, vmf, 0x0000, SPUFS_PS_MAP_SIZE); 137727d5bf2aSBenjamin Herrenschmidt } 137827d5bf2aSBenjamin Herrenschmidt 1379f0f37e2fSAlexey Dobriyan static const struct vm_operations_struct spufs_psmap_mmap_vmops = { 1380b1e2270fSNick Piggin .fault = spufs_psmap_mmap_fault, 138127d5bf2aSBenjamin Herrenschmidt }; 138227d5bf2aSBenjamin Herrenschmidt 138327d5bf2aSBenjamin Herrenschmidt /* 138427d5bf2aSBenjamin Herrenschmidt * mmap support for full problem state area [0x00000 - 0x1ffff]. 138527d5bf2aSBenjamin Herrenschmidt */ 138627d5bf2aSBenjamin Herrenschmidt static int spufs_psmap_mmap(struct file *file, struct vm_area_struct *vma) 138727d5bf2aSBenjamin Herrenschmidt { 138827d5bf2aSBenjamin Herrenschmidt if (!(vma->vm_flags & VM_SHARED)) 138927d5bf2aSBenjamin Herrenschmidt return -EINVAL; 139027d5bf2aSBenjamin Herrenschmidt 139178bde53eSBenjamin Herrenschmidt vma->vm_flags |= VM_IO | VM_PFNMAP; 139264b3d0e8SBenjamin Herrenschmidt vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot); 139327d5bf2aSBenjamin Herrenschmidt 139427d5bf2aSBenjamin Herrenschmidt vma->vm_ops = &spufs_psmap_mmap_vmops; 139527d5bf2aSBenjamin Herrenschmidt return 0; 139627d5bf2aSBenjamin Herrenschmidt } 139727d5bf2aSBenjamin Herrenschmidt 139827d5bf2aSBenjamin Herrenschmidt static int spufs_psmap_open(struct inode *inode, struct file *file) 139927d5bf2aSBenjamin Herrenschmidt { 140027d5bf2aSBenjamin Herrenschmidt struct spufs_inode_info *i = SPUFS_I(inode); 140117e0e270SBenjamin Herrenschmidt struct spu_context *ctx = i->i_ctx; 140227d5bf2aSBenjamin Herrenschmidt 140347d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 140427d5bf2aSBenjamin Herrenschmidt file->private_data = i->i_ctx; 140543c2bbd9SChristoph Hellwig if (!i->i_openers++) 140617e0e270SBenjamin Herrenschmidt ctx->psmap = inode->i_mapping; 140747d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 140827d5bf2aSBenjamin Herrenschmidt return nonseekable_open(inode, file); 140927d5bf2aSBenjamin Herrenschmidt } 141027d5bf2aSBenjamin Herrenschmidt 141143c2bbd9SChristoph Hellwig static int 141243c2bbd9SChristoph Hellwig spufs_psmap_release(struct inode *inode, struct file *file) 141343c2bbd9SChristoph Hellwig { 141443c2bbd9SChristoph Hellwig struct spufs_inode_info *i = SPUFS_I(inode); 141543c2bbd9SChristoph Hellwig struct spu_context *ctx = i->i_ctx; 141643c2bbd9SChristoph Hellwig 141747d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 141843c2bbd9SChristoph Hellwig if (!--i->i_openers) 141943c2bbd9SChristoph Hellwig ctx->psmap = NULL; 142047d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 142143c2bbd9SChristoph Hellwig return 0; 142243c2bbd9SChristoph Hellwig } 142343c2bbd9SChristoph Hellwig 14245dfe4c96SArjan van de Ven static const struct file_operations spufs_psmap_fops = { 142527d5bf2aSBenjamin Herrenschmidt .open = spufs_psmap_open, 142643c2bbd9SChristoph Hellwig .release = spufs_psmap_release, 142727d5bf2aSBenjamin Herrenschmidt .mmap = spufs_psmap_mmap, 1428fc15351dSArnd Bergmann .llseek = no_llseek, 1429d9379c4bSarnd@arndb.de }; 1430d9379c4bSarnd@arndb.de 1431d9379c4bSarnd@arndb.de 143227d5bf2aSBenjamin Herrenschmidt #if SPUFS_MMAP_4K 1433b1e2270fSNick Piggin static int 1434b1e2270fSNick Piggin spufs_mfc_mmap_fault(struct vm_area_struct *vma, struct vm_fault *vmf) 14356df10a82SMark Nutter { 143687ff6090SJeremy Kerr return spufs_ps_fault(vma, vmf, 0x3000, SPUFS_MFC_MAP_SIZE); 14376df10a82SMark Nutter } 14386df10a82SMark Nutter 1439f0f37e2fSAlexey Dobriyan static const struct vm_operations_struct spufs_mfc_mmap_vmops = { 1440b1e2270fSNick Piggin .fault = spufs_mfc_mmap_fault, 14416df10a82SMark Nutter }; 14426df10a82SMark Nutter 14436df10a82SMark Nutter /* 14446df10a82SMark Nutter * mmap support for problem state MFC DMA area [0x0000 - 0x0fff]. 14456df10a82SMark Nutter */ 14466df10a82SMark Nutter static int spufs_mfc_mmap(struct file *file, struct vm_area_struct *vma) 14476df10a82SMark Nutter { 14486df10a82SMark Nutter if (!(vma->vm_flags & VM_SHARED)) 14496df10a82SMark Nutter return -EINVAL; 14506df10a82SMark Nutter 145178bde53eSBenjamin Herrenschmidt vma->vm_flags |= VM_IO | VM_PFNMAP; 145264b3d0e8SBenjamin Herrenschmidt vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot); 14536df10a82SMark Nutter 14546df10a82SMark Nutter vma->vm_ops = &spufs_mfc_mmap_vmops; 14556df10a82SMark Nutter return 0; 14566df10a82SMark Nutter } 145727d5bf2aSBenjamin Herrenschmidt #else /* SPUFS_MMAP_4K */ 145827d5bf2aSBenjamin Herrenschmidt #define spufs_mfc_mmap NULL 145927d5bf2aSBenjamin Herrenschmidt #endif /* !SPUFS_MMAP_4K */ 1460a33a7d73SArnd Bergmann 1461a33a7d73SArnd Bergmann static int spufs_mfc_open(struct inode *inode, struct file *file) 1462a33a7d73SArnd Bergmann { 1463a33a7d73SArnd Bergmann struct spufs_inode_info *i = SPUFS_I(inode); 1464a33a7d73SArnd Bergmann struct spu_context *ctx = i->i_ctx; 1465a33a7d73SArnd Bergmann 1466a33a7d73SArnd Bergmann /* we don't want to deal with DMA into other processes */ 1467a33a7d73SArnd Bergmann if (ctx->owner != current->mm) 1468a33a7d73SArnd Bergmann return -EINVAL; 1469a33a7d73SArnd Bergmann 1470a33a7d73SArnd Bergmann if (atomic_read(&inode->i_count) != 1) 1471a33a7d73SArnd Bergmann return -EBUSY; 1472a33a7d73SArnd Bergmann 147347d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 1474a33a7d73SArnd Bergmann file->private_data = ctx; 147543c2bbd9SChristoph Hellwig if (!i->i_openers++) 147617e0e270SBenjamin Herrenschmidt ctx->mfc = inode->i_mapping; 147747d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 1478a33a7d73SArnd Bergmann return nonseekable_open(inode, file); 1479a33a7d73SArnd Bergmann } 1480a33a7d73SArnd Bergmann 148143c2bbd9SChristoph Hellwig static int 148243c2bbd9SChristoph Hellwig spufs_mfc_release(struct inode *inode, struct file *file) 148343c2bbd9SChristoph Hellwig { 148443c2bbd9SChristoph Hellwig struct spufs_inode_info *i = SPUFS_I(inode); 148543c2bbd9SChristoph Hellwig struct spu_context *ctx = i->i_ctx; 148643c2bbd9SChristoph Hellwig 148747d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 148843c2bbd9SChristoph Hellwig if (!--i->i_openers) 148943c2bbd9SChristoph Hellwig ctx->mfc = NULL; 149047d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 149143c2bbd9SChristoph Hellwig return 0; 149243c2bbd9SChristoph Hellwig } 149343c2bbd9SChristoph Hellwig 1494a33a7d73SArnd Bergmann /* interrupt-level mfc callback function. */ 1495a33a7d73SArnd Bergmann void spufs_mfc_callback(struct spu *spu) 1496a33a7d73SArnd Bergmann { 1497a33a7d73SArnd Bergmann struct spu_context *ctx = spu->ctx; 1498a33a7d73SArnd Bergmann 14997d7be3aaSAl Viro if (ctx) 1500a33a7d73SArnd Bergmann wake_up_all(&ctx->mfc_wq); 1501a33a7d73SArnd Bergmann } 1502a33a7d73SArnd Bergmann 1503a33a7d73SArnd Bergmann static int spufs_read_mfc_tagstatus(struct spu_context *ctx, u32 *status) 1504a33a7d73SArnd Bergmann { 1505a33a7d73SArnd Bergmann /* See if there is one tag group is complete */ 1506a33a7d73SArnd Bergmann /* FIXME we need locking around tagwait */ 1507a33a7d73SArnd Bergmann *status = ctx->ops->read_mfc_tagstatus(ctx) & ctx->tagwait; 1508a33a7d73SArnd Bergmann ctx->tagwait &= ~*status; 1509a33a7d73SArnd Bergmann if (*status) 1510a33a7d73SArnd Bergmann return 1; 1511a33a7d73SArnd Bergmann 1512a33a7d73SArnd Bergmann /* enable interrupt waiting for any tag group, 1513a33a7d73SArnd Bergmann may silently fail if interrupts are already enabled */ 1514a33a7d73SArnd Bergmann ctx->ops->set_mfc_query(ctx, ctx->tagwait, 1); 1515a33a7d73SArnd Bergmann return 0; 1516a33a7d73SArnd Bergmann } 1517a33a7d73SArnd Bergmann 1518a33a7d73SArnd Bergmann static ssize_t spufs_mfc_read(struct file *file, char __user *buffer, 1519a33a7d73SArnd Bergmann size_t size, loff_t *pos) 1520a33a7d73SArnd Bergmann { 1521a33a7d73SArnd Bergmann struct spu_context *ctx = file->private_data; 1522a33a7d73SArnd Bergmann int ret = -EINVAL; 1523a33a7d73SArnd Bergmann u32 status; 1524a33a7d73SArnd Bergmann 1525a33a7d73SArnd Bergmann if (size != 4) 1526a33a7d73SArnd Bergmann goto out; 1527a33a7d73SArnd Bergmann 1528c9101bdbSChristoph Hellwig ret = spu_acquire(ctx); 1529c9101bdbSChristoph Hellwig if (ret) 1530c9101bdbSChristoph Hellwig return ret; 1531c9101bdbSChristoph Hellwig 1532c9101bdbSChristoph Hellwig ret = -EINVAL; 1533a33a7d73SArnd Bergmann if (file->f_flags & O_NONBLOCK) { 1534a33a7d73SArnd Bergmann status = ctx->ops->read_mfc_tagstatus(ctx); 1535a33a7d73SArnd Bergmann if (!(status & ctx->tagwait)) 1536a33a7d73SArnd Bergmann ret = -EAGAIN; 1537a33a7d73SArnd Bergmann else 1538c9101bdbSChristoph Hellwig /* XXX(hch): shouldn't we clear ret here? */ 1539a33a7d73SArnd Bergmann ctx->tagwait &= ~status; 1540a33a7d73SArnd Bergmann } else { 1541a33a7d73SArnd Bergmann ret = spufs_wait(ctx->mfc_wq, 1542a33a7d73SArnd Bergmann spufs_read_mfc_tagstatus(ctx, &status)); 1543a33a7d73SArnd Bergmann if (ret) 1544a33a7d73SArnd Bergmann goto out; 1545eebead5bSChristoph Hellwig } 1546eebead5bSChristoph Hellwig spu_release(ctx); 1547a33a7d73SArnd Bergmann 1548a33a7d73SArnd Bergmann ret = 4; 1549a33a7d73SArnd Bergmann if (copy_to_user(buffer, &status, 4)) 1550a33a7d73SArnd Bergmann ret = -EFAULT; 1551a33a7d73SArnd Bergmann 1552a33a7d73SArnd Bergmann out: 1553a33a7d73SArnd Bergmann return ret; 1554a33a7d73SArnd Bergmann } 1555a33a7d73SArnd Bergmann 1556a33a7d73SArnd Bergmann static int spufs_check_valid_dma(struct mfc_dma_command *cmd) 1557a33a7d73SArnd Bergmann { 15589477e455SStephen Rothwell pr_debug("queueing DMA %x %llx %x %x %x\n", cmd->lsa, 1559a33a7d73SArnd Bergmann cmd->ea, cmd->size, cmd->tag, cmd->cmd); 1560a33a7d73SArnd Bergmann 1561a33a7d73SArnd Bergmann switch (cmd->cmd) { 1562a33a7d73SArnd Bergmann case MFC_PUT_CMD: 1563a33a7d73SArnd Bergmann case MFC_PUTF_CMD: 1564a33a7d73SArnd Bergmann case MFC_PUTB_CMD: 1565a33a7d73SArnd Bergmann case MFC_GET_CMD: 1566a33a7d73SArnd Bergmann case MFC_GETF_CMD: 1567a33a7d73SArnd Bergmann case MFC_GETB_CMD: 1568a33a7d73SArnd Bergmann break; 1569a33a7d73SArnd Bergmann default: 1570a33a7d73SArnd Bergmann pr_debug("invalid DMA opcode %x\n", cmd->cmd); 1571a33a7d73SArnd Bergmann return -EIO; 1572a33a7d73SArnd Bergmann } 1573a33a7d73SArnd Bergmann 1574a33a7d73SArnd Bergmann if ((cmd->lsa & 0xf) != (cmd->ea &0xf)) { 15759477e455SStephen Rothwell pr_debug("invalid DMA alignment, ea %llx lsa %x\n", 1576a33a7d73SArnd Bergmann cmd->ea, cmd->lsa); 1577a33a7d73SArnd Bergmann return -EIO; 1578a33a7d73SArnd Bergmann } 1579a33a7d73SArnd Bergmann 1580a33a7d73SArnd Bergmann switch (cmd->size & 0xf) { 1581a33a7d73SArnd Bergmann case 1: 1582a33a7d73SArnd Bergmann break; 1583a33a7d73SArnd Bergmann case 2: 1584a33a7d73SArnd Bergmann if (cmd->lsa & 1) 1585a33a7d73SArnd Bergmann goto error; 1586a33a7d73SArnd Bergmann break; 1587a33a7d73SArnd Bergmann case 4: 1588a33a7d73SArnd Bergmann if (cmd->lsa & 3) 1589a33a7d73SArnd Bergmann goto error; 1590a33a7d73SArnd Bergmann break; 1591a33a7d73SArnd Bergmann case 8: 1592a33a7d73SArnd Bergmann if (cmd->lsa & 7) 1593a33a7d73SArnd Bergmann goto error; 1594a33a7d73SArnd Bergmann break; 1595a33a7d73SArnd Bergmann case 0: 1596a33a7d73SArnd Bergmann if (cmd->lsa & 15) 1597a33a7d73SArnd Bergmann goto error; 1598a33a7d73SArnd Bergmann break; 1599a33a7d73SArnd Bergmann error: 1600a33a7d73SArnd Bergmann default: 1601a33a7d73SArnd Bergmann pr_debug("invalid DMA alignment %x for size %x\n", 1602a33a7d73SArnd Bergmann cmd->lsa & 0xf, cmd->size); 1603a33a7d73SArnd Bergmann return -EIO; 1604a33a7d73SArnd Bergmann } 1605a33a7d73SArnd Bergmann 1606a33a7d73SArnd Bergmann if (cmd->size > 16 * 1024) { 1607a33a7d73SArnd Bergmann pr_debug("invalid DMA size %x\n", cmd->size); 1608a33a7d73SArnd Bergmann return -EIO; 1609a33a7d73SArnd Bergmann } 1610a33a7d73SArnd Bergmann 1611a33a7d73SArnd Bergmann if (cmd->tag & 0xfff0) { 1612a33a7d73SArnd Bergmann /* we reserve the higher tag numbers for kernel use */ 1613a33a7d73SArnd Bergmann pr_debug("invalid DMA tag\n"); 1614a33a7d73SArnd Bergmann return -EIO; 1615a33a7d73SArnd Bergmann } 1616a33a7d73SArnd Bergmann 1617a33a7d73SArnd Bergmann if (cmd->class) { 1618a33a7d73SArnd Bergmann /* not supported in this version */ 1619a33a7d73SArnd Bergmann pr_debug("invalid DMA class\n"); 1620a33a7d73SArnd Bergmann return -EIO; 1621a33a7d73SArnd Bergmann } 1622a33a7d73SArnd Bergmann 1623a33a7d73SArnd Bergmann return 0; 1624a33a7d73SArnd Bergmann } 1625a33a7d73SArnd Bergmann 1626a33a7d73SArnd Bergmann static int spu_send_mfc_command(struct spu_context *ctx, 1627a33a7d73SArnd Bergmann struct mfc_dma_command cmd, 1628a33a7d73SArnd Bergmann int *error) 1629a33a7d73SArnd Bergmann { 1630a33a7d73SArnd Bergmann *error = ctx->ops->send_mfc_command(ctx, &cmd); 1631a33a7d73SArnd Bergmann if (*error == -EAGAIN) { 1632a33a7d73SArnd Bergmann /* wait for any tag group to complete 1633a33a7d73SArnd Bergmann so we have space for the new command */ 1634a33a7d73SArnd Bergmann ctx->ops->set_mfc_query(ctx, ctx->tagwait, 1); 1635a33a7d73SArnd Bergmann /* try again, because the queue might be 1636a33a7d73SArnd Bergmann empty again */ 1637a33a7d73SArnd Bergmann *error = ctx->ops->send_mfc_command(ctx, &cmd); 1638a33a7d73SArnd Bergmann if (*error == -EAGAIN) 1639a33a7d73SArnd Bergmann return 0; 1640a33a7d73SArnd Bergmann } 1641a33a7d73SArnd Bergmann return 1; 1642a33a7d73SArnd Bergmann } 1643a33a7d73SArnd Bergmann 1644a33a7d73SArnd Bergmann static ssize_t spufs_mfc_write(struct file *file, const char __user *buffer, 1645a33a7d73SArnd Bergmann size_t size, loff_t *pos) 1646a33a7d73SArnd Bergmann { 1647a33a7d73SArnd Bergmann struct spu_context *ctx = file->private_data; 1648a33a7d73SArnd Bergmann struct mfc_dma_command cmd; 1649a33a7d73SArnd Bergmann int ret = -EINVAL; 1650a33a7d73SArnd Bergmann 1651a33a7d73SArnd Bergmann if (size != sizeof cmd) 1652a33a7d73SArnd Bergmann goto out; 1653a33a7d73SArnd Bergmann 1654a33a7d73SArnd Bergmann ret = -EFAULT; 1655a33a7d73SArnd Bergmann if (copy_from_user(&cmd, buffer, sizeof cmd)) 1656a33a7d73SArnd Bergmann goto out; 1657a33a7d73SArnd Bergmann 1658a33a7d73SArnd Bergmann ret = spufs_check_valid_dma(&cmd); 1659a33a7d73SArnd Bergmann if (ret) 1660a33a7d73SArnd Bergmann goto out; 1661a33a7d73SArnd Bergmann 1662c9101bdbSChristoph Hellwig ret = spu_acquire(ctx); 1663c9101bdbSChristoph Hellwig if (ret) 1664c9101bdbSChristoph Hellwig goto out; 1665c9101bdbSChristoph Hellwig 166633bfd7a7SArnd Bergmann ret = spufs_wait(ctx->run_wq, ctx->state == SPU_STATE_RUNNABLE); 1667577f8f10SAkinobu Mita if (ret) 1668577f8f10SAkinobu Mita goto out; 1669577f8f10SAkinobu Mita 1670a33a7d73SArnd Bergmann if (file->f_flags & O_NONBLOCK) { 1671a33a7d73SArnd Bergmann ret = ctx->ops->send_mfc_command(ctx, &cmd); 1672a33a7d73SArnd Bergmann } else { 1673a33a7d73SArnd Bergmann int status; 1674a33a7d73SArnd Bergmann ret = spufs_wait(ctx->mfc_wq, 1675a33a7d73SArnd Bergmann spu_send_mfc_command(ctx, cmd, &status)); 1676eebead5bSChristoph Hellwig if (ret) 1677eebead5bSChristoph Hellwig goto out; 1678a33a7d73SArnd Bergmann if (status) 1679a33a7d73SArnd Bergmann ret = status; 1680a33a7d73SArnd Bergmann } 1681a33a7d73SArnd Bergmann 1682a33a7d73SArnd Bergmann if (ret) 1683933b0e35SKazunori Asayama goto out_unlock; 1684a33a7d73SArnd Bergmann 1685a33a7d73SArnd Bergmann ctx->tagwait |= 1 << cmd.tag; 16863692dc66SMasato Noguchi ret = size; 1687a33a7d73SArnd Bergmann 1688933b0e35SKazunori Asayama out_unlock: 1689933b0e35SKazunori Asayama spu_release(ctx); 1690a33a7d73SArnd Bergmann out: 1691a33a7d73SArnd Bergmann return ret; 1692a33a7d73SArnd Bergmann } 1693a33a7d73SArnd Bergmann 1694a33a7d73SArnd Bergmann static unsigned int spufs_mfc_poll(struct file *file,poll_table *wait) 1695a33a7d73SArnd Bergmann { 1696a33a7d73SArnd Bergmann struct spu_context *ctx = file->private_data; 1697a33a7d73SArnd Bergmann u32 free_elements, tagstatus; 1698a33a7d73SArnd Bergmann unsigned int mask; 1699a33a7d73SArnd Bergmann 1700933b0e35SKazunori Asayama poll_wait(file, &ctx->mfc_wq, wait); 1701933b0e35SKazunori Asayama 1702c9101bdbSChristoph Hellwig /* 1703c9101bdbSChristoph Hellwig * For now keep this uninterruptible and also ignore the rule 1704c9101bdbSChristoph Hellwig * that poll should not sleep. Will be fixed later. 1705c9101bdbSChristoph Hellwig */ 1706c9101bdbSChristoph Hellwig mutex_lock(&ctx->state_mutex); 1707a33a7d73SArnd Bergmann ctx->ops->set_mfc_query(ctx, ctx->tagwait, 2); 1708a33a7d73SArnd Bergmann free_elements = ctx->ops->get_mfc_free_elements(ctx); 1709a33a7d73SArnd Bergmann tagstatus = ctx->ops->read_mfc_tagstatus(ctx); 1710a33a7d73SArnd Bergmann spu_release(ctx); 1711a33a7d73SArnd Bergmann 1712a33a7d73SArnd Bergmann mask = 0; 1713a33a7d73SArnd Bergmann if (free_elements & 0xffff) 1714a33a7d73SArnd Bergmann mask |= POLLOUT | POLLWRNORM; 1715a33a7d73SArnd Bergmann if (tagstatus & ctx->tagwait) 1716a33a7d73SArnd Bergmann mask |= POLLIN | POLLRDNORM; 1717a33a7d73SArnd Bergmann 1718e48b1b45SHarvey Harrison pr_debug("%s: free %d tagstatus %d tagwait %d\n", __func__, 1719a33a7d73SArnd Bergmann free_elements, tagstatus, ctx->tagwait); 1720a33a7d73SArnd Bergmann 1721a33a7d73SArnd Bergmann return mask; 1722a33a7d73SArnd Bergmann } 1723a33a7d73SArnd Bergmann 172473b6af8aSAl Viro static int spufs_mfc_flush(struct file *file, fl_owner_t id) 1725a33a7d73SArnd Bergmann { 1726a33a7d73SArnd Bergmann struct spu_context *ctx = file->private_data; 1727a33a7d73SArnd Bergmann int ret; 1728a33a7d73SArnd Bergmann 1729c9101bdbSChristoph Hellwig ret = spu_acquire(ctx); 1730c9101bdbSChristoph Hellwig if (ret) 1731eebead5bSChristoph Hellwig goto out; 1732a33a7d73SArnd Bergmann #if 0 1733a33a7d73SArnd Bergmann /* this currently hangs */ 1734a33a7d73SArnd Bergmann ret = spufs_wait(ctx->mfc_wq, 1735a33a7d73SArnd Bergmann ctx->ops->set_mfc_query(ctx, ctx->tagwait, 2)); 1736a33a7d73SArnd Bergmann if (ret) 1737a33a7d73SArnd Bergmann goto out; 1738a33a7d73SArnd Bergmann ret = spufs_wait(ctx->mfc_wq, 1739a33a7d73SArnd Bergmann ctx->ops->read_mfc_tagstatus(ctx) == ctx->tagwait); 1740eebead5bSChristoph Hellwig if (ret) 1741eebead5bSChristoph Hellwig goto out; 1742a33a7d73SArnd Bergmann #else 1743a33a7d73SArnd Bergmann ret = 0; 1744a33a7d73SArnd Bergmann #endif 1745a33a7d73SArnd Bergmann spu_release(ctx); 1746eebead5bSChristoph Hellwig out: 1747a33a7d73SArnd Bergmann return ret; 1748a33a7d73SArnd Bergmann } 1749a33a7d73SArnd Bergmann 175002c24a82SJosef Bacik static int spufs_mfc_fsync(struct file *file, loff_t start, loff_t end, int datasync) 1751a33a7d73SArnd Bergmann { 1752496ad9aaSAl Viro struct inode *inode = file_inode(file); 175302c24a82SJosef Bacik int err = filemap_write_and_wait_range(inode->i_mapping, start, end); 175402c24a82SJosef Bacik if (!err) { 17555955102cSAl Viro inode_lock(inode); 175602c24a82SJosef Bacik err = spufs_mfc_flush(file, NULL); 17575955102cSAl Viro inode_unlock(inode); 175802c24a82SJosef Bacik } 175902c24a82SJosef Bacik return err; 1760a33a7d73SArnd Bergmann } 1761a33a7d73SArnd Bergmann 17625dfe4c96SArjan van de Ven static const struct file_operations spufs_mfc_fops = { 1763a33a7d73SArnd Bergmann .open = spufs_mfc_open, 176443c2bbd9SChristoph Hellwig .release = spufs_mfc_release, 1765a33a7d73SArnd Bergmann .read = spufs_mfc_read, 1766a33a7d73SArnd Bergmann .write = spufs_mfc_write, 1767a33a7d73SArnd Bergmann .poll = spufs_mfc_poll, 1768a33a7d73SArnd Bergmann .flush = spufs_mfc_flush, 1769a33a7d73SArnd Bergmann .fsync = spufs_mfc_fsync, 17706df10a82SMark Nutter .mmap = spufs_mfc_mmap, 1771fc15351dSArnd Bergmann .llseek = no_llseek, 1772a33a7d73SArnd Bergmann }; 1773a33a7d73SArnd Bergmann 1774197b1a82SChristoph Hellwig static int spufs_npc_set(void *data, u64 val) 177567207b96SArnd Bergmann { 177667207b96SArnd Bergmann struct spu_context *ctx = data; 1777c9101bdbSChristoph Hellwig int ret; 1778c9101bdbSChristoph Hellwig 1779c9101bdbSChristoph Hellwig ret = spu_acquire(ctx); 1780c9101bdbSChristoph Hellwig if (ret) 1781c9101bdbSChristoph Hellwig return ret; 17828b3d6663SArnd Bergmann ctx->ops->npc_write(ctx, val); 17838b3d6663SArnd Bergmann spu_release(ctx); 1784197b1a82SChristoph Hellwig 1785197b1a82SChristoph Hellwig return 0; 178667207b96SArnd Bergmann } 178767207b96SArnd Bergmann 1788104f0cc2SMichael Ellerman static u64 spufs_npc_get(struct spu_context *ctx) 178978810ff6SMichael Ellerman { 179078810ff6SMichael Ellerman return ctx->ops->npc_read(ctx); 179178810ff6SMichael Ellerman } 1792104f0cc2SMichael Ellerman DEFINE_SPUFS_ATTRIBUTE(spufs_npc_ops, spufs_npc_get, spufs_npc_set, 1793104f0cc2SMichael Ellerman "0x%llx\n", SPU_ATTR_ACQUIRE); 179467207b96SArnd Bergmann 1795197b1a82SChristoph Hellwig static int spufs_decr_set(void *data, u64 val) 17968b3d6663SArnd Bergmann { 17978b3d6663SArnd Bergmann struct spu_context *ctx = data; 17988b3d6663SArnd Bergmann struct spu_lscsa *lscsa = ctx->csa.lscsa; 1799c9101bdbSChristoph Hellwig int ret; 1800c9101bdbSChristoph Hellwig 1801c9101bdbSChristoph Hellwig ret = spu_acquire_saved(ctx); 1802c9101bdbSChristoph Hellwig if (ret) 1803c9101bdbSChristoph Hellwig return ret; 18048b3d6663SArnd Bergmann lscsa->decr.slot[0] = (u32) val; 180527b1ea09SChristoph Hellwig spu_release_saved(ctx); 1806197b1a82SChristoph Hellwig 1807197b1a82SChristoph Hellwig return 0; 18088b3d6663SArnd Bergmann } 18098b3d6663SArnd Bergmann 1810104f0cc2SMichael Ellerman static u64 spufs_decr_get(struct spu_context *ctx) 18118b3d6663SArnd Bergmann { 18128b3d6663SArnd Bergmann struct spu_lscsa *lscsa = ctx->csa.lscsa; 1813bf1ab978SDwayne Grant McConnell return lscsa->decr.slot[0]; 1814bf1ab978SDwayne Grant McConnell } 1815104f0cc2SMichael Ellerman DEFINE_SPUFS_ATTRIBUTE(spufs_decr_ops, spufs_decr_get, spufs_decr_set, 1816104f0cc2SMichael Ellerman "0x%llx\n", SPU_ATTR_ACQUIRE_SAVED); 18178b3d6663SArnd Bergmann 1818197b1a82SChristoph Hellwig static int spufs_decr_status_set(void *data, u64 val) 18198b3d6663SArnd Bergmann { 18208b3d6663SArnd Bergmann struct spu_context *ctx = data; 1821c9101bdbSChristoph Hellwig int ret; 1822c9101bdbSChristoph Hellwig 1823c9101bdbSChristoph Hellwig ret = spu_acquire_saved(ctx); 1824c9101bdbSChristoph Hellwig if (ret) 1825c9101bdbSChristoph Hellwig return ret; 1826d40a01d4SMasato Noguchi if (val) 1827d40a01d4SMasato Noguchi ctx->csa.priv2.mfc_control_RW |= MFC_CNTL_DECREMENTER_RUNNING; 1828d40a01d4SMasato Noguchi else 1829d40a01d4SMasato Noguchi ctx->csa.priv2.mfc_control_RW &= ~MFC_CNTL_DECREMENTER_RUNNING; 183027b1ea09SChristoph Hellwig spu_release_saved(ctx); 1831197b1a82SChristoph Hellwig 1832197b1a82SChristoph Hellwig return 0; 18338b3d6663SArnd Bergmann } 18348b3d6663SArnd Bergmann 1835104f0cc2SMichael Ellerman static u64 spufs_decr_status_get(struct spu_context *ctx) 18368b3d6663SArnd Bergmann { 1837d40a01d4SMasato Noguchi if (ctx->csa.priv2.mfc_control_RW & MFC_CNTL_DECREMENTER_RUNNING) 1838d40a01d4SMasato Noguchi return SPU_DECR_STATUS_RUNNING; 1839d40a01d4SMasato Noguchi else 1840d40a01d4SMasato Noguchi return 0; 1841bf1ab978SDwayne Grant McConnell } 1842104f0cc2SMichael Ellerman DEFINE_SPUFS_ATTRIBUTE(spufs_decr_status_ops, spufs_decr_status_get, 1843104f0cc2SMichael Ellerman spufs_decr_status_set, "0x%llx\n", 1844104f0cc2SMichael Ellerman SPU_ATTR_ACQUIRE_SAVED); 18458b3d6663SArnd Bergmann 1846197b1a82SChristoph Hellwig static int spufs_event_mask_set(void *data, u64 val) 18478b3d6663SArnd Bergmann { 18488b3d6663SArnd Bergmann struct spu_context *ctx = data; 18498b3d6663SArnd Bergmann struct spu_lscsa *lscsa = ctx->csa.lscsa; 1850c9101bdbSChristoph Hellwig int ret; 1851c9101bdbSChristoph Hellwig 1852c9101bdbSChristoph Hellwig ret = spu_acquire_saved(ctx); 1853c9101bdbSChristoph Hellwig if (ret) 1854c9101bdbSChristoph Hellwig return ret; 18558b3d6663SArnd Bergmann lscsa->event_mask.slot[0] = (u32) val; 185627b1ea09SChristoph Hellwig spu_release_saved(ctx); 1857197b1a82SChristoph Hellwig 1858197b1a82SChristoph Hellwig return 0; 18598b3d6663SArnd Bergmann } 18608b3d6663SArnd Bergmann 1861104f0cc2SMichael Ellerman static u64 spufs_event_mask_get(struct spu_context *ctx) 18628b3d6663SArnd Bergmann { 18638b3d6663SArnd Bergmann struct spu_lscsa *lscsa = ctx->csa.lscsa; 1864bf1ab978SDwayne Grant McConnell return lscsa->event_mask.slot[0]; 1865bf1ab978SDwayne Grant McConnell } 1866bf1ab978SDwayne Grant McConnell 1867104f0cc2SMichael Ellerman DEFINE_SPUFS_ATTRIBUTE(spufs_event_mask_ops, spufs_event_mask_get, 1868104f0cc2SMichael Ellerman spufs_event_mask_set, "0x%llx\n", 1869104f0cc2SMichael Ellerman SPU_ATTR_ACQUIRE_SAVED); 18708b3d6663SArnd Bergmann 1871104f0cc2SMichael Ellerman static u64 spufs_event_status_get(struct spu_context *ctx) 1872b9e3bd77SDwayne Grant McConnell { 1873b9e3bd77SDwayne Grant McConnell struct spu_state *state = &ctx->csa; 1874b9e3bd77SDwayne Grant McConnell u64 stat; 1875b9e3bd77SDwayne Grant McConnell stat = state->spu_chnlcnt_RW[0]; 1876b9e3bd77SDwayne Grant McConnell if (stat) 1877bf1ab978SDwayne Grant McConnell return state->spu_chnldata_RW[0]; 1878bf1ab978SDwayne Grant McConnell return 0; 1879bf1ab978SDwayne Grant McConnell } 1880104f0cc2SMichael Ellerman DEFINE_SPUFS_ATTRIBUTE(spufs_event_status_ops, spufs_event_status_get, 1881104f0cc2SMichael Ellerman NULL, "0x%llx\n", SPU_ATTR_ACQUIRE_SAVED) 1882b9e3bd77SDwayne Grant McConnell 1883197b1a82SChristoph Hellwig static int spufs_srr0_set(void *data, u64 val) 18848b3d6663SArnd Bergmann { 18858b3d6663SArnd Bergmann struct spu_context *ctx = data; 18868b3d6663SArnd Bergmann struct spu_lscsa *lscsa = ctx->csa.lscsa; 1887c9101bdbSChristoph Hellwig int ret; 1888c9101bdbSChristoph Hellwig 1889c9101bdbSChristoph Hellwig ret = spu_acquire_saved(ctx); 1890c9101bdbSChristoph Hellwig if (ret) 1891c9101bdbSChristoph Hellwig return ret; 18928b3d6663SArnd Bergmann lscsa->srr0.slot[0] = (u32) val; 189327b1ea09SChristoph Hellwig spu_release_saved(ctx); 1894197b1a82SChristoph Hellwig 1895197b1a82SChristoph Hellwig return 0; 18968b3d6663SArnd Bergmann } 18978b3d6663SArnd Bergmann 1898104f0cc2SMichael Ellerman static u64 spufs_srr0_get(struct spu_context *ctx) 18998b3d6663SArnd Bergmann { 19008b3d6663SArnd Bergmann struct spu_lscsa *lscsa = ctx->csa.lscsa; 1901104f0cc2SMichael Ellerman return lscsa->srr0.slot[0]; 19028b3d6663SArnd Bergmann } 1903104f0cc2SMichael Ellerman DEFINE_SPUFS_ATTRIBUTE(spufs_srr0_ops, spufs_srr0_get, spufs_srr0_set, 1904104f0cc2SMichael Ellerman "0x%llx\n", SPU_ATTR_ACQUIRE_SAVED) 19058b3d6663SArnd Bergmann 1906104f0cc2SMichael Ellerman static u64 spufs_id_get(struct spu_context *ctx) 19077b1a7014Sarnd@arndb.de { 19087b1a7014Sarnd@arndb.de u64 num; 19097b1a7014Sarnd@arndb.de 19107b1a7014Sarnd@arndb.de if (ctx->state == SPU_STATE_RUNNABLE) 19117b1a7014Sarnd@arndb.de num = ctx->spu->number; 19127b1a7014Sarnd@arndb.de else 19137b1a7014Sarnd@arndb.de num = (unsigned int)-1; 19147b1a7014Sarnd@arndb.de 19157b1a7014Sarnd@arndb.de return num; 19167b1a7014Sarnd@arndb.de } 1917104f0cc2SMichael Ellerman DEFINE_SPUFS_ATTRIBUTE(spufs_id_ops, spufs_id_get, NULL, "0x%llx\n", 1918104f0cc2SMichael Ellerman SPU_ATTR_ACQUIRE) 19197b1a7014Sarnd@arndb.de 1920104f0cc2SMichael Ellerman static u64 spufs_object_id_get(struct spu_context *ctx) 1921bf1ab978SDwayne Grant McConnell { 1922bf1ab978SDwayne Grant McConnell /* FIXME: Should there really be no locking here? */ 1923104f0cc2SMichael Ellerman return ctx->object_id; 1924bf1ab978SDwayne Grant McConnell } 1925bf1ab978SDwayne Grant McConnell 1926197b1a82SChristoph Hellwig static int spufs_object_id_set(void *data, u64 id) 192786767277SArnd Bergmann { 192886767277SArnd Bergmann struct spu_context *ctx = data; 192986767277SArnd Bergmann ctx->object_id = id; 1930197b1a82SChristoph Hellwig 1931197b1a82SChristoph Hellwig return 0; 193286767277SArnd Bergmann } 193386767277SArnd Bergmann 1934104f0cc2SMichael Ellerman DEFINE_SPUFS_ATTRIBUTE(spufs_object_id_ops, spufs_object_id_get, 1935104f0cc2SMichael Ellerman spufs_object_id_set, "0x%llx\n", SPU_ATTR_NOACQUIRE); 193686767277SArnd Bergmann 1937104f0cc2SMichael Ellerman static u64 spufs_lslr_get(struct spu_context *ctx) 1938bf1ab978SDwayne Grant McConnell { 1939bf1ab978SDwayne Grant McConnell return ctx->csa.priv2.spu_lslr_RW; 1940bf1ab978SDwayne Grant McConnell } 1941104f0cc2SMichael Ellerman DEFINE_SPUFS_ATTRIBUTE(spufs_lslr_ops, spufs_lslr_get, NULL, "0x%llx\n", 1942104f0cc2SMichael Ellerman SPU_ATTR_ACQUIRE_SAVED); 1943b9e3bd77SDwayne Grant McConnell 1944b9e3bd77SDwayne Grant McConnell static int spufs_info_open(struct inode *inode, struct file *file) 1945b9e3bd77SDwayne Grant McConnell { 1946b9e3bd77SDwayne Grant McConnell struct spufs_inode_info *i = SPUFS_I(inode); 1947b9e3bd77SDwayne Grant McConnell struct spu_context *ctx = i->i_ctx; 1948b9e3bd77SDwayne Grant McConnell file->private_data = ctx; 1949b9e3bd77SDwayne Grant McConnell return 0; 1950b9e3bd77SDwayne Grant McConnell } 1951b9e3bd77SDwayne Grant McConnell 1952cbe709c1SBenjamin Herrenschmidt static int spufs_caps_show(struct seq_file *s, void *private) 1953cbe709c1SBenjamin Herrenschmidt { 1954cbe709c1SBenjamin Herrenschmidt struct spu_context *ctx = s->private; 1955cbe709c1SBenjamin Herrenschmidt 1956cbe709c1SBenjamin Herrenschmidt if (!(ctx->flags & SPU_CREATE_NOSCHED)) 1957cbe709c1SBenjamin Herrenschmidt seq_puts(s, "sched\n"); 1958cbe709c1SBenjamin Herrenschmidt if (!(ctx->flags & SPU_CREATE_ISOLATE)) 1959cbe709c1SBenjamin Herrenschmidt seq_puts(s, "step\n"); 1960cbe709c1SBenjamin Herrenschmidt return 0; 1961cbe709c1SBenjamin Herrenschmidt } 1962cbe709c1SBenjamin Herrenschmidt 1963cbe709c1SBenjamin Herrenschmidt static int spufs_caps_open(struct inode *inode, struct file *file) 1964cbe709c1SBenjamin Herrenschmidt { 1965cbe709c1SBenjamin Herrenschmidt return single_open(file, spufs_caps_show, SPUFS_I(inode)->i_ctx); 1966cbe709c1SBenjamin Herrenschmidt } 1967cbe709c1SBenjamin Herrenschmidt 1968cbe709c1SBenjamin Herrenschmidt static const struct file_operations spufs_caps_fops = { 1969cbe709c1SBenjamin Herrenschmidt .open = spufs_caps_open, 1970cbe709c1SBenjamin Herrenschmidt .read = seq_read, 1971cbe709c1SBenjamin Herrenschmidt .llseek = seq_lseek, 1972cbe709c1SBenjamin Herrenschmidt .release = single_release, 1973cbe709c1SBenjamin Herrenschmidt }; 1974cbe709c1SBenjamin Herrenschmidt 1975bf1ab978SDwayne Grant McConnell static ssize_t __spufs_mbox_info_read(struct spu_context *ctx, 1976bf1ab978SDwayne Grant McConnell char __user *buf, size_t len, loff_t *pos) 1977bf1ab978SDwayne Grant McConnell { 1978bf1ab978SDwayne Grant McConnell u32 data; 1979bf1ab978SDwayne Grant McConnell 1980cbea9238SJeremy Kerr /* EOF if there's no entry in the mbox */ 1981cbea9238SJeremy Kerr if (!(ctx->csa.prob.mb_stat_R & 0x0000ff)) 1982cbea9238SJeremy Kerr return 0; 1983cbea9238SJeremy Kerr 1984bf1ab978SDwayne Grant McConnell data = ctx->csa.prob.pu_mb_R; 1985bf1ab978SDwayne Grant McConnell 1986bf1ab978SDwayne Grant McConnell return simple_read_from_buffer(buf, len, pos, &data, sizeof data); 1987bf1ab978SDwayne Grant McConnell } 1988bf1ab978SDwayne Grant McConnell 198969a2f00cSDwayne Grant McConnell static ssize_t spufs_mbox_info_read(struct file *file, char __user *buf, 199069a2f00cSDwayne Grant McConnell size_t len, loff_t *pos) 199169a2f00cSDwayne Grant McConnell { 1992bf1ab978SDwayne Grant McConnell int ret; 199369a2f00cSDwayne Grant McConnell struct spu_context *ctx = file->private_data; 199469a2f00cSDwayne Grant McConnell 199569a2f00cSDwayne Grant McConnell if (!access_ok(VERIFY_WRITE, buf, len)) 199669a2f00cSDwayne Grant McConnell return -EFAULT; 199769a2f00cSDwayne Grant McConnell 1998c9101bdbSChristoph Hellwig ret = spu_acquire_saved(ctx); 1999c9101bdbSChristoph Hellwig if (ret) 2000c9101bdbSChristoph Hellwig return ret; 200169a2f00cSDwayne Grant McConnell spin_lock(&ctx->csa.register_lock); 2002bf1ab978SDwayne Grant McConnell ret = __spufs_mbox_info_read(ctx, buf, len, pos); 200369a2f00cSDwayne Grant McConnell spin_unlock(&ctx->csa.register_lock); 200427b1ea09SChristoph Hellwig spu_release_saved(ctx); 200569a2f00cSDwayne Grant McConnell 2006bf1ab978SDwayne Grant McConnell return ret; 200769a2f00cSDwayne Grant McConnell } 200869a2f00cSDwayne Grant McConnell 20095dfe4c96SArjan van de Ven static const struct file_operations spufs_mbox_info_fops = { 201069a2f00cSDwayne Grant McConnell .open = spufs_info_open, 201169a2f00cSDwayne Grant McConnell .read = spufs_mbox_info_read, 201269a2f00cSDwayne Grant McConnell .llseek = generic_file_llseek, 201369a2f00cSDwayne Grant McConnell }; 201469a2f00cSDwayne Grant McConnell 2015bf1ab978SDwayne Grant McConnell static ssize_t __spufs_ibox_info_read(struct spu_context *ctx, 2016bf1ab978SDwayne Grant McConnell char __user *buf, size_t len, loff_t *pos) 2017bf1ab978SDwayne Grant McConnell { 2018bf1ab978SDwayne Grant McConnell u32 data; 2019bf1ab978SDwayne Grant McConnell 2020cbea9238SJeremy Kerr /* EOF if there's no entry in the ibox */ 2021cbea9238SJeremy Kerr if (!(ctx->csa.prob.mb_stat_R & 0xff0000)) 2022cbea9238SJeremy Kerr return 0; 2023cbea9238SJeremy Kerr 2024bf1ab978SDwayne Grant McConnell data = ctx->csa.priv2.puint_mb_R; 2025bf1ab978SDwayne Grant McConnell 2026bf1ab978SDwayne Grant McConnell return simple_read_from_buffer(buf, len, pos, &data, sizeof data); 2027bf1ab978SDwayne Grant McConnell } 2028bf1ab978SDwayne Grant McConnell 202969a2f00cSDwayne Grant McConnell static ssize_t spufs_ibox_info_read(struct file *file, char __user *buf, 203069a2f00cSDwayne Grant McConnell size_t len, loff_t *pos) 203169a2f00cSDwayne Grant McConnell { 203269a2f00cSDwayne Grant McConnell struct spu_context *ctx = file->private_data; 2033bf1ab978SDwayne Grant McConnell int ret; 203469a2f00cSDwayne Grant McConnell 203569a2f00cSDwayne Grant McConnell if (!access_ok(VERIFY_WRITE, buf, len)) 203669a2f00cSDwayne Grant McConnell return -EFAULT; 203769a2f00cSDwayne Grant McConnell 2038c9101bdbSChristoph Hellwig ret = spu_acquire_saved(ctx); 2039c9101bdbSChristoph Hellwig if (ret) 2040c9101bdbSChristoph Hellwig return ret; 204169a2f00cSDwayne Grant McConnell spin_lock(&ctx->csa.register_lock); 2042bf1ab978SDwayne Grant McConnell ret = __spufs_ibox_info_read(ctx, buf, len, pos); 204369a2f00cSDwayne Grant McConnell spin_unlock(&ctx->csa.register_lock); 204427b1ea09SChristoph Hellwig spu_release_saved(ctx); 204569a2f00cSDwayne Grant McConnell 2046bf1ab978SDwayne Grant McConnell return ret; 204769a2f00cSDwayne Grant McConnell } 204869a2f00cSDwayne Grant McConnell 20495dfe4c96SArjan van de Ven static const struct file_operations spufs_ibox_info_fops = { 205069a2f00cSDwayne Grant McConnell .open = spufs_info_open, 205169a2f00cSDwayne Grant McConnell .read = spufs_ibox_info_read, 205269a2f00cSDwayne Grant McConnell .llseek = generic_file_llseek, 205369a2f00cSDwayne Grant McConnell }; 205469a2f00cSDwayne Grant McConnell 2055bf1ab978SDwayne Grant McConnell static ssize_t __spufs_wbox_info_read(struct spu_context *ctx, 2056bf1ab978SDwayne Grant McConnell char __user *buf, size_t len, loff_t *pos) 2057bf1ab978SDwayne Grant McConnell { 2058bf1ab978SDwayne Grant McConnell int i, cnt; 2059bf1ab978SDwayne Grant McConnell u32 data[4]; 2060bf1ab978SDwayne Grant McConnell u32 wbox_stat; 2061bf1ab978SDwayne Grant McConnell 2062bf1ab978SDwayne Grant McConnell wbox_stat = ctx->csa.prob.mb_stat_R; 2063bf1ab978SDwayne Grant McConnell cnt = 4 - ((wbox_stat & 0x00ff00) >> 8); 2064bf1ab978SDwayne Grant McConnell for (i = 0; i < cnt; i++) { 2065bf1ab978SDwayne Grant McConnell data[i] = ctx->csa.spu_mailbox_data[i]; 2066bf1ab978SDwayne Grant McConnell } 2067bf1ab978SDwayne Grant McConnell 2068bf1ab978SDwayne Grant McConnell return simple_read_from_buffer(buf, len, pos, &data, 2069bf1ab978SDwayne Grant McConnell cnt * sizeof(u32)); 2070bf1ab978SDwayne Grant McConnell } 2071bf1ab978SDwayne Grant McConnell 207269a2f00cSDwayne Grant McConnell static ssize_t spufs_wbox_info_read(struct file *file, char __user *buf, 207369a2f00cSDwayne Grant McConnell size_t len, loff_t *pos) 207469a2f00cSDwayne Grant McConnell { 207569a2f00cSDwayne Grant McConnell struct spu_context *ctx = file->private_data; 2076bf1ab978SDwayne Grant McConnell int ret; 207769a2f00cSDwayne Grant McConnell 207869a2f00cSDwayne Grant McConnell if (!access_ok(VERIFY_WRITE, buf, len)) 207969a2f00cSDwayne Grant McConnell return -EFAULT; 208069a2f00cSDwayne Grant McConnell 2081c9101bdbSChristoph Hellwig ret = spu_acquire_saved(ctx); 2082c9101bdbSChristoph Hellwig if (ret) 2083c9101bdbSChristoph Hellwig return ret; 208469a2f00cSDwayne Grant McConnell spin_lock(&ctx->csa.register_lock); 2085bf1ab978SDwayne Grant McConnell ret = __spufs_wbox_info_read(ctx, buf, len, pos); 208669a2f00cSDwayne Grant McConnell spin_unlock(&ctx->csa.register_lock); 208727b1ea09SChristoph Hellwig spu_release_saved(ctx); 208869a2f00cSDwayne Grant McConnell 2089bf1ab978SDwayne Grant McConnell return ret; 209069a2f00cSDwayne Grant McConnell } 209169a2f00cSDwayne Grant McConnell 20925dfe4c96SArjan van de Ven static const struct file_operations spufs_wbox_info_fops = { 209369a2f00cSDwayne Grant McConnell .open = spufs_info_open, 209469a2f00cSDwayne Grant McConnell .read = spufs_wbox_info_read, 209569a2f00cSDwayne Grant McConnell .llseek = generic_file_llseek, 209669a2f00cSDwayne Grant McConnell }; 209769a2f00cSDwayne Grant McConnell 2098bf1ab978SDwayne Grant McConnell static ssize_t __spufs_dma_info_read(struct spu_context *ctx, 2099bf1ab978SDwayne Grant McConnell char __user *buf, size_t len, loff_t *pos) 2100b9e3bd77SDwayne Grant McConnell { 2101b9e3bd77SDwayne Grant McConnell struct spu_dma_info info; 2102b9e3bd77SDwayne Grant McConnell struct mfc_cq_sr *qp, *spuqp; 2103b9e3bd77SDwayne Grant McConnell int i; 2104b9e3bd77SDwayne Grant McConnell 2105b9e3bd77SDwayne Grant McConnell info.dma_info_type = ctx->csa.priv2.spu_tag_status_query_RW; 2106b9e3bd77SDwayne Grant McConnell info.dma_info_mask = ctx->csa.lscsa->tag_mask.slot[0]; 2107b9e3bd77SDwayne Grant McConnell info.dma_info_status = ctx->csa.spu_chnldata_RW[24]; 2108b9e3bd77SDwayne Grant McConnell info.dma_info_stall_and_notify = ctx->csa.spu_chnldata_RW[25]; 2109b9e3bd77SDwayne Grant McConnell info.dma_info_atomic_command_status = ctx->csa.spu_chnldata_RW[27]; 2110b9e3bd77SDwayne Grant McConnell for (i = 0; i < 16; i++) { 2111b9e3bd77SDwayne Grant McConnell qp = &info.dma_info_command_data[i]; 2112b9e3bd77SDwayne Grant McConnell spuqp = &ctx->csa.priv2.spuq[i]; 2113b9e3bd77SDwayne Grant McConnell 2114b9e3bd77SDwayne Grant McConnell qp->mfc_cq_data0_RW = spuqp->mfc_cq_data0_RW; 2115b9e3bd77SDwayne Grant McConnell qp->mfc_cq_data1_RW = spuqp->mfc_cq_data1_RW; 2116b9e3bd77SDwayne Grant McConnell qp->mfc_cq_data2_RW = spuqp->mfc_cq_data2_RW; 2117b9e3bd77SDwayne Grant McConnell qp->mfc_cq_data3_RW = spuqp->mfc_cq_data3_RW; 2118b9e3bd77SDwayne Grant McConnell } 2119b9e3bd77SDwayne Grant McConnell 2120b9e3bd77SDwayne Grant McConnell return simple_read_from_buffer(buf, len, pos, &info, 2121b9e3bd77SDwayne Grant McConnell sizeof info); 2122b9e3bd77SDwayne Grant McConnell } 2123b9e3bd77SDwayne Grant McConnell 2124bf1ab978SDwayne Grant McConnell static ssize_t spufs_dma_info_read(struct file *file, char __user *buf, 2125bf1ab978SDwayne Grant McConnell size_t len, loff_t *pos) 2126bf1ab978SDwayne Grant McConnell { 2127bf1ab978SDwayne Grant McConnell struct spu_context *ctx = file->private_data; 2128bf1ab978SDwayne Grant McConnell int ret; 2129bf1ab978SDwayne Grant McConnell 2130bf1ab978SDwayne Grant McConnell if (!access_ok(VERIFY_WRITE, buf, len)) 2131bf1ab978SDwayne Grant McConnell return -EFAULT; 2132bf1ab978SDwayne Grant McConnell 2133c9101bdbSChristoph Hellwig ret = spu_acquire_saved(ctx); 2134c9101bdbSChristoph Hellwig if (ret) 2135c9101bdbSChristoph Hellwig return ret; 2136bf1ab978SDwayne Grant McConnell spin_lock(&ctx->csa.register_lock); 2137bf1ab978SDwayne Grant McConnell ret = __spufs_dma_info_read(ctx, buf, len, pos); 2138bf1ab978SDwayne Grant McConnell spin_unlock(&ctx->csa.register_lock); 213927b1ea09SChristoph Hellwig spu_release_saved(ctx); 2140bf1ab978SDwayne Grant McConnell 2141bf1ab978SDwayne Grant McConnell return ret; 2142bf1ab978SDwayne Grant McConnell } 2143bf1ab978SDwayne Grant McConnell 21445dfe4c96SArjan van de Ven static const struct file_operations spufs_dma_info_fops = { 2145b9e3bd77SDwayne Grant McConnell .open = spufs_info_open, 2146b9e3bd77SDwayne Grant McConnell .read = spufs_dma_info_read, 2147fc15351dSArnd Bergmann .llseek = no_llseek, 2148b9e3bd77SDwayne Grant McConnell }; 2149b9e3bd77SDwayne Grant McConnell 2150bf1ab978SDwayne Grant McConnell static ssize_t __spufs_proxydma_info_read(struct spu_context *ctx, 2151bf1ab978SDwayne Grant McConnell char __user *buf, size_t len, loff_t *pos) 2152b9e3bd77SDwayne Grant McConnell { 2153b9e3bd77SDwayne Grant McConnell struct spu_proxydma_info info; 2154b9e3bd77SDwayne Grant McConnell struct mfc_cq_sr *qp, *puqp; 2155bf1ab978SDwayne Grant McConnell int ret = sizeof info; 2156b9e3bd77SDwayne Grant McConnell int i; 2157b9e3bd77SDwayne Grant McConnell 2158b9e3bd77SDwayne Grant McConnell if (len < ret) 2159b9e3bd77SDwayne Grant McConnell return -EINVAL; 2160b9e3bd77SDwayne Grant McConnell 2161b9e3bd77SDwayne Grant McConnell if (!access_ok(VERIFY_WRITE, buf, len)) 2162b9e3bd77SDwayne Grant McConnell return -EFAULT; 2163b9e3bd77SDwayne Grant McConnell 2164b9e3bd77SDwayne Grant McConnell info.proxydma_info_type = ctx->csa.prob.dma_querytype_RW; 2165b9e3bd77SDwayne Grant McConnell info.proxydma_info_mask = ctx->csa.prob.dma_querymask_RW; 2166b9e3bd77SDwayne Grant McConnell info.proxydma_info_status = ctx->csa.prob.dma_tagstatus_R; 2167b9e3bd77SDwayne Grant McConnell for (i = 0; i < 8; i++) { 2168b9e3bd77SDwayne Grant McConnell qp = &info.proxydma_info_command_data[i]; 2169b9e3bd77SDwayne Grant McConnell puqp = &ctx->csa.priv2.puq[i]; 2170b9e3bd77SDwayne Grant McConnell 2171b9e3bd77SDwayne Grant McConnell qp->mfc_cq_data0_RW = puqp->mfc_cq_data0_RW; 2172b9e3bd77SDwayne Grant McConnell qp->mfc_cq_data1_RW = puqp->mfc_cq_data1_RW; 2173b9e3bd77SDwayne Grant McConnell qp->mfc_cq_data2_RW = puqp->mfc_cq_data2_RW; 2174b9e3bd77SDwayne Grant McConnell qp->mfc_cq_data3_RW = puqp->mfc_cq_data3_RW; 2175b9e3bd77SDwayne Grant McConnell } 2176bf1ab978SDwayne Grant McConnell 2177bf1ab978SDwayne Grant McConnell return simple_read_from_buffer(buf, len, pos, &info, 2178bf1ab978SDwayne Grant McConnell sizeof info); 2179bf1ab978SDwayne Grant McConnell } 2180bf1ab978SDwayne Grant McConnell 2181bf1ab978SDwayne Grant McConnell static ssize_t spufs_proxydma_info_read(struct file *file, char __user *buf, 2182bf1ab978SDwayne Grant McConnell size_t len, loff_t *pos) 2183bf1ab978SDwayne Grant McConnell { 2184bf1ab978SDwayne Grant McConnell struct spu_context *ctx = file->private_data; 2185bf1ab978SDwayne Grant McConnell int ret; 2186bf1ab978SDwayne Grant McConnell 2187c9101bdbSChristoph Hellwig ret = spu_acquire_saved(ctx); 2188c9101bdbSChristoph Hellwig if (ret) 2189c9101bdbSChristoph Hellwig return ret; 2190bf1ab978SDwayne Grant McConnell spin_lock(&ctx->csa.register_lock); 2191bf1ab978SDwayne Grant McConnell ret = __spufs_proxydma_info_read(ctx, buf, len, pos); 2192b9e3bd77SDwayne Grant McConnell spin_unlock(&ctx->csa.register_lock); 219327b1ea09SChristoph Hellwig spu_release_saved(ctx); 2194b9e3bd77SDwayne Grant McConnell 2195b9e3bd77SDwayne Grant McConnell return ret; 2196b9e3bd77SDwayne Grant McConnell } 2197b9e3bd77SDwayne Grant McConnell 21985dfe4c96SArjan van de Ven static const struct file_operations spufs_proxydma_info_fops = { 2199b9e3bd77SDwayne Grant McConnell .open = spufs_info_open, 2200b9e3bd77SDwayne Grant McConnell .read = spufs_proxydma_info_read, 2201fc15351dSArnd Bergmann .llseek = no_llseek, 2202b9e3bd77SDwayne Grant McConnell }; 2203b9e3bd77SDwayne Grant McConnell 2204476273adSChristoph Hellwig static int spufs_show_tid(struct seq_file *s, void *private) 2205476273adSChristoph Hellwig { 2206476273adSChristoph Hellwig struct spu_context *ctx = s->private; 2207476273adSChristoph Hellwig 2208476273adSChristoph Hellwig seq_printf(s, "%d\n", ctx->tid); 2209476273adSChristoph Hellwig return 0; 2210476273adSChristoph Hellwig } 2211476273adSChristoph Hellwig 2212476273adSChristoph Hellwig static int spufs_tid_open(struct inode *inode, struct file *file) 2213476273adSChristoph Hellwig { 2214476273adSChristoph Hellwig return single_open(file, spufs_show_tid, SPUFS_I(inode)->i_ctx); 2215476273adSChristoph Hellwig } 2216476273adSChristoph Hellwig 2217476273adSChristoph Hellwig static const struct file_operations spufs_tid_fops = { 2218476273adSChristoph Hellwig .open = spufs_tid_open, 2219476273adSChristoph Hellwig .read = seq_read, 2220476273adSChristoph Hellwig .llseek = seq_lseek, 2221476273adSChristoph Hellwig .release = single_release, 2222476273adSChristoph Hellwig }; 2223476273adSChristoph Hellwig 2224e9f8a0b6SChristoph Hellwig static const char *ctx_state_names[] = { 2225e9f8a0b6SChristoph Hellwig "user", "system", "iowait", "loaded" 2226e9f8a0b6SChristoph Hellwig }; 2227e9f8a0b6SChristoph Hellwig 2228e9f8a0b6SChristoph Hellwig static unsigned long long spufs_acct_time(struct spu_context *ctx, 222927ec41d3SAndre Detsch enum spu_utilization_state state) 2230e9f8a0b6SChristoph Hellwig { 223127ec41d3SAndre Detsch unsigned long long time = ctx->stats.times[state]; 2232e9f8a0b6SChristoph Hellwig 223327ec41d3SAndre Detsch /* 223427ec41d3SAndre Detsch * In general, utilization statistics are updated by the controlling 223527ec41d3SAndre Detsch * thread as the spu context moves through various well defined 223627ec41d3SAndre Detsch * state transitions, but if the context is lazily loaded its 223727ec41d3SAndre Detsch * utilization statistics are not updated as the controlling thread 223827ec41d3SAndre Detsch * is not tightly coupled with the execution of the spu context. We 223927ec41d3SAndre Detsch * calculate and apply the time delta from the last recorded state 224027ec41d3SAndre Detsch * of the spu context. 224127ec41d3SAndre Detsch */ 224227ec41d3SAndre Detsch if (ctx->spu && ctx->stats.util_state == state) { 2243f2dec1eaSThomas Gleixner time += ktime_get_ns() - ctx->stats.tstamp; 224427ec41d3SAndre Detsch } 2245e9f8a0b6SChristoph Hellwig 224627ec41d3SAndre Detsch return time / NSEC_PER_MSEC; 2247e9f8a0b6SChristoph Hellwig } 2248e9f8a0b6SChristoph Hellwig 2249e9f8a0b6SChristoph Hellwig static unsigned long long spufs_slb_flts(struct spu_context *ctx) 2250e9f8a0b6SChristoph Hellwig { 2251e9f8a0b6SChristoph Hellwig unsigned long long slb_flts = ctx->stats.slb_flt; 2252e9f8a0b6SChristoph Hellwig 2253e9f8a0b6SChristoph Hellwig if (ctx->state == SPU_STATE_RUNNABLE) { 2254e9f8a0b6SChristoph Hellwig slb_flts += (ctx->spu->stats.slb_flt - 2255e9f8a0b6SChristoph Hellwig ctx->stats.slb_flt_base); 2256e9f8a0b6SChristoph Hellwig } 2257e9f8a0b6SChristoph Hellwig 2258e9f8a0b6SChristoph Hellwig return slb_flts; 2259e9f8a0b6SChristoph Hellwig } 2260e9f8a0b6SChristoph Hellwig 2261e9f8a0b6SChristoph Hellwig static unsigned long long spufs_class2_intrs(struct spu_context *ctx) 2262e9f8a0b6SChristoph Hellwig { 2263e9f8a0b6SChristoph Hellwig unsigned long long class2_intrs = ctx->stats.class2_intr; 2264e9f8a0b6SChristoph Hellwig 2265e9f8a0b6SChristoph Hellwig if (ctx->state == SPU_STATE_RUNNABLE) { 2266e9f8a0b6SChristoph Hellwig class2_intrs += (ctx->spu->stats.class2_intr - 2267e9f8a0b6SChristoph Hellwig ctx->stats.class2_intr_base); 2268e9f8a0b6SChristoph Hellwig } 2269e9f8a0b6SChristoph Hellwig 2270e9f8a0b6SChristoph Hellwig return class2_intrs; 2271e9f8a0b6SChristoph Hellwig } 2272e9f8a0b6SChristoph Hellwig 2273e9f8a0b6SChristoph Hellwig 2274e9f8a0b6SChristoph Hellwig static int spufs_show_stat(struct seq_file *s, void *private) 2275e9f8a0b6SChristoph Hellwig { 2276e9f8a0b6SChristoph Hellwig struct spu_context *ctx = s->private; 2277c9101bdbSChristoph Hellwig int ret; 2278e9f8a0b6SChristoph Hellwig 2279c9101bdbSChristoph Hellwig ret = spu_acquire(ctx); 2280c9101bdbSChristoph Hellwig if (ret) 2281c9101bdbSChristoph Hellwig return ret; 2282c9101bdbSChristoph Hellwig 2283e9f8a0b6SChristoph Hellwig seq_printf(s, "%s %llu %llu %llu %llu " 2284e9f8a0b6SChristoph Hellwig "%llu %llu %llu %llu %llu %llu %llu %llu\n", 228527ec41d3SAndre Detsch ctx_state_names[ctx->stats.util_state], 228627ec41d3SAndre Detsch spufs_acct_time(ctx, SPU_UTIL_USER), 228727ec41d3SAndre Detsch spufs_acct_time(ctx, SPU_UTIL_SYSTEM), 228827ec41d3SAndre Detsch spufs_acct_time(ctx, SPU_UTIL_IOWAIT), 228927ec41d3SAndre Detsch spufs_acct_time(ctx, SPU_UTIL_IDLE_LOADED), 2290e9f8a0b6SChristoph Hellwig ctx->stats.vol_ctx_switch, 2291e9f8a0b6SChristoph Hellwig ctx->stats.invol_ctx_switch, 2292e9f8a0b6SChristoph Hellwig spufs_slb_flts(ctx), 2293e9f8a0b6SChristoph Hellwig ctx->stats.hash_flt, 2294e9f8a0b6SChristoph Hellwig ctx->stats.min_flt, 2295e9f8a0b6SChristoph Hellwig ctx->stats.maj_flt, 2296e9f8a0b6SChristoph Hellwig spufs_class2_intrs(ctx), 2297e9f8a0b6SChristoph Hellwig ctx->stats.libassist); 2298e9f8a0b6SChristoph Hellwig spu_release(ctx); 2299e9f8a0b6SChristoph Hellwig return 0; 2300e9f8a0b6SChristoph Hellwig } 2301e9f8a0b6SChristoph Hellwig 2302e9f8a0b6SChristoph Hellwig static int spufs_stat_open(struct inode *inode, struct file *file) 2303e9f8a0b6SChristoph Hellwig { 2304e9f8a0b6SChristoph Hellwig return single_open(file, spufs_show_stat, SPUFS_I(inode)->i_ctx); 2305e9f8a0b6SChristoph Hellwig } 2306e9f8a0b6SChristoph Hellwig 2307e9f8a0b6SChristoph Hellwig static const struct file_operations spufs_stat_fops = { 2308e9f8a0b6SChristoph Hellwig .open = spufs_stat_open, 2309e9f8a0b6SChristoph Hellwig .read = seq_read, 2310e9f8a0b6SChristoph Hellwig .llseek = seq_lseek, 2311e9f8a0b6SChristoph Hellwig .release = single_release, 2312e9f8a0b6SChristoph Hellwig }; 2313e9f8a0b6SChristoph Hellwig 23145158e9b5SChristoph Hellwig static inline int spufs_switch_log_used(struct spu_context *ctx) 23155158e9b5SChristoph Hellwig { 23165158e9b5SChristoph Hellwig return (ctx->switch_log->head - ctx->switch_log->tail) % 23175158e9b5SChristoph Hellwig SWITCH_LOG_BUFSIZE; 23185158e9b5SChristoph Hellwig } 23195158e9b5SChristoph Hellwig 23205158e9b5SChristoph Hellwig static inline int spufs_switch_log_avail(struct spu_context *ctx) 23215158e9b5SChristoph Hellwig { 23225158e9b5SChristoph Hellwig return SWITCH_LOG_BUFSIZE - spufs_switch_log_used(ctx); 23235158e9b5SChristoph Hellwig } 23245158e9b5SChristoph Hellwig 23255158e9b5SChristoph Hellwig static int spufs_switch_log_open(struct inode *inode, struct file *file) 23265158e9b5SChristoph Hellwig { 23275158e9b5SChristoph Hellwig struct spu_context *ctx = SPUFS_I(inode)->i_ctx; 2328f5ed0eb6SJeremy Kerr int rc; 23295158e9b5SChristoph Hellwig 2330f5ed0eb6SJeremy Kerr rc = spu_acquire(ctx); 2331f5ed0eb6SJeremy Kerr if (rc) 2332f5ed0eb6SJeremy Kerr return rc; 2333f5ed0eb6SJeremy Kerr 23345158e9b5SChristoph Hellwig if (ctx->switch_log) { 2335f5ed0eb6SJeremy Kerr rc = -EBUSY; 2336f5ed0eb6SJeremy Kerr goto out; 2337f5ed0eb6SJeremy Kerr } 2338f5ed0eb6SJeremy Kerr 2339837ef884SJeremy Kerr ctx->switch_log = kmalloc(sizeof(struct switch_log) + 23405158e9b5SChristoph Hellwig SWITCH_LOG_BUFSIZE * sizeof(struct switch_log_entry), 23415158e9b5SChristoph Hellwig GFP_KERNEL); 2342f5ed0eb6SJeremy Kerr 2343f5ed0eb6SJeremy Kerr if (!ctx->switch_log) { 2344f5ed0eb6SJeremy Kerr rc = -ENOMEM; 23455158e9b5SChristoph Hellwig goto out; 23465158e9b5SChristoph Hellwig } 2347f5ed0eb6SJeremy Kerr 2348837ef884SJeremy Kerr ctx->switch_log->head = ctx->switch_log->tail = 0; 2349f5ed0eb6SJeremy Kerr init_waitqueue_head(&ctx->switch_log->wait); 2350f5ed0eb6SJeremy Kerr rc = 0; 2351f5ed0eb6SJeremy Kerr 2352f5ed0eb6SJeremy Kerr out: 2353f5ed0eb6SJeremy Kerr spu_release(ctx); 2354f5ed0eb6SJeremy Kerr return rc; 2355f5ed0eb6SJeremy Kerr } 2356f5ed0eb6SJeremy Kerr 2357f5ed0eb6SJeremy Kerr static int spufs_switch_log_release(struct inode *inode, struct file *file) 2358f5ed0eb6SJeremy Kerr { 2359f5ed0eb6SJeremy Kerr struct spu_context *ctx = SPUFS_I(inode)->i_ctx; 2360f5ed0eb6SJeremy Kerr int rc; 2361f5ed0eb6SJeremy Kerr 2362f5ed0eb6SJeremy Kerr rc = spu_acquire(ctx); 2363f5ed0eb6SJeremy Kerr if (rc) 2364f5ed0eb6SJeremy Kerr return rc; 2365f5ed0eb6SJeremy Kerr 2366f5ed0eb6SJeremy Kerr kfree(ctx->switch_log); 2367f5ed0eb6SJeremy Kerr ctx->switch_log = NULL; 2368f5ed0eb6SJeremy Kerr spu_release(ctx); 23695158e9b5SChristoph Hellwig 23705158e9b5SChristoph Hellwig return 0; 23715158e9b5SChristoph Hellwig } 23725158e9b5SChristoph Hellwig 23735158e9b5SChristoph Hellwig static int switch_log_sprint(struct spu_context *ctx, char *tbuf, int n) 23745158e9b5SChristoph Hellwig { 23755158e9b5SChristoph Hellwig struct switch_log_entry *p; 23765158e9b5SChristoph Hellwig 23775158e9b5SChristoph Hellwig p = ctx->switch_log->log + ctx->switch_log->tail % SWITCH_LOG_BUFSIZE; 23785158e9b5SChristoph Hellwig 23795158e9b5SChristoph Hellwig return snprintf(tbuf, n, "%u.%09u %d %u %u %llu\n", 23805158e9b5SChristoph Hellwig (unsigned int) p->tstamp.tv_sec, 23815158e9b5SChristoph Hellwig (unsigned int) p->tstamp.tv_nsec, 23825158e9b5SChristoph Hellwig p->spu_id, 23835158e9b5SChristoph Hellwig (unsigned int) p->type, 23845158e9b5SChristoph Hellwig (unsigned int) p->val, 23855158e9b5SChristoph Hellwig (unsigned long long) p->timebase); 23865158e9b5SChristoph Hellwig } 23875158e9b5SChristoph Hellwig 23885158e9b5SChristoph Hellwig static ssize_t spufs_switch_log_read(struct file *file, char __user *buf, 23895158e9b5SChristoph Hellwig size_t len, loff_t *ppos) 23905158e9b5SChristoph Hellwig { 2391496ad9aaSAl Viro struct inode *inode = file_inode(file); 23925158e9b5SChristoph Hellwig struct spu_context *ctx = SPUFS_I(inode)->i_ctx; 23935158e9b5SChristoph Hellwig int error = 0, cnt = 0; 23945158e9b5SChristoph Hellwig 239517e37675Sroel kluin if (!buf) 23965158e9b5SChristoph Hellwig return -EINVAL; 23975158e9b5SChristoph Hellwig 2398f5ed0eb6SJeremy Kerr error = spu_acquire(ctx); 2399f5ed0eb6SJeremy Kerr if (error) 2400f5ed0eb6SJeremy Kerr return error; 2401f5ed0eb6SJeremy Kerr 24025158e9b5SChristoph Hellwig while (cnt < len) { 24035158e9b5SChristoph Hellwig char tbuf[128]; 24045158e9b5SChristoph Hellwig int width; 24055158e9b5SChristoph Hellwig 2406f5ed0eb6SJeremy Kerr if (spufs_switch_log_used(ctx) == 0) { 240714f693eeSJeremy Kerr if (cnt > 0) { 240814f693eeSJeremy Kerr /* If there's data ready to go, we can 240914f693eeSJeremy Kerr * just return straight away */ 241014f693eeSJeremy Kerr break; 241114f693eeSJeremy Kerr 241214f693eeSJeremy Kerr } else if (file->f_flags & O_NONBLOCK) { 2413f5ed0eb6SJeremy Kerr error = -EAGAIN; 24145158e9b5SChristoph Hellwig break; 241514f693eeSJeremy Kerr 2416f5ed0eb6SJeremy Kerr } else { 241714f693eeSJeremy Kerr /* spufs_wait will drop the mutex and 241814f693eeSJeremy Kerr * re-acquire, but since we're in read(), the 241914f693eeSJeremy Kerr * file cannot be _released (and so 242014f693eeSJeremy Kerr * ctx->switch_log is stable). 2421f5ed0eb6SJeremy Kerr */ 2422f5ed0eb6SJeremy Kerr error = spufs_wait(ctx->switch_log->wait, 2423f5ed0eb6SJeremy Kerr spufs_switch_log_used(ctx) > 0); 24245158e9b5SChristoph Hellwig 2425f5ed0eb6SJeremy Kerr /* On error, spufs_wait returns without the 2426f5ed0eb6SJeremy Kerr * state mutex held */ 2427f5ed0eb6SJeremy Kerr if (error) 2428f5ed0eb6SJeremy Kerr return error; 24295158e9b5SChristoph Hellwig 243014f693eeSJeremy Kerr /* We may have had entries read from underneath 243114f693eeSJeremy Kerr * us while we dropped the mutex in spufs_wait, 243214f693eeSJeremy Kerr * so re-check */ 243314f693eeSJeremy Kerr if (spufs_switch_log_used(ctx) == 0) 2434f5ed0eb6SJeremy Kerr continue; 243514f693eeSJeremy Kerr } 243614f693eeSJeremy Kerr } 2437f5ed0eb6SJeremy Kerr 24385158e9b5SChristoph Hellwig width = switch_log_sprint(ctx, tbuf, sizeof(tbuf)); 2439f5ed0eb6SJeremy Kerr if (width < len) 24405158e9b5SChristoph Hellwig ctx->switch_log->tail = 24415158e9b5SChristoph Hellwig (ctx->switch_log->tail + 1) % 24425158e9b5SChristoph Hellwig SWITCH_LOG_BUFSIZE; 2443f5ed0eb6SJeremy Kerr else 2444f5ed0eb6SJeremy Kerr /* If the record is greater than space available return 2445f5ed0eb6SJeremy Kerr * partial buffer (so far) */ 24465158e9b5SChristoph Hellwig break; 24475158e9b5SChristoph Hellwig 24485158e9b5SChristoph Hellwig error = copy_to_user(buf + cnt, tbuf, width); 24495158e9b5SChristoph Hellwig if (error) 24505158e9b5SChristoph Hellwig break; 24515158e9b5SChristoph Hellwig cnt += width; 24525158e9b5SChristoph Hellwig } 24535158e9b5SChristoph Hellwig 2454f5ed0eb6SJeremy Kerr spu_release(ctx); 2455f5ed0eb6SJeremy Kerr 24565158e9b5SChristoph Hellwig return cnt == 0 ? error : cnt; 24575158e9b5SChristoph Hellwig } 24585158e9b5SChristoph Hellwig 24595158e9b5SChristoph Hellwig static unsigned int spufs_switch_log_poll(struct file *file, poll_table *wait) 24605158e9b5SChristoph Hellwig { 2461496ad9aaSAl Viro struct inode *inode = file_inode(file); 24625158e9b5SChristoph Hellwig struct spu_context *ctx = SPUFS_I(inode)->i_ctx; 24635158e9b5SChristoph Hellwig unsigned int mask = 0; 2464f5ed0eb6SJeremy Kerr int rc; 24655158e9b5SChristoph Hellwig 24665158e9b5SChristoph Hellwig poll_wait(file, &ctx->switch_log->wait, wait); 24675158e9b5SChristoph Hellwig 2468f5ed0eb6SJeremy Kerr rc = spu_acquire(ctx); 2469f5ed0eb6SJeremy Kerr if (rc) 2470f5ed0eb6SJeremy Kerr return rc; 2471f5ed0eb6SJeremy Kerr 24725158e9b5SChristoph Hellwig if (spufs_switch_log_used(ctx) > 0) 24735158e9b5SChristoph Hellwig mask |= POLLIN; 24745158e9b5SChristoph Hellwig 2475f5ed0eb6SJeremy Kerr spu_release(ctx); 2476f5ed0eb6SJeremy Kerr 24775158e9b5SChristoph Hellwig return mask; 24785158e9b5SChristoph Hellwig } 24795158e9b5SChristoph Hellwig 24805158e9b5SChristoph Hellwig static const struct file_operations spufs_switch_log_fops = { 24815158e9b5SChristoph Hellwig .open = spufs_switch_log_open, 24825158e9b5SChristoph Hellwig .read = spufs_switch_log_read, 24835158e9b5SChristoph Hellwig .poll = spufs_switch_log_poll, 2484f5ed0eb6SJeremy Kerr .release = spufs_switch_log_release, 2485fc15351dSArnd Bergmann .llseek = no_llseek, 24865158e9b5SChristoph Hellwig }; 24875158e9b5SChristoph Hellwig 2488f5ed0eb6SJeremy Kerr /** 2489f5ed0eb6SJeremy Kerr * Log a context switch event to a switch log reader. 2490f5ed0eb6SJeremy Kerr * 2491f5ed0eb6SJeremy Kerr * Must be called with ctx->state_mutex held. 2492f5ed0eb6SJeremy Kerr */ 24935158e9b5SChristoph Hellwig void spu_switch_log_notify(struct spu *spu, struct spu_context *ctx, 24945158e9b5SChristoph Hellwig u32 type, u32 val) 24955158e9b5SChristoph Hellwig { 24965158e9b5SChristoph Hellwig if (!ctx->switch_log) 24975158e9b5SChristoph Hellwig return; 24985158e9b5SChristoph Hellwig 24995158e9b5SChristoph Hellwig if (spufs_switch_log_avail(ctx) > 1) { 25005158e9b5SChristoph Hellwig struct switch_log_entry *p; 25015158e9b5SChristoph Hellwig 25025158e9b5SChristoph Hellwig p = ctx->switch_log->log + ctx->switch_log->head; 25035158e9b5SChristoph Hellwig ktime_get_ts(&p->tstamp); 25045158e9b5SChristoph Hellwig p->timebase = get_tb(); 25055158e9b5SChristoph Hellwig p->spu_id = spu ? spu->number : -1; 25065158e9b5SChristoph Hellwig p->type = type; 25075158e9b5SChristoph Hellwig p->val = val; 25085158e9b5SChristoph Hellwig 25095158e9b5SChristoph Hellwig ctx->switch_log->head = 25105158e9b5SChristoph Hellwig (ctx->switch_log->head + 1) % SWITCH_LOG_BUFSIZE; 25115158e9b5SChristoph Hellwig } 25125158e9b5SChristoph Hellwig 25135158e9b5SChristoph Hellwig wake_up(&ctx->switch_log->wait); 25145158e9b5SChristoph Hellwig } 2515e9f8a0b6SChristoph Hellwig 251646deed69SLuke Browning static int spufs_show_ctx(struct seq_file *s, void *private) 251746deed69SLuke Browning { 251846deed69SLuke Browning struct spu_context *ctx = s->private; 251946deed69SLuke Browning u64 mfc_control_RW; 252046deed69SLuke Browning 252146deed69SLuke Browning mutex_lock(&ctx->state_mutex); 252246deed69SLuke Browning if (ctx->spu) { 252346deed69SLuke Browning struct spu *spu = ctx->spu; 252446deed69SLuke Browning struct spu_priv2 __iomem *priv2 = spu->priv2; 252546deed69SLuke Browning 252646deed69SLuke Browning spin_lock_irq(&spu->register_lock); 252746deed69SLuke Browning mfc_control_RW = in_be64(&priv2->mfc_control_RW); 252846deed69SLuke Browning spin_unlock_irq(&spu->register_lock); 252946deed69SLuke Browning } else { 253046deed69SLuke Browning struct spu_state *csa = &ctx->csa; 253146deed69SLuke Browning 253246deed69SLuke Browning mfc_control_RW = csa->priv2.mfc_control_RW; 253346deed69SLuke Browning } 253446deed69SLuke Browning 253546deed69SLuke Browning seq_printf(s, "%c flgs(%lx) sflgs(%lx) pri(%d) ts(%d) spu(%02d)" 25369477e455SStephen Rothwell " %c %llx %llx %llx %llx %x %x\n", 253746deed69SLuke Browning ctx->state == SPU_STATE_SAVED ? 'S' : 'R', 253846deed69SLuke Browning ctx->flags, 253946deed69SLuke Browning ctx->sched_flags, 254046deed69SLuke Browning ctx->prio, 254146deed69SLuke Browning ctx->time_slice, 254246deed69SLuke Browning ctx->spu ? ctx->spu->number : -1, 254346deed69SLuke Browning !list_empty(&ctx->rq) ? 'q' : ' ', 254446deed69SLuke Browning ctx->csa.class_0_pending, 254546deed69SLuke Browning ctx->csa.class_0_dar, 254646deed69SLuke Browning ctx->csa.class_1_dsisr, 254746deed69SLuke Browning mfc_control_RW, 254846deed69SLuke Browning ctx->ops->runcntl_read(ctx), 254946deed69SLuke Browning ctx->ops->status_read(ctx)); 255046deed69SLuke Browning 255146deed69SLuke Browning mutex_unlock(&ctx->state_mutex); 255246deed69SLuke Browning 255346deed69SLuke Browning return 0; 255446deed69SLuke Browning } 255546deed69SLuke Browning 255646deed69SLuke Browning static int spufs_ctx_open(struct inode *inode, struct file *file) 255746deed69SLuke Browning { 255846deed69SLuke Browning return single_open(file, spufs_show_ctx, SPUFS_I(inode)->i_ctx); 255946deed69SLuke Browning } 256046deed69SLuke Browning 256146deed69SLuke Browning static const struct file_operations spufs_ctx_fops = { 256246deed69SLuke Browning .open = spufs_ctx_open, 256346deed69SLuke Browning .read = seq_read, 256446deed69SLuke Browning .llseek = seq_lseek, 256546deed69SLuke Browning .release = single_release, 256646deed69SLuke Browning }; 256746deed69SLuke Browning 256874254647SJeremy Kerr const struct spufs_tree_descr spufs_dir_contents[] = { 2569cbe709c1SBenjamin Herrenschmidt { "capabilities", &spufs_caps_fops, 0444, }, 25706f7dde81SJeremy Kerr { "mem", &spufs_mem_fops, 0666, LS_SIZE, }, 25716f7dde81SJeremy Kerr { "regs", &spufs_regs_fops, 0666, sizeof(struct spu_reg128[128]), }, 257267207b96SArnd Bergmann { "mbox", &spufs_mbox_fops, 0444, }, 257367207b96SArnd Bergmann { "ibox", &spufs_ibox_fops, 0444, }, 257467207b96SArnd Bergmann { "wbox", &spufs_wbox_fops, 0222, }, 25756f7dde81SJeremy Kerr { "mbox_stat", &spufs_mbox_stat_fops, 0444, sizeof(u32), }, 25766f7dde81SJeremy Kerr { "ibox_stat", &spufs_ibox_stat_fops, 0444, sizeof(u32), }, 25776f7dde81SJeremy Kerr { "wbox_stat", &spufs_wbox_stat_fops, 0444, sizeof(u32), }, 2578603c4612SJeremy Kerr { "signal1", &spufs_signal1_fops, 0666, }, 2579603c4612SJeremy Kerr { "signal2", &spufs_signal2_fops, 0666, }, 258067207b96SArnd Bergmann { "signal1_type", &spufs_signal1_type, 0666, }, 258167207b96SArnd Bergmann { "signal2_type", &spufs_signal2_type, 0666, }, 25826df10a82SMark Nutter { "cntl", &spufs_cntl_fops, 0666, }, 25836f7dde81SJeremy Kerr { "fpcr", &spufs_fpcr_fops, 0666, sizeof(struct spu_reg128), }, 2584b9e3bd77SDwayne Grant McConnell { "lslr", &spufs_lslr_ops, 0444, }, 2585b9e3bd77SDwayne Grant McConnell { "mfc", &spufs_mfc_fops, 0666, }, 2586b9e3bd77SDwayne Grant McConnell { "mss", &spufs_mss_fops, 0666, }, 2587b9e3bd77SDwayne Grant McConnell { "npc", &spufs_npc_ops, 0666, }, 2588b9e3bd77SDwayne Grant McConnell { "srr0", &spufs_srr0_ops, 0666, }, 25898b3d6663SArnd Bergmann { "decr", &spufs_decr_ops, 0666, }, 25908b3d6663SArnd Bergmann { "decr_status", &spufs_decr_status_ops, 0666, }, 25918b3d6663SArnd Bergmann { "event_mask", &spufs_event_mask_ops, 0666, }, 2592b9e3bd77SDwayne Grant McConnell { "event_status", &spufs_event_status_ops, 0444, }, 25936f7dde81SJeremy Kerr { "psmap", &spufs_psmap_fops, 0666, SPUFS_PS_MAP_SIZE, }, 259486767277SArnd Bergmann { "phys-id", &spufs_id_ops, 0666, }, 259586767277SArnd Bergmann { "object-id", &spufs_object_id_ops, 0666, }, 25966f7dde81SJeremy Kerr { "mbox_info", &spufs_mbox_info_fops, 0444, sizeof(u32), }, 25976f7dde81SJeremy Kerr { "ibox_info", &spufs_ibox_info_fops, 0444, sizeof(u32), }, 25986f7dde81SJeremy Kerr { "wbox_info", &spufs_wbox_info_fops, 0444, sizeof(u32), }, 25996f7dde81SJeremy Kerr { "dma_info", &spufs_dma_info_fops, 0444, 26006f7dde81SJeremy Kerr sizeof(struct spu_dma_info), }, 26016f7dde81SJeremy Kerr { "proxydma_info", &spufs_proxydma_info_fops, 0444, 26026f7dde81SJeremy Kerr sizeof(struct spu_proxydma_info)}, 2603476273adSChristoph Hellwig { "tid", &spufs_tid_fops, 0444, }, 2604e9f8a0b6SChristoph Hellwig { "stat", &spufs_stat_fops, 0444, }, 26055158e9b5SChristoph Hellwig { "switch_log", &spufs_switch_log_fops, 0444 }, 260667207b96SArnd Bergmann {}, 260767207b96SArnd Bergmann }; 26085737edd1SMark Nutter 260974254647SJeremy Kerr const struct spufs_tree_descr spufs_dir_nosched_contents[] = { 2610cbe709c1SBenjamin Herrenschmidt { "capabilities", &spufs_caps_fops, 0444, }, 26116f7dde81SJeremy Kerr { "mem", &spufs_mem_fops, 0666, LS_SIZE, }, 26125737edd1SMark Nutter { "mbox", &spufs_mbox_fops, 0444, }, 26135737edd1SMark Nutter { "ibox", &spufs_ibox_fops, 0444, }, 26145737edd1SMark Nutter { "wbox", &spufs_wbox_fops, 0222, }, 26156f7dde81SJeremy Kerr { "mbox_stat", &spufs_mbox_stat_fops, 0444, sizeof(u32), }, 26166f7dde81SJeremy Kerr { "ibox_stat", &spufs_ibox_stat_fops, 0444, sizeof(u32), }, 26176f7dde81SJeremy Kerr { "wbox_stat", &spufs_wbox_stat_fops, 0444, sizeof(u32), }, 2618d054b36fSJeremy Kerr { "signal1", &spufs_signal1_nosched_fops, 0222, }, 2619d054b36fSJeremy Kerr { "signal2", &spufs_signal2_nosched_fops, 0222, }, 26205737edd1SMark Nutter { "signal1_type", &spufs_signal1_type, 0666, }, 26215737edd1SMark Nutter { "signal2_type", &spufs_signal2_type, 0666, }, 26225737edd1SMark Nutter { "mss", &spufs_mss_fops, 0666, }, 26235737edd1SMark Nutter { "mfc", &spufs_mfc_fops, 0666, }, 26245737edd1SMark Nutter { "cntl", &spufs_cntl_fops, 0666, }, 26255737edd1SMark Nutter { "npc", &spufs_npc_ops, 0666, }, 26266f7dde81SJeremy Kerr { "psmap", &spufs_psmap_fops, 0666, SPUFS_PS_MAP_SIZE, }, 26275737edd1SMark Nutter { "phys-id", &spufs_id_ops, 0666, }, 26285737edd1SMark Nutter { "object-id", &spufs_object_id_ops, 0666, }, 2629476273adSChristoph Hellwig { "tid", &spufs_tid_fops, 0444, }, 2630e9f8a0b6SChristoph Hellwig { "stat", &spufs_stat_fops, 0444, }, 26312c3e4787SJeremy Kerr {}, 26322c3e4787SJeremy Kerr }; 26332c3e4787SJeremy Kerr 263474254647SJeremy Kerr const struct spufs_tree_descr spufs_dir_debug_contents[] = { 263546deed69SLuke Browning { ".ctx", &spufs_ctx_fops, 0444, }, 26365737edd1SMark Nutter {}, 26375737edd1SMark Nutter }; 2638bf1ab978SDwayne Grant McConnell 263974254647SJeremy Kerr const struct spufs_coredump_reader spufs_coredump_read[] = { 26404fca9c42SMichael Ellerman { "regs", __spufs_regs_read, NULL, sizeof(struct spu_reg128[128])}, 26414fca9c42SMichael Ellerman { "fpcr", __spufs_fpcr_read, NULL, sizeof(struct spu_reg128) }, 2642104f0cc2SMichael Ellerman { "lslr", NULL, spufs_lslr_get, 19 }, 2643104f0cc2SMichael Ellerman { "decr", NULL, spufs_decr_get, 19 }, 2644104f0cc2SMichael Ellerman { "decr_status", NULL, spufs_decr_status_get, 19 }, 26454fca9c42SMichael Ellerman { "mem", __spufs_mem_read, NULL, LS_SIZE, }, 26464fca9c42SMichael Ellerman { "signal1", __spufs_signal1_read, NULL, sizeof(u32) }, 2647104f0cc2SMichael Ellerman { "signal1_type", NULL, spufs_signal1_type_get, 19 }, 26484fca9c42SMichael Ellerman { "signal2", __spufs_signal2_read, NULL, sizeof(u32) }, 2649104f0cc2SMichael Ellerman { "signal2_type", NULL, spufs_signal2_type_get, 19 }, 2650104f0cc2SMichael Ellerman { "event_mask", NULL, spufs_event_mask_get, 19 }, 2651104f0cc2SMichael Ellerman { "event_status", NULL, spufs_event_status_get, 19 }, 26524fca9c42SMichael Ellerman { "mbox_info", __spufs_mbox_info_read, NULL, sizeof(u32) }, 26534fca9c42SMichael Ellerman { "ibox_info", __spufs_ibox_info_read, NULL, sizeof(u32) }, 26544fca9c42SMichael Ellerman { "wbox_info", __spufs_wbox_info_read, NULL, 4 * sizeof(u32)}, 26554fca9c42SMichael Ellerman { "dma_info", __spufs_dma_info_read, NULL, sizeof(struct spu_dma_info)}, 26564fca9c42SMichael Ellerman { "proxydma_info", __spufs_proxydma_info_read, 26574fca9c42SMichael Ellerman NULL, sizeof(struct spu_proxydma_info)}, 2658104f0cc2SMichael Ellerman { "object-id", NULL, spufs_object_id_get, 19 }, 2659104f0cc2SMichael Ellerman { "npc", NULL, spufs_npc_get, 19 }, 2660936d5bf1SMichael Ellerman { NULL }, 2661bf1ab978SDwayne Grant McConnell }; 2662