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 23611bac800SDave Jiang spufs_mem_mmap_fault(struct vm_fault *vmf) 2378b3d6663SArnd Bergmann { 23811bac800SDave Jiang struct vm_area_struct *vma = vmf->vma; 2398b3d6663SArnd Bergmann struct spu_context *ctx = vma->vm_file->private_data; 240b1e2270fSNick Piggin unsigned long pfn, offset; 241b1e2270fSNick Piggin 242b1e2270fSNick Piggin offset = vmf->pgoff << PAGE_SHIFT; 243128b8546SMasato Noguchi if (offset >= LS_SIZE) 244b1e2270fSNick Piggin return VM_FAULT_SIGBUS; 245128b8546SMasato Noguchi 246b1e2270fSNick Piggin pr_debug("spufs_mem_mmap_fault address=0x%lx, offset=0x%lx\n", 2471a29d85eSJan Kara vmf->address, offset); 248f1fa74f4SBenjamin Herrenschmidt 249c9101bdbSChristoph Hellwig if (spu_acquire(ctx)) 250b1e2270fSNick Piggin return VM_FAULT_NOPAGE; 2518b3d6663SArnd Bergmann 252ac91cb8dSArnd Bergmann if (ctx->state == SPU_STATE_SAVED) { 25364b3d0e8SBenjamin Herrenschmidt vma->vm_page_prot = pgprot_cached(vma->vm_page_prot); 25478bde53eSBenjamin Herrenschmidt pfn = vmalloc_to_pfn(ctx->csa.lscsa->ls + offset); 255ac91cb8dSArnd Bergmann } else { 25664b3d0e8SBenjamin Herrenschmidt vma->vm_page_prot = pgprot_noncached_wc(vma->vm_page_prot); 25778bde53eSBenjamin Herrenschmidt pfn = (ctx->spu->local_store_phys + offset) >> PAGE_SHIFT; 258ac91cb8dSArnd Bergmann } 2591a29d85eSJan Kara vm_insert_pfn(vma, vmf->address, pfn); 26078bde53eSBenjamin Herrenschmidt 2618b3d6663SArnd Bergmann spu_release(ctx); 2628b3d6663SArnd Bergmann 263b1e2270fSNick Piggin return VM_FAULT_NOPAGE; 2648b3d6663SArnd Bergmann } 2658b3d6663SArnd Bergmann 266a352894dSBenjamin Herrenschmidt static int spufs_mem_mmap_access(struct vm_area_struct *vma, 267a352894dSBenjamin Herrenschmidt unsigned long address, 268a352894dSBenjamin Herrenschmidt void *buf, int len, int write) 269a352894dSBenjamin Herrenschmidt { 270a352894dSBenjamin Herrenschmidt struct spu_context *ctx = vma->vm_file->private_data; 271a352894dSBenjamin Herrenschmidt unsigned long offset = address - vma->vm_start; 272a352894dSBenjamin Herrenschmidt char *local_store; 273a352894dSBenjamin Herrenschmidt 274a352894dSBenjamin Herrenschmidt if (write && !(vma->vm_flags & VM_WRITE)) 275a352894dSBenjamin Herrenschmidt return -EACCES; 276a352894dSBenjamin Herrenschmidt if (spu_acquire(ctx)) 277a352894dSBenjamin Herrenschmidt return -EINTR; 278a352894dSBenjamin Herrenschmidt if ((offset + len) > vma->vm_end) 279a352894dSBenjamin Herrenschmidt len = vma->vm_end - offset; 280a352894dSBenjamin Herrenschmidt local_store = ctx->ops->get_ls(ctx); 281a352894dSBenjamin Herrenschmidt if (write) 282a352894dSBenjamin Herrenschmidt memcpy_toio(local_store + offset, buf, len); 283a352894dSBenjamin Herrenschmidt else 284a352894dSBenjamin Herrenschmidt memcpy_fromio(buf, local_store + offset, len); 285a352894dSBenjamin Herrenschmidt spu_release(ctx); 286a352894dSBenjamin Herrenschmidt return len; 287a352894dSBenjamin Herrenschmidt } 28878bde53eSBenjamin Herrenschmidt 289f0f37e2fSAlexey Dobriyan static const struct vm_operations_struct spufs_mem_mmap_vmops = { 290b1e2270fSNick Piggin .fault = spufs_mem_mmap_fault, 291a352894dSBenjamin Herrenschmidt .access = spufs_mem_mmap_access, 2928b3d6663SArnd Bergmann }; 2938b3d6663SArnd Bergmann 294f1fa74f4SBenjamin Herrenschmidt static int spufs_mem_mmap(struct file *file, struct vm_area_struct *vma) 29567207b96SArnd Bergmann { 2968b3d6663SArnd Bergmann if (!(vma->vm_flags & VM_SHARED)) 2978b3d6663SArnd Bergmann return -EINVAL; 29867207b96SArnd Bergmann 29978bde53eSBenjamin Herrenschmidt vma->vm_flags |= VM_IO | VM_PFNMAP; 30064b3d0e8SBenjamin Herrenschmidt vma->vm_page_prot = pgprot_noncached_wc(vma->vm_page_prot); 3018b3d6663SArnd Bergmann 3028b3d6663SArnd Bergmann vma->vm_ops = &spufs_mem_mmap_vmops; 30367207b96SArnd Bergmann return 0; 30467207b96SArnd Bergmann } 30567207b96SArnd Bergmann 3065dfe4c96SArjan van de Ven static const struct file_operations spufs_mem_fops = { 30767207b96SArnd Bergmann .open = spufs_mem_open, 308ce92987bSChristoph Hellwig .release = spufs_mem_release, 30967207b96SArnd Bergmann .read = spufs_mem_read, 31067207b96SArnd Bergmann .write = spufs_mem_write, 3118b3d6663SArnd Bergmann .llseek = generic_file_llseek, 31267207b96SArnd Bergmann .mmap = spufs_mem_mmap, 3138b3d6663SArnd Bergmann }; 3148b3d6663SArnd Bergmann 31511bac800SDave Jiang static int spufs_ps_fault(struct vm_fault *vmf, 31678bde53eSBenjamin Herrenschmidt unsigned long ps_offs, 31727d5bf2aSBenjamin Herrenschmidt unsigned long ps_size) 3186df10a82SMark Nutter { 31911bac800SDave Jiang struct spu_context *ctx = vmf->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; 35711bac800SDave Jiang vm_insert_pfn(vmf->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 37011bac800SDave Jiang static int spufs_cntl_mmap_fault(struct vm_fault *vmf) 3716df10a82SMark Nutter { 37211bac800SDave Jiang return spufs_ps_fault(vmf, 0x4000, SPUFS_CNTL_MAP_SIZE); 3736df10a82SMark Nutter } 3746df10a82SMark Nutter 375f0f37e2fSAlexey Dobriyan static const struct vm_operations_struct spufs_cntl_mmap_vmops = { 376b1e2270fSNick Piggin .fault = spufs_cntl_mmap_fault, 3776df10a82SMark Nutter }; 3786df10a82SMark Nutter 3796df10a82SMark Nutter /* 3806df10a82SMark Nutter * mmap support for problem state control area [0x4000 - 0x4fff]. 3816df10a82SMark Nutter */ 3826df10a82SMark Nutter static int spufs_cntl_mmap(struct file *file, struct vm_area_struct *vma) 3836df10a82SMark Nutter { 3846df10a82SMark Nutter if (!(vma->vm_flags & VM_SHARED)) 3856df10a82SMark Nutter return -EINVAL; 3866df10a82SMark Nutter 38778bde53eSBenjamin Herrenschmidt vma->vm_flags |= VM_IO | VM_PFNMAP; 38864b3d0e8SBenjamin Herrenschmidt vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot); 3896df10a82SMark Nutter 3906df10a82SMark Nutter vma->vm_ops = &spufs_cntl_mmap_vmops; 3916df10a82SMark Nutter return 0; 3926df10a82SMark Nutter } 39327d5bf2aSBenjamin Herrenschmidt #else /* SPUFS_MMAP_4K */ 39427d5bf2aSBenjamin Herrenschmidt #define spufs_cntl_mmap NULL 39527d5bf2aSBenjamin Herrenschmidt #endif /* !SPUFS_MMAP_4K */ 3966df10a82SMark Nutter 397197b1a82SChristoph Hellwig static int spufs_cntl_get(void *data, u64 *val) 398e1dbff2bSArnd Bergmann { 399e1dbff2bSArnd Bergmann struct spu_context *ctx = data; 400c9101bdbSChristoph Hellwig int ret; 401e1dbff2bSArnd Bergmann 402c9101bdbSChristoph Hellwig ret = spu_acquire(ctx); 403c9101bdbSChristoph Hellwig if (ret) 404c9101bdbSChristoph Hellwig return ret; 405197b1a82SChristoph Hellwig *val = ctx->ops->status_read(ctx); 406e1dbff2bSArnd Bergmann spu_release(ctx); 407e1dbff2bSArnd Bergmann 408197b1a82SChristoph Hellwig return 0; 409e1dbff2bSArnd Bergmann } 410e1dbff2bSArnd Bergmann 411197b1a82SChristoph Hellwig static int spufs_cntl_set(void *data, u64 val) 412e1dbff2bSArnd Bergmann { 413e1dbff2bSArnd Bergmann struct spu_context *ctx = data; 414c9101bdbSChristoph Hellwig int ret; 415e1dbff2bSArnd Bergmann 416c9101bdbSChristoph Hellwig ret = spu_acquire(ctx); 417c9101bdbSChristoph Hellwig if (ret) 418c9101bdbSChristoph Hellwig return ret; 419e1dbff2bSArnd Bergmann ctx->ops->runcntl_write(ctx, val); 420e1dbff2bSArnd Bergmann spu_release(ctx); 421197b1a82SChristoph Hellwig 422197b1a82SChristoph Hellwig return 0; 423e1dbff2bSArnd Bergmann } 424e1dbff2bSArnd Bergmann 4256df10a82SMark Nutter static int spufs_cntl_open(struct inode *inode, struct file *file) 4266df10a82SMark Nutter { 4276df10a82SMark Nutter struct spufs_inode_info *i = SPUFS_I(inode); 4286df10a82SMark Nutter struct spu_context *ctx = i->i_ctx; 4296df10a82SMark Nutter 43047d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 4316df10a82SMark Nutter file->private_data = ctx; 43243c2bbd9SChristoph Hellwig if (!i->i_openers++) 4336df10a82SMark Nutter ctx->cntl = inode->i_mapping; 43447d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 4358b88b099SChristoph Hellwig return simple_attr_open(inode, file, spufs_cntl_get, 436e1dbff2bSArnd Bergmann spufs_cntl_set, "0x%08lx"); 4376df10a82SMark Nutter } 4386df10a82SMark Nutter 43943c2bbd9SChristoph Hellwig static int 44043c2bbd9SChristoph Hellwig spufs_cntl_release(struct inode *inode, struct file *file) 44143c2bbd9SChristoph Hellwig { 44243c2bbd9SChristoph Hellwig struct spufs_inode_info *i = SPUFS_I(inode); 44343c2bbd9SChristoph Hellwig struct spu_context *ctx = i->i_ctx; 44443c2bbd9SChristoph Hellwig 44574bedc4dSChristoph Hellwig simple_attr_release(inode, file); 44643c2bbd9SChristoph Hellwig 44747d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 44843c2bbd9SChristoph Hellwig if (!--i->i_openers) 44943c2bbd9SChristoph Hellwig ctx->cntl = NULL; 45047d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 45143c2bbd9SChristoph Hellwig return 0; 45243c2bbd9SChristoph Hellwig } 45343c2bbd9SChristoph Hellwig 4545dfe4c96SArjan van de Ven static const struct file_operations spufs_cntl_fops = { 4556df10a82SMark Nutter .open = spufs_cntl_open, 45643c2bbd9SChristoph Hellwig .release = spufs_cntl_release, 4578b88b099SChristoph Hellwig .read = simple_attr_read, 4588b88b099SChristoph Hellwig .write = simple_attr_write, 459fc15351dSArnd Bergmann .llseek = generic_file_llseek, 4606df10a82SMark Nutter .mmap = spufs_cntl_mmap, 4616df10a82SMark Nutter }; 4626df10a82SMark Nutter 4638b3d6663SArnd Bergmann static int 4648b3d6663SArnd Bergmann spufs_regs_open(struct inode *inode, struct file *file) 4658b3d6663SArnd Bergmann { 4668b3d6663SArnd Bergmann struct spufs_inode_info *i = SPUFS_I(inode); 4678b3d6663SArnd Bergmann file->private_data = i->i_ctx; 4688b3d6663SArnd Bergmann return 0; 4698b3d6663SArnd Bergmann } 4708b3d6663SArnd Bergmann 4718b3d6663SArnd Bergmann static ssize_t 472bf1ab978SDwayne Grant McConnell __spufs_regs_read(struct spu_context *ctx, char __user *buffer, 473bf1ab978SDwayne Grant McConnell size_t size, loff_t *pos) 474bf1ab978SDwayne Grant McConnell { 475bf1ab978SDwayne Grant McConnell struct spu_lscsa *lscsa = ctx->csa.lscsa; 476bf1ab978SDwayne Grant McConnell return simple_read_from_buffer(buffer, size, pos, 477bf1ab978SDwayne Grant McConnell lscsa->gprs, sizeof lscsa->gprs); 478bf1ab978SDwayne Grant McConnell } 479bf1ab978SDwayne Grant McConnell 480bf1ab978SDwayne Grant McConnell static ssize_t 4818b3d6663SArnd Bergmann spufs_regs_read(struct file *file, char __user *buffer, 4828b3d6663SArnd Bergmann size_t size, loff_t *pos) 4838b3d6663SArnd Bergmann { 4848b3d6663SArnd Bergmann int ret; 485bf1ab978SDwayne Grant McConnell struct spu_context *ctx = file->private_data; 4868b3d6663SArnd Bergmann 487f027faa2SJeremy Kerr /* pre-check for file position: if we'd return EOF, there's no point 488f027faa2SJeremy Kerr * causing a deschedule */ 489f027faa2SJeremy Kerr if (*pos >= sizeof(ctx->csa.lscsa->gprs)) 490f027faa2SJeremy Kerr return 0; 491f027faa2SJeremy Kerr 492c9101bdbSChristoph Hellwig ret = spu_acquire_saved(ctx); 493c9101bdbSChristoph Hellwig if (ret) 494c9101bdbSChristoph Hellwig return ret; 495bf1ab978SDwayne Grant McConnell ret = __spufs_regs_read(ctx, buffer, size, pos); 49627b1ea09SChristoph Hellwig spu_release_saved(ctx); 4978b3d6663SArnd Bergmann return ret; 4988b3d6663SArnd Bergmann } 4998b3d6663SArnd Bergmann 5008b3d6663SArnd Bergmann static ssize_t 5018b3d6663SArnd Bergmann spufs_regs_write(struct file *file, const char __user *buffer, 5028b3d6663SArnd Bergmann size_t size, loff_t *pos) 5038b3d6663SArnd Bergmann { 5048b3d6663SArnd Bergmann struct spu_context *ctx = file->private_data; 5058b3d6663SArnd Bergmann struct spu_lscsa *lscsa = ctx->csa.lscsa; 5068b3d6663SArnd Bergmann int ret; 5078b3d6663SArnd Bergmann 508d219889bSJeremy Kerr if (*pos >= sizeof(lscsa->gprs)) 5098b3d6663SArnd Bergmann return -EFBIG; 510d219889bSJeremy Kerr 511c9101bdbSChristoph Hellwig ret = spu_acquire_saved(ctx); 512c9101bdbSChristoph Hellwig if (ret) 513c9101bdbSChristoph Hellwig return ret; 5148b3d6663SArnd Bergmann 51563c3b9d7SAkinobu Mita size = simple_write_to_buffer(lscsa->gprs, sizeof(lscsa->gprs), pos, 51663c3b9d7SAkinobu Mita buffer, size); 5178b3d6663SArnd Bergmann 51827b1ea09SChristoph Hellwig spu_release_saved(ctx); 51963c3b9d7SAkinobu Mita return size; 5208b3d6663SArnd Bergmann } 5218b3d6663SArnd Bergmann 5225dfe4c96SArjan van de Ven static const struct file_operations spufs_regs_fops = { 5238b3d6663SArnd Bergmann .open = spufs_regs_open, 5248b3d6663SArnd Bergmann .read = spufs_regs_read, 5258b3d6663SArnd Bergmann .write = spufs_regs_write, 5268b3d6663SArnd Bergmann .llseek = generic_file_llseek, 5278b3d6663SArnd Bergmann }; 5288b3d6663SArnd Bergmann 5298b3d6663SArnd Bergmann static ssize_t 530bf1ab978SDwayne Grant McConnell __spufs_fpcr_read(struct spu_context *ctx, char __user * buffer, 531bf1ab978SDwayne Grant McConnell size_t size, loff_t * pos) 532bf1ab978SDwayne Grant McConnell { 533bf1ab978SDwayne Grant McConnell struct spu_lscsa *lscsa = ctx->csa.lscsa; 534bf1ab978SDwayne Grant McConnell return simple_read_from_buffer(buffer, size, pos, 535bf1ab978SDwayne Grant McConnell &lscsa->fpcr, sizeof(lscsa->fpcr)); 536bf1ab978SDwayne Grant McConnell } 537bf1ab978SDwayne Grant McConnell 538bf1ab978SDwayne Grant McConnell static ssize_t 5398b3d6663SArnd Bergmann spufs_fpcr_read(struct file *file, char __user * buffer, 5408b3d6663SArnd Bergmann size_t size, loff_t * pos) 5418b3d6663SArnd Bergmann { 5428b3d6663SArnd Bergmann int ret; 543bf1ab978SDwayne Grant McConnell struct spu_context *ctx = file->private_data; 5448b3d6663SArnd Bergmann 545c9101bdbSChristoph Hellwig ret = spu_acquire_saved(ctx); 546c9101bdbSChristoph Hellwig if (ret) 547c9101bdbSChristoph Hellwig return ret; 548bf1ab978SDwayne Grant McConnell ret = __spufs_fpcr_read(ctx, buffer, size, pos); 54927b1ea09SChristoph Hellwig spu_release_saved(ctx); 5508b3d6663SArnd Bergmann return ret; 5518b3d6663SArnd Bergmann } 5528b3d6663SArnd Bergmann 5538b3d6663SArnd Bergmann static ssize_t 5548b3d6663SArnd Bergmann spufs_fpcr_write(struct file *file, const char __user * buffer, 5558b3d6663SArnd Bergmann size_t size, loff_t * pos) 5568b3d6663SArnd Bergmann { 5578b3d6663SArnd Bergmann struct spu_context *ctx = file->private_data; 5588b3d6663SArnd Bergmann struct spu_lscsa *lscsa = ctx->csa.lscsa; 5598b3d6663SArnd Bergmann int ret; 5608b3d6663SArnd Bergmann 561d219889bSJeremy Kerr if (*pos >= sizeof(lscsa->fpcr)) 5628b3d6663SArnd Bergmann return -EFBIG; 563c9101bdbSChristoph Hellwig 564c9101bdbSChristoph Hellwig ret = spu_acquire_saved(ctx); 565c9101bdbSChristoph Hellwig if (ret) 566c9101bdbSChristoph Hellwig return ret; 567c9101bdbSChristoph Hellwig 56863c3b9d7SAkinobu Mita size = simple_write_to_buffer(&lscsa->fpcr, sizeof(lscsa->fpcr), pos, 56963c3b9d7SAkinobu Mita buffer, size); 5708b3d6663SArnd Bergmann 57127b1ea09SChristoph Hellwig spu_release_saved(ctx); 57263c3b9d7SAkinobu Mita return size; 5738b3d6663SArnd Bergmann } 5748b3d6663SArnd Bergmann 5755dfe4c96SArjan van de Ven static const struct file_operations spufs_fpcr_fops = { 5768b3d6663SArnd Bergmann .open = spufs_regs_open, 5778b3d6663SArnd Bergmann .read = spufs_fpcr_read, 5788b3d6663SArnd Bergmann .write = spufs_fpcr_write, 57967207b96SArnd Bergmann .llseek = generic_file_llseek, 58067207b96SArnd Bergmann }; 58167207b96SArnd Bergmann 58267207b96SArnd Bergmann /* generic open function for all pipe-like files */ 58367207b96SArnd Bergmann static int spufs_pipe_open(struct inode *inode, struct file *file) 58467207b96SArnd Bergmann { 58567207b96SArnd Bergmann struct spufs_inode_info *i = SPUFS_I(inode); 58667207b96SArnd Bergmann file->private_data = i->i_ctx; 58767207b96SArnd Bergmann 58867207b96SArnd Bergmann return nonseekable_open(inode, file); 58967207b96SArnd Bergmann } 59067207b96SArnd Bergmann 591cdcc89bbSArnd Bergmann /* 592cdcc89bbSArnd Bergmann * Read as many bytes from the mailbox as possible, until 593cdcc89bbSArnd Bergmann * one of the conditions becomes true: 594cdcc89bbSArnd Bergmann * 595cdcc89bbSArnd Bergmann * - no more data available in the mailbox 596cdcc89bbSArnd Bergmann * - end of the user provided buffer 597cdcc89bbSArnd Bergmann * - end of the mapped area 598cdcc89bbSArnd Bergmann */ 59967207b96SArnd Bergmann static ssize_t spufs_mbox_read(struct file *file, char __user *buf, 60067207b96SArnd Bergmann size_t len, loff_t *pos) 60167207b96SArnd Bergmann { 6028b3d6663SArnd Bergmann struct spu_context *ctx = file->private_data; 603cdcc89bbSArnd Bergmann u32 mbox_data, __user *udata; 604cdcc89bbSArnd Bergmann ssize_t count; 60567207b96SArnd Bergmann 60667207b96SArnd Bergmann if (len < 4) 60767207b96SArnd Bergmann return -EINVAL; 60867207b96SArnd Bergmann 609cdcc89bbSArnd Bergmann if (!access_ok(VERIFY_WRITE, buf, len)) 61067207b96SArnd Bergmann return -EFAULT; 61167207b96SArnd Bergmann 612cdcc89bbSArnd Bergmann udata = (void __user *)buf; 613cdcc89bbSArnd Bergmann 614c9101bdbSChristoph Hellwig count = spu_acquire(ctx); 615c9101bdbSChristoph Hellwig if (count) 616c9101bdbSChristoph Hellwig return count; 617c9101bdbSChristoph Hellwig 618274cef5eSArnd Bergmann for (count = 0; (count + 4) <= len; count += 4, udata++) { 619cdcc89bbSArnd Bergmann int ret; 620cdcc89bbSArnd Bergmann ret = ctx->ops->mbox_read(ctx, &mbox_data); 621cdcc89bbSArnd Bergmann if (ret == 0) 622cdcc89bbSArnd Bergmann break; 623cdcc89bbSArnd Bergmann 624cdcc89bbSArnd Bergmann /* 625cdcc89bbSArnd Bergmann * at the end of the mapped area, we can fault 626cdcc89bbSArnd Bergmann * but still need to return the data we have 627cdcc89bbSArnd Bergmann * read successfully so far. 628cdcc89bbSArnd Bergmann */ 629cdcc89bbSArnd Bergmann ret = __put_user(mbox_data, udata); 630cdcc89bbSArnd Bergmann if (ret) { 631cdcc89bbSArnd Bergmann if (!count) 632cdcc89bbSArnd Bergmann count = -EFAULT; 633cdcc89bbSArnd Bergmann break; 634cdcc89bbSArnd Bergmann } 635cdcc89bbSArnd Bergmann } 636cdcc89bbSArnd Bergmann spu_release(ctx); 637cdcc89bbSArnd Bergmann 638cdcc89bbSArnd Bergmann if (!count) 639cdcc89bbSArnd Bergmann count = -EAGAIN; 640cdcc89bbSArnd Bergmann 641cdcc89bbSArnd Bergmann return count; 64267207b96SArnd Bergmann } 64367207b96SArnd Bergmann 6445dfe4c96SArjan van de Ven static const struct file_operations spufs_mbox_fops = { 64567207b96SArnd Bergmann .open = spufs_pipe_open, 64667207b96SArnd Bergmann .read = spufs_mbox_read, 647fc15351dSArnd Bergmann .llseek = no_llseek, 64867207b96SArnd Bergmann }; 64967207b96SArnd Bergmann 65067207b96SArnd Bergmann static ssize_t spufs_mbox_stat_read(struct file *file, char __user *buf, 65167207b96SArnd Bergmann size_t len, loff_t *pos) 65267207b96SArnd Bergmann { 6538b3d6663SArnd Bergmann struct spu_context *ctx = file->private_data; 654c9101bdbSChristoph Hellwig ssize_t ret; 65567207b96SArnd Bergmann u32 mbox_stat; 65667207b96SArnd Bergmann 65767207b96SArnd Bergmann if (len < 4) 65867207b96SArnd Bergmann return -EINVAL; 65967207b96SArnd Bergmann 660c9101bdbSChristoph Hellwig ret = spu_acquire(ctx); 661c9101bdbSChristoph Hellwig if (ret) 662c9101bdbSChristoph Hellwig return ret; 6638b3d6663SArnd Bergmann 6648b3d6663SArnd Bergmann mbox_stat = ctx->ops->mbox_stat_read(ctx) & 0xff; 6658b3d6663SArnd Bergmann 6668b3d6663SArnd Bergmann spu_release(ctx); 66767207b96SArnd Bergmann 66867207b96SArnd Bergmann if (copy_to_user(buf, &mbox_stat, sizeof mbox_stat)) 66967207b96SArnd Bergmann return -EFAULT; 67067207b96SArnd Bergmann 67167207b96SArnd Bergmann return 4; 67267207b96SArnd Bergmann } 67367207b96SArnd Bergmann 6745dfe4c96SArjan van de Ven static const struct file_operations spufs_mbox_stat_fops = { 67567207b96SArnd Bergmann .open = spufs_pipe_open, 67667207b96SArnd Bergmann .read = spufs_mbox_stat_read, 677fc15351dSArnd Bergmann .llseek = no_llseek, 67867207b96SArnd Bergmann }; 67967207b96SArnd Bergmann 68067207b96SArnd Bergmann /* low-level ibox access function */ 6818b3d6663SArnd Bergmann size_t spu_ibox_read(struct spu_context *ctx, u32 *data) 68267207b96SArnd Bergmann { 6838b3d6663SArnd Bergmann return ctx->ops->ibox_read(ctx, data); 68467207b96SArnd Bergmann } 68567207b96SArnd Bergmann 68667207b96SArnd Bergmann static int spufs_ibox_fasync(int fd, struct file *file, int on) 68767207b96SArnd Bergmann { 6888b3d6663SArnd Bergmann struct spu_context *ctx = file->private_data; 6898b3d6663SArnd Bergmann 6908b3d6663SArnd Bergmann return fasync_helper(fd, file, on, &ctx->ibox_fasync); 6918b3d6663SArnd Bergmann } 6928b3d6663SArnd Bergmann 6938b3d6663SArnd Bergmann /* interrupt-level ibox callback function. */ 6948b3d6663SArnd Bergmann void spufs_ibox_callback(struct spu *spu) 6958b3d6663SArnd Bergmann { 6968b3d6663SArnd Bergmann struct spu_context *ctx = spu->ctx; 6978b3d6663SArnd Bergmann 698e65c2f6fSLuke Browning if (!ctx) 699e65c2f6fSLuke Browning return; 700e65c2f6fSLuke Browning 7018b3d6663SArnd Bergmann wake_up_all(&ctx->ibox_wq); 7028b3d6663SArnd Bergmann kill_fasync(&ctx->ibox_fasync, SIGIO, POLLIN); 70367207b96SArnd Bergmann } 70467207b96SArnd Bergmann 705cdcc89bbSArnd Bergmann /* 706cdcc89bbSArnd Bergmann * Read as many bytes from the interrupt mailbox as possible, until 707cdcc89bbSArnd Bergmann * one of the conditions becomes true: 708cdcc89bbSArnd Bergmann * 709cdcc89bbSArnd Bergmann * - no more data available in the mailbox 710cdcc89bbSArnd Bergmann * - end of the user provided buffer 711cdcc89bbSArnd Bergmann * - end of the mapped area 712cdcc89bbSArnd Bergmann * 713cdcc89bbSArnd Bergmann * If the file is opened without O_NONBLOCK, we wait here until 714cdcc89bbSArnd Bergmann * any data is available, but return when we have been able to 715cdcc89bbSArnd Bergmann * read something. 716cdcc89bbSArnd Bergmann */ 71767207b96SArnd Bergmann static ssize_t spufs_ibox_read(struct file *file, char __user *buf, 71867207b96SArnd Bergmann size_t len, loff_t *pos) 71967207b96SArnd Bergmann { 7208b3d6663SArnd Bergmann struct spu_context *ctx = file->private_data; 721cdcc89bbSArnd Bergmann u32 ibox_data, __user *udata; 722cdcc89bbSArnd Bergmann ssize_t count; 72367207b96SArnd Bergmann 72467207b96SArnd Bergmann if (len < 4) 72567207b96SArnd Bergmann return -EINVAL; 72667207b96SArnd Bergmann 727cdcc89bbSArnd Bergmann if (!access_ok(VERIFY_WRITE, buf, len)) 728cdcc89bbSArnd Bergmann return -EFAULT; 729cdcc89bbSArnd Bergmann 730cdcc89bbSArnd Bergmann udata = (void __user *)buf; 731cdcc89bbSArnd Bergmann 732c9101bdbSChristoph Hellwig count = spu_acquire(ctx); 733c9101bdbSChristoph Hellwig if (count) 734eebead5bSChristoph Hellwig goto out; 73567207b96SArnd Bergmann 736cdcc89bbSArnd Bergmann /* wait only for the first element */ 737cdcc89bbSArnd Bergmann count = 0; 73867207b96SArnd Bergmann if (file->f_flags & O_NONBLOCK) { 739eebead5bSChristoph Hellwig if (!spu_ibox_read(ctx, &ibox_data)) { 740cdcc89bbSArnd Bergmann count = -EAGAIN; 741eebead5bSChristoph Hellwig goto out_unlock; 742eebead5bSChristoph Hellwig } 74367207b96SArnd Bergmann } else { 744cdcc89bbSArnd Bergmann count = spufs_wait(ctx->ibox_wq, spu_ibox_read(ctx, &ibox_data)); 745cdcc89bbSArnd Bergmann if (count) 746cdcc89bbSArnd Bergmann goto out; 747eebead5bSChristoph Hellwig } 748cdcc89bbSArnd Bergmann 749cdcc89bbSArnd Bergmann /* if we can't write at all, return -EFAULT */ 750cdcc89bbSArnd Bergmann count = __put_user(ibox_data, udata); 751cdcc89bbSArnd Bergmann if (count) 752eebead5bSChristoph Hellwig goto out_unlock; 753cdcc89bbSArnd Bergmann 754cdcc89bbSArnd Bergmann for (count = 4, udata++; (count + 4) <= len; count += 4, udata++) { 755cdcc89bbSArnd Bergmann int ret; 756cdcc89bbSArnd Bergmann ret = ctx->ops->ibox_read(ctx, &ibox_data); 757cdcc89bbSArnd Bergmann if (ret == 0) 758cdcc89bbSArnd Bergmann break; 759cdcc89bbSArnd Bergmann /* 760cdcc89bbSArnd Bergmann * at the end of the mapped area, we can fault 761cdcc89bbSArnd Bergmann * but still need to return the data we have 762cdcc89bbSArnd Bergmann * read successfully so far. 763cdcc89bbSArnd Bergmann */ 764cdcc89bbSArnd Bergmann ret = __put_user(ibox_data, udata); 765cdcc89bbSArnd Bergmann if (ret) 766cdcc89bbSArnd Bergmann break; 76767207b96SArnd Bergmann } 76867207b96SArnd Bergmann 769eebead5bSChristoph Hellwig out_unlock: 7708b3d6663SArnd Bergmann spu_release(ctx); 771eebead5bSChristoph Hellwig out: 772cdcc89bbSArnd Bergmann return count; 77367207b96SArnd Bergmann } 77467207b96SArnd Bergmann 77567207b96SArnd Bergmann static unsigned int spufs_ibox_poll(struct file *file, poll_table *wait) 77667207b96SArnd Bergmann { 7778b3d6663SArnd Bergmann struct spu_context *ctx = file->private_data; 77867207b96SArnd Bergmann unsigned int mask; 77967207b96SArnd Bergmann 7808b3d6663SArnd Bergmann poll_wait(file, &ctx->ibox_wq, wait); 78167207b96SArnd Bergmann 782c9101bdbSChristoph Hellwig /* 783c9101bdbSChristoph Hellwig * For now keep this uninterruptible and also ignore the rule 784c9101bdbSChristoph Hellwig * that poll should not sleep. Will be fixed later. 785c9101bdbSChristoph Hellwig */ 786c9101bdbSChristoph Hellwig mutex_lock(&ctx->state_mutex); 7873a843d7cSArnd Bergmann mask = ctx->ops->mbox_stat_poll(ctx, POLLIN | POLLRDNORM); 7883a843d7cSArnd Bergmann spu_release(ctx); 78967207b96SArnd Bergmann 79067207b96SArnd Bergmann return mask; 79167207b96SArnd Bergmann } 79267207b96SArnd Bergmann 7935dfe4c96SArjan van de Ven static const struct file_operations spufs_ibox_fops = { 79467207b96SArnd Bergmann .open = spufs_pipe_open, 79567207b96SArnd Bergmann .read = spufs_ibox_read, 79667207b96SArnd Bergmann .poll = spufs_ibox_poll, 79767207b96SArnd Bergmann .fasync = spufs_ibox_fasync, 798fc15351dSArnd Bergmann .llseek = no_llseek, 79967207b96SArnd Bergmann }; 80067207b96SArnd Bergmann 80167207b96SArnd Bergmann static ssize_t spufs_ibox_stat_read(struct file *file, char __user *buf, 80267207b96SArnd Bergmann size_t len, loff_t *pos) 80367207b96SArnd Bergmann { 8048b3d6663SArnd Bergmann struct spu_context *ctx = file->private_data; 805c9101bdbSChristoph Hellwig ssize_t ret; 80667207b96SArnd Bergmann u32 ibox_stat; 80767207b96SArnd Bergmann 80867207b96SArnd Bergmann if (len < 4) 80967207b96SArnd Bergmann return -EINVAL; 81067207b96SArnd Bergmann 811c9101bdbSChristoph Hellwig ret = spu_acquire(ctx); 812c9101bdbSChristoph Hellwig if (ret) 813c9101bdbSChristoph Hellwig return ret; 8148b3d6663SArnd Bergmann ibox_stat = (ctx->ops->mbox_stat_read(ctx) >> 16) & 0xff; 8158b3d6663SArnd Bergmann spu_release(ctx); 81667207b96SArnd Bergmann 81767207b96SArnd Bergmann if (copy_to_user(buf, &ibox_stat, sizeof ibox_stat)) 81867207b96SArnd Bergmann return -EFAULT; 81967207b96SArnd Bergmann 82067207b96SArnd Bergmann return 4; 82167207b96SArnd Bergmann } 82267207b96SArnd Bergmann 8235dfe4c96SArjan van de Ven static const struct file_operations spufs_ibox_stat_fops = { 82467207b96SArnd Bergmann .open = spufs_pipe_open, 82567207b96SArnd Bergmann .read = spufs_ibox_stat_read, 826fc15351dSArnd Bergmann .llseek = no_llseek, 82767207b96SArnd Bergmann }; 82867207b96SArnd Bergmann 82967207b96SArnd Bergmann /* low-level mailbox write */ 8308b3d6663SArnd Bergmann size_t spu_wbox_write(struct spu_context *ctx, u32 data) 83167207b96SArnd Bergmann { 8328b3d6663SArnd Bergmann return ctx->ops->wbox_write(ctx, data); 83367207b96SArnd Bergmann } 83467207b96SArnd Bergmann 83567207b96SArnd Bergmann static int spufs_wbox_fasync(int fd, struct file *file, int on) 83667207b96SArnd Bergmann { 8378b3d6663SArnd Bergmann struct spu_context *ctx = file->private_data; 8388b3d6663SArnd Bergmann int ret; 8398b3d6663SArnd Bergmann 8408b3d6663SArnd Bergmann ret = fasync_helper(fd, file, on, &ctx->wbox_fasync); 8418b3d6663SArnd Bergmann 8428b3d6663SArnd Bergmann return ret; 8438b3d6663SArnd Bergmann } 8448b3d6663SArnd Bergmann 8458b3d6663SArnd Bergmann /* interrupt-level wbox callback function. */ 8468b3d6663SArnd Bergmann void spufs_wbox_callback(struct spu *spu) 8478b3d6663SArnd Bergmann { 8488b3d6663SArnd Bergmann struct spu_context *ctx = spu->ctx; 8498b3d6663SArnd Bergmann 850e65c2f6fSLuke Browning if (!ctx) 851e65c2f6fSLuke Browning return; 852e65c2f6fSLuke Browning 8538b3d6663SArnd Bergmann wake_up_all(&ctx->wbox_wq); 8548b3d6663SArnd Bergmann kill_fasync(&ctx->wbox_fasync, SIGIO, POLLOUT); 85567207b96SArnd Bergmann } 85667207b96SArnd Bergmann 857cdcc89bbSArnd Bergmann /* 858cdcc89bbSArnd Bergmann * Write as many bytes to the interrupt mailbox as possible, until 859cdcc89bbSArnd Bergmann * one of the conditions becomes true: 860cdcc89bbSArnd Bergmann * 861cdcc89bbSArnd Bergmann * - the mailbox is full 862cdcc89bbSArnd Bergmann * - end of the user provided buffer 863cdcc89bbSArnd Bergmann * - end of the mapped area 864cdcc89bbSArnd Bergmann * 865cdcc89bbSArnd Bergmann * If the file is opened without O_NONBLOCK, we wait here until 866027dfac6SMichael Ellerman * space is available, but return when we have been able to 867cdcc89bbSArnd Bergmann * write something. 868cdcc89bbSArnd Bergmann */ 86967207b96SArnd Bergmann static ssize_t spufs_wbox_write(struct file *file, const char __user *buf, 87067207b96SArnd Bergmann size_t len, loff_t *pos) 87167207b96SArnd Bergmann { 8728b3d6663SArnd Bergmann struct spu_context *ctx = file->private_data; 873cdcc89bbSArnd Bergmann u32 wbox_data, __user *udata; 874cdcc89bbSArnd Bergmann ssize_t count; 87567207b96SArnd Bergmann 87667207b96SArnd Bergmann if (len < 4) 87767207b96SArnd Bergmann return -EINVAL; 87867207b96SArnd Bergmann 879cdcc89bbSArnd Bergmann udata = (void __user *)buf; 880cdcc89bbSArnd Bergmann if (!access_ok(VERIFY_READ, buf, len)) 881cdcc89bbSArnd Bergmann return -EFAULT; 882cdcc89bbSArnd Bergmann 883cdcc89bbSArnd Bergmann if (__get_user(wbox_data, udata)) 88467207b96SArnd Bergmann return -EFAULT; 88567207b96SArnd Bergmann 886c9101bdbSChristoph Hellwig count = spu_acquire(ctx); 887c9101bdbSChristoph Hellwig if (count) 888eebead5bSChristoph Hellwig goto out; 8898b3d6663SArnd Bergmann 890cdcc89bbSArnd Bergmann /* 891cdcc89bbSArnd Bergmann * make sure we can at least write one element, by waiting 892cdcc89bbSArnd Bergmann * in case of !O_NONBLOCK 893cdcc89bbSArnd Bergmann */ 894cdcc89bbSArnd Bergmann count = 0; 89567207b96SArnd Bergmann if (file->f_flags & O_NONBLOCK) { 896eebead5bSChristoph Hellwig if (!spu_wbox_write(ctx, wbox_data)) { 897cdcc89bbSArnd Bergmann count = -EAGAIN; 898eebead5bSChristoph Hellwig goto out_unlock; 899eebead5bSChristoph Hellwig } 90067207b96SArnd Bergmann } else { 901cdcc89bbSArnd Bergmann count = spufs_wait(ctx->wbox_wq, spu_wbox_write(ctx, wbox_data)); 902cdcc89bbSArnd Bergmann if (count) 903cdcc89bbSArnd Bergmann goto out; 904eebead5bSChristoph Hellwig } 905eebead5bSChristoph Hellwig 9068b3d6663SArnd Bergmann 90796de0e25SJan Engelhardt /* write as much as possible */ 908cdcc89bbSArnd Bergmann for (count = 4, udata++; (count + 4) <= len; count += 4, udata++) { 909cdcc89bbSArnd Bergmann int ret; 910cdcc89bbSArnd Bergmann ret = __get_user(wbox_data, udata); 911cdcc89bbSArnd Bergmann if (ret) 912cdcc89bbSArnd Bergmann break; 913cdcc89bbSArnd Bergmann 914cdcc89bbSArnd Bergmann ret = spu_wbox_write(ctx, wbox_data); 915cdcc89bbSArnd Bergmann if (ret == 0) 916cdcc89bbSArnd Bergmann break; 917cdcc89bbSArnd Bergmann } 918cdcc89bbSArnd Bergmann 919eebead5bSChristoph Hellwig out_unlock: 920cdcc89bbSArnd Bergmann spu_release(ctx); 921eebead5bSChristoph Hellwig out: 922cdcc89bbSArnd Bergmann return count; 92367207b96SArnd Bergmann } 92467207b96SArnd Bergmann 92567207b96SArnd Bergmann static unsigned int spufs_wbox_poll(struct file *file, poll_table *wait) 92667207b96SArnd Bergmann { 9278b3d6663SArnd Bergmann struct spu_context *ctx = file->private_data; 92867207b96SArnd Bergmann unsigned int mask; 92967207b96SArnd Bergmann 9308b3d6663SArnd Bergmann poll_wait(file, &ctx->wbox_wq, wait); 93167207b96SArnd Bergmann 932c9101bdbSChristoph Hellwig /* 933c9101bdbSChristoph Hellwig * For now keep this uninterruptible and also ignore the rule 934c9101bdbSChristoph Hellwig * that poll should not sleep. Will be fixed later. 935c9101bdbSChristoph Hellwig */ 936c9101bdbSChristoph Hellwig mutex_lock(&ctx->state_mutex); 9373a843d7cSArnd Bergmann mask = ctx->ops->mbox_stat_poll(ctx, POLLOUT | POLLWRNORM); 9383a843d7cSArnd Bergmann spu_release(ctx); 93967207b96SArnd Bergmann 94067207b96SArnd Bergmann return mask; 94167207b96SArnd Bergmann } 94267207b96SArnd Bergmann 9435dfe4c96SArjan van de Ven static const struct file_operations spufs_wbox_fops = { 94467207b96SArnd Bergmann .open = spufs_pipe_open, 94567207b96SArnd Bergmann .write = spufs_wbox_write, 94667207b96SArnd Bergmann .poll = spufs_wbox_poll, 94767207b96SArnd Bergmann .fasync = spufs_wbox_fasync, 948fc15351dSArnd Bergmann .llseek = no_llseek, 94967207b96SArnd Bergmann }; 95067207b96SArnd Bergmann 95167207b96SArnd Bergmann static ssize_t spufs_wbox_stat_read(struct file *file, char __user *buf, 95267207b96SArnd Bergmann size_t len, loff_t *pos) 95367207b96SArnd Bergmann { 9548b3d6663SArnd Bergmann struct spu_context *ctx = file->private_data; 955c9101bdbSChristoph Hellwig ssize_t ret; 95667207b96SArnd Bergmann u32 wbox_stat; 95767207b96SArnd Bergmann 95867207b96SArnd Bergmann if (len < 4) 95967207b96SArnd Bergmann return -EINVAL; 96067207b96SArnd Bergmann 961c9101bdbSChristoph Hellwig ret = spu_acquire(ctx); 962c9101bdbSChristoph Hellwig if (ret) 963c9101bdbSChristoph Hellwig return ret; 9648b3d6663SArnd Bergmann wbox_stat = (ctx->ops->mbox_stat_read(ctx) >> 8) & 0xff; 9658b3d6663SArnd Bergmann spu_release(ctx); 96667207b96SArnd Bergmann 96767207b96SArnd Bergmann if (copy_to_user(buf, &wbox_stat, sizeof wbox_stat)) 96867207b96SArnd Bergmann return -EFAULT; 96967207b96SArnd Bergmann 97067207b96SArnd Bergmann return 4; 97167207b96SArnd Bergmann } 97267207b96SArnd Bergmann 9735dfe4c96SArjan van de Ven static const struct file_operations spufs_wbox_stat_fops = { 97467207b96SArnd Bergmann .open = spufs_pipe_open, 97567207b96SArnd Bergmann .read = spufs_wbox_stat_read, 976fc15351dSArnd Bergmann .llseek = no_llseek, 97767207b96SArnd Bergmann }; 97867207b96SArnd Bergmann 9796df10a82SMark Nutter static int spufs_signal1_open(struct inode *inode, struct file *file) 9806df10a82SMark Nutter { 9816df10a82SMark Nutter struct spufs_inode_info *i = SPUFS_I(inode); 9826df10a82SMark Nutter struct spu_context *ctx = i->i_ctx; 98343c2bbd9SChristoph Hellwig 98447d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 9856df10a82SMark Nutter file->private_data = ctx; 98643c2bbd9SChristoph Hellwig if (!i->i_openers++) 9876df10a82SMark Nutter ctx->signal1 = inode->i_mapping; 98847d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 9896df10a82SMark Nutter return nonseekable_open(inode, file); 9906df10a82SMark Nutter } 9916df10a82SMark Nutter 99243c2bbd9SChristoph Hellwig static int 99343c2bbd9SChristoph Hellwig spufs_signal1_release(struct inode *inode, struct file *file) 99443c2bbd9SChristoph Hellwig { 99543c2bbd9SChristoph Hellwig struct spufs_inode_info *i = SPUFS_I(inode); 99643c2bbd9SChristoph Hellwig struct spu_context *ctx = i->i_ctx; 99743c2bbd9SChristoph Hellwig 99847d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 99943c2bbd9SChristoph Hellwig if (!--i->i_openers) 100043c2bbd9SChristoph Hellwig ctx->signal1 = NULL; 100147d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 100243c2bbd9SChristoph Hellwig return 0; 100343c2bbd9SChristoph Hellwig } 100443c2bbd9SChristoph Hellwig 1005bf1ab978SDwayne Grant McConnell static ssize_t __spufs_signal1_read(struct spu_context *ctx, char __user *buf, 100667207b96SArnd Bergmann size_t len, loff_t *pos) 100767207b96SArnd Bergmann { 100817f88cebSDwayne Grant McConnell int ret = 0; 100967207b96SArnd Bergmann u32 data; 101067207b96SArnd Bergmann 101167207b96SArnd Bergmann if (len < 4) 101267207b96SArnd Bergmann return -EINVAL; 101367207b96SArnd Bergmann 101417f88cebSDwayne Grant McConnell if (ctx->csa.spu_chnlcnt_RW[3]) { 101517f88cebSDwayne Grant McConnell data = ctx->csa.spu_chnldata_RW[3]; 101617f88cebSDwayne Grant McConnell ret = 4; 101717f88cebSDwayne Grant McConnell } 10188b3d6663SArnd Bergmann 101917f88cebSDwayne Grant McConnell if (!ret) 102017f88cebSDwayne Grant McConnell goto out; 102117f88cebSDwayne Grant McConnell 102267207b96SArnd Bergmann if (copy_to_user(buf, &data, 4)) 102367207b96SArnd Bergmann return -EFAULT; 102467207b96SArnd Bergmann 102517f88cebSDwayne Grant McConnell out: 102617f88cebSDwayne Grant McConnell return ret; 102767207b96SArnd Bergmann } 102867207b96SArnd Bergmann 1029bf1ab978SDwayne Grant McConnell static ssize_t spufs_signal1_read(struct file *file, char __user *buf, 1030bf1ab978SDwayne Grant McConnell size_t len, loff_t *pos) 1031bf1ab978SDwayne Grant McConnell { 1032bf1ab978SDwayne Grant McConnell int ret; 1033bf1ab978SDwayne Grant McConnell struct spu_context *ctx = file->private_data; 1034bf1ab978SDwayne Grant McConnell 1035c9101bdbSChristoph Hellwig ret = spu_acquire_saved(ctx); 1036c9101bdbSChristoph Hellwig if (ret) 1037c9101bdbSChristoph Hellwig return ret; 1038bf1ab978SDwayne Grant McConnell ret = __spufs_signal1_read(ctx, buf, len, pos); 103927b1ea09SChristoph Hellwig spu_release_saved(ctx); 1040bf1ab978SDwayne Grant McConnell 1041bf1ab978SDwayne Grant McConnell return ret; 1042bf1ab978SDwayne Grant McConnell } 1043bf1ab978SDwayne Grant McConnell 104467207b96SArnd Bergmann static ssize_t spufs_signal1_write(struct file *file, const char __user *buf, 104567207b96SArnd Bergmann size_t len, loff_t *pos) 104667207b96SArnd Bergmann { 104767207b96SArnd Bergmann struct spu_context *ctx; 1048c9101bdbSChristoph Hellwig ssize_t ret; 104967207b96SArnd Bergmann u32 data; 105067207b96SArnd Bergmann 105167207b96SArnd Bergmann ctx = file->private_data; 105267207b96SArnd Bergmann 105367207b96SArnd Bergmann if (len < 4) 105467207b96SArnd Bergmann return -EINVAL; 105567207b96SArnd Bergmann 105667207b96SArnd Bergmann if (copy_from_user(&data, buf, 4)) 105767207b96SArnd Bergmann return -EFAULT; 105867207b96SArnd Bergmann 1059c9101bdbSChristoph Hellwig ret = spu_acquire(ctx); 1060c9101bdbSChristoph Hellwig if (ret) 1061c9101bdbSChristoph Hellwig return ret; 10628b3d6663SArnd Bergmann ctx->ops->signal1_write(ctx, data); 10638b3d6663SArnd Bergmann spu_release(ctx); 106467207b96SArnd Bergmann 106567207b96SArnd Bergmann return 4; 106667207b96SArnd Bergmann } 106767207b96SArnd Bergmann 1068b1e2270fSNick Piggin static int 106911bac800SDave Jiang spufs_signal1_mmap_fault(struct vm_fault *vmf) 10706df10a82SMark Nutter { 107187ff6090SJeremy Kerr #if SPUFS_SIGNAL_MAP_SIZE == 0x1000 107211bac800SDave Jiang return spufs_ps_fault(vmf, 0x14000, SPUFS_SIGNAL_MAP_SIZE); 107387ff6090SJeremy Kerr #elif SPUFS_SIGNAL_MAP_SIZE == 0x10000 107427d5bf2aSBenjamin Herrenschmidt /* For 64k pages, both signal1 and signal2 can be used to mmap the whole 107527d5bf2aSBenjamin Herrenschmidt * signal 1 and 2 area 107627d5bf2aSBenjamin Herrenschmidt */ 107711bac800SDave Jiang return spufs_ps_fault(vmf, 0x10000, SPUFS_SIGNAL_MAP_SIZE); 107827d5bf2aSBenjamin Herrenschmidt #else 107927d5bf2aSBenjamin Herrenschmidt #error unsupported page size 108027d5bf2aSBenjamin Herrenschmidt #endif 10816df10a82SMark Nutter } 10826df10a82SMark Nutter 1083f0f37e2fSAlexey Dobriyan static const struct vm_operations_struct spufs_signal1_mmap_vmops = { 1084b1e2270fSNick Piggin .fault = spufs_signal1_mmap_fault, 10856df10a82SMark Nutter }; 10866df10a82SMark Nutter 10876df10a82SMark Nutter static int spufs_signal1_mmap(struct file *file, struct vm_area_struct *vma) 10886df10a82SMark Nutter { 10896df10a82SMark Nutter if (!(vma->vm_flags & VM_SHARED)) 10906df10a82SMark Nutter return -EINVAL; 10916df10a82SMark Nutter 109278bde53eSBenjamin Herrenschmidt vma->vm_flags |= VM_IO | VM_PFNMAP; 109364b3d0e8SBenjamin Herrenschmidt vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot); 10946df10a82SMark Nutter 10956df10a82SMark Nutter vma->vm_ops = &spufs_signal1_mmap_vmops; 10966df10a82SMark Nutter return 0; 10976df10a82SMark Nutter } 10986df10a82SMark Nutter 10995dfe4c96SArjan van de Ven static const struct file_operations spufs_signal1_fops = { 11006df10a82SMark Nutter .open = spufs_signal1_open, 110143c2bbd9SChristoph Hellwig .release = spufs_signal1_release, 110267207b96SArnd Bergmann .read = spufs_signal1_read, 110367207b96SArnd Bergmann .write = spufs_signal1_write, 11046df10a82SMark Nutter .mmap = spufs_signal1_mmap, 1105fc15351dSArnd Bergmann .llseek = no_llseek, 110667207b96SArnd Bergmann }; 110767207b96SArnd Bergmann 1108d054b36fSJeremy Kerr static const struct file_operations spufs_signal1_nosched_fops = { 1109d054b36fSJeremy Kerr .open = spufs_signal1_open, 1110d054b36fSJeremy Kerr .release = spufs_signal1_release, 1111d054b36fSJeremy Kerr .write = spufs_signal1_write, 1112d054b36fSJeremy Kerr .mmap = spufs_signal1_mmap, 1113fc15351dSArnd Bergmann .llseek = no_llseek, 1114d054b36fSJeremy Kerr }; 1115d054b36fSJeremy Kerr 11166df10a82SMark Nutter static int spufs_signal2_open(struct inode *inode, struct file *file) 11176df10a82SMark Nutter { 11186df10a82SMark Nutter struct spufs_inode_info *i = SPUFS_I(inode); 11196df10a82SMark Nutter struct spu_context *ctx = i->i_ctx; 112043c2bbd9SChristoph Hellwig 112147d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 11226df10a82SMark Nutter file->private_data = ctx; 112343c2bbd9SChristoph Hellwig if (!i->i_openers++) 11246df10a82SMark Nutter ctx->signal2 = inode->i_mapping; 112547d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 11266df10a82SMark Nutter return nonseekable_open(inode, file); 11276df10a82SMark Nutter } 11286df10a82SMark Nutter 112943c2bbd9SChristoph Hellwig static int 113043c2bbd9SChristoph Hellwig spufs_signal2_release(struct inode *inode, struct file *file) 113143c2bbd9SChristoph Hellwig { 113243c2bbd9SChristoph Hellwig struct spufs_inode_info *i = SPUFS_I(inode); 113343c2bbd9SChristoph Hellwig struct spu_context *ctx = i->i_ctx; 113443c2bbd9SChristoph Hellwig 113547d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 113643c2bbd9SChristoph Hellwig if (!--i->i_openers) 113743c2bbd9SChristoph Hellwig ctx->signal2 = NULL; 113847d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 113943c2bbd9SChristoph Hellwig return 0; 114043c2bbd9SChristoph Hellwig } 114143c2bbd9SChristoph Hellwig 1142bf1ab978SDwayne Grant McConnell static ssize_t __spufs_signal2_read(struct spu_context *ctx, char __user *buf, 114367207b96SArnd Bergmann size_t len, loff_t *pos) 114467207b96SArnd Bergmann { 114517f88cebSDwayne Grant McConnell int ret = 0; 114667207b96SArnd Bergmann u32 data; 114767207b96SArnd Bergmann 114867207b96SArnd Bergmann if (len < 4) 114967207b96SArnd Bergmann return -EINVAL; 115067207b96SArnd Bergmann 115117f88cebSDwayne Grant McConnell if (ctx->csa.spu_chnlcnt_RW[4]) { 115217f88cebSDwayne Grant McConnell data = ctx->csa.spu_chnldata_RW[4]; 115317f88cebSDwayne Grant McConnell ret = 4; 115417f88cebSDwayne Grant McConnell } 11558b3d6663SArnd Bergmann 115617f88cebSDwayne Grant McConnell if (!ret) 115717f88cebSDwayne Grant McConnell goto out; 115817f88cebSDwayne Grant McConnell 115967207b96SArnd Bergmann if (copy_to_user(buf, &data, 4)) 116067207b96SArnd Bergmann return -EFAULT; 116167207b96SArnd Bergmann 116217f88cebSDwayne Grant McConnell out: 1163bf1ab978SDwayne Grant McConnell return ret; 1164bf1ab978SDwayne Grant McConnell } 1165bf1ab978SDwayne Grant McConnell 1166bf1ab978SDwayne Grant McConnell static ssize_t spufs_signal2_read(struct file *file, char __user *buf, 1167bf1ab978SDwayne Grant McConnell size_t len, loff_t *pos) 1168bf1ab978SDwayne Grant McConnell { 1169bf1ab978SDwayne Grant McConnell struct spu_context *ctx = file->private_data; 1170bf1ab978SDwayne Grant McConnell int ret; 1171bf1ab978SDwayne Grant McConnell 1172c9101bdbSChristoph Hellwig ret = spu_acquire_saved(ctx); 1173c9101bdbSChristoph Hellwig if (ret) 1174c9101bdbSChristoph Hellwig return ret; 1175bf1ab978SDwayne Grant McConnell ret = __spufs_signal2_read(ctx, buf, len, pos); 117627b1ea09SChristoph Hellwig spu_release_saved(ctx); 1177bf1ab978SDwayne Grant McConnell 1178bf1ab978SDwayne Grant McConnell return ret; 117967207b96SArnd Bergmann } 118067207b96SArnd Bergmann 118167207b96SArnd Bergmann static ssize_t spufs_signal2_write(struct file *file, const char __user *buf, 118267207b96SArnd Bergmann size_t len, loff_t *pos) 118367207b96SArnd Bergmann { 118467207b96SArnd Bergmann struct spu_context *ctx; 1185c9101bdbSChristoph Hellwig ssize_t ret; 118667207b96SArnd Bergmann u32 data; 118767207b96SArnd Bergmann 118867207b96SArnd Bergmann ctx = file->private_data; 118967207b96SArnd Bergmann 119067207b96SArnd Bergmann if (len < 4) 119167207b96SArnd Bergmann return -EINVAL; 119267207b96SArnd Bergmann 119367207b96SArnd Bergmann if (copy_from_user(&data, buf, 4)) 119467207b96SArnd Bergmann return -EFAULT; 119567207b96SArnd Bergmann 1196c9101bdbSChristoph Hellwig ret = spu_acquire(ctx); 1197c9101bdbSChristoph Hellwig if (ret) 1198c9101bdbSChristoph Hellwig return ret; 11998b3d6663SArnd Bergmann ctx->ops->signal2_write(ctx, data); 12008b3d6663SArnd Bergmann spu_release(ctx); 120167207b96SArnd Bergmann 120267207b96SArnd Bergmann return 4; 120367207b96SArnd Bergmann } 120467207b96SArnd Bergmann 120527d5bf2aSBenjamin Herrenschmidt #if SPUFS_MMAP_4K 1206b1e2270fSNick Piggin static int 120711bac800SDave Jiang spufs_signal2_mmap_fault(struct vm_fault *vmf) 12086df10a82SMark Nutter { 120987ff6090SJeremy Kerr #if SPUFS_SIGNAL_MAP_SIZE == 0x1000 121011bac800SDave Jiang return spufs_ps_fault(vmf, 0x1c000, SPUFS_SIGNAL_MAP_SIZE); 121187ff6090SJeremy Kerr #elif SPUFS_SIGNAL_MAP_SIZE == 0x10000 121227d5bf2aSBenjamin Herrenschmidt /* For 64k pages, both signal1 and signal2 can be used to mmap the whole 121327d5bf2aSBenjamin Herrenschmidt * signal 1 and 2 area 121427d5bf2aSBenjamin Herrenschmidt */ 121511bac800SDave Jiang return spufs_ps_fault(vmf, 0x10000, SPUFS_SIGNAL_MAP_SIZE); 121627d5bf2aSBenjamin Herrenschmidt #else 121727d5bf2aSBenjamin Herrenschmidt #error unsupported page size 121827d5bf2aSBenjamin Herrenschmidt #endif 12196df10a82SMark Nutter } 12206df10a82SMark Nutter 1221f0f37e2fSAlexey Dobriyan static const struct vm_operations_struct spufs_signal2_mmap_vmops = { 1222b1e2270fSNick Piggin .fault = spufs_signal2_mmap_fault, 12236df10a82SMark Nutter }; 12246df10a82SMark Nutter 12256df10a82SMark Nutter static int spufs_signal2_mmap(struct file *file, struct vm_area_struct *vma) 12266df10a82SMark Nutter { 12276df10a82SMark Nutter if (!(vma->vm_flags & VM_SHARED)) 12286df10a82SMark Nutter return -EINVAL; 12296df10a82SMark Nutter 123078bde53eSBenjamin Herrenschmidt vma->vm_flags |= VM_IO | VM_PFNMAP; 123164b3d0e8SBenjamin Herrenschmidt vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot); 12326df10a82SMark Nutter 12336df10a82SMark Nutter vma->vm_ops = &spufs_signal2_mmap_vmops; 12346df10a82SMark Nutter return 0; 12356df10a82SMark Nutter } 123627d5bf2aSBenjamin Herrenschmidt #else /* SPUFS_MMAP_4K */ 123727d5bf2aSBenjamin Herrenschmidt #define spufs_signal2_mmap NULL 123827d5bf2aSBenjamin Herrenschmidt #endif /* !SPUFS_MMAP_4K */ 12396df10a82SMark Nutter 12405dfe4c96SArjan van de Ven static const struct file_operations spufs_signal2_fops = { 12416df10a82SMark Nutter .open = spufs_signal2_open, 124243c2bbd9SChristoph Hellwig .release = spufs_signal2_release, 124367207b96SArnd Bergmann .read = spufs_signal2_read, 124467207b96SArnd Bergmann .write = spufs_signal2_write, 12456df10a82SMark Nutter .mmap = spufs_signal2_mmap, 1246fc15351dSArnd Bergmann .llseek = no_llseek, 124767207b96SArnd Bergmann }; 124867207b96SArnd Bergmann 1249d054b36fSJeremy Kerr static const struct file_operations spufs_signal2_nosched_fops = { 1250d054b36fSJeremy Kerr .open = spufs_signal2_open, 1251d054b36fSJeremy Kerr .release = spufs_signal2_release, 1252d054b36fSJeremy Kerr .write = spufs_signal2_write, 1253d054b36fSJeremy Kerr .mmap = spufs_signal2_mmap, 1254fc15351dSArnd Bergmann .llseek = no_llseek, 1255d054b36fSJeremy Kerr }; 1256d054b36fSJeremy Kerr 1257104f0cc2SMichael Ellerman /* 1258104f0cc2SMichael Ellerman * This is a wrapper around DEFINE_SIMPLE_ATTRIBUTE which does the 1259104f0cc2SMichael Ellerman * work of acquiring (or not) the SPU context before calling through 1260104f0cc2SMichael Ellerman * to the actual get routine. The set routine is called directly. 1261104f0cc2SMichael Ellerman */ 1262104f0cc2SMichael Ellerman #define SPU_ATTR_NOACQUIRE 0 1263104f0cc2SMichael Ellerman #define SPU_ATTR_ACQUIRE 1 1264104f0cc2SMichael Ellerman #define SPU_ATTR_ACQUIRE_SAVED 2 1265104f0cc2SMichael Ellerman 1266104f0cc2SMichael Ellerman #define DEFINE_SPUFS_ATTRIBUTE(__name, __get, __set, __fmt, __acquire) \ 1267197b1a82SChristoph Hellwig static int __##__get(void *data, u64 *val) \ 1268104f0cc2SMichael Ellerman { \ 1269104f0cc2SMichael Ellerman struct spu_context *ctx = data; \ 1270c9101bdbSChristoph Hellwig int ret = 0; \ 1271104f0cc2SMichael Ellerman \ 1272104f0cc2SMichael Ellerman if (__acquire == SPU_ATTR_ACQUIRE) { \ 1273c9101bdbSChristoph Hellwig ret = spu_acquire(ctx); \ 1274c9101bdbSChristoph Hellwig if (ret) \ 1275c9101bdbSChristoph Hellwig return ret; \ 1276197b1a82SChristoph Hellwig *val = __get(ctx); \ 1277104f0cc2SMichael Ellerman spu_release(ctx); \ 1278104f0cc2SMichael Ellerman } else if (__acquire == SPU_ATTR_ACQUIRE_SAVED) { \ 1279c9101bdbSChristoph Hellwig ret = spu_acquire_saved(ctx); \ 1280c9101bdbSChristoph Hellwig if (ret) \ 1281c9101bdbSChristoph Hellwig return ret; \ 1282197b1a82SChristoph Hellwig *val = __get(ctx); \ 1283104f0cc2SMichael Ellerman spu_release_saved(ctx); \ 1284104f0cc2SMichael Ellerman } else \ 1285197b1a82SChristoph Hellwig *val = __get(ctx); \ 1286104f0cc2SMichael Ellerman \ 1287197b1a82SChristoph Hellwig return 0; \ 1288104f0cc2SMichael Ellerman } \ 1289197b1a82SChristoph Hellwig DEFINE_SPUFS_SIMPLE_ATTRIBUTE(__name, __##__get, __set, __fmt); 1290104f0cc2SMichael Ellerman 1291197b1a82SChristoph Hellwig static int spufs_signal1_type_set(void *data, u64 val) 129267207b96SArnd Bergmann { 129367207b96SArnd Bergmann struct spu_context *ctx = data; 1294c9101bdbSChristoph Hellwig int ret; 129567207b96SArnd Bergmann 1296c9101bdbSChristoph Hellwig ret = spu_acquire(ctx); 1297c9101bdbSChristoph Hellwig if (ret) 1298c9101bdbSChristoph Hellwig return ret; 12998b3d6663SArnd Bergmann ctx->ops->signal1_type_set(ctx, val); 13008b3d6663SArnd Bergmann spu_release(ctx); 1301197b1a82SChristoph Hellwig 1302197b1a82SChristoph Hellwig return 0; 130367207b96SArnd Bergmann } 130467207b96SArnd Bergmann 1305104f0cc2SMichael Ellerman static u64 spufs_signal1_type_get(struct spu_context *ctx) 1306bf1ab978SDwayne Grant McConnell { 1307bf1ab978SDwayne Grant McConnell return ctx->ops->signal1_type_get(ctx); 1308bf1ab978SDwayne Grant McConnell } 1309104f0cc2SMichael Ellerman DEFINE_SPUFS_ATTRIBUTE(spufs_signal1_type, spufs_signal1_type_get, 1310af8b44e0SJeremy Kerr spufs_signal1_type_set, "%llu\n", SPU_ATTR_ACQUIRE); 1311bf1ab978SDwayne Grant McConnell 131267207b96SArnd Bergmann 1313197b1a82SChristoph Hellwig static int spufs_signal2_type_set(void *data, u64 val) 131467207b96SArnd Bergmann { 131567207b96SArnd Bergmann struct spu_context *ctx = data; 1316c9101bdbSChristoph Hellwig int ret; 131767207b96SArnd Bergmann 1318c9101bdbSChristoph Hellwig ret = spu_acquire(ctx); 1319c9101bdbSChristoph Hellwig if (ret) 1320c9101bdbSChristoph Hellwig return ret; 13218b3d6663SArnd Bergmann ctx->ops->signal2_type_set(ctx, val); 13228b3d6663SArnd Bergmann spu_release(ctx); 1323197b1a82SChristoph Hellwig 1324197b1a82SChristoph Hellwig return 0; 132567207b96SArnd Bergmann } 132667207b96SArnd Bergmann 1327104f0cc2SMichael Ellerman static u64 spufs_signal2_type_get(struct spu_context *ctx) 1328bf1ab978SDwayne Grant McConnell { 1329bf1ab978SDwayne Grant McConnell return ctx->ops->signal2_type_get(ctx); 1330bf1ab978SDwayne Grant McConnell } 1331104f0cc2SMichael Ellerman DEFINE_SPUFS_ATTRIBUTE(spufs_signal2_type, spufs_signal2_type_get, 1332af8b44e0SJeremy Kerr spufs_signal2_type_set, "%llu\n", SPU_ATTR_ACQUIRE); 133367207b96SArnd Bergmann 133427d5bf2aSBenjamin Herrenschmidt #if SPUFS_MMAP_4K 1335b1e2270fSNick Piggin static int 133611bac800SDave Jiang spufs_mss_mmap_fault(struct vm_fault *vmf) 1337d9379c4bSarnd@arndb.de { 133811bac800SDave Jiang return spufs_ps_fault(vmf, 0x0000, SPUFS_MSS_MAP_SIZE); 1339d9379c4bSarnd@arndb.de } 1340d9379c4bSarnd@arndb.de 1341f0f37e2fSAlexey Dobriyan static const struct vm_operations_struct spufs_mss_mmap_vmops = { 1342b1e2270fSNick Piggin .fault = spufs_mss_mmap_fault, 1343d9379c4bSarnd@arndb.de }; 1344d9379c4bSarnd@arndb.de 1345d9379c4bSarnd@arndb.de /* 1346d9379c4bSarnd@arndb.de * mmap support for problem state MFC DMA area [0x0000 - 0x0fff]. 1347d9379c4bSarnd@arndb.de */ 1348d9379c4bSarnd@arndb.de static int spufs_mss_mmap(struct file *file, struct vm_area_struct *vma) 1349d9379c4bSarnd@arndb.de { 1350d9379c4bSarnd@arndb.de if (!(vma->vm_flags & VM_SHARED)) 1351d9379c4bSarnd@arndb.de return -EINVAL; 1352d9379c4bSarnd@arndb.de 135378bde53eSBenjamin Herrenschmidt vma->vm_flags |= VM_IO | VM_PFNMAP; 135464b3d0e8SBenjamin Herrenschmidt vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot); 1355d9379c4bSarnd@arndb.de 1356d9379c4bSarnd@arndb.de vma->vm_ops = &spufs_mss_mmap_vmops; 1357d9379c4bSarnd@arndb.de return 0; 1358d9379c4bSarnd@arndb.de } 135927d5bf2aSBenjamin Herrenschmidt #else /* SPUFS_MMAP_4K */ 136027d5bf2aSBenjamin Herrenschmidt #define spufs_mss_mmap NULL 136127d5bf2aSBenjamin Herrenschmidt #endif /* !SPUFS_MMAP_4K */ 1362d9379c4bSarnd@arndb.de 1363d9379c4bSarnd@arndb.de static int spufs_mss_open(struct inode *inode, struct file *file) 1364d9379c4bSarnd@arndb.de { 1365d9379c4bSarnd@arndb.de struct spufs_inode_info *i = SPUFS_I(inode); 136617e0e270SBenjamin Herrenschmidt struct spu_context *ctx = i->i_ctx; 1367d9379c4bSarnd@arndb.de 1368d9379c4bSarnd@arndb.de file->private_data = i->i_ctx; 136943c2bbd9SChristoph Hellwig 137047d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 137143c2bbd9SChristoph Hellwig if (!i->i_openers++) 137217e0e270SBenjamin Herrenschmidt ctx->mss = inode->i_mapping; 137347d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 1374d9379c4bSarnd@arndb.de return nonseekable_open(inode, file); 1375d9379c4bSarnd@arndb.de } 1376d9379c4bSarnd@arndb.de 137743c2bbd9SChristoph Hellwig static int 137843c2bbd9SChristoph Hellwig spufs_mss_release(struct inode *inode, struct file *file) 137943c2bbd9SChristoph Hellwig { 138043c2bbd9SChristoph Hellwig struct spufs_inode_info *i = SPUFS_I(inode); 138143c2bbd9SChristoph Hellwig struct spu_context *ctx = i->i_ctx; 138243c2bbd9SChristoph Hellwig 138347d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 138443c2bbd9SChristoph Hellwig if (!--i->i_openers) 138543c2bbd9SChristoph Hellwig ctx->mss = NULL; 138647d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 138743c2bbd9SChristoph Hellwig return 0; 138843c2bbd9SChristoph Hellwig } 138943c2bbd9SChristoph Hellwig 13905dfe4c96SArjan van de Ven static const struct file_operations spufs_mss_fops = { 1391d9379c4bSarnd@arndb.de .open = spufs_mss_open, 139243c2bbd9SChristoph Hellwig .release = spufs_mss_release, 1393d9379c4bSarnd@arndb.de .mmap = spufs_mss_mmap, 1394fc15351dSArnd Bergmann .llseek = no_llseek, 139527d5bf2aSBenjamin Herrenschmidt }; 139627d5bf2aSBenjamin Herrenschmidt 1397b1e2270fSNick Piggin static int 139811bac800SDave Jiang spufs_psmap_mmap_fault(struct vm_fault *vmf) 139927d5bf2aSBenjamin Herrenschmidt { 140011bac800SDave Jiang return spufs_ps_fault(vmf, 0x0000, SPUFS_PS_MAP_SIZE); 140127d5bf2aSBenjamin Herrenschmidt } 140227d5bf2aSBenjamin Herrenschmidt 1403f0f37e2fSAlexey Dobriyan static const struct vm_operations_struct spufs_psmap_mmap_vmops = { 1404b1e2270fSNick Piggin .fault = spufs_psmap_mmap_fault, 140527d5bf2aSBenjamin Herrenschmidt }; 140627d5bf2aSBenjamin Herrenschmidt 140727d5bf2aSBenjamin Herrenschmidt /* 140827d5bf2aSBenjamin Herrenschmidt * mmap support for full problem state area [0x00000 - 0x1ffff]. 140927d5bf2aSBenjamin Herrenschmidt */ 141027d5bf2aSBenjamin Herrenschmidt static int spufs_psmap_mmap(struct file *file, struct vm_area_struct *vma) 141127d5bf2aSBenjamin Herrenschmidt { 141227d5bf2aSBenjamin Herrenschmidt if (!(vma->vm_flags & VM_SHARED)) 141327d5bf2aSBenjamin Herrenschmidt return -EINVAL; 141427d5bf2aSBenjamin Herrenschmidt 141578bde53eSBenjamin Herrenschmidt vma->vm_flags |= VM_IO | VM_PFNMAP; 141664b3d0e8SBenjamin Herrenschmidt vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot); 141727d5bf2aSBenjamin Herrenschmidt 141827d5bf2aSBenjamin Herrenschmidt vma->vm_ops = &spufs_psmap_mmap_vmops; 141927d5bf2aSBenjamin Herrenschmidt return 0; 142027d5bf2aSBenjamin Herrenschmidt } 142127d5bf2aSBenjamin Herrenschmidt 142227d5bf2aSBenjamin Herrenschmidt static int spufs_psmap_open(struct inode *inode, struct file *file) 142327d5bf2aSBenjamin Herrenschmidt { 142427d5bf2aSBenjamin Herrenschmidt struct spufs_inode_info *i = SPUFS_I(inode); 142517e0e270SBenjamin Herrenschmidt struct spu_context *ctx = i->i_ctx; 142627d5bf2aSBenjamin Herrenschmidt 142747d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 142827d5bf2aSBenjamin Herrenschmidt file->private_data = i->i_ctx; 142943c2bbd9SChristoph Hellwig if (!i->i_openers++) 143017e0e270SBenjamin Herrenschmidt ctx->psmap = inode->i_mapping; 143147d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 143227d5bf2aSBenjamin Herrenschmidt return nonseekable_open(inode, file); 143327d5bf2aSBenjamin Herrenschmidt } 143427d5bf2aSBenjamin Herrenschmidt 143543c2bbd9SChristoph Hellwig static int 143643c2bbd9SChristoph Hellwig spufs_psmap_release(struct inode *inode, struct file *file) 143743c2bbd9SChristoph Hellwig { 143843c2bbd9SChristoph Hellwig struct spufs_inode_info *i = SPUFS_I(inode); 143943c2bbd9SChristoph Hellwig struct spu_context *ctx = i->i_ctx; 144043c2bbd9SChristoph Hellwig 144147d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 144243c2bbd9SChristoph Hellwig if (!--i->i_openers) 144343c2bbd9SChristoph Hellwig ctx->psmap = NULL; 144447d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 144543c2bbd9SChristoph Hellwig return 0; 144643c2bbd9SChristoph Hellwig } 144743c2bbd9SChristoph Hellwig 14485dfe4c96SArjan van de Ven static const struct file_operations spufs_psmap_fops = { 144927d5bf2aSBenjamin Herrenschmidt .open = spufs_psmap_open, 145043c2bbd9SChristoph Hellwig .release = spufs_psmap_release, 145127d5bf2aSBenjamin Herrenschmidt .mmap = spufs_psmap_mmap, 1452fc15351dSArnd Bergmann .llseek = no_llseek, 1453d9379c4bSarnd@arndb.de }; 1454d9379c4bSarnd@arndb.de 1455d9379c4bSarnd@arndb.de 145627d5bf2aSBenjamin Herrenschmidt #if SPUFS_MMAP_4K 1457b1e2270fSNick Piggin static int 145811bac800SDave Jiang spufs_mfc_mmap_fault(struct vm_fault *vmf) 14596df10a82SMark Nutter { 146011bac800SDave Jiang return spufs_ps_fault(vmf, 0x3000, SPUFS_MFC_MAP_SIZE); 14616df10a82SMark Nutter } 14626df10a82SMark Nutter 1463f0f37e2fSAlexey Dobriyan static const struct vm_operations_struct spufs_mfc_mmap_vmops = { 1464b1e2270fSNick Piggin .fault = spufs_mfc_mmap_fault, 14656df10a82SMark Nutter }; 14666df10a82SMark Nutter 14676df10a82SMark Nutter /* 14686df10a82SMark Nutter * mmap support for problem state MFC DMA area [0x0000 - 0x0fff]. 14696df10a82SMark Nutter */ 14706df10a82SMark Nutter static int spufs_mfc_mmap(struct file *file, struct vm_area_struct *vma) 14716df10a82SMark Nutter { 14726df10a82SMark Nutter if (!(vma->vm_flags & VM_SHARED)) 14736df10a82SMark Nutter return -EINVAL; 14746df10a82SMark Nutter 147578bde53eSBenjamin Herrenschmidt vma->vm_flags |= VM_IO | VM_PFNMAP; 147664b3d0e8SBenjamin Herrenschmidt vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot); 14776df10a82SMark Nutter 14786df10a82SMark Nutter vma->vm_ops = &spufs_mfc_mmap_vmops; 14796df10a82SMark Nutter return 0; 14806df10a82SMark Nutter } 148127d5bf2aSBenjamin Herrenschmidt #else /* SPUFS_MMAP_4K */ 148227d5bf2aSBenjamin Herrenschmidt #define spufs_mfc_mmap NULL 148327d5bf2aSBenjamin Herrenschmidt #endif /* !SPUFS_MMAP_4K */ 1484a33a7d73SArnd Bergmann 1485a33a7d73SArnd Bergmann static int spufs_mfc_open(struct inode *inode, struct file *file) 1486a33a7d73SArnd Bergmann { 1487a33a7d73SArnd Bergmann struct spufs_inode_info *i = SPUFS_I(inode); 1488a33a7d73SArnd Bergmann struct spu_context *ctx = i->i_ctx; 1489a33a7d73SArnd Bergmann 1490a33a7d73SArnd Bergmann /* we don't want to deal with DMA into other processes */ 1491a33a7d73SArnd Bergmann if (ctx->owner != current->mm) 1492a33a7d73SArnd Bergmann return -EINVAL; 1493a33a7d73SArnd Bergmann 1494a33a7d73SArnd Bergmann if (atomic_read(&inode->i_count) != 1) 1495a33a7d73SArnd Bergmann return -EBUSY; 1496a33a7d73SArnd Bergmann 149747d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 1498a33a7d73SArnd Bergmann file->private_data = ctx; 149943c2bbd9SChristoph Hellwig if (!i->i_openers++) 150017e0e270SBenjamin Herrenschmidt ctx->mfc = inode->i_mapping; 150147d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 1502a33a7d73SArnd Bergmann return nonseekable_open(inode, file); 1503a33a7d73SArnd Bergmann } 1504a33a7d73SArnd Bergmann 150543c2bbd9SChristoph Hellwig static int 150643c2bbd9SChristoph Hellwig spufs_mfc_release(struct inode *inode, struct file *file) 150743c2bbd9SChristoph Hellwig { 150843c2bbd9SChristoph Hellwig struct spufs_inode_info *i = SPUFS_I(inode); 150943c2bbd9SChristoph Hellwig struct spu_context *ctx = i->i_ctx; 151043c2bbd9SChristoph Hellwig 151147d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 151243c2bbd9SChristoph Hellwig if (!--i->i_openers) 151343c2bbd9SChristoph Hellwig ctx->mfc = NULL; 151447d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 151543c2bbd9SChristoph Hellwig return 0; 151643c2bbd9SChristoph Hellwig } 151743c2bbd9SChristoph Hellwig 1518a33a7d73SArnd Bergmann /* interrupt-level mfc callback function. */ 1519a33a7d73SArnd Bergmann void spufs_mfc_callback(struct spu *spu) 1520a33a7d73SArnd Bergmann { 1521a33a7d73SArnd Bergmann struct spu_context *ctx = spu->ctx; 1522a33a7d73SArnd Bergmann 1523e65c2f6fSLuke Browning if (!ctx) 1524e65c2f6fSLuke Browning return; 1525e65c2f6fSLuke Browning 1526a33a7d73SArnd Bergmann wake_up_all(&ctx->mfc_wq); 1527a33a7d73SArnd Bergmann 1528e48b1b45SHarvey Harrison pr_debug("%s %s\n", __func__, spu->name); 1529a33a7d73SArnd Bergmann if (ctx->mfc_fasync) { 1530a33a7d73SArnd Bergmann u32 free_elements, tagstatus; 1531a33a7d73SArnd Bergmann unsigned int mask; 1532a33a7d73SArnd Bergmann 1533a33a7d73SArnd Bergmann /* no need for spu_acquire in interrupt context */ 1534a33a7d73SArnd Bergmann free_elements = ctx->ops->get_mfc_free_elements(ctx); 1535a33a7d73SArnd Bergmann tagstatus = ctx->ops->read_mfc_tagstatus(ctx); 1536a33a7d73SArnd Bergmann 1537a33a7d73SArnd Bergmann mask = 0; 1538a33a7d73SArnd Bergmann if (free_elements & 0xffff) 1539a33a7d73SArnd Bergmann mask |= POLLOUT; 1540a33a7d73SArnd Bergmann if (tagstatus & ctx->tagwait) 1541a33a7d73SArnd Bergmann mask |= POLLIN; 1542a33a7d73SArnd Bergmann 1543a33a7d73SArnd Bergmann kill_fasync(&ctx->mfc_fasync, SIGIO, mask); 1544a33a7d73SArnd Bergmann } 1545a33a7d73SArnd Bergmann } 1546a33a7d73SArnd Bergmann 1547a33a7d73SArnd Bergmann static int spufs_read_mfc_tagstatus(struct spu_context *ctx, u32 *status) 1548a33a7d73SArnd Bergmann { 1549a33a7d73SArnd Bergmann /* See if there is one tag group is complete */ 1550a33a7d73SArnd Bergmann /* FIXME we need locking around tagwait */ 1551a33a7d73SArnd Bergmann *status = ctx->ops->read_mfc_tagstatus(ctx) & ctx->tagwait; 1552a33a7d73SArnd Bergmann ctx->tagwait &= ~*status; 1553a33a7d73SArnd Bergmann if (*status) 1554a33a7d73SArnd Bergmann return 1; 1555a33a7d73SArnd Bergmann 1556a33a7d73SArnd Bergmann /* enable interrupt waiting for any tag group, 1557a33a7d73SArnd Bergmann may silently fail if interrupts are already enabled */ 1558a33a7d73SArnd Bergmann ctx->ops->set_mfc_query(ctx, ctx->tagwait, 1); 1559a33a7d73SArnd Bergmann return 0; 1560a33a7d73SArnd Bergmann } 1561a33a7d73SArnd Bergmann 1562a33a7d73SArnd Bergmann static ssize_t spufs_mfc_read(struct file *file, char __user *buffer, 1563a33a7d73SArnd Bergmann size_t size, loff_t *pos) 1564a33a7d73SArnd Bergmann { 1565a33a7d73SArnd Bergmann struct spu_context *ctx = file->private_data; 1566a33a7d73SArnd Bergmann int ret = -EINVAL; 1567a33a7d73SArnd Bergmann u32 status; 1568a33a7d73SArnd Bergmann 1569a33a7d73SArnd Bergmann if (size != 4) 1570a33a7d73SArnd Bergmann goto out; 1571a33a7d73SArnd Bergmann 1572c9101bdbSChristoph Hellwig ret = spu_acquire(ctx); 1573c9101bdbSChristoph Hellwig if (ret) 1574c9101bdbSChristoph Hellwig return ret; 1575c9101bdbSChristoph Hellwig 1576c9101bdbSChristoph Hellwig ret = -EINVAL; 1577a33a7d73SArnd Bergmann if (file->f_flags & O_NONBLOCK) { 1578a33a7d73SArnd Bergmann status = ctx->ops->read_mfc_tagstatus(ctx); 1579a33a7d73SArnd Bergmann if (!(status & ctx->tagwait)) 1580a33a7d73SArnd Bergmann ret = -EAGAIN; 1581a33a7d73SArnd Bergmann else 1582c9101bdbSChristoph Hellwig /* XXX(hch): shouldn't we clear ret here? */ 1583a33a7d73SArnd Bergmann ctx->tagwait &= ~status; 1584a33a7d73SArnd Bergmann } else { 1585a33a7d73SArnd Bergmann ret = spufs_wait(ctx->mfc_wq, 1586a33a7d73SArnd Bergmann spufs_read_mfc_tagstatus(ctx, &status)); 1587a33a7d73SArnd Bergmann if (ret) 1588a33a7d73SArnd Bergmann goto out; 1589eebead5bSChristoph Hellwig } 1590eebead5bSChristoph Hellwig spu_release(ctx); 1591a33a7d73SArnd Bergmann 1592a33a7d73SArnd Bergmann ret = 4; 1593a33a7d73SArnd Bergmann if (copy_to_user(buffer, &status, 4)) 1594a33a7d73SArnd Bergmann ret = -EFAULT; 1595a33a7d73SArnd Bergmann 1596a33a7d73SArnd Bergmann out: 1597a33a7d73SArnd Bergmann return ret; 1598a33a7d73SArnd Bergmann } 1599a33a7d73SArnd Bergmann 1600a33a7d73SArnd Bergmann static int spufs_check_valid_dma(struct mfc_dma_command *cmd) 1601a33a7d73SArnd Bergmann { 16029477e455SStephen Rothwell pr_debug("queueing DMA %x %llx %x %x %x\n", cmd->lsa, 1603a33a7d73SArnd Bergmann cmd->ea, cmd->size, cmd->tag, cmd->cmd); 1604a33a7d73SArnd Bergmann 1605a33a7d73SArnd Bergmann switch (cmd->cmd) { 1606a33a7d73SArnd Bergmann case MFC_PUT_CMD: 1607a33a7d73SArnd Bergmann case MFC_PUTF_CMD: 1608a33a7d73SArnd Bergmann case MFC_PUTB_CMD: 1609a33a7d73SArnd Bergmann case MFC_GET_CMD: 1610a33a7d73SArnd Bergmann case MFC_GETF_CMD: 1611a33a7d73SArnd Bergmann case MFC_GETB_CMD: 1612a33a7d73SArnd Bergmann break; 1613a33a7d73SArnd Bergmann default: 1614a33a7d73SArnd Bergmann pr_debug("invalid DMA opcode %x\n", cmd->cmd); 1615a33a7d73SArnd Bergmann return -EIO; 1616a33a7d73SArnd Bergmann } 1617a33a7d73SArnd Bergmann 1618a33a7d73SArnd Bergmann if ((cmd->lsa & 0xf) != (cmd->ea &0xf)) { 16199477e455SStephen Rothwell pr_debug("invalid DMA alignment, ea %llx lsa %x\n", 1620a33a7d73SArnd Bergmann cmd->ea, cmd->lsa); 1621a33a7d73SArnd Bergmann return -EIO; 1622a33a7d73SArnd Bergmann } 1623a33a7d73SArnd Bergmann 1624a33a7d73SArnd Bergmann switch (cmd->size & 0xf) { 1625a33a7d73SArnd Bergmann case 1: 1626a33a7d73SArnd Bergmann break; 1627a33a7d73SArnd Bergmann case 2: 1628a33a7d73SArnd Bergmann if (cmd->lsa & 1) 1629a33a7d73SArnd Bergmann goto error; 1630a33a7d73SArnd Bergmann break; 1631a33a7d73SArnd Bergmann case 4: 1632a33a7d73SArnd Bergmann if (cmd->lsa & 3) 1633a33a7d73SArnd Bergmann goto error; 1634a33a7d73SArnd Bergmann break; 1635a33a7d73SArnd Bergmann case 8: 1636a33a7d73SArnd Bergmann if (cmd->lsa & 7) 1637a33a7d73SArnd Bergmann goto error; 1638a33a7d73SArnd Bergmann break; 1639a33a7d73SArnd Bergmann case 0: 1640a33a7d73SArnd Bergmann if (cmd->lsa & 15) 1641a33a7d73SArnd Bergmann goto error; 1642a33a7d73SArnd Bergmann break; 1643a33a7d73SArnd Bergmann error: 1644a33a7d73SArnd Bergmann default: 1645a33a7d73SArnd Bergmann pr_debug("invalid DMA alignment %x for size %x\n", 1646a33a7d73SArnd Bergmann cmd->lsa & 0xf, cmd->size); 1647a33a7d73SArnd Bergmann return -EIO; 1648a33a7d73SArnd Bergmann } 1649a33a7d73SArnd Bergmann 1650a33a7d73SArnd Bergmann if (cmd->size > 16 * 1024) { 1651a33a7d73SArnd Bergmann pr_debug("invalid DMA size %x\n", cmd->size); 1652a33a7d73SArnd Bergmann return -EIO; 1653a33a7d73SArnd Bergmann } 1654a33a7d73SArnd Bergmann 1655a33a7d73SArnd Bergmann if (cmd->tag & 0xfff0) { 1656a33a7d73SArnd Bergmann /* we reserve the higher tag numbers for kernel use */ 1657a33a7d73SArnd Bergmann pr_debug("invalid DMA tag\n"); 1658a33a7d73SArnd Bergmann return -EIO; 1659a33a7d73SArnd Bergmann } 1660a33a7d73SArnd Bergmann 1661a33a7d73SArnd Bergmann if (cmd->class) { 1662a33a7d73SArnd Bergmann /* not supported in this version */ 1663a33a7d73SArnd Bergmann pr_debug("invalid DMA class\n"); 1664a33a7d73SArnd Bergmann return -EIO; 1665a33a7d73SArnd Bergmann } 1666a33a7d73SArnd Bergmann 1667a33a7d73SArnd Bergmann return 0; 1668a33a7d73SArnd Bergmann } 1669a33a7d73SArnd Bergmann 1670a33a7d73SArnd Bergmann static int spu_send_mfc_command(struct spu_context *ctx, 1671a33a7d73SArnd Bergmann struct mfc_dma_command cmd, 1672a33a7d73SArnd Bergmann int *error) 1673a33a7d73SArnd Bergmann { 1674a33a7d73SArnd Bergmann *error = ctx->ops->send_mfc_command(ctx, &cmd); 1675a33a7d73SArnd Bergmann if (*error == -EAGAIN) { 1676a33a7d73SArnd Bergmann /* wait for any tag group to complete 1677a33a7d73SArnd Bergmann so we have space for the new command */ 1678a33a7d73SArnd Bergmann ctx->ops->set_mfc_query(ctx, ctx->tagwait, 1); 1679a33a7d73SArnd Bergmann /* try again, because the queue might be 1680a33a7d73SArnd Bergmann empty again */ 1681a33a7d73SArnd Bergmann *error = ctx->ops->send_mfc_command(ctx, &cmd); 1682a33a7d73SArnd Bergmann if (*error == -EAGAIN) 1683a33a7d73SArnd Bergmann return 0; 1684a33a7d73SArnd Bergmann } 1685a33a7d73SArnd Bergmann return 1; 1686a33a7d73SArnd Bergmann } 1687a33a7d73SArnd Bergmann 1688a33a7d73SArnd Bergmann static ssize_t spufs_mfc_write(struct file *file, const char __user *buffer, 1689a33a7d73SArnd Bergmann size_t size, loff_t *pos) 1690a33a7d73SArnd Bergmann { 1691a33a7d73SArnd Bergmann struct spu_context *ctx = file->private_data; 1692a33a7d73SArnd Bergmann struct mfc_dma_command cmd; 1693a33a7d73SArnd Bergmann int ret = -EINVAL; 1694a33a7d73SArnd Bergmann 1695a33a7d73SArnd Bergmann if (size != sizeof cmd) 1696a33a7d73SArnd Bergmann goto out; 1697a33a7d73SArnd Bergmann 1698a33a7d73SArnd Bergmann ret = -EFAULT; 1699a33a7d73SArnd Bergmann if (copy_from_user(&cmd, buffer, sizeof cmd)) 1700a33a7d73SArnd Bergmann goto out; 1701a33a7d73SArnd Bergmann 1702a33a7d73SArnd Bergmann ret = spufs_check_valid_dma(&cmd); 1703a33a7d73SArnd Bergmann if (ret) 1704a33a7d73SArnd Bergmann goto out; 1705a33a7d73SArnd Bergmann 1706c9101bdbSChristoph Hellwig ret = spu_acquire(ctx); 1707c9101bdbSChristoph Hellwig if (ret) 1708c9101bdbSChristoph Hellwig goto out; 1709c9101bdbSChristoph Hellwig 171033bfd7a7SArnd Bergmann ret = spufs_wait(ctx->run_wq, ctx->state == SPU_STATE_RUNNABLE); 1711577f8f10SAkinobu Mita if (ret) 1712577f8f10SAkinobu Mita goto out; 1713577f8f10SAkinobu Mita 1714a33a7d73SArnd Bergmann if (file->f_flags & O_NONBLOCK) { 1715a33a7d73SArnd Bergmann ret = ctx->ops->send_mfc_command(ctx, &cmd); 1716a33a7d73SArnd Bergmann } else { 1717a33a7d73SArnd Bergmann int status; 1718a33a7d73SArnd Bergmann ret = spufs_wait(ctx->mfc_wq, 1719a33a7d73SArnd Bergmann spu_send_mfc_command(ctx, cmd, &status)); 1720eebead5bSChristoph Hellwig if (ret) 1721eebead5bSChristoph Hellwig goto out; 1722a33a7d73SArnd Bergmann if (status) 1723a33a7d73SArnd Bergmann ret = status; 1724a33a7d73SArnd Bergmann } 1725a33a7d73SArnd Bergmann 1726a33a7d73SArnd Bergmann if (ret) 1727933b0e35SKazunori Asayama goto out_unlock; 1728a33a7d73SArnd Bergmann 1729a33a7d73SArnd Bergmann ctx->tagwait |= 1 << cmd.tag; 17303692dc66SMasato Noguchi ret = size; 1731a33a7d73SArnd Bergmann 1732933b0e35SKazunori Asayama out_unlock: 1733933b0e35SKazunori Asayama spu_release(ctx); 1734a33a7d73SArnd Bergmann out: 1735a33a7d73SArnd Bergmann return ret; 1736a33a7d73SArnd Bergmann } 1737a33a7d73SArnd Bergmann 1738a33a7d73SArnd Bergmann static unsigned int spufs_mfc_poll(struct file *file,poll_table *wait) 1739a33a7d73SArnd Bergmann { 1740a33a7d73SArnd Bergmann struct spu_context *ctx = file->private_data; 1741a33a7d73SArnd Bergmann u32 free_elements, tagstatus; 1742a33a7d73SArnd Bergmann unsigned int mask; 1743a33a7d73SArnd Bergmann 1744933b0e35SKazunori Asayama poll_wait(file, &ctx->mfc_wq, wait); 1745933b0e35SKazunori Asayama 1746c9101bdbSChristoph Hellwig /* 1747c9101bdbSChristoph Hellwig * For now keep this uninterruptible and also ignore the rule 1748c9101bdbSChristoph Hellwig * that poll should not sleep. Will be fixed later. 1749c9101bdbSChristoph Hellwig */ 1750c9101bdbSChristoph Hellwig mutex_lock(&ctx->state_mutex); 1751a33a7d73SArnd Bergmann ctx->ops->set_mfc_query(ctx, ctx->tagwait, 2); 1752a33a7d73SArnd Bergmann free_elements = ctx->ops->get_mfc_free_elements(ctx); 1753a33a7d73SArnd Bergmann tagstatus = ctx->ops->read_mfc_tagstatus(ctx); 1754a33a7d73SArnd Bergmann spu_release(ctx); 1755a33a7d73SArnd Bergmann 1756a33a7d73SArnd Bergmann mask = 0; 1757a33a7d73SArnd Bergmann if (free_elements & 0xffff) 1758a33a7d73SArnd Bergmann mask |= POLLOUT | POLLWRNORM; 1759a33a7d73SArnd Bergmann if (tagstatus & ctx->tagwait) 1760a33a7d73SArnd Bergmann mask |= POLLIN | POLLRDNORM; 1761a33a7d73SArnd Bergmann 1762e48b1b45SHarvey Harrison pr_debug("%s: free %d tagstatus %d tagwait %d\n", __func__, 1763a33a7d73SArnd Bergmann free_elements, tagstatus, ctx->tagwait); 1764a33a7d73SArnd Bergmann 1765a33a7d73SArnd Bergmann return mask; 1766a33a7d73SArnd Bergmann } 1767a33a7d73SArnd Bergmann 176873b6af8aSAl Viro static int spufs_mfc_flush(struct file *file, fl_owner_t id) 1769a33a7d73SArnd Bergmann { 1770a33a7d73SArnd Bergmann struct spu_context *ctx = file->private_data; 1771a33a7d73SArnd Bergmann int ret; 1772a33a7d73SArnd Bergmann 1773c9101bdbSChristoph Hellwig ret = spu_acquire(ctx); 1774c9101bdbSChristoph Hellwig if (ret) 1775eebead5bSChristoph Hellwig goto out; 1776a33a7d73SArnd Bergmann #if 0 1777a33a7d73SArnd Bergmann /* this currently hangs */ 1778a33a7d73SArnd Bergmann ret = spufs_wait(ctx->mfc_wq, 1779a33a7d73SArnd Bergmann ctx->ops->set_mfc_query(ctx, ctx->tagwait, 2)); 1780a33a7d73SArnd Bergmann if (ret) 1781a33a7d73SArnd Bergmann goto out; 1782a33a7d73SArnd Bergmann ret = spufs_wait(ctx->mfc_wq, 1783a33a7d73SArnd Bergmann ctx->ops->read_mfc_tagstatus(ctx) == ctx->tagwait); 1784eebead5bSChristoph Hellwig if (ret) 1785eebead5bSChristoph Hellwig goto out; 1786a33a7d73SArnd Bergmann #else 1787a33a7d73SArnd Bergmann ret = 0; 1788a33a7d73SArnd Bergmann #endif 1789a33a7d73SArnd Bergmann spu_release(ctx); 1790eebead5bSChristoph Hellwig out: 1791a33a7d73SArnd Bergmann return ret; 1792a33a7d73SArnd Bergmann } 1793a33a7d73SArnd Bergmann 179402c24a82SJosef Bacik static int spufs_mfc_fsync(struct file *file, loff_t start, loff_t end, int datasync) 1795a33a7d73SArnd Bergmann { 1796496ad9aaSAl Viro struct inode *inode = file_inode(file); 179702c24a82SJosef Bacik int err = filemap_write_and_wait_range(inode->i_mapping, start, end); 179802c24a82SJosef Bacik if (!err) { 17995955102cSAl Viro inode_lock(inode); 180002c24a82SJosef Bacik err = spufs_mfc_flush(file, NULL); 18015955102cSAl Viro inode_unlock(inode); 180202c24a82SJosef Bacik } 180302c24a82SJosef Bacik return err; 1804a33a7d73SArnd Bergmann } 1805a33a7d73SArnd Bergmann 1806a33a7d73SArnd Bergmann static int spufs_mfc_fasync(int fd, struct file *file, int on) 1807a33a7d73SArnd Bergmann { 1808a33a7d73SArnd Bergmann struct spu_context *ctx = file->private_data; 1809a33a7d73SArnd Bergmann 1810a33a7d73SArnd Bergmann return fasync_helper(fd, file, on, &ctx->mfc_fasync); 1811a33a7d73SArnd Bergmann } 1812a33a7d73SArnd Bergmann 18135dfe4c96SArjan van de Ven static const struct file_operations spufs_mfc_fops = { 1814a33a7d73SArnd Bergmann .open = spufs_mfc_open, 181543c2bbd9SChristoph Hellwig .release = spufs_mfc_release, 1816a33a7d73SArnd Bergmann .read = spufs_mfc_read, 1817a33a7d73SArnd Bergmann .write = spufs_mfc_write, 1818a33a7d73SArnd Bergmann .poll = spufs_mfc_poll, 1819a33a7d73SArnd Bergmann .flush = spufs_mfc_flush, 1820a33a7d73SArnd Bergmann .fsync = spufs_mfc_fsync, 1821a33a7d73SArnd Bergmann .fasync = spufs_mfc_fasync, 18226df10a82SMark Nutter .mmap = spufs_mfc_mmap, 1823fc15351dSArnd Bergmann .llseek = no_llseek, 1824a33a7d73SArnd Bergmann }; 1825a33a7d73SArnd Bergmann 1826197b1a82SChristoph Hellwig static int spufs_npc_set(void *data, u64 val) 182767207b96SArnd Bergmann { 182867207b96SArnd Bergmann struct spu_context *ctx = data; 1829c9101bdbSChristoph Hellwig int ret; 1830c9101bdbSChristoph Hellwig 1831c9101bdbSChristoph Hellwig ret = spu_acquire(ctx); 1832c9101bdbSChristoph Hellwig if (ret) 1833c9101bdbSChristoph Hellwig return ret; 18348b3d6663SArnd Bergmann ctx->ops->npc_write(ctx, val); 18358b3d6663SArnd Bergmann spu_release(ctx); 1836197b1a82SChristoph Hellwig 1837197b1a82SChristoph Hellwig return 0; 183867207b96SArnd Bergmann } 183967207b96SArnd Bergmann 1840104f0cc2SMichael Ellerman static u64 spufs_npc_get(struct spu_context *ctx) 184178810ff6SMichael Ellerman { 184278810ff6SMichael Ellerman return ctx->ops->npc_read(ctx); 184378810ff6SMichael Ellerman } 1844104f0cc2SMichael Ellerman DEFINE_SPUFS_ATTRIBUTE(spufs_npc_ops, spufs_npc_get, spufs_npc_set, 1845104f0cc2SMichael Ellerman "0x%llx\n", SPU_ATTR_ACQUIRE); 184667207b96SArnd Bergmann 1847197b1a82SChristoph Hellwig static int spufs_decr_set(void *data, u64 val) 18488b3d6663SArnd Bergmann { 18498b3d6663SArnd Bergmann struct spu_context *ctx = data; 18508b3d6663SArnd Bergmann struct spu_lscsa *lscsa = ctx->csa.lscsa; 1851c9101bdbSChristoph Hellwig int ret; 1852c9101bdbSChristoph Hellwig 1853c9101bdbSChristoph Hellwig ret = spu_acquire_saved(ctx); 1854c9101bdbSChristoph Hellwig if (ret) 1855c9101bdbSChristoph Hellwig return ret; 18568b3d6663SArnd Bergmann lscsa->decr.slot[0] = (u32) val; 185727b1ea09SChristoph Hellwig spu_release_saved(ctx); 1858197b1a82SChristoph Hellwig 1859197b1a82SChristoph Hellwig return 0; 18608b3d6663SArnd Bergmann } 18618b3d6663SArnd Bergmann 1862104f0cc2SMichael Ellerman static u64 spufs_decr_get(struct spu_context *ctx) 18638b3d6663SArnd Bergmann { 18648b3d6663SArnd Bergmann struct spu_lscsa *lscsa = ctx->csa.lscsa; 1865bf1ab978SDwayne Grant McConnell return lscsa->decr.slot[0]; 1866bf1ab978SDwayne Grant McConnell } 1867104f0cc2SMichael Ellerman DEFINE_SPUFS_ATTRIBUTE(spufs_decr_ops, spufs_decr_get, spufs_decr_set, 1868104f0cc2SMichael Ellerman "0x%llx\n", SPU_ATTR_ACQUIRE_SAVED); 18698b3d6663SArnd Bergmann 1870197b1a82SChristoph Hellwig static int spufs_decr_status_set(void *data, u64 val) 18718b3d6663SArnd Bergmann { 18728b3d6663SArnd Bergmann struct spu_context *ctx = data; 1873c9101bdbSChristoph Hellwig int ret; 1874c9101bdbSChristoph Hellwig 1875c9101bdbSChristoph Hellwig ret = spu_acquire_saved(ctx); 1876c9101bdbSChristoph Hellwig if (ret) 1877c9101bdbSChristoph Hellwig return ret; 1878d40a01d4SMasato Noguchi if (val) 1879d40a01d4SMasato Noguchi ctx->csa.priv2.mfc_control_RW |= MFC_CNTL_DECREMENTER_RUNNING; 1880d40a01d4SMasato Noguchi else 1881d40a01d4SMasato Noguchi ctx->csa.priv2.mfc_control_RW &= ~MFC_CNTL_DECREMENTER_RUNNING; 188227b1ea09SChristoph Hellwig spu_release_saved(ctx); 1883197b1a82SChristoph Hellwig 1884197b1a82SChristoph Hellwig return 0; 18858b3d6663SArnd Bergmann } 18868b3d6663SArnd Bergmann 1887104f0cc2SMichael Ellerman static u64 spufs_decr_status_get(struct spu_context *ctx) 18888b3d6663SArnd Bergmann { 1889d40a01d4SMasato Noguchi if (ctx->csa.priv2.mfc_control_RW & MFC_CNTL_DECREMENTER_RUNNING) 1890d40a01d4SMasato Noguchi return SPU_DECR_STATUS_RUNNING; 1891d40a01d4SMasato Noguchi else 1892d40a01d4SMasato Noguchi return 0; 1893bf1ab978SDwayne Grant McConnell } 1894104f0cc2SMichael Ellerman DEFINE_SPUFS_ATTRIBUTE(spufs_decr_status_ops, spufs_decr_status_get, 1895104f0cc2SMichael Ellerman spufs_decr_status_set, "0x%llx\n", 1896104f0cc2SMichael Ellerman SPU_ATTR_ACQUIRE_SAVED); 18978b3d6663SArnd Bergmann 1898197b1a82SChristoph Hellwig static int spufs_event_mask_set(void *data, u64 val) 18998b3d6663SArnd Bergmann { 19008b3d6663SArnd Bergmann struct spu_context *ctx = data; 19018b3d6663SArnd Bergmann struct spu_lscsa *lscsa = ctx->csa.lscsa; 1902c9101bdbSChristoph Hellwig int ret; 1903c9101bdbSChristoph Hellwig 1904c9101bdbSChristoph Hellwig ret = spu_acquire_saved(ctx); 1905c9101bdbSChristoph Hellwig if (ret) 1906c9101bdbSChristoph Hellwig return ret; 19078b3d6663SArnd Bergmann lscsa->event_mask.slot[0] = (u32) val; 190827b1ea09SChristoph Hellwig spu_release_saved(ctx); 1909197b1a82SChristoph Hellwig 1910197b1a82SChristoph Hellwig return 0; 19118b3d6663SArnd Bergmann } 19128b3d6663SArnd Bergmann 1913104f0cc2SMichael Ellerman static u64 spufs_event_mask_get(struct spu_context *ctx) 19148b3d6663SArnd Bergmann { 19158b3d6663SArnd Bergmann struct spu_lscsa *lscsa = ctx->csa.lscsa; 1916bf1ab978SDwayne Grant McConnell return lscsa->event_mask.slot[0]; 1917bf1ab978SDwayne Grant McConnell } 1918bf1ab978SDwayne Grant McConnell 1919104f0cc2SMichael Ellerman DEFINE_SPUFS_ATTRIBUTE(spufs_event_mask_ops, spufs_event_mask_get, 1920104f0cc2SMichael Ellerman spufs_event_mask_set, "0x%llx\n", 1921104f0cc2SMichael Ellerman SPU_ATTR_ACQUIRE_SAVED); 19228b3d6663SArnd Bergmann 1923104f0cc2SMichael Ellerman static u64 spufs_event_status_get(struct spu_context *ctx) 1924b9e3bd77SDwayne Grant McConnell { 1925b9e3bd77SDwayne Grant McConnell struct spu_state *state = &ctx->csa; 1926b9e3bd77SDwayne Grant McConnell u64 stat; 1927b9e3bd77SDwayne Grant McConnell stat = state->spu_chnlcnt_RW[0]; 1928b9e3bd77SDwayne Grant McConnell if (stat) 1929bf1ab978SDwayne Grant McConnell return state->spu_chnldata_RW[0]; 1930bf1ab978SDwayne Grant McConnell return 0; 1931bf1ab978SDwayne Grant McConnell } 1932104f0cc2SMichael Ellerman DEFINE_SPUFS_ATTRIBUTE(spufs_event_status_ops, spufs_event_status_get, 1933104f0cc2SMichael Ellerman NULL, "0x%llx\n", SPU_ATTR_ACQUIRE_SAVED) 1934b9e3bd77SDwayne Grant McConnell 1935197b1a82SChristoph Hellwig static int spufs_srr0_set(void *data, u64 val) 19368b3d6663SArnd Bergmann { 19378b3d6663SArnd Bergmann struct spu_context *ctx = data; 19388b3d6663SArnd Bergmann struct spu_lscsa *lscsa = ctx->csa.lscsa; 1939c9101bdbSChristoph Hellwig int ret; 1940c9101bdbSChristoph Hellwig 1941c9101bdbSChristoph Hellwig ret = spu_acquire_saved(ctx); 1942c9101bdbSChristoph Hellwig if (ret) 1943c9101bdbSChristoph Hellwig return ret; 19448b3d6663SArnd Bergmann lscsa->srr0.slot[0] = (u32) val; 194527b1ea09SChristoph Hellwig spu_release_saved(ctx); 1946197b1a82SChristoph Hellwig 1947197b1a82SChristoph Hellwig return 0; 19488b3d6663SArnd Bergmann } 19498b3d6663SArnd Bergmann 1950104f0cc2SMichael Ellerman static u64 spufs_srr0_get(struct spu_context *ctx) 19518b3d6663SArnd Bergmann { 19528b3d6663SArnd Bergmann struct spu_lscsa *lscsa = ctx->csa.lscsa; 1953104f0cc2SMichael Ellerman return lscsa->srr0.slot[0]; 19548b3d6663SArnd Bergmann } 1955104f0cc2SMichael Ellerman DEFINE_SPUFS_ATTRIBUTE(spufs_srr0_ops, spufs_srr0_get, spufs_srr0_set, 1956104f0cc2SMichael Ellerman "0x%llx\n", SPU_ATTR_ACQUIRE_SAVED) 19578b3d6663SArnd Bergmann 1958104f0cc2SMichael Ellerman static u64 spufs_id_get(struct spu_context *ctx) 19597b1a7014Sarnd@arndb.de { 19607b1a7014Sarnd@arndb.de u64 num; 19617b1a7014Sarnd@arndb.de 19627b1a7014Sarnd@arndb.de if (ctx->state == SPU_STATE_RUNNABLE) 19637b1a7014Sarnd@arndb.de num = ctx->spu->number; 19647b1a7014Sarnd@arndb.de else 19657b1a7014Sarnd@arndb.de num = (unsigned int)-1; 19667b1a7014Sarnd@arndb.de 19677b1a7014Sarnd@arndb.de return num; 19687b1a7014Sarnd@arndb.de } 1969104f0cc2SMichael Ellerman DEFINE_SPUFS_ATTRIBUTE(spufs_id_ops, spufs_id_get, NULL, "0x%llx\n", 1970104f0cc2SMichael Ellerman SPU_ATTR_ACQUIRE) 19717b1a7014Sarnd@arndb.de 1972104f0cc2SMichael Ellerman static u64 spufs_object_id_get(struct spu_context *ctx) 1973bf1ab978SDwayne Grant McConnell { 1974bf1ab978SDwayne Grant McConnell /* FIXME: Should there really be no locking here? */ 1975104f0cc2SMichael Ellerman return ctx->object_id; 1976bf1ab978SDwayne Grant McConnell } 1977bf1ab978SDwayne Grant McConnell 1978197b1a82SChristoph Hellwig static int spufs_object_id_set(void *data, u64 id) 197986767277SArnd Bergmann { 198086767277SArnd Bergmann struct spu_context *ctx = data; 198186767277SArnd Bergmann ctx->object_id = id; 1982197b1a82SChristoph Hellwig 1983197b1a82SChristoph Hellwig return 0; 198486767277SArnd Bergmann } 198586767277SArnd Bergmann 1986104f0cc2SMichael Ellerman DEFINE_SPUFS_ATTRIBUTE(spufs_object_id_ops, spufs_object_id_get, 1987104f0cc2SMichael Ellerman spufs_object_id_set, "0x%llx\n", SPU_ATTR_NOACQUIRE); 198886767277SArnd Bergmann 1989104f0cc2SMichael Ellerman static u64 spufs_lslr_get(struct spu_context *ctx) 1990bf1ab978SDwayne Grant McConnell { 1991bf1ab978SDwayne Grant McConnell return ctx->csa.priv2.spu_lslr_RW; 1992bf1ab978SDwayne Grant McConnell } 1993104f0cc2SMichael Ellerman DEFINE_SPUFS_ATTRIBUTE(spufs_lslr_ops, spufs_lslr_get, NULL, "0x%llx\n", 1994104f0cc2SMichael Ellerman SPU_ATTR_ACQUIRE_SAVED); 1995b9e3bd77SDwayne Grant McConnell 1996b9e3bd77SDwayne Grant McConnell static int spufs_info_open(struct inode *inode, struct file *file) 1997b9e3bd77SDwayne Grant McConnell { 1998b9e3bd77SDwayne Grant McConnell struct spufs_inode_info *i = SPUFS_I(inode); 1999b9e3bd77SDwayne Grant McConnell struct spu_context *ctx = i->i_ctx; 2000b9e3bd77SDwayne Grant McConnell file->private_data = ctx; 2001b9e3bd77SDwayne Grant McConnell return 0; 2002b9e3bd77SDwayne Grant McConnell } 2003b9e3bd77SDwayne Grant McConnell 2004cbe709c1SBenjamin Herrenschmidt static int spufs_caps_show(struct seq_file *s, void *private) 2005cbe709c1SBenjamin Herrenschmidt { 2006cbe709c1SBenjamin Herrenschmidt struct spu_context *ctx = s->private; 2007cbe709c1SBenjamin Herrenschmidt 2008cbe709c1SBenjamin Herrenschmidt if (!(ctx->flags & SPU_CREATE_NOSCHED)) 2009cbe709c1SBenjamin Herrenschmidt seq_puts(s, "sched\n"); 2010cbe709c1SBenjamin Herrenschmidt if (!(ctx->flags & SPU_CREATE_ISOLATE)) 2011cbe709c1SBenjamin Herrenschmidt seq_puts(s, "step\n"); 2012cbe709c1SBenjamin Herrenschmidt return 0; 2013cbe709c1SBenjamin Herrenschmidt } 2014cbe709c1SBenjamin Herrenschmidt 2015cbe709c1SBenjamin Herrenschmidt static int spufs_caps_open(struct inode *inode, struct file *file) 2016cbe709c1SBenjamin Herrenschmidt { 2017cbe709c1SBenjamin Herrenschmidt return single_open(file, spufs_caps_show, SPUFS_I(inode)->i_ctx); 2018cbe709c1SBenjamin Herrenschmidt } 2019cbe709c1SBenjamin Herrenschmidt 2020cbe709c1SBenjamin Herrenschmidt static const struct file_operations spufs_caps_fops = { 2021cbe709c1SBenjamin Herrenschmidt .open = spufs_caps_open, 2022cbe709c1SBenjamin Herrenschmidt .read = seq_read, 2023cbe709c1SBenjamin Herrenschmidt .llseek = seq_lseek, 2024cbe709c1SBenjamin Herrenschmidt .release = single_release, 2025cbe709c1SBenjamin Herrenschmidt }; 2026cbe709c1SBenjamin Herrenschmidt 2027bf1ab978SDwayne Grant McConnell static ssize_t __spufs_mbox_info_read(struct spu_context *ctx, 2028bf1ab978SDwayne Grant McConnell char __user *buf, size_t len, loff_t *pos) 2029bf1ab978SDwayne Grant McConnell { 2030bf1ab978SDwayne Grant McConnell u32 data; 2031bf1ab978SDwayne Grant McConnell 2032cbea9238SJeremy Kerr /* EOF if there's no entry in the mbox */ 2033cbea9238SJeremy Kerr if (!(ctx->csa.prob.mb_stat_R & 0x0000ff)) 2034cbea9238SJeremy Kerr return 0; 2035cbea9238SJeremy Kerr 2036bf1ab978SDwayne Grant McConnell data = ctx->csa.prob.pu_mb_R; 2037bf1ab978SDwayne Grant McConnell 2038bf1ab978SDwayne Grant McConnell return simple_read_from_buffer(buf, len, pos, &data, sizeof data); 2039bf1ab978SDwayne Grant McConnell } 2040bf1ab978SDwayne Grant McConnell 204169a2f00cSDwayne Grant McConnell static ssize_t spufs_mbox_info_read(struct file *file, char __user *buf, 204269a2f00cSDwayne Grant McConnell size_t len, loff_t *pos) 204369a2f00cSDwayne Grant McConnell { 2044bf1ab978SDwayne Grant McConnell int ret; 204569a2f00cSDwayne Grant McConnell struct spu_context *ctx = file->private_data; 204669a2f00cSDwayne Grant McConnell 204769a2f00cSDwayne Grant McConnell if (!access_ok(VERIFY_WRITE, buf, len)) 204869a2f00cSDwayne Grant McConnell return -EFAULT; 204969a2f00cSDwayne Grant McConnell 2050c9101bdbSChristoph Hellwig ret = spu_acquire_saved(ctx); 2051c9101bdbSChristoph Hellwig if (ret) 2052c9101bdbSChristoph Hellwig return ret; 205369a2f00cSDwayne Grant McConnell spin_lock(&ctx->csa.register_lock); 2054bf1ab978SDwayne Grant McConnell ret = __spufs_mbox_info_read(ctx, buf, len, pos); 205569a2f00cSDwayne Grant McConnell spin_unlock(&ctx->csa.register_lock); 205627b1ea09SChristoph Hellwig spu_release_saved(ctx); 205769a2f00cSDwayne Grant McConnell 2058bf1ab978SDwayne Grant McConnell return ret; 205969a2f00cSDwayne Grant McConnell } 206069a2f00cSDwayne Grant McConnell 20615dfe4c96SArjan van de Ven static const struct file_operations spufs_mbox_info_fops = { 206269a2f00cSDwayne Grant McConnell .open = spufs_info_open, 206369a2f00cSDwayne Grant McConnell .read = spufs_mbox_info_read, 206469a2f00cSDwayne Grant McConnell .llseek = generic_file_llseek, 206569a2f00cSDwayne Grant McConnell }; 206669a2f00cSDwayne Grant McConnell 2067bf1ab978SDwayne Grant McConnell static ssize_t __spufs_ibox_info_read(struct spu_context *ctx, 2068bf1ab978SDwayne Grant McConnell char __user *buf, size_t len, loff_t *pos) 2069bf1ab978SDwayne Grant McConnell { 2070bf1ab978SDwayne Grant McConnell u32 data; 2071bf1ab978SDwayne Grant McConnell 2072cbea9238SJeremy Kerr /* EOF if there's no entry in the ibox */ 2073cbea9238SJeremy Kerr if (!(ctx->csa.prob.mb_stat_R & 0xff0000)) 2074cbea9238SJeremy Kerr return 0; 2075cbea9238SJeremy Kerr 2076bf1ab978SDwayne Grant McConnell data = ctx->csa.priv2.puint_mb_R; 2077bf1ab978SDwayne Grant McConnell 2078bf1ab978SDwayne Grant McConnell return simple_read_from_buffer(buf, len, pos, &data, sizeof data); 2079bf1ab978SDwayne Grant McConnell } 2080bf1ab978SDwayne Grant McConnell 208169a2f00cSDwayne Grant McConnell static ssize_t spufs_ibox_info_read(struct file *file, char __user *buf, 208269a2f00cSDwayne Grant McConnell size_t len, loff_t *pos) 208369a2f00cSDwayne Grant McConnell { 208469a2f00cSDwayne Grant McConnell struct spu_context *ctx = file->private_data; 2085bf1ab978SDwayne Grant McConnell int ret; 208669a2f00cSDwayne Grant McConnell 208769a2f00cSDwayne Grant McConnell if (!access_ok(VERIFY_WRITE, buf, len)) 208869a2f00cSDwayne Grant McConnell return -EFAULT; 208969a2f00cSDwayne Grant McConnell 2090c9101bdbSChristoph Hellwig ret = spu_acquire_saved(ctx); 2091c9101bdbSChristoph Hellwig if (ret) 2092c9101bdbSChristoph Hellwig return ret; 209369a2f00cSDwayne Grant McConnell spin_lock(&ctx->csa.register_lock); 2094bf1ab978SDwayne Grant McConnell ret = __spufs_ibox_info_read(ctx, buf, len, pos); 209569a2f00cSDwayne Grant McConnell spin_unlock(&ctx->csa.register_lock); 209627b1ea09SChristoph Hellwig spu_release_saved(ctx); 209769a2f00cSDwayne Grant McConnell 2098bf1ab978SDwayne Grant McConnell return ret; 209969a2f00cSDwayne Grant McConnell } 210069a2f00cSDwayne Grant McConnell 21015dfe4c96SArjan van de Ven static const struct file_operations spufs_ibox_info_fops = { 210269a2f00cSDwayne Grant McConnell .open = spufs_info_open, 210369a2f00cSDwayne Grant McConnell .read = spufs_ibox_info_read, 210469a2f00cSDwayne Grant McConnell .llseek = generic_file_llseek, 210569a2f00cSDwayne Grant McConnell }; 210669a2f00cSDwayne Grant McConnell 2107bf1ab978SDwayne Grant McConnell static ssize_t __spufs_wbox_info_read(struct spu_context *ctx, 2108bf1ab978SDwayne Grant McConnell char __user *buf, size_t len, loff_t *pos) 2109bf1ab978SDwayne Grant McConnell { 2110bf1ab978SDwayne Grant McConnell int i, cnt; 2111bf1ab978SDwayne Grant McConnell u32 data[4]; 2112bf1ab978SDwayne Grant McConnell u32 wbox_stat; 2113bf1ab978SDwayne Grant McConnell 2114bf1ab978SDwayne Grant McConnell wbox_stat = ctx->csa.prob.mb_stat_R; 2115bf1ab978SDwayne Grant McConnell cnt = 4 - ((wbox_stat & 0x00ff00) >> 8); 2116bf1ab978SDwayne Grant McConnell for (i = 0; i < cnt; i++) { 2117bf1ab978SDwayne Grant McConnell data[i] = ctx->csa.spu_mailbox_data[i]; 2118bf1ab978SDwayne Grant McConnell } 2119bf1ab978SDwayne Grant McConnell 2120bf1ab978SDwayne Grant McConnell return simple_read_from_buffer(buf, len, pos, &data, 2121bf1ab978SDwayne Grant McConnell cnt * sizeof(u32)); 2122bf1ab978SDwayne Grant McConnell } 2123bf1ab978SDwayne Grant McConnell 212469a2f00cSDwayne Grant McConnell static ssize_t spufs_wbox_info_read(struct file *file, char __user *buf, 212569a2f00cSDwayne Grant McConnell size_t len, loff_t *pos) 212669a2f00cSDwayne Grant McConnell { 212769a2f00cSDwayne Grant McConnell struct spu_context *ctx = file->private_data; 2128bf1ab978SDwayne Grant McConnell int ret; 212969a2f00cSDwayne Grant McConnell 213069a2f00cSDwayne Grant McConnell if (!access_ok(VERIFY_WRITE, buf, len)) 213169a2f00cSDwayne Grant McConnell return -EFAULT; 213269a2f00cSDwayne Grant McConnell 2133c9101bdbSChristoph Hellwig ret = spu_acquire_saved(ctx); 2134c9101bdbSChristoph Hellwig if (ret) 2135c9101bdbSChristoph Hellwig return ret; 213669a2f00cSDwayne Grant McConnell spin_lock(&ctx->csa.register_lock); 2137bf1ab978SDwayne Grant McConnell ret = __spufs_wbox_info_read(ctx, buf, len, pos); 213869a2f00cSDwayne Grant McConnell spin_unlock(&ctx->csa.register_lock); 213927b1ea09SChristoph Hellwig spu_release_saved(ctx); 214069a2f00cSDwayne Grant McConnell 2141bf1ab978SDwayne Grant McConnell return ret; 214269a2f00cSDwayne Grant McConnell } 214369a2f00cSDwayne Grant McConnell 21445dfe4c96SArjan van de Ven static const struct file_operations spufs_wbox_info_fops = { 214569a2f00cSDwayne Grant McConnell .open = spufs_info_open, 214669a2f00cSDwayne Grant McConnell .read = spufs_wbox_info_read, 214769a2f00cSDwayne Grant McConnell .llseek = generic_file_llseek, 214869a2f00cSDwayne Grant McConnell }; 214969a2f00cSDwayne Grant McConnell 2150bf1ab978SDwayne Grant McConnell static ssize_t __spufs_dma_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_dma_info info; 2154b9e3bd77SDwayne Grant McConnell struct mfc_cq_sr *qp, *spuqp; 2155b9e3bd77SDwayne Grant McConnell int i; 2156b9e3bd77SDwayne Grant McConnell 2157b9e3bd77SDwayne Grant McConnell info.dma_info_type = ctx->csa.priv2.spu_tag_status_query_RW; 2158b9e3bd77SDwayne Grant McConnell info.dma_info_mask = ctx->csa.lscsa->tag_mask.slot[0]; 2159b9e3bd77SDwayne Grant McConnell info.dma_info_status = ctx->csa.spu_chnldata_RW[24]; 2160b9e3bd77SDwayne Grant McConnell info.dma_info_stall_and_notify = ctx->csa.spu_chnldata_RW[25]; 2161b9e3bd77SDwayne Grant McConnell info.dma_info_atomic_command_status = ctx->csa.spu_chnldata_RW[27]; 2162b9e3bd77SDwayne Grant McConnell for (i = 0; i < 16; i++) { 2163b9e3bd77SDwayne Grant McConnell qp = &info.dma_info_command_data[i]; 2164b9e3bd77SDwayne Grant McConnell spuqp = &ctx->csa.priv2.spuq[i]; 2165b9e3bd77SDwayne Grant McConnell 2166b9e3bd77SDwayne Grant McConnell qp->mfc_cq_data0_RW = spuqp->mfc_cq_data0_RW; 2167b9e3bd77SDwayne Grant McConnell qp->mfc_cq_data1_RW = spuqp->mfc_cq_data1_RW; 2168b9e3bd77SDwayne Grant McConnell qp->mfc_cq_data2_RW = spuqp->mfc_cq_data2_RW; 2169b9e3bd77SDwayne Grant McConnell qp->mfc_cq_data3_RW = spuqp->mfc_cq_data3_RW; 2170b9e3bd77SDwayne Grant McConnell } 2171b9e3bd77SDwayne Grant McConnell 2172b9e3bd77SDwayne Grant McConnell return simple_read_from_buffer(buf, len, pos, &info, 2173b9e3bd77SDwayne Grant McConnell sizeof info); 2174b9e3bd77SDwayne Grant McConnell } 2175b9e3bd77SDwayne Grant McConnell 2176bf1ab978SDwayne Grant McConnell static ssize_t spufs_dma_info_read(struct file *file, char __user *buf, 2177bf1ab978SDwayne Grant McConnell size_t len, loff_t *pos) 2178bf1ab978SDwayne Grant McConnell { 2179bf1ab978SDwayne Grant McConnell struct spu_context *ctx = file->private_data; 2180bf1ab978SDwayne Grant McConnell int ret; 2181bf1ab978SDwayne Grant McConnell 2182bf1ab978SDwayne Grant McConnell if (!access_ok(VERIFY_WRITE, buf, len)) 2183bf1ab978SDwayne Grant McConnell return -EFAULT; 2184bf1ab978SDwayne Grant McConnell 2185c9101bdbSChristoph Hellwig ret = spu_acquire_saved(ctx); 2186c9101bdbSChristoph Hellwig if (ret) 2187c9101bdbSChristoph Hellwig return ret; 2188bf1ab978SDwayne Grant McConnell spin_lock(&ctx->csa.register_lock); 2189bf1ab978SDwayne Grant McConnell ret = __spufs_dma_info_read(ctx, buf, len, pos); 2190bf1ab978SDwayne Grant McConnell spin_unlock(&ctx->csa.register_lock); 219127b1ea09SChristoph Hellwig spu_release_saved(ctx); 2192bf1ab978SDwayne Grant McConnell 2193bf1ab978SDwayne Grant McConnell return ret; 2194bf1ab978SDwayne Grant McConnell } 2195bf1ab978SDwayne Grant McConnell 21965dfe4c96SArjan van de Ven static const struct file_operations spufs_dma_info_fops = { 2197b9e3bd77SDwayne Grant McConnell .open = spufs_info_open, 2198b9e3bd77SDwayne Grant McConnell .read = spufs_dma_info_read, 2199fc15351dSArnd Bergmann .llseek = no_llseek, 2200b9e3bd77SDwayne Grant McConnell }; 2201b9e3bd77SDwayne Grant McConnell 2202bf1ab978SDwayne Grant McConnell static ssize_t __spufs_proxydma_info_read(struct spu_context *ctx, 2203bf1ab978SDwayne Grant McConnell char __user *buf, size_t len, loff_t *pos) 2204b9e3bd77SDwayne Grant McConnell { 2205b9e3bd77SDwayne Grant McConnell struct spu_proxydma_info info; 2206b9e3bd77SDwayne Grant McConnell struct mfc_cq_sr *qp, *puqp; 2207bf1ab978SDwayne Grant McConnell int ret = sizeof info; 2208b9e3bd77SDwayne Grant McConnell int i; 2209b9e3bd77SDwayne Grant McConnell 2210b9e3bd77SDwayne Grant McConnell if (len < ret) 2211b9e3bd77SDwayne Grant McConnell return -EINVAL; 2212b9e3bd77SDwayne Grant McConnell 2213b9e3bd77SDwayne Grant McConnell if (!access_ok(VERIFY_WRITE, buf, len)) 2214b9e3bd77SDwayne Grant McConnell return -EFAULT; 2215b9e3bd77SDwayne Grant McConnell 2216b9e3bd77SDwayne Grant McConnell info.proxydma_info_type = ctx->csa.prob.dma_querytype_RW; 2217b9e3bd77SDwayne Grant McConnell info.proxydma_info_mask = ctx->csa.prob.dma_querymask_RW; 2218b9e3bd77SDwayne Grant McConnell info.proxydma_info_status = ctx->csa.prob.dma_tagstatus_R; 2219b9e3bd77SDwayne Grant McConnell for (i = 0; i < 8; i++) { 2220b9e3bd77SDwayne Grant McConnell qp = &info.proxydma_info_command_data[i]; 2221b9e3bd77SDwayne Grant McConnell puqp = &ctx->csa.priv2.puq[i]; 2222b9e3bd77SDwayne Grant McConnell 2223b9e3bd77SDwayne Grant McConnell qp->mfc_cq_data0_RW = puqp->mfc_cq_data0_RW; 2224b9e3bd77SDwayne Grant McConnell qp->mfc_cq_data1_RW = puqp->mfc_cq_data1_RW; 2225b9e3bd77SDwayne Grant McConnell qp->mfc_cq_data2_RW = puqp->mfc_cq_data2_RW; 2226b9e3bd77SDwayne Grant McConnell qp->mfc_cq_data3_RW = puqp->mfc_cq_data3_RW; 2227b9e3bd77SDwayne Grant McConnell } 2228bf1ab978SDwayne Grant McConnell 2229bf1ab978SDwayne Grant McConnell return simple_read_from_buffer(buf, len, pos, &info, 2230bf1ab978SDwayne Grant McConnell sizeof info); 2231bf1ab978SDwayne Grant McConnell } 2232bf1ab978SDwayne Grant McConnell 2233bf1ab978SDwayne Grant McConnell static ssize_t spufs_proxydma_info_read(struct file *file, char __user *buf, 2234bf1ab978SDwayne Grant McConnell size_t len, loff_t *pos) 2235bf1ab978SDwayne Grant McConnell { 2236bf1ab978SDwayne Grant McConnell struct spu_context *ctx = file->private_data; 2237bf1ab978SDwayne Grant McConnell int ret; 2238bf1ab978SDwayne Grant McConnell 2239c9101bdbSChristoph Hellwig ret = spu_acquire_saved(ctx); 2240c9101bdbSChristoph Hellwig if (ret) 2241c9101bdbSChristoph Hellwig return ret; 2242bf1ab978SDwayne Grant McConnell spin_lock(&ctx->csa.register_lock); 2243bf1ab978SDwayne Grant McConnell ret = __spufs_proxydma_info_read(ctx, buf, len, pos); 2244b9e3bd77SDwayne Grant McConnell spin_unlock(&ctx->csa.register_lock); 224527b1ea09SChristoph Hellwig spu_release_saved(ctx); 2246b9e3bd77SDwayne Grant McConnell 2247b9e3bd77SDwayne Grant McConnell return ret; 2248b9e3bd77SDwayne Grant McConnell } 2249b9e3bd77SDwayne Grant McConnell 22505dfe4c96SArjan van de Ven static const struct file_operations spufs_proxydma_info_fops = { 2251b9e3bd77SDwayne Grant McConnell .open = spufs_info_open, 2252b9e3bd77SDwayne Grant McConnell .read = spufs_proxydma_info_read, 2253fc15351dSArnd Bergmann .llseek = no_llseek, 2254b9e3bd77SDwayne Grant McConnell }; 2255b9e3bd77SDwayne Grant McConnell 2256476273adSChristoph Hellwig static int spufs_show_tid(struct seq_file *s, void *private) 2257476273adSChristoph Hellwig { 2258476273adSChristoph Hellwig struct spu_context *ctx = s->private; 2259476273adSChristoph Hellwig 2260476273adSChristoph Hellwig seq_printf(s, "%d\n", ctx->tid); 2261476273adSChristoph Hellwig return 0; 2262476273adSChristoph Hellwig } 2263476273adSChristoph Hellwig 2264476273adSChristoph Hellwig static int spufs_tid_open(struct inode *inode, struct file *file) 2265476273adSChristoph Hellwig { 2266476273adSChristoph Hellwig return single_open(file, spufs_show_tid, SPUFS_I(inode)->i_ctx); 2267476273adSChristoph Hellwig } 2268476273adSChristoph Hellwig 2269476273adSChristoph Hellwig static const struct file_operations spufs_tid_fops = { 2270476273adSChristoph Hellwig .open = spufs_tid_open, 2271476273adSChristoph Hellwig .read = seq_read, 2272476273adSChristoph Hellwig .llseek = seq_lseek, 2273476273adSChristoph Hellwig .release = single_release, 2274476273adSChristoph Hellwig }; 2275476273adSChristoph Hellwig 2276e9f8a0b6SChristoph Hellwig static const char *ctx_state_names[] = { 2277e9f8a0b6SChristoph Hellwig "user", "system", "iowait", "loaded" 2278e9f8a0b6SChristoph Hellwig }; 2279e9f8a0b6SChristoph Hellwig 2280e9f8a0b6SChristoph Hellwig static unsigned long long spufs_acct_time(struct spu_context *ctx, 228127ec41d3SAndre Detsch enum spu_utilization_state state) 2282e9f8a0b6SChristoph Hellwig { 228327ec41d3SAndre Detsch unsigned long long time = ctx->stats.times[state]; 2284e9f8a0b6SChristoph Hellwig 228527ec41d3SAndre Detsch /* 228627ec41d3SAndre Detsch * In general, utilization statistics are updated by the controlling 228727ec41d3SAndre Detsch * thread as the spu context moves through various well defined 228827ec41d3SAndre Detsch * state transitions, but if the context is lazily loaded its 228927ec41d3SAndre Detsch * utilization statistics are not updated as the controlling thread 229027ec41d3SAndre Detsch * is not tightly coupled with the execution of the spu context. We 229127ec41d3SAndre Detsch * calculate and apply the time delta from the last recorded state 229227ec41d3SAndre Detsch * of the spu context. 229327ec41d3SAndre Detsch */ 229427ec41d3SAndre Detsch if (ctx->spu && ctx->stats.util_state == state) { 2295f2dec1eaSThomas Gleixner time += ktime_get_ns() - ctx->stats.tstamp; 229627ec41d3SAndre Detsch } 2297e9f8a0b6SChristoph Hellwig 229827ec41d3SAndre Detsch return time / NSEC_PER_MSEC; 2299e9f8a0b6SChristoph Hellwig } 2300e9f8a0b6SChristoph Hellwig 2301e9f8a0b6SChristoph Hellwig static unsigned long long spufs_slb_flts(struct spu_context *ctx) 2302e9f8a0b6SChristoph Hellwig { 2303e9f8a0b6SChristoph Hellwig unsigned long long slb_flts = ctx->stats.slb_flt; 2304e9f8a0b6SChristoph Hellwig 2305e9f8a0b6SChristoph Hellwig if (ctx->state == SPU_STATE_RUNNABLE) { 2306e9f8a0b6SChristoph Hellwig slb_flts += (ctx->spu->stats.slb_flt - 2307e9f8a0b6SChristoph Hellwig ctx->stats.slb_flt_base); 2308e9f8a0b6SChristoph Hellwig } 2309e9f8a0b6SChristoph Hellwig 2310e9f8a0b6SChristoph Hellwig return slb_flts; 2311e9f8a0b6SChristoph Hellwig } 2312e9f8a0b6SChristoph Hellwig 2313e9f8a0b6SChristoph Hellwig static unsigned long long spufs_class2_intrs(struct spu_context *ctx) 2314e9f8a0b6SChristoph Hellwig { 2315e9f8a0b6SChristoph Hellwig unsigned long long class2_intrs = ctx->stats.class2_intr; 2316e9f8a0b6SChristoph Hellwig 2317e9f8a0b6SChristoph Hellwig if (ctx->state == SPU_STATE_RUNNABLE) { 2318e9f8a0b6SChristoph Hellwig class2_intrs += (ctx->spu->stats.class2_intr - 2319e9f8a0b6SChristoph Hellwig ctx->stats.class2_intr_base); 2320e9f8a0b6SChristoph Hellwig } 2321e9f8a0b6SChristoph Hellwig 2322e9f8a0b6SChristoph Hellwig return class2_intrs; 2323e9f8a0b6SChristoph Hellwig } 2324e9f8a0b6SChristoph Hellwig 2325e9f8a0b6SChristoph Hellwig 2326e9f8a0b6SChristoph Hellwig static int spufs_show_stat(struct seq_file *s, void *private) 2327e9f8a0b6SChristoph Hellwig { 2328e9f8a0b6SChristoph Hellwig struct spu_context *ctx = s->private; 2329c9101bdbSChristoph Hellwig int ret; 2330e9f8a0b6SChristoph Hellwig 2331c9101bdbSChristoph Hellwig ret = spu_acquire(ctx); 2332c9101bdbSChristoph Hellwig if (ret) 2333c9101bdbSChristoph Hellwig return ret; 2334c9101bdbSChristoph Hellwig 2335e9f8a0b6SChristoph Hellwig seq_printf(s, "%s %llu %llu %llu %llu " 2336e9f8a0b6SChristoph Hellwig "%llu %llu %llu %llu %llu %llu %llu %llu\n", 233727ec41d3SAndre Detsch ctx_state_names[ctx->stats.util_state], 233827ec41d3SAndre Detsch spufs_acct_time(ctx, SPU_UTIL_USER), 233927ec41d3SAndre Detsch spufs_acct_time(ctx, SPU_UTIL_SYSTEM), 234027ec41d3SAndre Detsch spufs_acct_time(ctx, SPU_UTIL_IOWAIT), 234127ec41d3SAndre Detsch spufs_acct_time(ctx, SPU_UTIL_IDLE_LOADED), 2342e9f8a0b6SChristoph Hellwig ctx->stats.vol_ctx_switch, 2343e9f8a0b6SChristoph Hellwig ctx->stats.invol_ctx_switch, 2344e9f8a0b6SChristoph Hellwig spufs_slb_flts(ctx), 2345e9f8a0b6SChristoph Hellwig ctx->stats.hash_flt, 2346e9f8a0b6SChristoph Hellwig ctx->stats.min_flt, 2347e9f8a0b6SChristoph Hellwig ctx->stats.maj_flt, 2348e9f8a0b6SChristoph Hellwig spufs_class2_intrs(ctx), 2349e9f8a0b6SChristoph Hellwig ctx->stats.libassist); 2350e9f8a0b6SChristoph Hellwig spu_release(ctx); 2351e9f8a0b6SChristoph Hellwig return 0; 2352e9f8a0b6SChristoph Hellwig } 2353e9f8a0b6SChristoph Hellwig 2354e9f8a0b6SChristoph Hellwig static int spufs_stat_open(struct inode *inode, struct file *file) 2355e9f8a0b6SChristoph Hellwig { 2356e9f8a0b6SChristoph Hellwig return single_open(file, spufs_show_stat, SPUFS_I(inode)->i_ctx); 2357e9f8a0b6SChristoph Hellwig } 2358e9f8a0b6SChristoph Hellwig 2359e9f8a0b6SChristoph Hellwig static const struct file_operations spufs_stat_fops = { 2360e9f8a0b6SChristoph Hellwig .open = spufs_stat_open, 2361e9f8a0b6SChristoph Hellwig .read = seq_read, 2362e9f8a0b6SChristoph Hellwig .llseek = seq_lseek, 2363e9f8a0b6SChristoph Hellwig .release = single_release, 2364e9f8a0b6SChristoph Hellwig }; 2365e9f8a0b6SChristoph Hellwig 23665158e9b5SChristoph Hellwig static inline int spufs_switch_log_used(struct spu_context *ctx) 23675158e9b5SChristoph Hellwig { 23685158e9b5SChristoph Hellwig return (ctx->switch_log->head - ctx->switch_log->tail) % 23695158e9b5SChristoph Hellwig SWITCH_LOG_BUFSIZE; 23705158e9b5SChristoph Hellwig } 23715158e9b5SChristoph Hellwig 23725158e9b5SChristoph Hellwig static inline int spufs_switch_log_avail(struct spu_context *ctx) 23735158e9b5SChristoph Hellwig { 23745158e9b5SChristoph Hellwig return SWITCH_LOG_BUFSIZE - spufs_switch_log_used(ctx); 23755158e9b5SChristoph Hellwig } 23765158e9b5SChristoph Hellwig 23775158e9b5SChristoph Hellwig static int spufs_switch_log_open(struct inode *inode, struct file *file) 23785158e9b5SChristoph Hellwig { 23795158e9b5SChristoph Hellwig struct spu_context *ctx = SPUFS_I(inode)->i_ctx; 2380f5ed0eb6SJeremy Kerr int rc; 23815158e9b5SChristoph Hellwig 2382f5ed0eb6SJeremy Kerr rc = spu_acquire(ctx); 2383f5ed0eb6SJeremy Kerr if (rc) 2384f5ed0eb6SJeremy Kerr return rc; 2385f5ed0eb6SJeremy Kerr 23865158e9b5SChristoph Hellwig if (ctx->switch_log) { 2387f5ed0eb6SJeremy Kerr rc = -EBUSY; 2388f5ed0eb6SJeremy Kerr goto out; 2389f5ed0eb6SJeremy Kerr } 2390f5ed0eb6SJeremy Kerr 2391837ef884SJeremy Kerr ctx->switch_log = kmalloc(sizeof(struct switch_log) + 23925158e9b5SChristoph Hellwig SWITCH_LOG_BUFSIZE * sizeof(struct switch_log_entry), 23935158e9b5SChristoph Hellwig GFP_KERNEL); 2394f5ed0eb6SJeremy Kerr 2395f5ed0eb6SJeremy Kerr if (!ctx->switch_log) { 2396f5ed0eb6SJeremy Kerr rc = -ENOMEM; 23975158e9b5SChristoph Hellwig goto out; 23985158e9b5SChristoph Hellwig } 2399f5ed0eb6SJeremy Kerr 2400837ef884SJeremy Kerr ctx->switch_log->head = ctx->switch_log->tail = 0; 2401f5ed0eb6SJeremy Kerr init_waitqueue_head(&ctx->switch_log->wait); 2402f5ed0eb6SJeremy Kerr rc = 0; 2403f5ed0eb6SJeremy Kerr 2404f5ed0eb6SJeremy Kerr out: 2405f5ed0eb6SJeremy Kerr spu_release(ctx); 2406f5ed0eb6SJeremy Kerr return rc; 2407f5ed0eb6SJeremy Kerr } 2408f5ed0eb6SJeremy Kerr 2409f5ed0eb6SJeremy Kerr static int spufs_switch_log_release(struct inode *inode, struct file *file) 2410f5ed0eb6SJeremy Kerr { 2411f5ed0eb6SJeremy Kerr struct spu_context *ctx = SPUFS_I(inode)->i_ctx; 2412f5ed0eb6SJeremy Kerr int rc; 2413f5ed0eb6SJeremy Kerr 2414f5ed0eb6SJeremy Kerr rc = spu_acquire(ctx); 2415f5ed0eb6SJeremy Kerr if (rc) 2416f5ed0eb6SJeremy Kerr return rc; 2417f5ed0eb6SJeremy Kerr 2418f5ed0eb6SJeremy Kerr kfree(ctx->switch_log); 2419f5ed0eb6SJeremy Kerr ctx->switch_log = NULL; 2420f5ed0eb6SJeremy Kerr spu_release(ctx); 24215158e9b5SChristoph Hellwig 24225158e9b5SChristoph Hellwig return 0; 24235158e9b5SChristoph Hellwig } 24245158e9b5SChristoph Hellwig 24255158e9b5SChristoph Hellwig static int switch_log_sprint(struct spu_context *ctx, char *tbuf, int n) 24265158e9b5SChristoph Hellwig { 24275158e9b5SChristoph Hellwig struct switch_log_entry *p; 24285158e9b5SChristoph Hellwig 24295158e9b5SChristoph Hellwig p = ctx->switch_log->log + ctx->switch_log->tail % SWITCH_LOG_BUFSIZE; 24305158e9b5SChristoph Hellwig 24315158e9b5SChristoph Hellwig return snprintf(tbuf, n, "%u.%09u %d %u %u %llu\n", 24325158e9b5SChristoph Hellwig (unsigned int) p->tstamp.tv_sec, 24335158e9b5SChristoph Hellwig (unsigned int) p->tstamp.tv_nsec, 24345158e9b5SChristoph Hellwig p->spu_id, 24355158e9b5SChristoph Hellwig (unsigned int) p->type, 24365158e9b5SChristoph Hellwig (unsigned int) p->val, 24375158e9b5SChristoph Hellwig (unsigned long long) p->timebase); 24385158e9b5SChristoph Hellwig } 24395158e9b5SChristoph Hellwig 24405158e9b5SChristoph Hellwig static ssize_t spufs_switch_log_read(struct file *file, char __user *buf, 24415158e9b5SChristoph Hellwig size_t len, loff_t *ppos) 24425158e9b5SChristoph Hellwig { 2443496ad9aaSAl Viro struct inode *inode = file_inode(file); 24445158e9b5SChristoph Hellwig struct spu_context *ctx = SPUFS_I(inode)->i_ctx; 24455158e9b5SChristoph Hellwig int error = 0, cnt = 0; 24465158e9b5SChristoph Hellwig 244717e37675Sroel kluin if (!buf) 24485158e9b5SChristoph Hellwig return -EINVAL; 24495158e9b5SChristoph Hellwig 2450f5ed0eb6SJeremy Kerr error = spu_acquire(ctx); 2451f5ed0eb6SJeremy Kerr if (error) 2452f5ed0eb6SJeremy Kerr return error; 2453f5ed0eb6SJeremy Kerr 24545158e9b5SChristoph Hellwig while (cnt < len) { 24555158e9b5SChristoph Hellwig char tbuf[128]; 24565158e9b5SChristoph Hellwig int width; 24575158e9b5SChristoph Hellwig 2458f5ed0eb6SJeremy Kerr if (spufs_switch_log_used(ctx) == 0) { 245914f693eeSJeremy Kerr if (cnt > 0) { 246014f693eeSJeremy Kerr /* If there's data ready to go, we can 246114f693eeSJeremy Kerr * just return straight away */ 246214f693eeSJeremy Kerr break; 246314f693eeSJeremy Kerr 246414f693eeSJeremy Kerr } else if (file->f_flags & O_NONBLOCK) { 2465f5ed0eb6SJeremy Kerr error = -EAGAIN; 24665158e9b5SChristoph Hellwig break; 246714f693eeSJeremy Kerr 2468f5ed0eb6SJeremy Kerr } else { 246914f693eeSJeremy Kerr /* spufs_wait will drop the mutex and 247014f693eeSJeremy Kerr * re-acquire, but since we're in read(), the 247114f693eeSJeremy Kerr * file cannot be _released (and so 247214f693eeSJeremy Kerr * ctx->switch_log is stable). 2473f5ed0eb6SJeremy Kerr */ 2474f5ed0eb6SJeremy Kerr error = spufs_wait(ctx->switch_log->wait, 2475f5ed0eb6SJeremy Kerr spufs_switch_log_used(ctx) > 0); 24765158e9b5SChristoph Hellwig 2477f5ed0eb6SJeremy Kerr /* On error, spufs_wait returns without the 2478f5ed0eb6SJeremy Kerr * state mutex held */ 2479f5ed0eb6SJeremy Kerr if (error) 2480f5ed0eb6SJeremy Kerr return error; 24815158e9b5SChristoph Hellwig 248214f693eeSJeremy Kerr /* We may have had entries read from underneath 248314f693eeSJeremy Kerr * us while we dropped the mutex in spufs_wait, 248414f693eeSJeremy Kerr * so re-check */ 248514f693eeSJeremy Kerr if (spufs_switch_log_used(ctx) == 0) 2486f5ed0eb6SJeremy Kerr continue; 248714f693eeSJeremy Kerr } 248814f693eeSJeremy Kerr } 2489f5ed0eb6SJeremy Kerr 24905158e9b5SChristoph Hellwig width = switch_log_sprint(ctx, tbuf, sizeof(tbuf)); 2491f5ed0eb6SJeremy Kerr if (width < len) 24925158e9b5SChristoph Hellwig ctx->switch_log->tail = 24935158e9b5SChristoph Hellwig (ctx->switch_log->tail + 1) % 24945158e9b5SChristoph Hellwig SWITCH_LOG_BUFSIZE; 2495f5ed0eb6SJeremy Kerr else 2496f5ed0eb6SJeremy Kerr /* If the record is greater than space available return 2497f5ed0eb6SJeremy Kerr * partial buffer (so far) */ 24985158e9b5SChristoph Hellwig break; 24995158e9b5SChristoph Hellwig 25005158e9b5SChristoph Hellwig error = copy_to_user(buf + cnt, tbuf, width); 25015158e9b5SChristoph Hellwig if (error) 25025158e9b5SChristoph Hellwig break; 25035158e9b5SChristoph Hellwig cnt += width; 25045158e9b5SChristoph Hellwig } 25055158e9b5SChristoph Hellwig 2506f5ed0eb6SJeremy Kerr spu_release(ctx); 2507f5ed0eb6SJeremy Kerr 25085158e9b5SChristoph Hellwig return cnt == 0 ? error : cnt; 25095158e9b5SChristoph Hellwig } 25105158e9b5SChristoph Hellwig 25115158e9b5SChristoph Hellwig static unsigned int spufs_switch_log_poll(struct file *file, poll_table *wait) 25125158e9b5SChristoph Hellwig { 2513496ad9aaSAl Viro struct inode *inode = file_inode(file); 25145158e9b5SChristoph Hellwig struct spu_context *ctx = SPUFS_I(inode)->i_ctx; 25155158e9b5SChristoph Hellwig unsigned int mask = 0; 2516f5ed0eb6SJeremy Kerr int rc; 25175158e9b5SChristoph Hellwig 25185158e9b5SChristoph Hellwig poll_wait(file, &ctx->switch_log->wait, wait); 25195158e9b5SChristoph Hellwig 2520f5ed0eb6SJeremy Kerr rc = spu_acquire(ctx); 2521f5ed0eb6SJeremy Kerr if (rc) 2522f5ed0eb6SJeremy Kerr return rc; 2523f5ed0eb6SJeremy Kerr 25245158e9b5SChristoph Hellwig if (spufs_switch_log_used(ctx) > 0) 25255158e9b5SChristoph Hellwig mask |= POLLIN; 25265158e9b5SChristoph Hellwig 2527f5ed0eb6SJeremy Kerr spu_release(ctx); 2528f5ed0eb6SJeremy Kerr 25295158e9b5SChristoph Hellwig return mask; 25305158e9b5SChristoph Hellwig } 25315158e9b5SChristoph Hellwig 25325158e9b5SChristoph Hellwig static const struct file_operations spufs_switch_log_fops = { 25335158e9b5SChristoph Hellwig .open = spufs_switch_log_open, 25345158e9b5SChristoph Hellwig .read = spufs_switch_log_read, 25355158e9b5SChristoph Hellwig .poll = spufs_switch_log_poll, 2536f5ed0eb6SJeremy Kerr .release = spufs_switch_log_release, 2537fc15351dSArnd Bergmann .llseek = no_llseek, 25385158e9b5SChristoph Hellwig }; 25395158e9b5SChristoph Hellwig 2540f5ed0eb6SJeremy Kerr /** 2541f5ed0eb6SJeremy Kerr * Log a context switch event to a switch log reader. 2542f5ed0eb6SJeremy Kerr * 2543f5ed0eb6SJeremy Kerr * Must be called with ctx->state_mutex held. 2544f5ed0eb6SJeremy Kerr */ 25455158e9b5SChristoph Hellwig void spu_switch_log_notify(struct spu *spu, struct spu_context *ctx, 25465158e9b5SChristoph Hellwig u32 type, u32 val) 25475158e9b5SChristoph Hellwig { 25485158e9b5SChristoph Hellwig if (!ctx->switch_log) 25495158e9b5SChristoph Hellwig return; 25505158e9b5SChristoph Hellwig 25515158e9b5SChristoph Hellwig if (spufs_switch_log_avail(ctx) > 1) { 25525158e9b5SChristoph Hellwig struct switch_log_entry *p; 25535158e9b5SChristoph Hellwig 25545158e9b5SChristoph Hellwig p = ctx->switch_log->log + ctx->switch_log->head; 25555158e9b5SChristoph Hellwig ktime_get_ts(&p->tstamp); 25565158e9b5SChristoph Hellwig p->timebase = get_tb(); 25575158e9b5SChristoph Hellwig p->spu_id = spu ? spu->number : -1; 25585158e9b5SChristoph Hellwig p->type = type; 25595158e9b5SChristoph Hellwig p->val = val; 25605158e9b5SChristoph Hellwig 25615158e9b5SChristoph Hellwig ctx->switch_log->head = 25625158e9b5SChristoph Hellwig (ctx->switch_log->head + 1) % SWITCH_LOG_BUFSIZE; 25635158e9b5SChristoph Hellwig } 25645158e9b5SChristoph Hellwig 25655158e9b5SChristoph Hellwig wake_up(&ctx->switch_log->wait); 25665158e9b5SChristoph Hellwig } 2567e9f8a0b6SChristoph Hellwig 256846deed69SLuke Browning static int spufs_show_ctx(struct seq_file *s, void *private) 256946deed69SLuke Browning { 257046deed69SLuke Browning struct spu_context *ctx = s->private; 257146deed69SLuke Browning u64 mfc_control_RW; 257246deed69SLuke Browning 257346deed69SLuke Browning mutex_lock(&ctx->state_mutex); 257446deed69SLuke Browning if (ctx->spu) { 257546deed69SLuke Browning struct spu *spu = ctx->spu; 257646deed69SLuke Browning struct spu_priv2 __iomem *priv2 = spu->priv2; 257746deed69SLuke Browning 257846deed69SLuke Browning spin_lock_irq(&spu->register_lock); 257946deed69SLuke Browning mfc_control_RW = in_be64(&priv2->mfc_control_RW); 258046deed69SLuke Browning spin_unlock_irq(&spu->register_lock); 258146deed69SLuke Browning } else { 258246deed69SLuke Browning struct spu_state *csa = &ctx->csa; 258346deed69SLuke Browning 258446deed69SLuke Browning mfc_control_RW = csa->priv2.mfc_control_RW; 258546deed69SLuke Browning } 258646deed69SLuke Browning 258746deed69SLuke Browning seq_printf(s, "%c flgs(%lx) sflgs(%lx) pri(%d) ts(%d) spu(%02d)" 25889477e455SStephen Rothwell " %c %llx %llx %llx %llx %x %x\n", 258946deed69SLuke Browning ctx->state == SPU_STATE_SAVED ? 'S' : 'R', 259046deed69SLuke Browning ctx->flags, 259146deed69SLuke Browning ctx->sched_flags, 259246deed69SLuke Browning ctx->prio, 259346deed69SLuke Browning ctx->time_slice, 259446deed69SLuke Browning ctx->spu ? ctx->spu->number : -1, 259546deed69SLuke Browning !list_empty(&ctx->rq) ? 'q' : ' ', 259646deed69SLuke Browning ctx->csa.class_0_pending, 259746deed69SLuke Browning ctx->csa.class_0_dar, 259846deed69SLuke Browning ctx->csa.class_1_dsisr, 259946deed69SLuke Browning mfc_control_RW, 260046deed69SLuke Browning ctx->ops->runcntl_read(ctx), 260146deed69SLuke Browning ctx->ops->status_read(ctx)); 260246deed69SLuke Browning 260346deed69SLuke Browning mutex_unlock(&ctx->state_mutex); 260446deed69SLuke Browning 260546deed69SLuke Browning return 0; 260646deed69SLuke Browning } 260746deed69SLuke Browning 260846deed69SLuke Browning static int spufs_ctx_open(struct inode *inode, struct file *file) 260946deed69SLuke Browning { 261046deed69SLuke Browning return single_open(file, spufs_show_ctx, SPUFS_I(inode)->i_ctx); 261146deed69SLuke Browning } 261246deed69SLuke Browning 261346deed69SLuke Browning static const struct file_operations spufs_ctx_fops = { 261446deed69SLuke Browning .open = spufs_ctx_open, 261546deed69SLuke Browning .read = seq_read, 261646deed69SLuke Browning .llseek = seq_lseek, 261746deed69SLuke Browning .release = single_release, 261846deed69SLuke Browning }; 261946deed69SLuke Browning 262074254647SJeremy Kerr const struct spufs_tree_descr spufs_dir_contents[] = { 2621cbe709c1SBenjamin Herrenschmidt { "capabilities", &spufs_caps_fops, 0444, }, 26226f7dde81SJeremy Kerr { "mem", &spufs_mem_fops, 0666, LS_SIZE, }, 26236f7dde81SJeremy Kerr { "regs", &spufs_regs_fops, 0666, sizeof(struct spu_reg128[128]), }, 262467207b96SArnd Bergmann { "mbox", &spufs_mbox_fops, 0444, }, 262567207b96SArnd Bergmann { "ibox", &spufs_ibox_fops, 0444, }, 262667207b96SArnd Bergmann { "wbox", &spufs_wbox_fops, 0222, }, 26276f7dde81SJeremy Kerr { "mbox_stat", &spufs_mbox_stat_fops, 0444, sizeof(u32), }, 26286f7dde81SJeremy Kerr { "ibox_stat", &spufs_ibox_stat_fops, 0444, sizeof(u32), }, 26296f7dde81SJeremy Kerr { "wbox_stat", &spufs_wbox_stat_fops, 0444, sizeof(u32), }, 2630603c4612SJeremy Kerr { "signal1", &spufs_signal1_fops, 0666, }, 2631603c4612SJeremy Kerr { "signal2", &spufs_signal2_fops, 0666, }, 263267207b96SArnd Bergmann { "signal1_type", &spufs_signal1_type, 0666, }, 263367207b96SArnd Bergmann { "signal2_type", &spufs_signal2_type, 0666, }, 26346df10a82SMark Nutter { "cntl", &spufs_cntl_fops, 0666, }, 26356f7dde81SJeremy Kerr { "fpcr", &spufs_fpcr_fops, 0666, sizeof(struct spu_reg128), }, 2636b9e3bd77SDwayne Grant McConnell { "lslr", &spufs_lslr_ops, 0444, }, 2637b9e3bd77SDwayne Grant McConnell { "mfc", &spufs_mfc_fops, 0666, }, 2638b9e3bd77SDwayne Grant McConnell { "mss", &spufs_mss_fops, 0666, }, 2639b9e3bd77SDwayne Grant McConnell { "npc", &spufs_npc_ops, 0666, }, 2640b9e3bd77SDwayne Grant McConnell { "srr0", &spufs_srr0_ops, 0666, }, 26418b3d6663SArnd Bergmann { "decr", &spufs_decr_ops, 0666, }, 26428b3d6663SArnd Bergmann { "decr_status", &spufs_decr_status_ops, 0666, }, 26438b3d6663SArnd Bergmann { "event_mask", &spufs_event_mask_ops, 0666, }, 2644b9e3bd77SDwayne Grant McConnell { "event_status", &spufs_event_status_ops, 0444, }, 26456f7dde81SJeremy Kerr { "psmap", &spufs_psmap_fops, 0666, SPUFS_PS_MAP_SIZE, }, 264686767277SArnd Bergmann { "phys-id", &spufs_id_ops, 0666, }, 264786767277SArnd Bergmann { "object-id", &spufs_object_id_ops, 0666, }, 26486f7dde81SJeremy Kerr { "mbox_info", &spufs_mbox_info_fops, 0444, sizeof(u32), }, 26496f7dde81SJeremy Kerr { "ibox_info", &spufs_ibox_info_fops, 0444, sizeof(u32), }, 26506f7dde81SJeremy Kerr { "wbox_info", &spufs_wbox_info_fops, 0444, sizeof(u32), }, 26516f7dde81SJeremy Kerr { "dma_info", &spufs_dma_info_fops, 0444, 26526f7dde81SJeremy Kerr sizeof(struct spu_dma_info), }, 26536f7dde81SJeremy Kerr { "proxydma_info", &spufs_proxydma_info_fops, 0444, 26546f7dde81SJeremy Kerr sizeof(struct spu_proxydma_info)}, 2655476273adSChristoph Hellwig { "tid", &spufs_tid_fops, 0444, }, 2656e9f8a0b6SChristoph Hellwig { "stat", &spufs_stat_fops, 0444, }, 26575158e9b5SChristoph Hellwig { "switch_log", &spufs_switch_log_fops, 0444 }, 265867207b96SArnd Bergmann {}, 265967207b96SArnd Bergmann }; 26605737edd1SMark Nutter 266174254647SJeremy Kerr const struct spufs_tree_descr spufs_dir_nosched_contents[] = { 2662cbe709c1SBenjamin Herrenschmidt { "capabilities", &spufs_caps_fops, 0444, }, 26636f7dde81SJeremy Kerr { "mem", &spufs_mem_fops, 0666, LS_SIZE, }, 26645737edd1SMark Nutter { "mbox", &spufs_mbox_fops, 0444, }, 26655737edd1SMark Nutter { "ibox", &spufs_ibox_fops, 0444, }, 26665737edd1SMark Nutter { "wbox", &spufs_wbox_fops, 0222, }, 26676f7dde81SJeremy Kerr { "mbox_stat", &spufs_mbox_stat_fops, 0444, sizeof(u32), }, 26686f7dde81SJeremy Kerr { "ibox_stat", &spufs_ibox_stat_fops, 0444, sizeof(u32), }, 26696f7dde81SJeremy Kerr { "wbox_stat", &spufs_wbox_stat_fops, 0444, sizeof(u32), }, 2670d054b36fSJeremy Kerr { "signal1", &spufs_signal1_nosched_fops, 0222, }, 2671d054b36fSJeremy Kerr { "signal2", &spufs_signal2_nosched_fops, 0222, }, 26725737edd1SMark Nutter { "signal1_type", &spufs_signal1_type, 0666, }, 26735737edd1SMark Nutter { "signal2_type", &spufs_signal2_type, 0666, }, 26745737edd1SMark Nutter { "mss", &spufs_mss_fops, 0666, }, 26755737edd1SMark Nutter { "mfc", &spufs_mfc_fops, 0666, }, 26765737edd1SMark Nutter { "cntl", &spufs_cntl_fops, 0666, }, 26775737edd1SMark Nutter { "npc", &spufs_npc_ops, 0666, }, 26786f7dde81SJeremy Kerr { "psmap", &spufs_psmap_fops, 0666, SPUFS_PS_MAP_SIZE, }, 26795737edd1SMark Nutter { "phys-id", &spufs_id_ops, 0666, }, 26805737edd1SMark Nutter { "object-id", &spufs_object_id_ops, 0666, }, 2681476273adSChristoph Hellwig { "tid", &spufs_tid_fops, 0444, }, 2682e9f8a0b6SChristoph Hellwig { "stat", &spufs_stat_fops, 0444, }, 26832c3e4787SJeremy Kerr {}, 26842c3e4787SJeremy Kerr }; 26852c3e4787SJeremy Kerr 268674254647SJeremy Kerr const struct spufs_tree_descr spufs_dir_debug_contents[] = { 268746deed69SLuke Browning { ".ctx", &spufs_ctx_fops, 0444, }, 26885737edd1SMark Nutter {}, 26895737edd1SMark Nutter }; 2690bf1ab978SDwayne Grant McConnell 269174254647SJeremy Kerr const struct spufs_coredump_reader spufs_coredump_read[] = { 26924fca9c42SMichael Ellerman { "regs", __spufs_regs_read, NULL, sizeof(struct spu_reg128[128])}, 26934fca9c42SMichael Ellerman { "fpcr", __spufs_fpcr_read, NULL, sizeof(struct spu_reg128) }, 2694104f0cc2SMichael Ellerman { "lslr", NULL, spufs_lslr_get, 19 }, 2695104f0cc2SMichael Ellerman { "decr", NULL, spufs_decr_get, 19 }, 2696104f0cc2SMichael Ellerman { "decr_status", NULL, spufs_decr_status_get, 19 }, 26974fca9c42SMichael Ellerman { "mem", __spufs_mem_read, NULL, LS_SIZE, }, 26984fca9c42SMichael Ellerman { "signal1", __spufs_signal1_read, NULL, sizeof(u32) }, 2699104f0cc2SMichael Ellerman { "signal1_type", NULL, spufs_signal1_type_get, 19 }, 27004fca9c42SMichael Ellerman { "signal2", __spufs_signal2_read, NULL, sizeof(u32) }, 2701104f0cc2SMichael Ellerman { "signal2_type", NULL, spufs_signal2_type_get, 19 }, 2702104f0cc2SMichael Ellerman { "event_mask", NULL, spufs_event_mask_get, 19 }, 2703104f0cc2SMichael Ellerman { "event_status", NULL, spufs_event_status_get, 19 }, 27044fca9c42SMichael Ellerman { "mbox_info", __spufs_mbox_info_read, NULL, sizeof(u32) }, 27054fca9c42SMichael Ellerman { "ibox_info", __spufs_ibox_info_read, NULL, sizeof(u32) }, 27064fca9c42SMichael Ellerman { "wbox_info", __spufs_wbox_info_read, NULL, 4 * sizeof(u32)}, 27074fca9c42SMichael Ellerman { "dma_info", __spufs_dma_info_read, NULL, sizeof(struct spu_dma_info)}, 27084fca9c42SMichael Ellerman { "proxydma_info", __spufs_proxydma_info_read, 27094fca9c42SMichael Ellerman NULL, sizeof(struct spu_proxydma_info)}, 2710104f0cc2SMichael Ellerman { "object-id", NULL, spufs_object_id_get, 19 }, 2711104f0cc2SMichael Ellerman { "npc", NULL, spufs_npc_get, 19 }, 2712936d5bf1SMichael Ellerman { NULL }, 2713bf1ab978SDwayne Grant McConnell }; 2714