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 6868b3d6663SArnd Bergmann /* interrupt-level ibox callback function. */ 6878b3d6663SArnd Bergmann void spufs_ibox_callback(struct spu *spu) 6888b3d6663SArnd Bergmann { 6898b3d6663SArnd Bergmann struct spu_context *ctx = spu->ctx; 6908b3d6663SArnd Bergmann 6917d7be3aaSAl Viro if (ctx) 6928b3d6663SArnd Bergmann wake_up_all(&ctx->ibox_wq); 69367207b96SArnd Bergmann } 69467207b96SArnd Bergmann 695cdcc89bbSArnd Bergmann /* 696cdcc89bbSArnd Bergmann * Read as many bytes from the interrupt mailbox as possible, until 697cdcc89bbSArnd Bergmann * one of the conditions becomes true: 698cdcc89bbSArnd Bergmann * 699cdcc89bbSArnd Bergmann * - no more data available in the mailbox 700cdcc89bbSArnd Bergmann * - end of the user provided buffer 701cdcc89bbSArnd Bergmann * - end of the mapped area 702cdcc89bbSArnd Bergmann * 703cdcc89bbSArnd Bergmann * If the file is opened without O_NONBLOCK, we wait here until 704cdcc89bbSArnd Bergmann * any data is available, but return when we have been able to 705cdcc89bbSArnd Bergmann * read something. 706cdcc89bbSArnd Bergmann */ 70767207b96SArnd Bergmann static ssize_t spufs_ibox_read(struct file *file, char __user *buf, 70867207b96SArnd Bergmann size_t len, loff_t *pos) 70967207b96SArnd Bergmann { 7108b3d6663SArnd Bergmann struct spu_context *ctx = file->private_data; 711cdcc89bbSArnd Bergmann u32 ibox_data, __user *udata; 712cdcc89bbSArnd Bergmann ssize_t count; 71367207b96SArnd Bergmann 71467207b96SArnd Bergmann if (len < 4) 71567207b96SArnd Bergmann return -EINVAL; 71667207b96SArnd Bergmann 717cdcc89bbSArnd Bergmann if (!access_ok(VERIFY_WRITE, buf, len)) 718cdcc89bbSArnd Bergmann return -EFAULT; 719cdcc89bbSArnd Bergmann 720cdcc89bbSArnd Bergmann udata = (void __user *)buf; 721cdcc89bbSArnd Bergmann 722c9101bdbSChristoph Hellwig count = spu_acquire(ctx); 723c9101bdbSChristoph Hellwig if (count) 724eebead5bSChristoph Hellwig goto out; 72567207b96SArnd Bergmann 726cdcc89bbSArnd Bergmann /* wait only for the first element */ 727cdcc89bbSArnd Bergmann count = 0; 72867207b96SArnd Bergmann if (file->f_flags & O_NONBLOCK) { 729eebead5bSChristoph Hellwig if (!spu_ibox_read(ctx, &ibox_data)) { 730cdcc89bbSArnd Bergmann count = -EAGAIN; 731eebead5bSChristoph Hellwig goto out_unlock; 732eebead5bSChristoph Hellwig } 73367207b96SArnd Bergmann } else { 734cdcc89bbSArnd Bergmann count = spufs_wait(ctx->ibox_wq, spu_ibox_read(ctx, &ibox_data)); 735cdcc89bbSArnd Bergmann if (count) 736cdcc89bbSArnd Bergmann goto out; 737eebead5bSChristoph Hellwig } 738cdcc89bbSArnd Bergmann 739cdcc89bbSArnd Bergmann /* if we can't write at all, return -EFAULT */ 740cdcc89bbSArnd Bergmann count = __put_user(ibox_data, udata); 741cdcc89bbSArnd Bergmann if (count) 742eebead5bSChristoph Hellwig goto out_unlock; 743cdcc89bbSArnd Bergmann 744cdcc89bbSArnd Bergmann for (count = 4, udata++; (count + 4) <= len; count += 4, udata++) { 745cdcc89bbSArnd Bergmann int ret; 746cdcc89bbSArnd Bergmann ret = ctx->ops->ibox_read(ctx, &ibox_data); 747cdcc89bbSArnd Bergmann if (ret == 0) 748cdcc89bbSArnd Bergmann break; 749cdcc89bbSArnd Bergmann /* 750cdcc89bbSArnd Bergmann * at the end of the mapped area, we can fault 751cdcc89bbSArnd Bergmann * but still need to return the data we have 752cdcc89bbSArnd Bergmann * read successfully so far. 753cdcc89bbSArnd Bergmann */ 754cdcc89bbSArnd Bergmann ret = __put_user(ibox_data, udata); 755cdcc89bbSArnd Bergmann if (ret) 756cdcc89bbSArnd Bergmann break; 75767207b96SArnd Bergmann } 75867207b96SArnd Bergmann 759eebead5bSChristoph Hellwig out_unlock: 7608b3d6663SArnd Bergmann spu_release(ctx); 761eebead5bSChristoph Hellwig out: 762cdcc89bbSArnd Bergmann return count; 76367207b96SArnd Bergmann } 76467207b96SArnd Bergmann 7658153a5eaSAl Viro static __poll_t spufs_ibox_poll(struct file *file, poll_table *wait) 76667207b96SArnd Bergmann { 7678b3d6663SArnd Bergmann struct spu_context *ctx = file->private_data; 7688153a5eaSAl Viro __poll_t mask; 76967207b96SArnd Bergmann 7708b3d6663SArnd Bergmann poll_wait(file, &ctx->ibox_wq, wait); 77167207b96SArnd Bergmann 772c9101bdbSChristoph Hellwig /* 773c9101bdbSChristoph Hellwig * For now keep this uninterruptible and also ignore the rule 774c9101bdbSChristoph Hellwig * that poll should not sleep. Will be fixed later. 775c9101bdbSChristoph Hellwig */ 776c9101bdbSChristoph Hellwig mutex_lock(&ctx->state_mutex); 777a9a08845SLinus Torvalds mask = ctx->ops->mbox_stat_poll(ctx, EPOLLIN | EPOLLRDNORM); 7783a843d7cSArnd Bergmann spu_release(ctx); 77967207b96SArnd Bergmann 78067207b96SArnd Bergmann return mask; 78167207b96SArnd Bergmann } 78267207b96SArnd Bergmann 7835dfe4c96SArjan van de Ven static const struct file_operations spufs_ibox_fops = { 78467207b96SArnd Bergmann .open = spufs_pipe_open, 78567207b96SArnd Bergmann .read = spufs_ibox_read, 78667207b96SArnd Bergmann .poll = spufs_ibox_poll, 787fc15351dSArnd Bergmann .llseek = no_llseek, 78867207b96SArnd Bergmann }; 78967207b96SArnd Bergmann 79067207b96SArnd Bergmann static ssize_t spufs_ibox_stat_read(struct file *file, char __user *buf, 79167207b96SArnd Bergmann size_t len, loff_t *pos) 79267207b96SArnd Bergmann { 7938b3d6663SArnd Bergmann struct spu_context *ctx = file->private_data; 794c9101bdbSChristoph Hellwig ssize_t ret; 79567207b96SArnd Bergmann u32 ibox_stat; 79667207b96SArnd Bergmann 79767207b96SArnd Bergmann if (len < 4) 79867207b96SArnd Bergmann return -EINVAL; 79967207b96SArnd Bergmann 800c9101bdbSChristoph Hellwig ret = spu_acquire(ctx); 801c9101bdbSChristoph Hellwig if (ret) 802c9101bdbSChristoph Hellwig return ret; 8038b3d6663SArnd Bergmann ibox_stat = (ctx->ops->mbox_stat_read(ctx) >> 16) & 0xff; 8048b3d6663SArnd Bergmann spu_release(ctx); 80567207b96SArnd Bergmann 80667207b96SArnd Bergmann if (copy_to_user(buf, &ibox_stat, sizeof ibox_stat)) 80767207b96SArnd Bergmann return -EFAULT; 80867207b96SArnd Bergmann 80967207b96SArnd Bergmann return 4; 81067207b96SArnd Bergmann } 81167207b96SArnd Bergmann 8125dfe4c96SArjan van de Ven static const struct file_operations spufs_ibox_stat_fops = { 81367207b96SArnd Bergmann .open = spufs_pipe_open, 81467207b96SArnd Bergmann .read = spufs_ibox_stat_read, 815fc15351dSArnd Bergmann .llseek = no_llseek, 81667207b96SArnd Bergmann }; 81767207b96SArnd Bergmann 81867207b96SArnd Bergmann /* low-level mailbox write */ 8198b3d6663SArnd Bergmann size_t spu_wbox_write(struct spu_context *ctx, u32 data) 82067207b96SArnd Bergmann { 8218b3d6663SArnd Bergmann return ctx->ops->wbox_write(ctx, data); 82267207b96SArnd Bergmann } 82367207b96SArnd Bergmann 8248b3d6663SArnd Bergmann /* interrupt-level wbox callback function. */ 8258b3d6663SArnd Bergmann void spufs_wbox_callback(struct spu *spu) 8268b3d6663SArnd Bergmann { 8278b3d6663SArnd Bergmann struct spu_context *ctx = spu->ctx; 8288b3d6663SArnd Bergmann 8297d7be3aaSAl Viro if (ctx) 8308b3d6663SArnd Bergmann wake_up_all(&ctx->wbox_wq); 83167207b96SArnd Bergmann } 83267207b96SArnd Bergmann 833cdcc89bbSArnd Bergmann /* 834cdcc89bbSArnd Bergmann * Write as many bytes to the interrupt mailbox as possible, until 835cdcc89bbSArnd Bergmann * one of the conditions becomes true: 836cdcc89bbSArnd Bergmann * 837cdcc89bbSArnd Bergmann * - the mailbox is full 838cdcc89bbSArnd Bergmann * - end of the user provided buffer 839cdcc89bbSArnd Bergmann * - end of the mapped area 840cdcc89bbSArnd Bergmann * 841cdcc89bbSArnd Bergmann * If the file is opened without O_NONBLOCK, we wait here until 842027dfac6SMichael Ellerman * space is available, but return when we have been able to 843cdcc89bbSArnd Bergmann * write something. 844cdcc89bbSArnd Bergmann */ 84567207b96SArnd Bergmann static ssize_t spufs_wbox_write(struct file *file, const char __user *buf, 84667207b96SArnd Bergmann size_t len, loff_t *pos) 84767207b96SArnd Bergmann { 8488b3d6663SArnd Bergmann struct spu_context *ctx = file->private_data; 849cdcc89bbSArnd Bergmann u32 wbox_data, __user *udata; 850cdcc89bbSArnd Bergmann ssize_t count; 85167207b96SArnd Bergmann 85267207b96SArnd Bergmann if (len < 4) 85367207b96SArnd Bergmann return -EINVAL; 85467207b96SArnd Bergmann 855cdcc89bbSArnd Bergmann udata = (void __user *)buf; 856cdcc89bbSArnd Bergmann if (!access_ok(VERIFY_READ, buf, len)) 857cdcc89bbSArnd Bergmann return -EFAULT; 858cdcc89bbSArnd Bergmann 859cdcc89bbSArnd Bergmann if (__get_user(wbox_data, udata)) 86067207b96SArnd Bergmann return -EFAULT; 86167207b96SArnd Bergmann 862c9101bdbSChristoph Hellwig count = spu_acquire(ctx); 863c9101bdbSChristoph Hellwig if (count) 864eebead5bSChristoph Hellwig goto out; 8658b3d6663SArnd Bergmann 866cdcc89bbSArnd Bergmann /* 867cdcc89bbSArnd Bergmann * make sure we can at least write one element, by waiting 868cdcc89bbSArnd Bergmann * in case of !O_NONBLOCK 869cdcc89bbSArnd Bergmann */ 870cdcc89bbSArnd Bergmann count = 0; 87167207b96SArnd Bergmann if (file->f_flags & O_NONBLOCK) { 872eebead5bSChristoph Hellwig if (!spu_wbox_write(ctx, wbox_data)) { 873cdcc89bbSArnd Bergmann count = -EAGAIN; 874eebead5bSChristoph Hellwig goto out_unlock; 875eebead5bSChristoph Hellwig } 87667207b96SArnd Bergmann } else { 877cdcc89bbSArnd Bergmann count = spufs_wait(ctx->wbox_wq, spu_wbox_write(ctx, wbox_data)); 878cdcc89bbSArnd Bergmann if (count) 879cdcc89bbSArnd Bergmann goto out; 880eebead5bSChristoph Hellwig } 881eebead5bSChristoph Hellwig 8828b3d6663SArnd Bergmann 88396de0e25SJan Engelhardt /* write as much as possible */ 884cdcc89bbSArnd Bergmann for (count = 4, udata++; (count + 4) <= len; count += 4, udata++) { 885cdcc89bbSArnd Bergmann int ret; 886cdcc89bbSArnd Bergmann ret = __get_user(wbox_data, udata); 887cdcc89bbSArnd Bergmann if (ret) 888cdcc89bbSArnd Bergmann break; 889cdcc89bbSArnd Bergmann 890cdcc89bbSArnd Bergmann ret = spu_wbox_write(ctx, wbox_data); 891cdcc89bbSArnd Bergmann if (ret == 0) 892cdcc89bbSArnd Bergmann break; 893cdcc89bbSArnd Bergmann } 894cdcc89bbSArnd Bergmann 895eebead5bSChristoph Hellwig out_unlock: 896cdcc89bbSArnd Bergmann spu_release(ctx); 897eebead5bSChristoph Hellwig out: 898cdcc89bbSArnd Bergmann return count; 89967207b96SArnd Bergmann } 90067207b96SArnd Bergmann 9018153a5eaSAl Viro static __poll_t spufs_wbox_poll(struct file *file, poll_table *wait) 90267207b96SArnd Bergmann { 9038b3d6663SArnd Bergmann struct spu_context *ctx = file->private_data; 9048153a5eaSAl Viro __poll_t mask; 90567207b96SArnd Bergmann 9068b3d6663SArnd Bergmann poll_wait(file, &ctx->wbox_wq, wait); 90767207b96SArnd Bergmann 908c9101bdbSChristoph Hellwig /* 909c9101bdbSChristoph Hellwig * For now keep this uninterruptible and also ignore the rule 910c9101bdbSChristoph Hellwig * that poll should not sleep. Will be fixed later. 911c9101bdbSChristoph Hellwig */ 912c9101bdbSChristoph Hellwig mutex_lock(&ctx->state_mutex); 913a9a08845SLinus Torvalds mask = ctx->ops->mbox_stat_poll(ctx, EPOLLOUT | EPOLLWRNORM); 9143a843d7cSArnd Bergmann spu_release(ctx); 91567207b96SArnd Bergmann 91667207b96SArnd Bergmann return mask; 91767207b96SArnd Bergmann } 91867207b96SArnd Bergmann 9195dfe4c96SArjan van de Ven static const struct file_operations spufs_wbox_fops = { 92067207b96SArnd Bergmann .open = spufs_pipe_open, 92167207b96SArnd Bergmann .write = spufs_wbox_write, 92267207b96SArnd Bergmann .poll = spufs_wbox_poll, 923fc15351dSArnd Bergmann .llseek = no_llseek, 92467207b96SArnd Bergmann }; 92567207b96SArnd Bergmann 92667207b96SArnd Bergmann static ssize_t spufs_wbox_stat_read(struct file *file, char __user *buf, 92767207b96SArnd Bergmann size_t len, loff_t *pos) 92867207b96SArnd Bergmann { 9298b3d6663SArnd Bergmann struct spu_context *ctx = file->private_data; 930c9101bdbSChristoph Hellwig ssize_t ret; 93167207b96SArnd Bergmann u32 wbox_stat; 93267207b96SArnd Bergmann 93367207b96SArnd Bergmann if (len < 4) 93467207b96SArnd Bergmann return -EINVAL; 93567207b96SArnd Bergmann 936c9101bdbSChristoph Hellwig ret = spu_acquire(ctx); 937c9101bdbSChristoph Hellwig if (ret) 938c9101bdbSChristoph Hellwig return ret; 9398b3d6663SArnd Bergmann wbox_stat = (ctx->ops->mbox_stat_read(ctx) >> 8) & 0xff; 9408b3d6663SArnd Bergmann spu_release(ctx); 94167207b96SArnd Bergmann 94267207b96SArnd Bergmann if (copy_to_user(buf, &wbox_stat, sizeof wbox_stat)) 94367207b96SArnd Bergmann return -EFAULT; 94467207b96SArnd Bergmann 94567207b96SArnd Bergmann return 4; 94667207b96SArnd Bergmann } 94767207b96SArnd Bergmann 9485dfe4c96SArjan van de Ven static const struct file_operations spufs_wbox_stat_fops = { 94967207b96SArnd Bergmann .open = spufs_pipe_open, 95067207b96SArnd Bergmann .read = spufs_wbox_stat_read, 951fc15351dSArnd Bergmann .llseek = no_llseek, 95267207b96SArnd Bergmann }; 95367207b96SArnd Bergmann 9546df10a82SMark Nutter static int spufs_signal1_open(struct inode *inode, struct file *file) 9556df10a82SMark Nutter { 9566df10a82SMark Nutter struct spufs_inode_info *i = SPUFS_I(inode); 9576df10a82SMark Nutter struct spu_context *ctx = i->i_ctx; 95843c2bbd9SChristoph Hellwig 95947d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 9606df10a82SMark Nutter file->private_data = ctx; 96143c2bbd9SChristoph Hellwig if (!i->i_openers++) 9626df10a82SMark Nutter ctx->signal1 = inode->i_mapping; 96347d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 9646df10a82SMark Nutter return nonseekable_open(inode, file); 9656df10a82SMark Nutter } 9666df10a82SMark Nutter 96743c2bbd9SChristoph Hellwig static int 96843c2bbd9SChristoph Hellwig spufs_signal1_release(struct inode *inode, struct file *file) 96943c2bbd9SChristoph Hellwig { 97043c2bbd9SChristoph Hellwig struct spufs_inode_info *i = SPUFS_I(inode); 97143c2bbd9SChristoph Hellwig struct spu_context *ctx = i->i_ctx; 97243c2bbd9SChristoph Hellwig 97347d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 97443c2bbd9SChristoph Hellwig if (!--i->i_openers) 97543c2bbd9SChristoph Hellwig ctx->signal1 = NULL; 97647d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 97743c2bbd9SChristoph Hellwig return 0; 97843c2bbd9SChristoph Hellwig } 97943c2bbd9SChristoph Hellwig 980bf1ab978SDwayne Grant McConnell static ssize_t __spufs_signal1_read(struct spu_context *ctx, char __user *buf, 98167207b96SArnd Bergmann size_t len, loff_t *pos) 98267207b96SArnd Bergmann { 98317f88cebSDwayne Grant McConnell int ret = 0; 98467207b96SArnd Bergmann u32 data; 98567207b96SArnd Bergmann 98667207b96SArnd Bergmann if (len < 4) 98767207b96SArnd Bergmann return -EINVAL; 98867207b96SArnd Bergmann 98917f88cebSDwayne Grant McConnell if (ctx->csa.spu_chnlcnt_RW[3]) { 99017f88cebSDwayne Grant McConnell data = ctx->csa.spu_chnldata_RW[3]; 99117f88cebSDwayne Grant McConnell ret = 4; 99217f88cebSDwayne Grant McConnell } 9938b3d6663SArnd Bergmann 99417f88cebSDwayne Grant McConnell if (!ret) 99517f88cebSDwayne Grant McConnell goto out; 99617f88cebSDwayne Grant McConnell 99767207b96SArnd Bergmann if (copy_to_user(buf, &data, 4)) 99867207b96SArnd Bergmann return -EFAULT; 99967207b96SArnd Bergmann 100017f88cebSDwayne Grant McConnell out: 100117f88cebSDwayne Grant McConnell return ret; 100267207b96SArnd Bergmann } 100367207b96SArnd Bergmann 1004bf1ab978SDwayne Grant McConnell static ssize_t spufs_signal1_read(struct file *file, char __user *buf, 1005bf1ab978SDwayne Grant McConnell size_t len, loff_t *pos) 1006bf1ab978SDwayne Grant McConnell { 1007bf1ab978SDwayne Grant McConnell int ret; 1008bf1ab978SDwayne Grant McConnell struct spu_context *ctx = file->private_data; 1009bf1ab978SDwayne Grant McConnell 1010c9101bdbSChristoph Hellwig ret = spu_acquire_saved(ctx); 1011c9101bdbSChristoph Hellwig if (ret) 1012c9101bdbSChristoph Hellwig return ret; 1013bf1ab978SDwayne Grant McConnell ret = __spufs_signal1_read(ctx, buf, len, pos); 101427b1ea09SChristoph Hellwig spu_release_saved(ctx); 1015bf1ab978SDwayne Grant McConnell 1016bf1ab978SDwayne Grant McConnell return ret; 1017bf1ab978SDwayne Grant McConnell } 1018bf1ab978SDwayne Grant McConnell 101967207b96SArnd Bergmann static ssize_t spufs_signal1_write(struct file *file, const char __user *buf, 102067207b96SArnd Bergmann size_t len, loff_t *pos) 102167207b96SArnd Bergmann { 102267207b96SArnd Bergmann struct spu_context *ctx; 1023c9101bdbSChristoph Hellwig ssize_t ret; 102467207b96SArnd Bergmann u32 data; 102567207b96SArnd Bergmann 102667207b96SArnd Bergmann ctx = file->private_data; 102767207b96SArnd Bergmann 102867207b96SArnd Bergmann if (len < 4) 102967207b96SArnd Bergmann return -EINVAL; 103067207b96SArnd Bergmann 103167207b96SArnd Bergmann if (copy_from_user(&data, buf, 4)) 103267207b96SArnd Bergmann return -EFAULT; 103367207b96SArnd Bergmann 1034c9101bdbSChristoph Hellwig ret = spu_acquire(ctx); 1035c9101bdbSChristoph Hellwig if (ret) 1036c9101bdbSChristoph Hellwig return ret; 10378b3d6663SArnd Bergmann ctx->ops->signal1_write(ctx, data); 10388b3d6663SArnd Bergmann spu_release(ctx); 103967207b96SArnd Bergmann 104067207b96SArnd Bergmann return 4; 104167207b96SArnd Bergmann } 104267207b96SArnd Bergmann 1043b1e2270fSNick Piggin static int 104411bac800SDave Jiang spufs_signal1_mmap_fault(struct vm_fault *vmf) 10456df10a82SMark Nutter { 104687ff6090SJeremy Kerr #if SPUFS_SIGNAL_MAP_SIZE == 0x1000 104711bac800SDave Jiang return spufs_ps_fault(vmf, 0x14000, SPUFS_SIGNAL_MAP_SIZE); 104887ff6090SJeremy Kerr #elif SPUFS_SIGNAL_MAP_SIZE == 0x10000 104927d5bf2aSBenjamin Herrenschmidt /* For 64k pages, both signal1 and signal2 can be used to mmap the whole 105027d5bf2aSBenjamin Herrenschmidt * signal 1 and 2 area 105127d5bf2aSBenjamin Herrenschmidt */ 105211bac800SDave Jiang return spufs_ps_fault(vmf, 0x10000, SPUFS_SIGNAL_MAP_SIZE); 105327d5bf2aSBenjamin Herrenschmidt #else 105427d5bf2aSBenjamin Herrenschmidt #error unsupported page size 105527d5bf2aSBenjamin Herrenschmidt #endif 10566df10a82SMark Nutter } 10576df10a82SMark Nutter 1058f0f37e2fSAlexey Dobriyan static const struct vm_operations_struct spufs_signal1_mmap_vmops = { 1059b1e2270fSNick Piggin .fault = spufs_signal1_mmap_fault, 10606df10a82SMark Nutter }; 10616df10a82SMark Nutter 10626df10a82SMark Nutter static int spufs_signal1_mmap(struct file *file, struct vm_area_struct *vma) 10636df10a82SMark Nutter { 10646df10a82SMark Nutter if (!(vma->vm_flags & VM_SHARED)) 10656df10a82SMark Nutter return -EINVAL; 10666df10a82SMark Nutter 106778bde53eSBenjamin Herrenschmidt vma->vm_flags |= VM_IO | VM_PFNMAP; 106864b3d0e8SBenjamin Herrenschmidt vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot); 10696df10a82SMark Nutter 10706df10a82SMark Nutter vma->vm_ops = &spufs_signal1_mmap_vmops; 10716df10a82SMark Nutter return 0; 10726df10a82SMark Nutter } 10736df10a82SMark Nutter 10745dfe4c96SArjan van de Ven static const struct file_operations spufs_signal1_fops = { 10756df10a82SMark Nutter .open = spufs_signal1_open, 107643c2bbd9SChristoph Hellwig .release = spufs_signal1_release, 107767207b96SArnd Bergmann .read = spufs_signal1_read, 107867207b96SArnd Bergmann .write = spufs_signal1_write, 10796df10a82SMark Nutter .mmap = spufs_signal1_mmap, 1080fc15351dSArnd Bergmann .llseek = no_llseek, 108167207b96SArnd Bergmann }; 108267207b96SArnd Bergmann 1083d054b36fSJeremy Kerr static const struct file_operations spufs_signal1_nosched_fops = { 1084d054b36fSJeremy Kerr .open = spufs_signal1_open, 1085d054b36fSJeremy Kerr .release = spufs_signal1_release, 1086d054b36fSJeremy Kerr .write = spufs_signal1_write, 1087d054b36fSJeremy Kerr .mmap = spufs_signal1_mmap, 1088fc15351dSArnd Bergmann .llseek = no_llseek, 1089d054b36fSJeremy Kerr }; 1090d054b36fSJeremy Kerr 10916df10a82SMark Nutter static int spufs_signal2_open(struct inode *inode, struct file *file) 10926df10a82SMark Nutter { 10936df10a82SMark Nutter struct spufs_inode_info *i = SPUFS_I(inode); 10946df10a82SMark Nutter struct spu_context *ctx = i->i_ctx; 109543c2bbd9SChristoph Hellwig 109647d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 10976df10a82SMark Nutter file->private_data = ctx; 109843c2bbd9SChristoph Hellwig if (!i->i_openers++) 10996df10a82SMark Nutter ctx->signal2 = inode->i_mapping; 110047d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 11016df10a82SMark Nutter return nonseekable_open(inode, file); 11026df10a82SMark Nutter } 11036df10a82SMark Nutter 110443c2bbd9SChristoph Hellwig static int 110543c2bbd9SChristoph Hellwig spufs_signal2_release(struct inode *inode, struct file *file) 110643c2bbd9SChristoph Hellwig { 110743c2bbd9SChristoph Hellwig struct spufs_inode_info *i = SPUFS_I(inode); 110843c2bbd9SChristoph Hellwig struct spu_context *ctx = i->i_ctx; 110943c2bbd9SChristoph Hellwig 111047d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 111143c2bbd9SChristoph Hellwig if (!--i->i_openers) 111243c2bbd9SChristoph Hellwig ctx->signal2 = NULL; 111347d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 111443c2bbd9SChristoph Hellwig return 0; 111543c2bbd9SChristoph Hellwig } 111643c2bbd9SChristoph Hellwig 1117bf1ab978SDwayne Grant McConnell static ssize_t __spufs_signal2_read(struct spu_context *ctx, char __user *buf, 111867207b96SArnd Bergmann size_t len, loff_t *pos) 111967207b96SArnd Bergmann { 112017f88cebSDwayne Grant McConnell int ret = 0; 112167207b96SArnd Bergmann u32 data; 112267207b96SArnd Bergmann 112367207b96SArnd Bergmann if (len < 4) 112467207b96SArnd Bergmann return -EINVAL; 112567207b96SArnd Bergmann 112617f88cebSDwayne Grant McConnell if (ctx->csa.spu_chnlcnt_RW[4]) { 112717f88cebSDwayne Grant McConnell data = ctx->csa.spu_chnldata_RW[4]; 112817f88cebSDwayne Grant McConnell ret = 4; 112917f88cebSDwayne Grant McConnell } 11308b3d6663SArnd Bergmann 113117f88cebSDwayne Grant McConnell if (!ret) 113217f88cebSDwayne Grant McConnell goto out; 113317f88cebSDwayne Grant McConnell 113467207b96SArnd Bergmann if (copy_to_user(buf, &data, 4)) 113567207b96SArnd Bergmann return -EFAULT; 113667207b96SArnd Bergmann 113717f88cebSDwayne Grant McConnell out: 1138bf1ab978SDwayne Grant McConnell return ret; 1139bf1ab978SDwayne Grant McConnell } 1140bf1ab978SDwayne Grant McConnell 1141bf1ab978SDwayne Grant McConnell static ssize_t spufs_signal2_read(struct file *file, char __user *buf, 1142bf1ab978SDwayne Grant McConnell size_t len, loff_t *pos) 1143bf1ab978SDwayne Grant McConnell { 1144bf1ab978SDwayne Grant McConnell struct spu_context *ctx = file->private_data; 1145bf1ab978SDwayne Grant McConnell int ret; 1146bf1ab978SDwayne Grant McConnell 1147c9101bdbSChristoph Hellwig ret = spu_acquire_saved(ctx); 1148c9101bdbSChristoph Hellwig if (ret) 1149c9101bdbSChristoph Hellwig return ret; 1150bf1ab978SDwayne Grant McConnell ret = __spufs_signal2_read(ctx, buf, len, pos); 115127b1ea09SChristoph Hellwig spu_release_saved(ctx); 1152bf1ab978SDwayne Grant McConnell 1153bf1ab978SDwayne Grant McConnell return ret; 115467207b96SArnd Bergmann } 115567207b96SArnd Bergmann 115667207b96SArnd Bergmann static ssize_t spufs_signal2_write(struct file *file, const char __user *buf, 115767207b96SArnd Bergmann size_t len, loff_t *pos) 115867207b96SArnd Bergmann { 115967207b96SArnd Bergmann struct spu_context *ctx; 1160c9101bdbSChristoph Hellwig ssize_t ret; 116167207b96SArnd Bergmann u32 data; 116267207b96SArnd Bergmann 116367207b96SArnd Bergmann ctx = file->private_data; 116467207b96SArnd Bergmann 116567207b96SArnd Bergmann if (len < 4) 116667207b96SArnd Bergmann return -EINVAL; 116767207b96SArnd Bergmann 116867207b96SArnd Bergmann if (copy_from_user(&data, buf, 4)) 116967207b96SArnd Bergmann return -EFAULT; 117067207b96SArnd Bergmann 1171c9101bdbSChristoph Hellwig ret = spu_acquire(ctx); 1172c9101bdbSChristoph Hellwig if (ret) 1173c9101bdbSChristoph Hellwig return ret; 11748b3d6663SArnd Bergmann ctx->ops->signal2_write(ctx, data); 11758b3d6663SArnd Bergmann spu_release(ctx); 117667207b96SArnd Bergmann 117767207b96SArnd Bergmann return 4; 117867207b96SArnd Bergmann } 117967207b96SArnd Bergmann 118027d5bf2aSBenjamin Herrenschmidt #if SPUFS_MMAP_4K 1181b1e2270fSNick Piggin static int 118211bac800SDave Jiang spufs_signal2_mmap_fault(struct vm_fault *vmf) 11836df10a82SMark Nutter { 118487ff6090SJeremy Kerr #if SPUFS_SIGNAL_MAP_SIZE == 0x1000 118511bac800SDave Jiang return spufs_ps_fault(vmf, 0x1c000, SPUFS_SIGNAL_MAP_SIZE); 118687ff6090SJeremy Kerr #elif SPUFS_SIGNAL_MAP_SIZE == 0x10000 118727d5bf2aSBenjamin Herrenschmidt /* For 64k pages, both signal1 and signal2 can be used to mmap the whole 118827d5bf2aSBenjamin Herrenschmidt * signal 1 and 2 area 118927d5bf2aSBenjamin Herrenschmidt */ 119011bac800SDave Jiang return spufs_ps_fault(vmf, 0x10000, SPUFS_SIGNAL_MAP_SIZE); 119127d5bf2aSBenjamin Herrenschmidt #else 119227d5bf2aSBenjamin Herrenschmidt #error unsupported page size 119327d5bf2aSBenjamin Herrenschmidt #endif 11946df10a82SMark Nutter } 11956df10a82SMark Nutter 1196f0f37e2fSAlexey Dobriyan static const struct vm_operations_struct spufs_signal2_mmap_vmops = { 1197b1e2270fSNick Piggin .fault = spufs_signal2_mmap_fault, 11986df10a82SMark Nutter }; 11996df10a82SMark Nutter 12006df10a82SMark Nutter static int spufs_signal2_mmap(struct file *file, struct vm_area_struct *vma) 12016df10a82SMark Nutter { 12026df10a82SMark Nutter if (!(vma->vm_flags & VM_SHARED)) 12036df10a82SMark Nutter return -EINVAL; 12046df10a82SMark Nutter 120578bde53eSBenjamin Herrenschmidt vma->vm_flags |= VM_IO | VM_PFNMAP; 120664b3d0e8SBenjamin Herrenschmidt vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot); 12076df10a82SMark Nutter 12086df10a82SMark Nutter vma->vm_ops = &spufs_signal2_mmap_vmops; 12096df10a82SMark Nutter return 0; 12106df10a82SMark Nutter } 121127d5bf2aSBenjamin Herrenschmidt #else /* SPUFS_MMAP_4K */ 121227d5bf2aSBenjamin Herrenschmidt #define spufs_signal2_mmap NULL 121327d5bf2aSBenjamin Herrenschmidt #endif /* !SPUFS_MMAP_4K */ 12146df10a82SMark Nutter 12155dfe4c96SArjan van de Ven static const struct file_operations spufs_signal2_fops = { 12166df10a82SMark Nutter .open = spufs_signal2_open, 121743c2bbd9SChristoph Hellwig .release = spufs_signal2_release, 121867207b96SArnd Bergmann .read = spufs_signal2_read, 121967207b96SArnd Bergmann .write = spufs_signal2_write, 12206df10a82SMark Nutter .mmap = spufs_signal2_mmap, 1221fc15351dSArnd Bergmann .llseek = no_llseek, 122267207b96SArnd Bergmann }; 122367207b96SArnd Bergmann 1224d054b36fSJeremy Kerr static const struct file_operations spufs_signal2_nosched_fops = { 1225d054b36fSJeremy Kerr .open = spufs_signal2_open, 1226d054b36fSJeremy Kerr .release = spufs_signal2_release, 1227d054b36fSJeremy Kerr .write = spufs_signal2_write, 1228d054b36fSJeremy Kerr .mmap = spufs_signal2_mmap, 1229fc15351dSArnd Bergmann .llseek = no_llseek, 1230d054b36fSJeremy Kerr }; 1231d054b36fSJeremy Kerr 1232104f0cc2SMichael Ellerman /* 1233104f0cc2SMichael Ellerman * This is a wrapper around DEFINE_SIMPLE_ATTRIBUTE which does the 1234104f0cc2SMichael Ellerman * work of acquiring (or not) the SPU context before calling through 1235104f0cc2SMichael Ellerman * to the actual get routine. The set routine is called directly. 1236104f0cc2SMichael Ellerman */ 1237104f0cc2SMichael Ellerman #define SPU_ATTR_NOACQUIRE 0 1238104f0cc2SMichael Ellerman #define SPU_ATTR_ACQUIRE 1 1239104f0cc2SMichael Ellerman #define SPU_ATTR_ACQUIRE_SAVED 2 1240104f0cc2SMichael Ellerman 1241104f0cc2SMichael Ellerman #define DEFINE_SPUFS_ATTRIBUTE(__name, __get, __set, __fmt, __acquire) \ 1242197b1a82SChristoph Hellwig static int __##__get(void *data, u64 *val) \ 1243104f0cc2SMichael Ellerman { \ 1244104f0cc2SMichael Ellerman struct spu_context *ctx = data; \ 1245c9101bdbSChristoph Hellwig int ret = 0; \ 1246104f0cc2SMichael Ellerman \ 1247104f0cc2SMichael Ellerman if (__acquire == SPU_ATTR_ACQUIRE) { \ 1248c9101bdbSChristoph Hellwig ret = spu_acquire(ctx); \ 1249c9101bdbSChristoph Hellwig if (ret) \ 1250c9101bdbSChristoph Hellwig return ret; \ 1251197b1a82SChristoph Hellwig *val = __get(ctx); \ 1252104f0cc2SMichael Ellerman spu_release(ctx); \ 1253104f0cc2SMichael Ellerman } else if (__acquire == SPU_ATTR_ACQUIRE_SAVED) { \ 1254c9101bdbSChristoph Hellwig ret = spu_acquire_saved(ctx); \ 1255c9101bdbSChristoph Hellwig if (ret) \ 1256c9101bdbSChristoph Hellwig return ret; \ 1257197b1a82SChristoph Hellwig *val = __get(ctx); \ 1258104f0cc2SMichael Ellerman spu_release_saved(ctx); \ 1259104f0cc2SMichael Ellerman } else \ 1260197b1a82SChristoph Hellwig *val = __get(ctx); \ 1261104f0cc2SMichael Ellerman \ 1262197b1a82SChristoph Hellwig return 0; \ 1263104f0cc2SMichael Ellerman } \ 1264197b1a82SChristoph Hellwig DEFINE_SPUFS_SIMPLE_ATTRIBUTE(__name, __##__get, __set, __fmt); 1265104f0cc2SMichael Ellerman 1266197b1a82SChristoph Hellwig static int spufs_signal1_type_set(void *data, u64 val) 126767207b96SArnd Bergmann { 126867207b96SArnd Bergmann struct spu_context *ctx = data; 1269c9101bdbSChristoph Hellwig int ret; 127067207b96SArnd Bergmann 1271c9101bdbSChristoph Hellwig ret = spu_acquire(ctx); 1272c9101bdbSChristoph Hellwig if (ret) 1273c9101bdbSChristoph Hellwig return ret; 12748b3d6663SArnd Bergmann ctx->ops->signal1_type_set(ctx, val); 12758b3d6663SArnd Bergmann spu_release(ctx); 1276197b1a82SChristoph Hellwig 1277197b1a82SChristoph Hellwig return 0; 127867207b96SArnd Bergmann } 127967207b96SArnd Bergmann 1280104f0cc2SMichael Ellerman static u64 spufs_signal1_type_get(struct spu_context *ctx) 1281bf1ab978SDwayne Grant McConnell { 1282bf1ab978SDwayne Grant McConnell return ctx->ops->signal1_type_get(ctx); 1283bf1ab978SDwayne Grant McConnell } 1284104f0cc2SMichael Ellerman DEFINE_SPUFS_ATTRIBUTE(spufs_signal1_type, spufs_signal1_type_get, 1285af8b44e0SJeremy Kerr spufs_signal1_type_set, "%llu\n", SPU_ATTR_ACQUIRE); 1286bf1ab978SDwayne Grant McConnell 128767207b96SArnd Bergmann 1288197b1a82SChristoph Hellwig static int spufs_signal2_type_set(void *data, u64 val) 128967207b96SArnd Bergmann { 129067207b96SArnd Bergmann struct spu_context *ctx = data; 1291c9101bdbSChristoph Hellwig int ret; 129267207b96SArnd Bergmann 1293c9101bdbSChristoph Hellwig ret = spu_acquire(ctx); 1294c9101bdbSChristoph Hellwig if (ret) 1295c9101bdbSChristoph Hellwig return ret; 12968b3d6663SArnd Bergmann ctx->ops->signal2_type_set(ctx, val); 12978b3d6663SArnd Bergmann spu_release(ctx); 1298197b1a82SChristoph Hellwig 1299197b1a82SChristoph Hellwig return 0; 130067207b96SArnd Bergmann } 130167207b96SArnd Bergmann 1302104f0cc2SMichael Ellerman static u64 spufs_signal2_type_get(struct spu_context *ctx) 1303bf1ab978SDwayne Grant McConnell { 1304bf1ab978SDwayne Grant McConnell return ctx->ops->signal2_type_get(ctx); 1305bf1ab978SDwayne Grant McConnell } 1306104f0cc2SMichael Ellerman DEFINE_SPUFS_ATTRIBUTE(spufs_signal2_type, spufs_signal2_type_get, 1307af8b44e0SJeremy Kerr spufs_signal2_type_set, "%llu\n", SPU_ATTR_ACQUIRE); 130867207b96SArnd Bergmann 130927d5bf2aSBenjamin Herrenschmidt #if SPUFS_MMAP_4K 1310b1e2270fSNick Piggin static int 131111bac800SDave Jiang spufs_mss_mmap_fault(struct vm_fault *vmf) 1312d9379c4bSarnd@arndb.de { 131311bac800SDave Jiang return spufs_ps_fault(vmf, 0x0000, SPUFS_MSS_MAP_SIZE); 1314d9379c4bSarnd@arndb.de } 1315d9379c4bSarnd@arndb.de 1316f0f37e2fSAlexey Dobriyan static const struct vm_operations_struct spufs_mss_mmap_vmops = { 1317b1e2270fSNick Piggin .fault = spufs_mss_mmap_fault, 1318d9379c4bSarnd@arndb.de }; 1319d9379c4bSarnd@arndb.de 1320d9379c4bSarnd@arndb.de /* 1321d9379c4bSarnd@arndb.de * mmap support for problem state MFC DMA area [0x0000 - 0x0fff]. 1322d9379c4bSarnd@arndb.de */ 1323d9379c4bSarnd@arndb.de static int spufs_mss_mmap(struct file *file, struct vm_area_struct *vma) 1324d9379c4bSarnd@arndb.de { 1325d9379c4bSarnd@arndb.de if (!(vma->vm_flags & VM_SHARED)) 1326d9379c4bSarnd@arndb.de return -EINVAL; 1327d9379c4bSarnd@arndb.de 132878bde53eSBenjamin Herrenschmidt vma->vm_flags |= VM_IO | VM_PFNMAP; 132964b3d0e8SBenjamin Herrenschmidt vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot); 1330d9379c4bSarnd@arndb.de 1331d9379c4bSarnd@arndb.de vma->vm_ops = &spufs_mss_mmap_vmops; 1332d9379c4bSarnd@arndb.de return 0; 1333d9379c4bSarnd@arndb.de } 133427d5bf2aSBenjamin Herrenschmidt #else /* SPUFS_MMAP_4K */ 133527d5bf2aSBenjamin Herrenschmidt #define spufs_mss_mmap NULL 133627d5bf2aSBenjamin Herrenschmidt #endif /* !SPUFS_MMAP_4K */ 1337d9379c4bSarnd@arndb.de 1338d9379c4bSarnd@arndb.de static int spufs_mss_open(struct inode *inode, struct file *file) 1339d9379c4bSarnd@arndb.de { 1340d9379c4bSarnd@arndb.de struct spufs_inode_info *i = SPUFS_I(inode); 134117e0e270SBenjamin Herrenschmidt struct spu_context *ctx = i->i_ctx; 1342d9379c4bSarnd@arndb.de 1343d9379c4bSarnd@arndb.de file->private_data = i->i_ctx; 134443c2bbd9SChristoph Hellwig 134547d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 134643c2bbd9SChristoph Hellwig if (!i->i_openers++) 134717e0e270SBenjamin Herrenschmidt ctx->mss = inode->i_mapping; 134847d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 1349d9379c4bSarnd@arndb.de return nonseekable_open(inode, file); 1350d9379c4bSarnd@arndb.de } 1351d9379c4bSarnd@arndb.de 135243c2bbd9SChristoph Hellwig static int 135343c2bbd9SChristoph Hellwig spufs_mss_release(struct inode *inode, struct file *file) 135443c2bbd9SChristoph Hellwig { 135543c2bbd9SChristoph Hellwig struct spufs_inode_info *i = SPUFS_I(inode); 135643c2bbd9SChristoph Hellwig struct spu_context *ctx = i->i_ctx; 135743c2bbd9SChristoph Hellwig 135847d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 135943c2bbd9SChristoph Hellwig if (!--i->i_openers) 136043c2bbd9SChristoph Hellwig ctx->mss = NULL; 136147d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 136243c2bbd9SChristoph Hellwig return 0; 136343c2bbd9SChristoph Hellwig } 136443c2bbd9SChristoph Hellwig 13655dfe4c96SArjan van de Ven static const struct file_operations spufs_mss_fops = { 1366d9379c4bSarnd@arndb.de .open = spufs_mss_open, 136743c2bbd9SChristoph Hellwig .release = spufs_mss_release, 1368d9379c4bSarnd@arndb.de .mmap = spufs_mss_mmap, 1369fc15351dSArnd Bergmann .llseek = no_llseek, 137027d5bf2aSBenjamin Herrenschmidt }; 137127d5bf2aSBenjamin Herrenschmidt 1372b1e2270fSNick Piggin static int 137311bac800SDave Jiang spufs_psmap_mmap_fault(struct vm_fault *vmf) 137427d5bf2aSBenjamin Herrenschmidt { 137511bac800SDave Jiang return spufs_ps_fault(vmf, 0x0000, SPUFS_PS_MAP_SIZE); 137627d5bf2aSBenjamin Herrenschmidt } 137727d5bf2aSBenjamin Herrenschmidt 1378f0f37e2fSAlexey Dobriyan static const struct vm_operations_struct spufs_psmap_mmap_vmops = { 1379b1e2270fSNick Piggin .fault = spufs_psmap_mmap_fault, 138027d5bf2aSBenjamin Herrenschmidt }; 138127d5bf2aSBenjamin Herrenschmidt 138227d5bf2aSBenjamin Herrenschmidt /* 138327d5bf2aSBenjamin Herrenschmidt * mmap support for full problem state area [0x00000 - 0x1ffff]. 138427d5bf2aSBenjamin Herrenschmidt */ 138527d5bf2aSBenjamin Herrenschmidt static int spufs_psmap_mmap(struct file *file, struct vm_area_struct *vma) 138627d5bf2aSBenjamin Herrenschmidt { 138727d5bf2aSBenjamin Herrenschmidt if (!(vma->vm_flags & VM_SHARED)) 138827d5bf2aSBenjamin Herrenschmidt return -EINVAL; 138927d5bf2aSBenjamin Herrenschmidt 139078bde53eSBenjamin Herrenschmidt vma->vm_flags |= VM_IO | VM_PFNMAP; 139164b3d0e8SBenjamin Herrenschmidt vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot); 139227d5bf2aSBenjamin Herrenschmidt 139327d5bf2aSBenjamin Herrenschmidt vma->vm_ops = &spufs_psmap_mmap_vmops; 139427d5bf2aSBenjamin Herrenschmidt return 0; 139527d5bf2aSBenjamin Herrenschmidt } 139627d5bf2aSBenjamin Herrenschmidt 139727d5bf2aSBenjamin Herrenschmidt static int spufs_psmap_open(struct inode *inode, struct file *file) 139827d5bf2aSBenjamin Herrenschmidt { 139927d5bf2aSBenjamin Herrenschmidt struct spufs_inode_info *i = SPUFS_I(inode); 140017e0e270SBenjamin Herrenschmidt struct spu_context *ctx = i->i_ctx; 140127d5bf2aSBenjamin Herrenschmidt 140247d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 140327d5bf2aSBenjamin Herrenschmidt file->private_data = i->i_ctx; 140443c2bbd9SChristoph Hellwig if (!i->i_openers++) 140517e0e270SBenjamin Herrenschmidt ctx->psmap = inode->i_mapping; 140647d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 140727d5bf2aSBenjamin Herrenschmidt return nonseekable_open(inode, file); 140827d5bf2aSBenjamin Herrenschmidt } 140927d5bf2aSBenjamin Herrenschmidt 141043c2bbd9SChristoph Hellwig static int 141143c2bbd9SChristoph Hellwig spufs_psmap_release(struct inode *inode, struct file *file) 141243c2bbd9SChristoph Hellwig { 141343c2bbd9SChristoph Hellwig struct spufs_inode_info *i = SPUFS_I(inode); 141443c2bbd9SChristoph Hellwig struct spu_context *ctx = i->i_ctx; 141543c2bbd9SChristoph Hellwig 141647d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 141743c2bbd9SChristoph Hellwig if (!--i->i_openers) 141843c2bbd9SChristoph Hellwig ctx->psmap = NULL; 141947d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 142043c2bbd9SChristoph Hellwig return 0; 142143c2bbd9SChristoph Hellwig } 142243c2bbd9SChristoph Hellwig 14235dfe4c96SArjan van de Ven static const struct file_operations spufs_psmap_fops = { 142427d5bf2aSBenjamin Herrenschmidt .open = spufs_psmap_open, 142543c2bbd9SChristoph Hellwig .release = spufs_psmap_release, 142627d5bf2aSBenjamin Herrenschmidt .mmap = spufs_psmap_mmap, 1427fc15351dSArnd Bergmann .llseek = no_llseek, 1428d9379c4bSarnd@arndb.de }; 1429d9379c4bSarnd@arndb.de 1430d9379c4bSarnd@arndb.de 143127d5bf2aSBenjamin Herrenschmidt #if SPUFS_MMAP_4K 1432b1e2270fSNick Piggin static int 143311bac800SDave Jiang spufs_mfc_mmap_fault(struct vm_fault *vmf) 14346df10a82SMark Nutter { 143511bac800SDave Jiang return spufs_ps_fault(vmf, 0x3000, SPUFS_MFC_MAP_SIZE); 14366df10a82SMark Nutter } 14376df10a82SMark Nutter 1438f0f37e2fSAlexey Dobriyan static const struct vm_operations_struct spufs_mfc_mmap_vmops = { 1439b1e2270fSNick Piggin .fault = spufs_mfc_mmap_fault, 14406df10a82SMark Nutter }; 14416df10a82SMark Nutter 14426df10a82SMark Nutter /* 14436df10a82SMark Nutter * mmap support for problem state MFC DMA area [0x0000 - 0x0fff]. 14446df10a82SMark Nutter */ 14456df10a82SMark Nutter static int spufs_mfc_mmap(struct file *file, struct vm_area_struct *vma) 14466df10a82SMark Nutter { 14476df10a82SMark Nutter if (!(vma->vm_flags & VM_SHARED)) 14486df10a82SMark Nutter return -EINVAL; 14496df10a82SMark Nutter 145078bde53eSBenjamin Herrenschmidt vma->vm_flags |= VM_IO | VM_PFNMAP; 145164b3d0e8SBenjamin Herrenschmidt vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot); 14526df10a82SMark Nutter 14536df10a82SMark Nutter vma->vm_ops = &spufs_mfc_mmap_vmops; 14546df10a82SMark Nutter return 0; 14556df10a82SMark Nutter } 145627d5bf2aSBenjamin Herrenschmidt #else /* SPUFS_MMAP_4K */ 145727d5bf2aSBenjamin Herrenschmidt #define spufs_mfc_mmap NULL 145827d5bf2aSBenjamin Herrenschmidt #endif /* !SPUFS_MMAP_4K */ 1459a33a7d73SArnd Bergmann 1460a33a7d73SArnd Bergmann static int spufs_mfc_open(struct inode *inode, struct file *file) 1461a33a7d73SArnd Bergmann { 1462a33a7d73SArnd Bergmann struct spufs_inode_info *i = SPUFS_I(inode); 1463a33a7d73SArnd Bergmann struct spu_context *ctx = i->i_ctx; 1464a33a7d73SArnd Bergmann 1465a33a7d73SArnd Bergmann /* we don't want to deal with DMA into other processes */ 1466a33a7d73SArnd Bergmann if (ctx->owner != current->mm) 1467a33a7d73SArnd Bergmann return -EINVAL; 1468a33a7d73SArnd Bergmann 1469a33a7d73SArnd Bergmann if (atomic_read(&inode->i_count) != 1) 1470a33a7d73SArnd Bergmann return -EBUSY; 1471a33a7d73SArnd Bergmann 147247d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 1473a33a7d73SArnd Bergmann file->private_data = ctx; 147443c2bbd9SChristoph Hellwig if (!i->i_openers++) 147517e0e270SBenjamin Herrenschmidt ctx->mfc = inode->i_mapping; 147647d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 1477a33a7d73SArnd Bergmann return nonseekable_open(inode, file); 1478a33a7d73SArnd Bergmann } 1479a33a7d73SArnd Bergmann 148043c2bbd9SChristoph Hellwig static int 148143c2bbd9SChristoph Hellwig spufs_mfc_release(struct inode *inode, struct file *file) 148243c2bbd9SChristoph Hellwig { 148343c2bbd9SChristoph Hellwig struct spufs_inode_info *i = SPUFS_I(inode); 148443c2bbd9SChristoph Hellwig struct spu_context *ctx = i->i_ctx; 148543c2bbd9SChristoph Hellwig 148647d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 148743c2bbd9SChristoph Hellwig if (!--i->i_openers) 148843c2bbd9SChristoph Hellwig ctx->mfc = NULL; 148947d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 149043c2bbd9SChristoph Hellwig return 0; 149143c2bbd9SChristoph Hellwig } 149243c2bbd9SChristoph Hellwig 1493a33a7d73SArnd Bergmann /* interrupt-level mfc callback function. */ 1494a33a7d73SArnd Bergmann void spufs_mfc_callback(struct spu *spu) 1495a33a7d73SArnd Bergmann { 1496a33a7d73SArnd Bergmann struct spu_context *ctx = spu->ctx; 1497a33a7d73SArnd Bergmann 14987d7be3aaSAl Viro if (ctx) 1499a33a7d73SArnd Bergmann wake_up_all(&ctx->mfc_wq); 1500a33a7d73SArnd Bergmann } 1501a33a7d73SArnd Bergmann 1502a33a7d73SArnd Bergmann static int spufs_read_mfc_tagstatus(struct spu_context *ctx, u32 *status) 1503a33a7d73SArnd Bergmann { 1504a33a7d73SArnd Bergmann /* See if there is one tag group is complete */ 1505a33a7d73SArnd Bergmann /* FIXME we need locking around tagwait */ 1506a33a7d73SArnd Bergmann *status = ctx->ops->read_mfc_tagstatus(ctx) & ctx->tagwait; 1507a33a7d73SArnd Bergmann ctx->tagwait &= ~*status; 1508a33a7d73SArnd Bergmann if (*status) 1509a33a7d73SArnd Bergmann return 1; 1510a33a7d73SArnd Bergmann 1511a33a7d73SArnd Bergmann /* enable interrupt waiting for any tag group, 1512a33a7d73SArnd Bergmann may silently fail if interrupts are already enabled */ 1513a33a7d73SArnd Bergmann ctx->ops->set_mfc_query(ctx, ctx->tagwait, 1); 1514a33a7d73SArnd Bergmann return 0; 1515a33a7d73SArnd Bergmann } 1516a33a7d73SArnd Bergmann 1517a33a7d73SArnd Bergmann static ssize_t spufs_mfc_read(struct file *file, char __user *buffer, 1518a33a7d73SArnd Bergmann size_t size, loff_t *pos) 1519a33a7d73SArnd Bergmann { 1520a33a7d73SArnd Bergmann struct spu_context *ctx = file->private_data; 1521a33a7d73SArnd Bergmann int ret = -EINVAL; 1522a33a7d73SArnd Bergmann u32 status; 1523a33a7d73SArnd Bergmann 1524a33a7d73SArnd Bergmann if (size != 4) 1525a33a7d73SArnd Bergmann goto out; 1526a33a7d73SArnd Bergmann 1527c9101bdbSChristoph Hellwig ret = spu_acquire(ctx); 1528c9101bdbSChristoph Hellwig if (ret) 1529c9101bdbSChristoph Hellwig return ret; 1530c9101bdbSChristoph Hellwig 1531c9101bdbSChristoph Hellwig ret = -EINVAL; 1532a33a7d73SArnd Bergmann if (file->f_flags & O_NONBLOCK) { 1533a33a7d73SArnd Bergmann status = ctx->ops->read_mfc_tagstatus(ctx); 1534a33a7d73SArnd Bergmann if (!(status & ctx->tagwait)) 1535a33a7d73SArnd Bergmann ret = -EAGAIN; 1536a33a7d73SArnd Bergmann else 1537c9101bdbSChristoph Hellwig /* XXX(hch): shouldn't we clear ret here? */ 1538a33a7d73SArnd Bergmann ctx->tagwait &= ~status; 1539a33a7d73SArnd Bergmann } else { 1540a33a7d73SArnd Bergmann ret = spufs_wait(ctx->mfc_wq, 1541a33a7d73SArnd Bergmann spufs_read_mfc_tagstatus(ctx, &status)); 1542a33a7d73SArnd Bergmann if (ret) 1543a33a7d73SArnd Bergmann goto out; 1544eebead5bSChristoph Hellwig } 1545eebead5bSChristoph Hellwig spu_release(ctx); 1546a33a7d73SArnd Bergmann 1547a33a7d73SArnd Bergmann ret = 4; 1548a33a7d73SArnd Bergmann if (copy_to_user(buffer, &status, 4)) 1549a33a7d73SArnd Bergmann ret = -EFAULT; 1550a33a7d73SArnd Bergmann 1551a33a7d73SArnd Bergmann out: 1552a33a7d73SArnd Bergmann return ret; 1553a33a7d73SArnd Bergmann } 1554a33a7d73SArnd Bergmann 1555a33a7d73SArnd Bergmann static int spufs_check_valid_dma(struct mfc_dma_command *cmd) 1556a33a7d73SArnd Bergmann { 15579477e455SStephen Rothwell pr_debug("queueing DMA %x %llx %x %x %x\n", cmd->lsa, 1558a33a7d73SArnd Bergmann cmd->ea, cmd->size, cmd->tag, cmd->cmd); 1559a33a7d73SArnd Bergmann 1560a33a7d73SArnd Bergmann switch (cmd->cmd) { 1561a33a7d73SArnd Bergmann case MFC_PUT_CMD: 1562a33a7d73SArnd Bergmann case MFC_PUTF_CMD: 1563a33a7d73SArnd Bergmann case MFC_PUTB_CMD: 1564a33a7d73SArnd Bergmann case MFC_GET_CMD: 1565a33a7d73SArnd Bergmann case MFC_GETF_CMD: 1566a33a7d73SArnd Bergmann case MFC_GETB_CMD: 1567a33a7d73SArnd Bergmann break; 1568a33a7d73SArnd Bergmann default: 1569a33a7d73SArnd Bergmann pr_debug("invalid DMA opcode %x\n", cmd->cmd); 1570a33a7d73SArnd Bergmann return -EIO; 1571a33a7d73SArnd Bergmann } 1572a33a7d73SArnd Bergmann 1573a33a7d73SArnd Bergmann if ((cmd->lsa & 0xf) != (cmd->ea &0xf)) { 15749477e455SStephen Rothwell pr_debug("invalid DMA alignment, ea %llx lsa %x\n", 1575a33a7d73SArnd Bergmann cmd->ea, cmd->lsa); 1576a33a7d73SArnd Bergmann return -EIO; 1577a33a7d73SArnd Bergmann } 1578a33a7d73SArnd Bergmann 1579a33a7d73SArnd Bergmann switch (cmd->size & 0xf) { 1580a33a7d73SArnd Bergmann case 1: 1581a33a7d73SArnd Bergmann break; 1582a33a7d73SArnd Bergmann case 2: 1583a33a7d73SArnd Bergmann if (cmd->lsa & 1) 1584a33a7d73SArnd Bergmann goto error; 1585a33a7d73SArnd Bergmann break; 1586a33a7d73SArnd Bergmann case 4: 1587a33a7d73SArnd Bergmann if (cmd->lsa & 3) 1588a33a7d73SArnd Bergmann goto error; 1589a33a7d73SArnd Bergmann break; 1590a33a7d73SArnd Bergmann case 8: 1591a33a7d73SArnd Bergmann if (cmd->lsa & 7) 1592a33a7d73SArnd Bergmann goto error; 1593a33a7d73SArnd Bergmann break; 1594a33a7d73SArnd Bergmann case 0: 1595a33a7d73SArnd Bergmann if (cmd->lsa & 15) 1596a33a7d73SArnd Bergmann goto error; 1597a33a7d73SArnd Bergmann break; 1598a33a7d73SArnd Bergmann error: 1599a33a7d73SArnd Bergmann default: 1600a33a7d73SArnd Bergmann pr_debug("invalid DMA alignment %x for size %x\n", 1601a33a7d73SArnd Bergmann cmd->lsa & 0xf, cmd->size); 1602a33a7d73SArnd Bergmann return -EIO; 1603a33a7d73SArnd Bergmann } 1604a33a7d73SArnd Bergmann 1605a33a7d73SArnd Bergmann if (cmd->size > 16 * 1024) { 1606a33a7d73SArnd Bergmann pr_debug("invalid DMA size %x\n", cmd->size); 1607a33a7d73SArnd Bergmann return -EIO; 1608a33a7d73SArnd Bergmann } 1609a33a7d73SArnd Bergmann 1610a33a7d73SArnd Bergmann if (cmd->tag & 0xfff0) { 1611a33a7d73SArnd Bergmann /* we reserve the higher tag numbers for kernel use */ 1612a33a7d73SArnd Bergmann pr_debug("invalid DMA tag\n"); 1613a33a7d73SArnd Bergmann return -EIO; 1614a33a7d73SArnd Bergmann } 1615a33a7d73SArnd Bergmann 1616a33a7d73SArnd Bergmann if (cmd->class) { 1617a33a7d73SArnd Bergmann /* not supported in this version */ 1618a33a7d73SArnd Bergmann pr_debug("invalid DMA class\n"); 1619a33a7d73SArnd Bergmann return -EIO; 1620a33a7d73SArnd Bergmann } 1621a33a7d73SArnd Bergmann 1622a33a7d73SArnd Bergmann return 0; 1623a33a7d73SArnd Bergmann } 1624a33a7d73SArnd Bergmann 1625a33a7d73SArnd Bergmann static int spu_send_mfc_command(struct spu_context *ctx, 1626a33a7d73SArnd Bergmann struct mfc_dma_command cmd, 1627a33a7d73SArnd Bergmann int *error) 1628a33a7d73SArnd Bergmann { 1629a33a7d73SArnd Bergmann *error = ctx->ops->send_mfc_command(ctx, &cmd); 1630a33a7d73SArnd Bergmann if (*error == -EAGAIN) { 1631a33a7d73SArnd Bergmann /* wait for any tag group to complete 1632a33a7d73SArnd Bergmann so we have space for the new command */ 1633a33a7d73SArnd Bergmann ctx->ops->set_mfc_query(ctx, ctx->tagwait, 1); 1634a33a7d73SArnd Bergmann /* try again, because the queue might be 1635a33a7d73SArnd Bergmann empty again */ 1636a33a7d73SArnd Bergmann *error = ctx->ops->send_mfc_command(ctx, &cmd); 1637a33a7d73SArnd Bergmann if (*error == -EAGAIN) 1638a33a7d73SArnd Bergmann return 0; 1639a33a7d73SArnd Bergmann } 1640a33a7d73SArnd Bergmann return 1; 1641a33a7d73SArnd Bergmann } 1642a33a7d73SArnd Bergmann 1643a33a7d73SArnd Bergmann static ssize_t spufs_mfc_write(struct file *file, const char __user *buffer, 1644a33a7d73SArnd Bergmann size_t size, loff_t *pos) 1645a33a7d73SArnd Bergmann { 1646a33a7d73SArnd Bergmann struct spu_context *ctx = file->private_data; 1647a33a7d73SArnd Bergmann struct mfc_dma_command cmd; 1648a33a7d73SArnd Bergmann int ret = -EINVAL; 1649a33a7d73SArnd Bergmann 1650a33a7d73SArnd Bergmann if (size != sizeof cmd) 1651a33a7d73SArnd Bergmann goto out; 1652a33a7d73SArnd Bergmann 1653a33a7d73SArnd Bergmann ret = -EFAULT; 1654a33a7d73SArnd Bergmann if (copy_from_user(&cmd, buffer, sizeof cmd)) 1655a33a7d73SArnd Bergmann goto out; 1656a33a7d73SArnd Bergmann 1657a33a7d73SArnd Bergmann ret = spufs_check_valid_dma(&cmd); 1658a33a7d73SArnd Bergmann if (ret) 1659a33a7d73SArnd Bergmann goto out; 1660a33a7d73SArnd Bergmann 1661c9101bdbSChristoph Hellwig ret = spu_acquire(ctx); 1662c9101bdbSChristoph Hellwig if (ret) 1663c9101bdbSChristoph Hellwig goto out; 1664c9101bdbSChristoph Hellwig 166533bfd7a7SArnd Bergmann ret = spufs_wait(ctx->run_wq, ctx->state == SPU_STATE_RUNNABLE); 1666577f8f10SAkinobu Mita if (ret) 1667577f8f10SAkinobu Mita goto out; 1668577f8f10SAkinobu Mita 1669a33a7d73SArnd Bergmann if (file->f_flags & O_NONBLOCK) { 1670a33a7d73SArnd Bergmann ret = ctx->ops->send_mfc_command(ctx, &cmd); 1671a33a7d73SArnd Bergmann } else { 1672a33a7d73SArnd Bergmann int status; 1673a33a7d73SArnd Bergmann ret = spufs_wait(ctx->mfc_wq, 1674a33a7d73SArnd Bergmann spu_send_mfc_command(ctx, cmd, &status)); 1675eebead5bSChristoph Hellwig if (ret) 1676eebead5bSChristoph Hellwig goto out; 1677a33a7d73SArnd Bergmann if (status) 1678a33a7d73SArnd Bergmann ret = status; 1679a33a7d73SArnd Bergmann } 1680a33a7d73SArnd Bergmann 1681a33a7d73SArnd Bergmann if (ret) 1682933b0e35SKazunori Asayama goto out_unlock; 1683a33a7d73SArnd Bergmann 1684a33a7d73SArnd Bergmann ctx->tagwait |= 1 << cmd.tag; 16853692dc66SMasato Noguchi ret = size; 1686a33a7d73SArnd Bergmann 1687933b0e35SKazunori Asayama out_unlock: 1688933b0e35SKazunori Asayama spu_release(ctx); 1689a33a7d73SArnd Bergmann out: 1690a33a7d73SArnd Bergmann return ret; 1691a33a7d73SArnd Bergmann } 1692a33a7d73SArnd Bergmann 16938153a5eaSAl Viro static __poll_t spufs_mfc_poll(struct file *file,poll_table *wait) 1694a33a7d73SArnd Bergmann { 1695a33a7d73SArnd Bergmann struct spu_context *ctx = file->private_data; 1696a33a7d73SArnd Bergmann u32 free_elements, tagstatus; 16978153a5eaSAl Viro __poll_t mask; 1698a33a7d73SArnd Bergmann 1699933b0e35SKazunori Asayama poll_wait(file, &ctx->mfc_wq, wait); 1700933b0e35SKazunori Asayama 1701c9101bdbSChristoph Hellwig /* 1702c9101bdbSChristoph Hellwig * For now keep this uninterruptible and also ignore the rule 1703c9101bdbSChristoph Hellwig * that poll should not sleep. Will be fixed later. 1704c9101bdbSChristoph Hellwig */ 1705c9101bdbSChristoph Hellwig mutex_lock(&ctx->state_mutex); 1706a33a7d73SArnd Bergmann ctx->ops->set_mfc_query(ctx, ctx->tagwait, 2); 1707a33a7d73SArnd Bergmann free_elements = ctx->ops->get_mfc_free_elements(ctx); 1708a33a7d73SArnd Bergmann tagstatus = ctx->ops->read_mfc_tagstatus(ctx); 1709a33a7d73SArnd Bergmann spu_release(ctx); 1710a33a7d73SArnd Bergmann 1711a33a7d73SArnd Bergmann mask = 0; 1712a33a7d73SArnd Bergmann if (free_elements & 0xffff) 1713a9a08845SLinus Torvalds mask |= EPOLLOUT | EPOLLWRNORM; 1714a33a7d73SArnd Bergmann if (tagstatus & ctx->tagwait) 1715a9a08845SLinus Torvalds mask |= EPOLLIN | EPOLLRDNORM; 1716a33a7d73SArnd Bergmann 1717e48b1b45SHarvey Harrison pr_debug("%s: free %d tagstatus %d tagwait %d\n", __func__, 1718a33a7d73SArnd Bergmann free_elements, tagstatus, ctx->tagwait); 1719a33a7d73SArnd Bergmann 1720a33a7d73SArnd Bergmann return mask; 1721a33a7d73SArnd Bergmann } 1722a33a7d73SArnd Bergmann 172373b6af8aSAl Viro static int spufs_mfc_flush(struct file *file, fl_owner_t id) 1724a33a7d73SArnd Bergmann { 1725a33a7d73SArnd Bergmann struct spu_context *ctx = file->private_data; 1726a33a7d73SArnd Bergmann int ret; 1727a33a7d73SArnd Bergmann 1728c9101bdbSChristoph Hellwig ret = spu_acquire(ctx); 1729c9101bdbSChristoph Hellwig if (ret) 1730eebead5bSChristoph Hellwig goto out; 1731a33a7d73SArnd Bergmann #if 0 1732a33a7d73SArnd Bergmann /* this currently hangs */ 1733a33a7d73SArnd Bergmann ret = spufs_wait(ctx->mfc_wq, 1734a33a7d73SArnd Bergmann ctx->ops->set_mfc_query(ctx, ctx->tagwait, 2)); 1735a33a7d73SArnd Bergmann if (ret) 1736a33a7d73SArnd Bergmann goto out; 1737a33a7d73SArnd Bergmann ret = spufs_wait(ctx->mfc_wq, 1738a33a7d73SArnd Bergmann ctx->ops->read_mfc_tagstatus(ctx) == ctx->tagwait); 1739eebead5bSChristoph Hellwig if (ret) 1740eebead5bSChristoph Hellwig goto out; 1741a33a7d73SArnd Bergmann #else 1742a33a7d73SArnd Bergmann ret = 0; 1743a33a7d73SArnd Bergmann #endif 1744a33a7d73SArnd Bergmann spu_release(ctx); 1745eebead5bSChristoph Hellwig out: 1746a33a7d73SArnd Bergmann return ret; 1747a33a7d73SArnd Bergmann } 1748a33a7d73SArnd Bergmann 174902c24a82SJosef Bacik static int spufs_mfc_fsync(struct file *file, loff_t start, loff_t end, int datasync) 1750a33a7d73SArnd Bergmann { 1751496ad9aaSAl Viro struct inode *inode = file_inode(file); 17523b49c9a1SJeff Layton int err = file_write_and_wait_range(file, start, end); 175302c24a82SJosef Bacik if (!err) { 17545955102cSAl Viro inode_lock(inode); 175502c24a82SJosef Bacik err = spufs_mfc_flush(file, NULL); 17565955102cSAl Viro inode_unlock(inode); 175702c24a82SJosef Bacik } 175802c24a82SJosef Bacik return err; 1759a33a7d73SArnd Bergmann } 1760a33a7d73SArnd Bergmann 17615dfe4c96SArjan van de Ven static const struct file_operations spufs_mfc_fops = { 1762a33a7d73SArnd Bergmann .open = spufs_mfc_open, 176343c2bbd9SChristoph Hellwig .release = spufs_mfc_release, 1764a33a7d73SArnd Bergmann .read = spufs_mfc_read, 1765a33a7d73SArnd Bergmann .write = spufs_mfc_write, 1766a33a7d73SArnd Bergmann .poll = spufs_mfc_poll, 1767a33a7d73SArnd Bergmann .flush = spufs_mfc_flush, 1768a33a7d73SArnd Bergmann .fsync = spufs_mfc_fsync, 17696df10a82SMark Nutter .mmap = spufs_mfc_mmap, 1770fc15351dSArnd Bergmann .llseek = no_llseek, 1771a33a7d73SArnd Bergmann }; 1772a33a7d73SArnd Bergmann 1773197b1a82SChristoph Hellwig static int spufs_npc_set(void *data, u64 val) 177467207b96SArnd Bergmann { 177567207b96SArnd Bergmann struct spu_context *ctx = data; 1776c9101bdbSChristoph Hellwig int ret; 1777c9101bdbSChristoph Hellwig 1778c9101bdbSChristoph Hellwig ret = spu_acquire(ctx); 1779c9101bdbSChristoph Hellwig if (ret) 1780c9101bdbSChristoph Hellwig return ret; 17818b3d6663SArnd Bergmann ctx->ops->npc_write(ctx, val); 17828b3d6663SArnd Bergmann spu_release(ctx); 1783197b1a82SChristoph Hellwig 1784197b1a82SChristoph Hellwig return 0; 178567207b96SArnd Bergmann } 178667207b96SArnd Bergmann 1787104f0cc2SMichael Ellerman static u64 spufs_npc_get(struct spu_context *ctx) 178878810ff6SMichael Ellerman { 178978810ff6SMichael Ellerman return ctx->ops->npc_read(ctx); 179078810ff6SMichael Ellerman } 1791104f0cc2SMichael Ellerman DEFINE_SPUFS_ATTRIBUTE(spufs_npc_ops, spufs_npc_get, spufs_npc_set, 1792104f0cc2SMichael Ellerman "0x%llx\n", SPU_ATTR_ACQUIRE); 179367207b96SArnd Bergmann 1794197b1a82SChristoph Hellwig static int spufs_decr_set(void *data, u64 val) 17958b3d6663SArnd Bergmann { 17968b3d6663SArnd Bergmann struct spu_context *ctx = data; 17978b3d6663SArnd Bergmann struct spu_lscsa *lscsa = ctx->csa.lscsa; 1798c9101bdbSChristoph Hellwig int ret; 1799c9101bdbSChristoph Hellwig 1800c9101bdbSChristoph Hellwig ret = spu_acquire_saved(ctx); 1801c9101bdbSChristoph Hellwig if (ret) 1802c9101bdbSChristoph Hellwig return ret; 18038b3d6663SArnd Bergmann lscsa->decr.slot[0] = (u32) val; 180427b1ea09SChristoph Hellwig spu_release_saved(ctx); 1805197b1a82SChristoph Hellwig 1806197b1a82SChristoph Hellwig return 0; 18078b3d6663SArnd Bergmann } 18088b3d6663SArnd Bergmann 1809104f0cc2SMichael Ellerman static u64 spufs_decr_get(struct spu_context *ctx) 18108b3d6663SArnd Bergmann { 18118b3d6663SArnd Bergmann struct spu_lscsa *lscsa = ctx->csa.lscsa; 1812bf1ab978SDwayne Grant McConnell return lscsa->decr.slot[0]; 1813bf1ab978SDwayne Grant McConnell } 1814104f0cc2SMichael Ellerman DEFINE_SPUFS_ATTRIBUTE(spufs_decr_ops, spufs_decr_get, spufs_decr_set, 1815104f0cc2SMichael Ellerman "0x%llx\n", SPU_ATTR_ACQUIRE_SAVED); 18168b3d6663SArnd Bergmann 1817197b1a82SChristoph Hellwig static int spufs_decr_status_set(void *data, u64 val) 18188b3d6663SArnd Bergmann { 18198b3d6663SArnd Bergmann struct spu_context *ctx = data; 1820c9101bdbSChristoph Hellwig int ret; 1821c9101bdbSChristoph Hellwig 1822c9101bdbSChristoph Hellwig ret = spu_acquire_saved(ctx); 1823c9101bdbSChristoph Hellwig if (ret) 1824c9101bdbSChristoph Hellwig return ret; 1825d40a01d4SMasato Noguchi if (val) 1826d40a01d4SMasato Noguchi ctx->csa.priv2.mfc_control_RW |= MFC_CNTL_DECREMENTER_RUNNING; 1827d40a01d4SMasato Noguchi else 1828d40a01d4SMasato Noguchi ctx->csa.priv2.mfc_control_RW &= ~MFC_CNTL_DECREMENTER_RUNNING; 182927b1ea09SChristoph Hellwig spu_release_saved(ctx); 1830197b1a82SChristoph Hellwig 1831197b1a82SChristoph Hellwig return 0; 18328b3d6663SArnd Bergmann } 18338b3d6663SArnd Bergmann 1834104f0cc2SMichael Ellerman static u64 spufs_decr_status_get(struct spu_context *ctx) 18358b3d6663SArnd Bergmann { 1836d40a01d4SMasato Noguchi if (ctx->csa.priv2.mfc_control_RW & MFC_CNTL_DECREMENTER_RUNNING) 1837d40a01d4SMasato Noguchi return SPU_DECR_STATUS_RUNNING; 1838d40a01d4SMasato Noguchi else 1839d40a01d4SMasato Noguchi return 0; 1840bf1ab978SDwayne Grant McConnell } 1841104f0cc2SMichael Ellerman DEFINE_SPUFS_ATTRIBUTE(spufs_decr_status_ops, spufs_decr_status_get, 1842104f0cc2SMichael Ellerman spufs_decr_status_set, "0x%llx\n", 1843104f0cc2SMichael Ellerman SPU_ATTR_ACQUIRE_SAVED); 18448b3d6663SArnd Bergmann 1845197b1a82SChristoph Hellwig static int spufs_event_mask_set(void *data, u64 val) 18468b3d6663SArnd Bergmann { 18478b3d6663SArnd Bergmann struct spu_context *ctx = data; 18488b3d6663SArnd Bergmann struct spu_lscsa *lscsa = ctx->csa.lscsa; 1849c9101bdbSChristoph Hellwig int ret; 1850c9101bdbSChristoph Hellwig 1851c9101bdbSChristoph Hellwig ret = spu_acquire_saved(ctx); 1852c9101bdbSChristoph Hellwig if (ret) 1853c9101bdbSChristoph Hellwig return ret; 18548b3d6663SArnd Bergmann lscsa->event_mask.slot[0] = (u32) val; 185527b1ea09SChristoph Hellwig spu_release_saved(ctx); 1856197b1a82SChristoph Hellwig 1857197b1a82SChristoph Hellwig return 0; 18588b3d6663SArnd Bergmann } 18598b3d6663SArnd Bergmann 1860104f0cc2SMichael Ellerman static u64 spufs_event_mask_get(struct spu_context *ctx) 18618b3d6663SArnd Bergmann { 18628b3d6663SArnd Bergmann struct spu_lscsa *lscsa = ctx->csa.lscsa; 1863bf1ab978SDwayne Grant McConnell return lscsa->event_mask.slot[0]; 1864bf1ab978SDwayne Grant McConnell } 1865bf1ab978SDwayne Grant McConnell 1866104f0cc2SMichael Ellerman DEFINE_SPUFS_ATTRIBUTE(spufs_event_mask_ops, spufs_event_mask_get, 1867104f0cc2SMichael Ellerman spufs_event_mask_set, "0x%llx\n", 1868104f0cc2SMichael Ellerman SPU_ATTR_ACQUIRE_SAVED); 18698b3d6663SArnd Bergmann 1870104f0cc2SMichael Ellerman static u64 spufs_event_status_get(struct spu_context *ctx) 1871b9e3bd77SDwayne Grant McConnell { 1872b9e3bd77SDwayne Grant McConnell struct spu_state *state = &ctx->csa; 1873b9e3bd77SDwayne Grant McConnell u64 stat; 1874b9e3bd77SDwayne Grant McConnell stat = state->spu_chnlcnt_RW[0]; 1875b9e3bd77SDwayne Grant McConnell if (stat) 1876bf1ab978SDwayne Grant McConnell return state->spu_chnldata_RW[0]; 1877bf1ab978SDwayne Grant McConnell return 0; 1878bf1ab978SDwayne Grant McConnell } 1879104f0cc2SMichael Ellerman DEFINE_SPUFS_ATTRIBUTE(spufs_event_status_ops, spufs_event_status_get, 1880104f0cc2SMichael Ellerman NULL, "0x%llx\n", SPU_ATTR_ACQUIRE_SAVED) 1881b9e3bd77SDwayne Grant McConnell 1882197b1a82SChristoph Hellwig static int spufs_srr0_set(void *data, u64 val) 18838b3d6663SArnd Bergmann { 18848b3d6663SArnd Bergmann struct spu_context *ctx = data; 18858b3d6663SArnd Bergmann struct spu_lscsa *lscsa = ctx->csa.lscsa; 1886c9101bdbSChristoph Hellwig int ret; 1887c9101bdbSChristoph Hellwig 1888c9101bdbSChristoph Hellwig ret = spu_acquire_saved(ctx); 1889c9101bdbSChristoph Hellwig if (ret) 1890c9101bdbSChristoph Hellwig return ret; 18918b3d6663SArnd Bergmann lscsa->srr0.slot[0] = (u32) val; 189227b1ea09SChristoph Hellwig spu_release_saved(ctx); 1893197b1a82SChristoph Hellwig 1894197b1a82SChristoph Hellwig return 0; 18958b3d6663SArnd Bergmann } 18968b3d6663SArnd Bergmann 1897104f0cc2SMichael Ellerman static u64 spufs_srr0_get(struct spu_context *ctx) 18988b3d6663SArnd Bergmann { 18998b3d6663SArnd Bergmann struct spu_lscsa *lscsa = ctx->csa.lscsa; 1900104f0cc2SMichael Ellerman return lscsa->srr0.slot[0]; 19018b3d6663SArnd Bergmann } 1902104f0cc2SMichael Ellerman DEFINE_SPUFS_ATTRIBUTE(spufs_srr0_ops, spufs_srr0_get, spufs_srr0_set, 1903104f0cc2SMichael Ellerman "0x%llx\n", SPU_ATTR_ACQUIRE_SAVED) 19048b3d6663SArnd Bergmann 1905104f0cc2SMichael Ellerman static u64 spufs_id_get(struct spu_context *ctx) 19067b1a7014Sarnd@arndb.de { 19077b1a7014Sarnd@arndb.de u64 num; 19087b1a7014Sarnd@arndb.de 19097b1a7014Sarnd@arndb.de if (ctx->state == SPU_STATE_RUNNABLE) 19107b1a7014Sarnd@arndb.de num = ctx->spu->number; 19117b1a7014Sarnd@arndb.de else 19127b1a7014Sarnd@arndb.de num = (unsigned int)-1; 19137b1a7014Sarnd@arndb.de 19147b1a7014Sarnd@arndb.de return num; 19157b1a7014Sarnd@arndb.de } 1916104f0cc2SMichael Ellerman DEFINE_SPUFS_ATTRIBUTE(spufs_id_ops, spufs_id_get, NULL, "0x%llx\n", 1917104f0cc2SMichael Ellerman SPU_ATTR_ACQUIRE) 19187b1a7014Sarnd@arndb.de 1919104f0cc2SMichael Ellerman static u64 spufs_object_id_get(struct spu_context *ctx) 1920bf1ab978SDwayne Grant McConnell { 1921bf1ab978SDwayne Grant McConnell /* FIXME: Should there really be no locking here? */ 1922104f0cc2SMichael Ellerman return ctx->object_id; 1923bf1ab978SDwayne Grant McConnell } 1924bf1ab978SDwayne Grant McConnell 1925197b1a82SChristoph Hellwig static int spufs_object_id_set(void *data, u64 id) 192686767277SArnd Bergmann { 192786767277SArnd Bergmann struct spu_context *ctx = data; 192886767277SArnd Bergmann ctx->object_id = id; 1929197b1a82SChristoph Hellwig 1930197b1a82SChristoph Hellwig return 0; 193186767277SArnd Bergmann } 193286767277SArnd Bergmann 1933104f0cc2SMichael Ellerman DEFINE_SPUFS_ATTRIBUTE(spufs_object_id_ops, spufs_object_id_get, 1934104f0cc2SMichael Ellerman spufs_object_id_set, "0x%llx\n", SPU_ATTR_NOACQUIRE); 193586767277SArnd Bergmann 1936104f0cc2SMichael Ellerman static u64 spufs_lslr_get(struct spu_context *ctx) 1937bf1ab978SDwayne Grant McConnell { 1938bf1ab978SDwayne Grant McConnell return ctx->csa.priv2.spu_lslr_RW; 1939bf1ab978SDwayne Grant McConnell } 1940104f0cc2SMichael Ellerman DEFINE_SPUFS_ATTRIBUTE(spufs_lslr_ops, spufs_lslr_get, NULL, "0x%llx\n", 1941104f0cc2SMichael Ellerman SPU_ATTR_ACQUIRE_SAVED); 1942b9e3bd77SDwayne Grant McConnell 1943b9e3bd77SDwayne Grant McConnell static int spufs_info_open(struct inode *inode, struct file *file) 1944b9e3bd77SDwayne Grant McConnell { 1945b9e3bd77SDwayne Grant McConnell struct spufs_inode_info *i = SPUFS_I(inode); 1946b9e3bd77SDwayne Grant McConnell struct spu_context *ctx = i->i_ctx; 1947b9e3bd77SDwayne Grant McConnell file->private_data = ctx; 1948b9e3bd77SDwayne Grant McConnell return 0; 1949b9e3bd77SDwayne Grant McConnell } 1950b9e3bd77SDwayne Grant McConnell 1951cbe709c1SBenjamin Herrenschmidt static int spufs_caps_show(struct seq_file *s, void *private) 1952cbe709c1SBenjamin Herrenschmidt { 1953cbe709c1SBenjamin Herrenschmidt struct spu_context *ctx = s->private; 1954cbe709c1SBenjamin Herrenschmidt 1955cbe709c1SBenjamin Herrenschmidt if (!(ctx->flags & SPU_CREATE_NOSCHED)) 1956cbe709c1SBenjamin Herrenschmidt seq_puts(s, "sched\n"); 1957cbe709c1SBenjamin Herrenschmidt if (!(ctx->flags & SPU_CREATE_ISOLATE)) 1958cbe709c1SBenjamin Herrenschmidt seq_puts(s, "step\n"); 1959cbe709c1SBenjamin Herrenschmidt return 0; 1960cbe709c1SBenjamin Herrenschmidt } 1961cbe709c1SBenjamin Herrenschmidt 1962cbe709c1SBenjamin Herrenschmidt static int spufs_caps_open(struct inode *inode, struct file *file) 1963cbe709c1SBenjamin Herrenschmidt { 1964cbe709c1SBenjamin Herrenschmidt return single_open(file, spufs_caps_show, SPUFS_I(inode)->i_ctx); 1965cbe709c1SBenjamin Herrenschmidt } 1966cbe709c1SBenjamin Herrenschmidt 1967cbe709c1SBenjamin Herrenschmidt static const struct file_operations spufs_caps_fops = { 1968cbe709c1SBenjamin Herrenschmidt .open = spufs_caps_open, 1969cbe709c1SBenjamin Herrenschmidt .read = seq_read, 1970cbe709c1SBenjamin Herrenschmidt .llseek = seq_lseek, 1971cbe709c1SBenjamin Herrenschmidt .release = single_release, 1972cbe709c1SBenjamin Herrenschmidt }; 1973cbe709c1SBenjamin Herrenschmidt 1974bf1ab978SDwayne Grant McConnell static ssize_t __spufs_mbox_info_read(struct spu_context *ctx, 1975bf1ab978SDwayne Grant McConnell char __user *buf, size_t len, loff_t *pos) 1976bf1ab978SDwayne Grant McConnell { 1977bf1ab978SDwayne Grant McConnell u32 data; 1978bf1ab978SDwayne Grant McConnell 1979cbea9238SJeremy Kerr /* EOF if there's no entry in the mbox */ 1980cbea9238SJeremy Kerr if (!(ctx->csa.prob.mb_stat_R & 0x0000ff)) 1981cbea9238SJeremy Kerr return 0; 1982cbea9238SJeremy Kerr 1983bf1ab978SDwayne Grant McConnell data = ctx->csa.prob.pu_mb_R; 1984bf1ab978SDwayne Grant McConnell 1985bf1ab978SDwayne Grant McConnell return simple_read_from_buffer(buf, len, pos, &data, sizeof data); 1986bf1ab978SDwayne Grant McConnell } 1987bf1ab978SDwayne Grant McConnell 198869a2f00cSDwayne Grant McConnell static ssize_t spufs_mbox_info_read(struct file *file, char __user *buf, 198969a2f00cSDwayne Grant McConnell size_t len, loff_t *pos) 199069a2f00cSDwayne Grant McConnell { 1991bf1ab978SDwayne Grant McConnell int ret; 199269a2f00cSDwayne Grant McConnell struct spu_context *ctx = file->private_data; 199369a2f00cSDwayne Grant McConnell 199469a2f00cSDwayne Grant McConnell if (!access_ok(VERIFY_WRITE, buf, len)) 199569a2f00cSDwayne Grant McConnell return -EFAULT; 199669a2f00cSDwayne Grant McConnell 1997c9101bdbSChristoph Hellwig ret = spu_acquire_saved(ctx); 1998c9101bdbSChristoph Hellwig if (ret) 1999c9101bdbSChristoph Hellwig return ret; 200069a2f00cSDwayne Grant McConnell spin_lock(&ctx->csa.register_lock); 2001bf1ab978SDwayne Grant McConnell ret = __spufs_mbox_info_read(ctx, buf, len, pos); 200269a2f00cSDwayne Grant McConnell spin_unlock(&ctx->csa.register_lock); 200327b1ea09SChristoph Hellwig spu_release_saved(ctx); 200469a2f00cSDwayne Grant McConnell 2005bf1ab978SDwayne Grant McConnell return ret; 200669a2f00cSDwayne Grant McConnell } 200769a2f00cSDwayne Grant McConnell 20085dfe4c96SArjan van de Ven static const struct file_operations spufs_mbox_info_fops = { 200969a2f00cSDwayne Grant McConnell .open = spufs_info_open, 201069a2f00cSDwayne Grant McConnell .read = spufs_mbox_info_read, 201169a2f00cSDwayne Grant McConnell .llseek = generic_file_llseek, 201269a2f00cSDwayne Grant McConnell }; 201369a2f00cSDwayne Grant McConnell 2014bf1ab978SDwayne Grant McConnell static ssize_t __spufs_ibox_info_read(struct spu_context *ctx, 2015bf1ab978SDwayne Grant McConnell char __user *buf, size_t len, loff_t *pos) 2016bf1ab978SDwayne Grant McConnell { 2017bf1ab978SDwayne Grant McConnell u32 data; 2018bf1ab978SDwayne Grant McConnell 2019cbea9238SJeremy Kerr /* EOF if there's no entry in the ibox */ 2020cbea9238SJeremy Kerr if (!(ctx->csa.prob.mb_stat_R & 0xff0000)) 2021cbea9238SJeremy Kerr return 0; 2022cbea9238SJeremy Kerr 2023bf1ab978SDwayne Grant McConnell data = ctx->csa.priv2.puint_mb_R; 2024bf1ab978SDwayne Grant McConnell 2025bf1ab978SDwayne Grant McConnell return simple_read_from_buffer(buf, len, pos, &data, sizeof data); 2026bf1ab978SDwayne Grant McConnell } 2027bf1ab978SDwayne Grant McConnell 202869a2f00cSDwayne Grant McConnell static ssize_t spufs_ibox_info_read(struct file *file, char __user *buf, 202969a2f00cSDwayne Grant McConnell size_t len, loff_t *pos) 203069a2f00cSDwayne Grant McConnell { 203169a2f00cSDwayne Grant McConnell struct spu_context *ctx = file->private_data; 2032bf1ab978SDwayne Grant McConnell int ret; 203369a2f00cSDwayne Grant McConnell 203469a2f00cSDwayne Grant McConnell if (!access_ok(VERIFY_WRITE, buf, len)) 203569a2f00cSDwayne Grant McConnell return -EFAULT; 203669a2f00cSDwayne Grant McConnell 2037c9101bdbSChristoph Hellwig ret = spu_acquire_saved(ctx); 2038c9101bdbSChristoph Hellwig if (ret) 2039c9101bdbSChristoph Hellwig return ret; 204069a2f00cSDwayne Grant McConnell spin_lock(&ctx->csa.register_lock); 2041bf1ab978SDwayne Grant McConnell ret = __spufs_ibox_info_read(ctx, buf, len, pos); 204269a2f00cSDwayne Grant McConnell spin_unlock(&ctx->csa.register_lock); 204327b1ea09SChristoph Hellwig spu_release_saved(ctx); 204469a2f00cSDwayne Grant McConnell 2045bf1ab978SDwayne Grant McConnell return ret; 204669a2f00cSDwayne Grant McConnell } 204769a2f00cSDwayne Grant McConnell 20485dfe4c96SArjan van de Ven static const struct file_operations spufs_ibox_info_fops = { 204969a2f00cSDwayne Grant McConnell .open = spufs_info_open, 205069a2f00cSDwayne Grant McConnell .read = spufs_ibox_info_read, 205169a2f00cSDwayne Grant McConnell .llseek = generic_file_llseek, 205269a2f00cSDwayne Grant McConnell }; 205369a2f00cSDwayne Grant McConnell 2054bf1ab978SDwayne Grant McConnell static ssize_t __spufs_wbox_info_read(struct spu_context *ctx, 2055bf1ab978SDwayne Grant McConnell char __user *buf, size_t len, loff_t *pos) 2056bf1ab978SDwayne Grant McConnell { 2057bf1ab978SDwayne Grant McConnell int i, cnt; 2058bf1ab978SDwayne Grant McConnell u32 data[4]; 2059bf1ab978SDwayne Grant McConnell u32 wbox_stat; 2060bf1ab978SDwayne Grant McConnell 2061bf1ab978SDwayne Grant McConnell wbox_stat = ctx->csa.prob.mb_stat_R; 2062bf1ab978SDwayne Grant McConnell cnt = 4 - ((wbox_stat & 0x00ff00) >> 8); 2063bf1ab978SDwayne Grant McConnell for (i = 0; i < cnt; i++) { 2064bf1ab978SDwayne Grant McConnell data[i] = ctx->csa.spu_mailbox_data[i]; 2065bf1ab978SDwayne Grant McConnell } 2066bf1ab978SDwayne Grant McConnell 2067bf1ab978SDwayne Grant McConnell return simple_read_from_buffer(buf, len, pos, &data, 2068bf1ab978SDwayne Grant McConnell cnt * sizeof(u32)); 2069bf1ab978SDwayne Grant McConnell } 2070bf1ab978SDwayne Grant McConnell 207169a2f00cSDwayne Grant McConnell static ssize_t spufs_wbox_info_read(struct file *file, char __user *buf, 207269a2f00cSDwayne Grant McConnell size_t len, loff_t *pos) 207369a2f00cSDwayne Grant McConnell { 207469a2f00cSDwayne Grant McConnell struct spu_context *ctx = file->private_data; 2075bf1ab978SDwayne Grant McConnell int ret; 207669a2f00cSDwayne Grant McConnell 207769a2f00cSDwayne Grant McConnell if (!access_ok(VERIFY_WRITE, buf, len)) 207869a2f00cSDwayne Grant McConnell return -EFAULT; 207969a2f00cSDwayne Grant McConnell 2080c9101bdbSChristoph Hellwig ret = spu_acquire_saved(ctx); 2081c9101bdbSChristoph Hellwig if (ret) 2082c9101bdbSChristoph Hellwig return ret; 208369a2f00cSDwayne Grant McConnell spin_lock(&ctx->csa.register_lock); 2084bf1ab978SDwayne Grant McConnell ret = __spufs_wbox_info_read(ctx, buf, len, pos); 208569a2f00cSDwayne Grant McConnell spin_unlock(&ctx->csa.register_lock); 208627b1ea09SChristoph Hellwig spu_release_saved(ctx); 208769a2f00cSDwayne Grant McConnell 2088bf1ab978SDwayne Grant McConnell return ret; 208969a2f00cSDwayne Grant McConnell } 209069a2f00cSDwayne Grant McConnell 20915dfe4c96SArjan van de Ven static const struct file_operations spufs_wbox_info_fops = { 209269a2f00cSDwayne Grant McConnell .open = spufs_info_open, 209369a2f00cSDwayne Grant McConnell .read = spufs_wbox_info_read, 209469a2f00cSDwayne Grant McConnell .llseek = generic_file_llseek, 209569a2f00cSDwayne Grant McConnell }; 209669a2f00cSDwayne Grant McConnell 2097bf1ab978SDwayne Grant McConnell static ssize_t __spufs_dma_info_read(struct spu_context *ctx, 2098bf1ab978SDwayne Grant McConnell char __user *buf, size_t len, loff_t *pos) 2099b9e3bd77SDwayne Grant McConnell { 2100b9e3bd77SDwayne Grant McConnell struct spu_dma_info info; 2101b9e3bd77SDwayne Grant McConnell struct mfc_cq_sr *qp, *spuqp; 2102b9e3bd77SDwayne Grant McConnell int i; 2103b9e3bd77SDwayne Grant McConnell 2104b9e3bd77SDwayne Grant McConnell info.dma_info_type = ctx->csa.priv2.spu_tag_status_query_RW; 2105b9e3bd77SDwayne Grant McConnell info.dma_info_mask = ctx->csa.lscsa->tag_mask.slot[0]; 2106b9e3bd77SDwayne Grant McConnell info.dma_info_status = ctx->csa.spu_chnldata_RW[24]; 2107b9e3bd77SDwayne Grant McConnell info.dma_info_stall_and_notify = ctx->csa.spu_chnldata_RW[25]; 2108b9e3bd77SDwayne Grant McConnell info.dma_info_atomic_command_status = ctx->csa.spu_chnldata_RW[27]; 2109b9e3bd77SDwayne Grant McConnell for (i = 0; i < 16; i++) { 2110b9e3bd77SDwayne Grant McConnell qp = &info.dma_info_command_data[i]; 2111b9e3bd77SDwayne Grant McConnell spuqp = &ctx->csa.priv2.spuq[i]; 2112b9e3bd77SDwayne Grant McConnell 2113b9e3bd77SDwayne Grant McConnell qp->mfc_cq_data0_RW = spuqp->mfc_cq_data0_RW; 2114b9e3bd77SDwayne Grant McConnell qp->mfc_cq_data1_RW = spuqp->mfc_cq_data1_RW; 2115b9e3bd77SDwayne Grant McConnell qp->mfc_cq_data2_RW = spuqp->mfc_cq_data2_RW; 2116b9e3bd77SDwayne Grant McConnell qp->mfc_cq_data3_RW = spuqp->mfc_cq_data3_RW; 2117b9e3bd77SDwayne Grant McConnell } 2118b9e3bd77SDwayne Grant McConnell 2119b9e3bd77SDwayne Grant McConnell return simple_read_from_buffer(buf, len, pos, &info, 2120b9e3bd77SDwayne Grant McConnell sizeof info); 2121b9e3bd77SDwayne Grant McConnell } 2122b9e3bd77SDwayne Grant McConnell 2123bf1ab978SDwayne Grant McConnell static ssize_t spufs_dma_info_read(struct file *file, char __user *buf, 2124bf1ab978SDwayne Grant McConnell size_t len, loff_t *pos) 2125bf1ab978SDwayne Grant McConnell { 2126bf1ab978SDwayne Grant McConnell struct spu_context *ctx = file->private_data; 2127bf1ab978SDwayne Grant McConnell int ret; 2128bf1ab978SDwayne Grant McConnell 2129bf1ab978SDwayne Grant McConnell if (!access_ok(VERIFY_WRITE, buf, len)) 2130bf1ab978SDwayne Grant McConnell return -EFAULT; 2131bf1ab978SDwayne Grant McConnell 2132c9101bdbSChristoph Hellwig ret = spu_acquire_saved(ctx); 2133c9101bdbSChristoph Hellwig if (ret) 2134c9101bdbSChristoph Hellwig return ret; 2135bf1ab978SDwayne Grant McConnell spin_lock(&ctx->csa.register_lock); 2136bf1ab978SDwayne Grant McConnell ret = __spufs_dma_info_read(ctx, buf, len, pos); 2137bf1ab978SDwayne Grant McConnell spin_unlock(&ctx->csa.register_lock); 213827b1ea09SChristoph Hellwig spu_release_saved(ctx); 2139bf1ab978SDwayne Grant McConnell 2140bf1ab978SDwayne Grant McConnell return ret; 2141bf1ab978SDwayne Grant McConnell } 2142bf1ab978SDwayne Grant McConnell 21435dfe4c96SArjan van de Ven static const struct file_operations spufs_dma_info_fops = { 2144b9e3bd77SDwayne Grant McConnell .open = spufs_info_open, 2145b9e3bd77SDwayne Grant McConnell .read = spufs_dma_info_read, 2146fc15351dSArnd Bergmann .llseek = no_llseek, 2147b9e3bd77SDwayne Grant McConnell }; 2148b9e3bd77SDwayne Grant McConnell 2149bf1ab978SDwayne Grant McConnell static ssize_t __spufs_proxydma_info_read(struct spu_context *ctx, 2150bf1ab978SDwayne Grant McConnell char __user *buf, size_t len, loff_t *pos) 2151b9e3bd77SDwayne Grant McConnell { 2152b9e3bd77SDwayne Grant McConnell struct spu_proxydma_info info; 2153b9e3bd77SDwayne Grant McConnell struct mfc_cq_sr *qp, *puqp; 2154bf1ab978SDwayne Grant McConnell int ret = sizeof info; 2155b9e3bd77SDwayne Grant McConnell int i; 2156b9e3bd77SDwayne Grant McConnell 2157b9e3bd77SDwayne Grant McConnell if (len < ret) 2158b9e3bd77SDwayne Grant McConnell return -EINVAL; 2159b9e3bd77SDwayne Grant McConnell 2160b9e3bd77SDwayne Grant McConnell if (!access_ok(VERIFY_WRITE, buf, len)) 2161b9e3bd77SDwayne Grant McConnell return -EFAULT; 2162b9e3bd77SDwayne Grant McConnell 2163b9e3bd77SDwayne Grant McConnell info.proxydma_info_type = ctx->csa.prob.dma_querytype_RW; 2164b9e3bd77SDwayne Grant McConnell info.proxydma_info_mask = ctx->csa.prob.dma_querymask_RW; 2165b9e3bd77SDwayne Grant McConnell info.proxydma_info_status = ctx->csa.prob.dma_tagstatus_R; 2166b9e3bd77SDwayne Grant McConnell for (i = 0; i < 8; i++) { 2167b9e3bd77SDwayne Grant McConnell qp = &info.proxydma_info_command_data[i]; 2168b9e3bd77SDwayne Grant McConnell puqp = &ctx->csa.priv2.puq[i]; 2169b9e3bd77SDwayne Grant McConnell 2170b9e3bd77SDwayne Grant McConnell qp->mfc_cq_data0_RW = puqp->mfc_cq_data0_RW; 2171b9e3bd77SDwayne Grant McConnell qp->mfc_cq_data1_RW = puqp->mfc_cq_data1_RW; 2172b9e3bd77SDwayne Grant McConnell qp->mfc_cq_data2_RW = puqp->mfc_cq_data2_RW; 2173b9e3bd77SDwayne Grant McConnell qp->mfc_cq_data3_RW = puqp->mfc_cq_data3_RW; 2174b9e3bd77SDwayne Grant McConnell } 2175bf1ab978SDwayne Grant McConnell 2176bf1ab978SDwayne Grant McConnell return simple_read_from_buffer(buf, len, pos, &info, 2177bf1ab978SDwayne Grant McConnell sizeof info); 2178bf1ab978SDwayne Grant McConnell } 2179bf1ab978SDwayne Grant McConnell 2180bf1ab978SDwayne Grant McConnell static ssize_t spufs_proxydma_info_read(struct file *file, char __user *buf, 2181bf1ab978SDwayne Grant McConnell size_t len, loff_t *pos) 2182bf1ab978SDwayne Grant McConnell { 2183bf1ab978SDwayne Grant McConnell struct spu_context *ctx = file->private_data; 2184bf1ab978SDwayne Grant McConnell int ret; 2185bf1ab978SDwayne Grant McConnell 2186c9101bdbSChristoph Hellwig ret = spu_acquire_saved(ctx); 2187c9101bdbSChristoph Hellwig if (ret) 2188c9101bdbSChristoph Hellwig return ret; 2189bf1ab978SDwayne Grant McConnell spin_lock(&ctx->csa.register_lock); 2190bf1ab978SDwayne Grant McConnell ret = __spufs_proxydma_info_read(ctx, buf, len, pos); 2191b9e3bd77SDwayne Grant McConnell spin_unlock(&ctx->csa.register_lock); 219227b1ea09SChristoph Hellwig spu_release_saved(ctx); 2193b9e3bd77SDwayne Grant McConnell 2194b9e3bd77SDwayne Grant McConnell return ret; 2195b9e3bd77SDwayne Grant McConnell } 2196b9e3bd77SDwayne Grant McConnell 21975dfe4c96SArjan van de Ven static const struct file_operations spufs_proxydma_info_fops = { 2198b9e3bd77SDwayne Grant McConnell .open = spufs_info_open, 2199b9e3bd77SDwayne Grant McConnell .read = spufs_proxydma_info_read, 2200fc15351dSArnd Bergmann .llseek = no_llseek, 2201b9e3bd77SDwayne Grant McConnell }; 2202b9e3bd77SDwayne Grant McConnell 2203476273adSChristoph Hellwig static int spufs_show_tid(struct seq_file *s, void *private) 2204476273adSChristoph Hellwig { 2205476273adSChristoph Hellwig struct spu_context *ctx = s->private; 2206476273adSChristoph Hellwig 2207476273adSChristoph Hellwig seq_printf(s, "%d\n", ctx->tid); 2208476273adSChristoph Hellwig return 0; 2209476273adSChristoph Hellwig } 2210476273adSChristoph Hellwig 2211476273adSChristoph Hellwig static int spufs_tid_open(struct inode *inode, struct file *file) 2212476273adSChristoph Hellwig { 2213476273adSChristoph Hellwig return single_open(file, spufs_show_tid, SPUFS_I(inode)->i_ctx); 2214476273adSChristoph Hellwig } 2215476273adSChristoph Hellwig 2216476273adSChristoph Hellwig static const struct file_operations spufs_tid_fops = { 2217476273adSChristoph Hellwig .open = spufs_tid_open, 2218476273adSChristoph Hellwig .read = seq_read, 2219476273adSChristoph Hellwig .llseek = seq_lseek, 2220476273adSChristoph Hellwig .release = single_release, 2221476273adSChristoph Hellwig }; 2222476273adSChristoph Hellwig 2223e9f8a0b6SChristoph Hellwig static const char *ctx_state_names[] = { 2224e9f8a0b6SChristoph Hellwig "user", "system", "iowait", "loaded" 2225e9f8a0b6SChristoph Hellwig }; 2226e9f8a0b6SChristoph Hellwig 2227e9f8a0b6SChristoph Hellwig static unsigned long long spufs_acct_time(struct spu_context *ctx, 222827ec41d3SAndre Detsch enum spu_utilization_state state) 2229e9f8a0b6SChristoph Hellwig { 223027ec41d3SAndre Detsch unsigned long long time = ctx->stats.times[state]; 2231e9f8a0b6SChristoph Hellwig 223227ec41d3SAndre Detsch /* 223327ec41d3SAndre Detsch * In general, utilization statistics are updated by the controlling 223427ec41d3SAndre Detsch * thread as the spu context moves through various well defined 223527ec41d3SAndre Detsch * state transitions, but if the context is lazily loaded its 223627ec41d3SAndre Detsch * utilization statistics are not updated as the controlling thread 223727ec41d3SAndre Detsch * is not tightly coupled with the execution of the spu context. We 223827ec41d3SAndre Detsch * calculate and apply the time delta from the last recorded state 223927ec41d3SAndre Detsch * of the spu context. 224027ec41d3SAndre Detsch */ 224127ec41d3SAndre Detsch if (ctx->spu && ctx->stats.util_state == state) { 2242f2dec1eaSThomas Gleixner time += ktime_get_ns() - ctx->stats.tstamp; 224327ec41d3SAndre Detsch } 2244e9f8a0b6SChristoph Hellwig 224527ec41d3SAndre Detsch return time / NSEC_PER_MSEC; 2246e9f8a0b6SChristoph Hellwig } 2247e9f8a0b6SChristoph Hellwig 2248e9f8a0b6SChristoph Hellwig static unsigned long long spufs_slb_flts(struct spu_context *ctx) 2249e9f8a0b6SChristoph Hellwig { 2250e9f8a0b6SChristoph Hellwig unsigned long long slb_flts = ctx->stats.slb_flt; 2251e9f8a0b6SChristoph Hellwig 2252e9f8a0b6SChristoph Hellwig if (ctx->state == SPU_STATE_RUNNABLE) { 2253e9f8a0b6SChristoph Hellwig slb_flts += (ctx->spu->stats.slb_flt - 2254e9f8a0b6SChristoph Hellwig ctx->stats.slb_flt_base); 2255e9f8a0b6SChristoph Hellwig } 2256e9f8a0b6SChristoph Hellwig 2257e9f8a0b6SChristoph Hellwig return slb_flts; 2258e9f8a0b6SChristoph Hellwig } 2259e9f8a0b6SChristoph Hellwig 2260e9f8a0b6SChristoph Hellwig static unsigned long long spufs_class2_intrs(struct spu_context *ctx) 2261e9f8a0b6SChristoph Hellwig { 2262e9f8a0b6SChristoph Hellwig unsigned long long class2_intrs = ctx->stats.class2_intr; 2263e9f8a0b6SChristoph Hellwig 2264e9f8a0b6SChristoph Hellwig if (ctx->state == SPU_STATE_RUNNABLE) { 2265e9f8a0b6SChristoph Hellwig class2_intrs += (ctx->spu->stats.class2_intr - 2266e9f8a0b6SChristoph Hellwig ctx->stats.class2_intr_base); 2267e9f8a0b6SChristoph Hellwig } 2268e9f8a0b6SChristoph Hellwig 2269e9f8a0b6SChristoph Hellwig return class2_intrs; 2270e9f8a0b6SChristoph Hellwig } 2271e9f8a0b6SChristoph Hellwig 2272e9f8a0b6SChristoph Hellwig 2273e9f8a0b6SChristoph Hellwig static int spufs_show_stat(struct seq_file *s, void *private) 2274e9f8a0b6SChristoph Hellwig { 2275e9f8a0b6SChristoph Hellwig struct spu_context *ctx = s->private; 2276c9101bdbSChristoph Hellwig int ret; 2277e9f8a0b6SChristoph Hellwig 2278c9101bdbSChristoph Hellwig ret = spu_acquire(ctx); 2279c9101bdbSChristoph Hellwig if (ret) 2280c9101bdbSChristoph Hellwig return ret; 2281c9101bdbSChristoph Hellwig 2282e9f8a0b6SChristoph Hellwig seq_printf(s, "%s %llu %llu %llu %llu " 2283e9f8a0b6SChristoph Hellwig "%llu %llu %llu %llu %llu %llu %llu %llu\n", 228427ec41d3SAndre Detsch ctx_state_names[ctx->stats.util_state], 228527ec41d3SAndre Detsch spufs_acct_time(ctx, SPU_UTIL_USER), 228627ec41d3SAndre Detsch spufs_acct_time(ctx, SPU_UTIL_SYSTEM), 228727ec41d3SAndre Detsch spufs_acct_time(ctx, SPU_UTIL_IOWAIT), 228827ec41d3SAndre Detsch spufs_acct_time(ctx, SPU_UTIL_IDLE_LOADED), 2289e9f8a0b6SChristoph Hellwig ctx->stats.vol_ctx_switch, 2290e9f8a0b6SChristoph Hellwig ctx->stats.invol_ctx_switch, 2291e9f8a0b6SChristoph Hellwig spufs_slb_flts(ctx), 2292e9f8a0b6SChristoph Hellwig ctx->stats.hash_flt, 2293e9f8a0b6SChristoph Hellwig ctx->stats.min_flt, 2294e9f8a0b6SChristoph Hellwig ctx->stats.maj_flt, 2295e9f8a0b6SChristoph Hellwig spufs_class2_intrs(ctx), 2296e9f8a0b6SChristoph Hellwig ctx->stats.libassist); 2297e9f8a0b6SChristoph Hellwig spu_release(ctx); 2298e9f8a0b6SChristoph Hellwig return 0; 2299e9f8a0b6SChristoph Hellwig } 2300e9f8a0b6SChristoph Hellwig 2301e9f8a0b6SChristoph Hellwig static int spufs_stat_open(struct inode *inode, struct file *file) 2302e9f8a0b6SChristoph Hellwig { 2303e9f8a0b6SChristoph Hellwig return single_open(file, spufs_show_stat, SPUFS_I(inode)->i_ctx); 2304e9f8a0b6SChristoph Hellwig } 2305e9f8a0b6SChristoph Hellwig 2306e9f8a0b6SChristoph Hellwig static const struct file_operations spufs_stat_fops = { 2307e9f8a0b6SChristoph Hellwig .open = spufs_stat_open, 2308e9f8a0b6SChristoph Hellwig .read = seq_read, 2309e9f8a0b6SChristoph Hellwig .llseek = seq_lseek, 2310e9f8a0b6SChristoph Hellwig .release = single_release, 2311e9f8a0b6SChristoph Hellwig }; 2312e9f8a0b6SChristoph Hellwig 23135158e9b5SChristoph Hellwig static inline int spufs_switch_log_used(struct spu_context *ctx) 23145158e9b5SChristoph Hellwig { 23155158e9b5SChristoph Hellwig return (ctx->switch_log->head - ctx->switch_log->tail) % 23165158e9b5SChristoph Hellwig SWITCH_LOG_BUFSIZE; 23175158e9b5SChristoph Hellwig } 23185158e9b5SChristoph Hellwig 23195158e9b5SChristoph Hellwig static inline int spufs_switch_log_avail(struct spu_context *ctx) 23205158e9b5SChristoph Hellwig { 23215158e9b5SChristoph Hellwig return SWITCH_LOG_BUFSIZE - spufs_switch_log_used(ctx); 23225158e9b5SChristoph Hellwig } 23235158e9b5SChristoph Hellwig 23245158e9b5SChristoph Hellwig static int spufs_switch_log_open(struct inode *inode, struct file *file) 23255158e9b5SChristoph Hellwig { 23265158e9b5SChristoph Hellwig struct spu_context *ctx = SPUFS_I(inode)->i_ctx; 2327f5ed0eb6SJeremy Kerr int rc; 23285158e9b5SChristoph Hellwig 2329f5ed0eb6SJeremy Kerr rc = spu_acquire(ctx); 2330f5ed0eb6SJeremy Kerr if (rc) 2331f5ed0eb6SJeremy Kerr return rc; 2332f5ed0eb6SJeremy Kerr 23335158e9b5SChristoph Hellwig if (ctx->switch_log) { 2334f5ed0eb6SJeremy Kerr rc = -EBUSY; 2335f5ed0eb6SJeremy Kerr goto out; 2336f5ed0eb6SJeremy Kerr } 2337f5ed0eb6SJeremy Kerr 2338837ef884SJeremy Kerr ctx->switch_log = kmalloc(sizeof(struct switch_log) + 23395158e9b5SChristoph Hellwig SWITCH_LOG_BUFSIZE * sizeof(struct switch_log_entry), 23405158e9b5SChristoph Hellwig GFP_KERNEL); 2341f5ed0eb6SJeremy Kerr 2342f5ed0eb6SJeremy Kerr if (!ctx->switch_log) { 2343f5ed0eb6SJeremy Kerr rc = -ENOMEM; 23445158e9b5SChristoph Hellwig goto out; 23455158e9b5SChristoph Hellwig } 2346f5ed0eb6SJeremy Kerr 2347837ef884SJeremy Kerr ctx->switch_log->head = ctx->switch_log->tail = 0; 2348f5ed0eb6SJeremy Kerr init_waitqueue_head(&ctx->switch_log->wait); 2349f5ed0eb6SJeremy Kerr rc = 0; 2350f5ed0eb6SJeremy Kerr 2351f5ed0eb6SJeremy Kerr out: 2352f5ed0eb6SJeremy Kerr spu_release(ctx); 2353f5ed0eb6SJeremy Kerr return rc; 2354f5ed0eb6SJeremy Kerr } 2355f5ed0eb6SJeremy Kerr 2356f5ed0eb6SJeremy Kerr static int spufs_switch_log_release(struct inode *inode, struct file *file) 2357f5ed0eb6SJeremy Kerr { 2358f5ed0eb6SJeremy Kerr struct spu_context *ctx = SPUFS_I(inode)->i_ctx; 2359f5ed0eb6SJeremy Kerr int rc; 2360f5ed0eb6SJeremy Kerr 2361f5ed0eb6SJeremy Kerr rc = spu_acquire(ctx); 2362f5ed0eb6SJeremy Kerr if (rc) 2363f5ed0eb6SJeremy Kerr return rc; 2364f5ed0eb6SJeremy Kerr 2365f5ed0eb6SJeremy Kerr kfree(ctx->switch_log); 2366f5ed0eb6SJeremy Kerr ctx->switch_log = NULL; 2367f5ed0eb6SJeremy Kerr spu_release(ctx); 23685158e9b5SChristoph Hellwig 23695158e9b5SChristoph Hellwig return 0; 23705158e9b5SChristoph Hellwig } 23715158e9b5SChristoph Hellwig 23725158e9b5SChristoph Hellwig static int switch_log_sprint(struct spu_context *ctx, char *tbuf, int n) 23735158e9b5SChristoph Hellwig { 23745158e9b5SChristoph Hellwig struct switch_log_entry *p; 23755158e9b5SChristoph Hellwig 23765158e9b5SChristoph Hellwig p = ctx->switch_log->log + ctx->switch_log->tail % SWITCH_LOG_BUFSIZE; 23775158e9b5SChristoph Hellwig 2378cef37ac1SArnd Bergmann return snprintf(tbuf, n, "%llu.%09u %d %u %u %llu\n", 2379cef37ac1SArnd Bergmann (unsigned long long) p->tstamp.tv_sec, 23805158e9b5SChristoph Hellwig (unsigned int) p->tstamp.tv_nsec, 23815158e9b5SChristoph Hellwig p->spu_id, 23825158e9b5SChristoph Hellwig (unsigned int) p->type, 23835158e9b5SChristoph Hellwig (unsigned int) p->val, 23845158e9b5SChristoph Hellwig (unsigned long long) p->timebase); 23855158e9b5SChristoph Hellwig } 23865158e9b5SChristoph Hellwig 23875158e9b5SChristoph Hellwig static ssize_t spufs_switch_log_read(struct file *file, char __user *buf, 23885158e9b5SChristoph Hellwig size_t len, loff_t *ppos) 23895158e9b5SChristoph Hellwig { 2390496ad9aaSAl Viro struct inode *inode = file_inode(file); 23915158e9b5SChristoph Hellwig struct spu_context *ctx = SPUFS_I(inode)->i_ctx; 23925158e9b5SChristoph Hellwig int error = 0, cnt = 0; 23935158e9b5SChristoph Hellwig 239417e37675Sroel kluin if (!buf) 23955158e9b5SChristoph Hellwig return -EINVAL; 23965158e9b5SChristoph Hellwig 2397f5ed0eb6SJeremy Kerr error = spu_acquire(ctx); 2398f5ed0eb6SJeremy Kerr if (error) 2399f5ed0eb6SJeremy Kerr return error; 2400f5ed0eb6SJeremy Kerr 24015158e9b5SChristoph Hellwig while (cnt < len) { 24025158e9b5SChristoph Hellwig char tbuf[128]; 24035158e9b5SChristoph Hellwig int width; 24045158e9b5SChristoph Hellwig 2405f5ed0eb6SJeremy Kerr if (spufs_switch_log_used(ctx) == 0) { 240614f693eeSJeremy Kerr if (cnt > 0) { 240714f693eeSJeremy Kerr /* If there's data ready to go, we can 240814f693eeSJeremy Kerr * just return straight away */ 240914f693eeSJeremy Kerr break; 241014f693eeSJeremy Kerr 241114f693eeSJeremy Kerr } else if (file->f_flags & O_NONBLOCK) { 2412f5ed0eb6SJeremy Kerr error = -EAGAIN; 24135158e9b5SChristoph Hellwig break; 241414f693eeSJeremy Kerr 2415f5ed0eb6SJeremy Kerr } else { 241614f693eeSJeremy Kerr /* spufs_wait will drop the mutex and 241714f693eeSJeremy Kerr * re-acquire, but since we're in read(), the 241814f693eeSJeremy Kerr * file cannot be _released (and so 241914f693eeSJeremy Kerr * ctx->switch_log is stable). 2420f5ed0eb6SJeremy Kerr */ 2421f5ed0eb6SJeremy Kerr error = spufs_wait(ctx->switch_log->wait, 2422f5ed0eb6SJeremy Kerr spufs_switch_log_used(ctx) > 0); 24235158e9b5SChristoph Hellwig 2424f5ed0eb6SJeremy Kerr /* On error, spufs_wait returns without the 2425f5ed0eb6SJeremy Kerr * state mutex held */ 2426f5ed0eb6SJeremy Kerr if (error) 2427f5ed0eb6SJeremy Kerr return error; 24285158e9b5SChristoph Hellwig 242914f693eeSJeremy Kerr /* We may have had entries read from underneath 243014f693eeSJeremy Kerr * us while we dropped the mutex in spufs_wait, 243114f693eeSJeremy Kerr * so re-check */ 243214f693eeSJeremy Kerr if (spufs_switch_log_used(ctx) == 0) 2433f5ed0eb6SJeremy Kerr continue; 243414f693eeSJeremy Kerr } 243514f693eeSJeremy Kerr } 2436f5ed0eb6SJeremy Kerr 24375158e9b5SChristoph Hellwig width = switch_log_sprint(ctx, tbuf, sizeof(tbuf)); 2438f5ed0eb6SJeremy Kerr if (width < len) 24395158e9b5SChristoph Hellwig ctx->switch_log->tail = 24405158e9b5SChristoph Hellwig (ctx->switch_log->tail + 1) % 24415158e9b5SChristoph Hellwig SWITCH_LOG_BUFSIZE; 2442f5ed0eb6SJeremy Kerr else 2443f5ed0eb6SJeremy Kerr /* If the record is greater than space available return 2444f5ed0eb6SJeremy Kerr * partial buffer (so far) */ 24455158e9b5SChristoph Hellwig break; 24465158e9b5SChristoph Hellwig 24475158e9b5SChristoph Hellwig error = copy_to_user(buf + cnt, tbuf, width); 24485158e9b5SChristoph Hellwig if (error) 24495158e9b5SChristoph Hellwig break; 24505158e9b5SChristoph Hellwig cnt += width; 24515158e9b5SChristoph Hellwig } 24525158e9b5SChristoph Hellwig 2453f5ed0eb6SJeremy Kerr spu_release(ctx); 2454f5ed0eb6SJeremy Kerr 24555158e9b5SChristoph Hellwig return cnt == 0 ? error : cnt; 24565158e9b5SChristoph Hellwig } 24575158e9b5SChristoph Hellwig 24588153a5eaSAl Viro static __poll_t spufs_switch_log_poll(struct file *file, poll_table *wait) 24595158e9b5SChristoph Hellwig { 2460496ad9aaSAl Viro struct inode *inode = file_inode(file); 24615158e9b5SChristoph Hellwig struct spu_context *ctx = SPUFS_I(inode)->i_ctx; 24628153a5eaSAl Viro __poll_t mask = 0; 2463f5ed0eb6SJeremy Kerr int rc; 24645158e9b5SChristoph Hellwig 24655158e9b5SChristoph Hellwig poll_wait(file, &ctx->switch_log->wait, wait); 24665158e9b5SChristoph Hellwig 2467f5ed0eb6SJeremy Kerr rc = spu_acquire(ctx); 2468f5ed0eb6SJeremy Kerr if (rc) 2469f5ed0eb6SJeremy Kerr return rc; 2470f5ed0eb6SJeremy Kerr 24715158e9b5SChristoph Hellwig if (spufs_switch_log_used(ctx) > 0) 2472a9a08845SLinus Torvalds mask |= EPOLLIN; 24735158e9b5SChristoph Hellwig 2474f5ed0eb6SJeremy Kerr spu_release(ctx); 2475f5ed0eb6SJeremy Kerr 24765158e9b5SChristoph Hellwig return mask; 24775158e9b5SChristoph Hellwig } 24785158e9b5SChristoph Hellwig 24795158e9b5SChristoph Hellwig static const struct file_operations spufs_switch_log_fops = { 24805158e9b5SChristoph Hellwig .open = spufs_switch_log_open, 24815158e9b5SChristoph Hellwig .read = spufs_switch_log_read, 24825158e9b5SChristoph Hellwig .poll = spufs_switch_log_poll, 2483f5ed0eb6SJeremy Kerr .release = spufs_switch_log_release, 2484fc15351dSArnd Bergmann .llseek = no_llseek, 24855158e9b5SChristoph Hellwig }; 24865158e9b5SChristoph Hellwig 2487f5ed0eb6SJeremy Kerr /** 2488f5ed0eb6SJeremy Kerr * Log a context switch event to a switch log reader. 2489f5ed0eb6SJeremy Kerr * 2490f5ed0eb6SJeremy Kerr * Must be called with ctx->state_mutex held. 2491f5ed0eb6SJeremy Kerr */ 24925158e9b5SChristoph Hellwig void spu_switch_log_notify(struct spu *spu, struct spu_context *ctx, 24935158e9b5SChristoph Hellwig u32 type, u32 val) 24945158e9b5SChristoph Hellwig { 24955158e9b5SChristoph Hellwig if (!ctx->switch_log) 24965158e9b5SChristoph Hellwig return; 24975158e9b5SChristoph Hellwig 24985158e9b5SChristoph Hellwig if (spufs_switch_log_avail(ctx) > 1) { 24995158e9b5SChristoph Hellwig struct switch_log_entry *p; 25005158e9b5SChristoph Hellwig 25015158e9b5SChristoph Hellwig p = ctx->switch_log->log + ctx->switch_log->head; 2502cef37ac1SArnd Bergmann ktime_get_ts64(&p->tstamp); 25035158e9b5SChristoph Hellwig p->timebase = get_tb(); 25045158e9b5SChristoph Hellwig p->spu_id = spu ? spu->number : -1; 25055158e9b5SChristoph Hellwig p->type = type; 25065158e9b5SChristoph Hellwig p->val = val; 25075158e9b5SChristoph Hellwig 25085158e9b5SChristoph Hellwig ctx->switch_log->head = 25095158e9b5SChristoph Hellwig (ctx->switch_log->head + 1) % SWITCH_LOG_BUFSIZE; 25105158e9b5SChristoph Hellwig } 25115158e9b5SChristoph Hellwig 25125158e9b5SChristoph Hellwig wake_up(&ctx->switch_log->wait); 25135158e9b5SChristoph Hellwig } 2514e9f8a0b6SChristoph Hellwig 251546deed69SLuke Browning static int spufs_show_ctx(struct seq_file *s, void *private) 251646deed69SLuke Browning { 251746deed69SLuke Browning struct spu_context *ctx = s->private; 251846deed69SLuke Browning u64 mfc_control_RW; 251946deed69SLuke Browning 252046deed69SLuke Browning mutex_lock(&ctx->state_mutex); 252146deed69SLuke Browning if (ctx->spu) { 252246deed69SLuke Browning struct spu *spu = ctx->spu; 252346deed69SLuke Browning struct spu_priv2 __iomem *priv2 = spu->priv2; 252446deed69SLuke Browning 252546deed69SLuke Browning spin_lock_irq(&spu->register_lock); 252646deed69SLuke Browning mfc_control_RW = in_be64(&priv2->mfc_control_RW); 252746deed69SLuke Browning spin_unlock_irq(&spu->register_lock); 252846deed69SLuke Browning } else { 252946deed69SLuke Browning struct spu_state *csa = &ctx->csa; 253046deed69SLuke Browning 253146deed69SLuke Browning mfc_control_RW = csa->priv2.mfc_control_RW; 253246deed69SLuke Browning } 253346deed69SLuke Browning 253446deed69SLuke Browning seq_printf(s, "%c flgs(%lx) sflgs(%lx) pri(%d) ts(%d) spu(%02d)" 25359477e455SStephen Rothwell " %c %llx %llx %llx %llx %x %x\n", 253646deed69SLuke Browning ctx->state == SPU_STATE_SAVED ? 'S' : 'R', 253746deed69SLuke Browning ctx->flags, 253846deed69SLuke Browning ctx->sched_flags, 253946deed69SLuke Browning ctx->prio, 254046deed69SLuke Browning ctx->time_slice, 254146deed69SLuke Browning ctx->spu ? ctx->spu->number : -1, 254246deed69SLuke Browning !list_empty(&ctx->rq) ? 'q' : ' ', 254346deed69SLuke Browning ctx->csa.class_0_pending, 254446deed69SLuke Browning ctx->csa.class_0_dar, 254546deed69SLuke Browning ctx->csa.class_1_dsisr, 254646deed69SLuke Browning mfc_control_RW, 254746deed69SLuke Browning ctx->ops->runcntl_read(ctx), 254846deed69SLuke Browning ctx->ops->status_read(ctx)); 254946deed69SLuke Browning 255046deed69SLuke Browning mutex_unlock(&ctx->state_mutex); 255146deed69SLuke Browning 255246deed69SLuke Browning return 0; 255346deed69SLuke Browning } 255446deed69SLuke Browning 255546deed69SLuke Browning static int spufs_ctx_open(struct inode *inode, struct file *file) 255646deed69SLuke Browning { 255746deed69SLuke Browning return single_open(file, spufs_show_ctx, SPUFS_I(inode)->i_ctx); 255846deed69SLuke Browning } 255946deed69SLuke Browning 256046deed69SLuke Browning static const struct file_operations spufs_ctx_fops = { 256146deed69SLuke Browning .open = spufs_ctx_open, 256246deed69SLuke Browning .read = seq_read, 256346deed69SLuke Browning .llseek = seq_lseek, 256446deed69SLuke Browning .release = single_release, 256546deed69SLuke Browning }; 256646deed69SLuke Browning 256774254647SJeremy Kerr const struct spufs_tree_descr spufs_dir_contents[] = { 2568cbe709c1SBenjamin Herrenschmidt { "capabilities", &spufs_caps_fops, 0444, }, 25696f7dde81SJeremy Kerr { "mem", &spufs_mem_fops, 0666, LS_SIZE, }, 25706f7dde81SJeremy Kerr { "regs", &spufs_regs_fops, 0666, sizeof(struct spu_reg128[128]), }, 257167207b96SArnd Bergmann { "mbox", &spufs_mbox_fops, 0444, }, 257267207b96SArnd Bergmann { "ibox", &spufs_ibox_fops, 0444, }, 257367207b96SArnd Bergmann { "wbox", &spufs_wbox_fops, 0222, }, 25746f7dde81SJeremy Kerr { "mbox_stat", &spufs_mbox_stat_fops, 0444, sizeof(u32), }, 25756f7dde81SJeremy Kerr { "ibox_stat", &spufs_ibox_stat_fops, 0444, sizeof(u32), }, 25766f7dde81SJeremy Kerr { "wbox_stat", &spufs_wbox_stat_fops, 0444, sizeof(u32), }, 2577603c4612SJeremy Kerr { "signal1", &spufs_signal1_fops, 0666, }, 2578603c4612SJeremy Kerr { "signal2", &spufs_signal2_fops, 0666, }, 257967207b96SArnd Bergmann { "signal1_type", &spufs_signal1_type, 0666, }, 258067207b96SArnd Bergmann { "signal2_type", &spufs_signal2_type, 0666, }, 25816df10a82SMark Nutter { "cntl", &spufs_cntl_fops, 0666, }, 25826f7dde81SJeremy Kerr { "fpcr", &spufs_fpcr_fops, 0666, sizeof(struct spu_reg128), }, 2583b9e3bd77SDwayne Grant McConnell { "lslr", &spufs_lslr_ops, 0444, }, 2584b9e3bd77SDwayne Grant McConnell { "mfc", &spufs_mfc_fops, 0666, }, 2585b9e3bd77SDwayne Grant McConnell { "mss", &spufs_mss_fops, 0666, }, 2586b9e3bd77SDwayne Grant McConnell { "npc", &spufs_npc_ops, 0666, }, 2587b9e3bd77SDwayne Grant McConnell { "srr0", &spufs_srr0_ops, 0666, }, 25888b3d6663SArnd Bergmann { "decr", &spufs_decr_ops, 0666, }, 25898b3d6663SArnd Bergmann { "decr_status", &spufs_decr_status_ops, 0666, }, 25908b3d6663SArnd Bergmann { "event_mask", &spufs_event_mask_ops, 0666, }, 2591b9e3bd77SDwayne Grant McConnell { "event_status", &spufs_event_status_ops, 0444, }, 25926f7dde81SJeremy Kerr { "psmap", &spufs_psmap_fops, 0666, SPUFS_PS_MAP_SIZE, }, 259386767277SArnd Bergmann { "phys-id", &spufs_id_ops, 0666, }, 259486767277SArnd Bergmann { "object-id", &spufs_object_id_ops, 0666, }, 25956f7dde81SJeremy Kerr { "mbox_info", &spufs_mbox_info_fops, 0444, sizeof(u32), }, 25966f7dde81SJeremy Kerr { "ibox_info", &spufs_ibox_info_fops, 0444, sizeof(u32), }, 25976f7dde81SJeremy Kerr { "wbox_info", &spufs_wbox_info_fops, 0444, sizeof(u32), }, 25986f7dde81SJeremy Kerr { "dma_info", &spufs_dma_info_fops, 0444, 25996f7dde81SJeremy Kerr sizeof(struct spu_dma_info), }, 26006f7dde81SJeremy Kerr { "proxydma_info", &spufs_proxydma_info_fops, 0444, 26016f7dde81SJeremy Kerr sizeof(struct spu_proxydma_info)}, 2602476273adSChristoph Hellwig { "tid", &spufs_tid_fops, 0444, }, 2603e9f8a0b6SChristoph Hellwig { "stat", &spufs_stat_fops, 0444, }, 26045158e9b5SChristoph Hellwig { "switch_log", &spufs_switch_log_fops, 0444 }, 260567207b96SArnd Bergmann {}, 260667207b96SArnd Bergmann }; 26075737edd1SMark Nutter 260874254647SJeremy Kerr const struct spufs_tree_descr spufs_dir_nosched_contents[] = { 2609cbe709c1SBenjamin Herrenschmidt { "capabilities", &spufs_caps_fops, 0444, }, 26106f7dde81SJeremy Kerr { "mem", &spufs_mem_fops, 0666, LS_SIZE, }, 26115737edd1SMark Nutter { "mbox", &spufs_mbox_fops, 0444, }, 26125737edd1SMark Nutter { "ibox", &spufs_ibox_fops, 0444, }, 26135737edd1SMark Nutter { "wbox", &spufs_wbox_fops, 0222, }, 26146f7dde81SJeremy Kerr { "mbox_stat", &spufs_mbox_stat_fops, 0444, sizeof(u32), }, 26156f7dde81SJeremy Kerr { "ibox_stat", &spufs_ibox_stat_fops, 0444, sizeof(u32), }, 26166f7dde81SJeremy Kerr { "wbox_stat", &spufs_wbox_stat_fops, 0444, sizeof(u32), }, 2617d054b36fSJeremy Kerr { "signal1", &spufs_signal1_nosched_fops, 0222, }, 2618d054b36fSJeremy Kerr { "signal2", &spufs_signal2_nosched_fops, 0222, }, 26195737edd1SMark Nutter { "signal1_type", &spufs_signal1_type, 0666, }, 26205737edd1SMark Nutter { "signal2_type", &spufs_signal2_type, 0666, }, 26215737edd1SMark Nutter { "mss", &spufs_mss_fops, 0666, }, 26225737edd1SMark Nutter { "mfc", &spufs_mfc_fops, 0666, }, 26235737edd1SMark Nutter { "cntl", &spufs_cntl_fops, 0666, }, 26245737edd1SMark Nutter { "npc", &spufs_npc_ops, 0666, }, 26256f7dde81SJeremy Kerr { "psmap", &spufs_psmap_fops, 0666, SPUFS_PS_MAP_SIZE, }, 26265737edd1SMark Nutter { "phys-id", &spufs_id_ops, 0666, }, 26275737edd1SMark Nutter { "object-id", &spufs_object_id_ops, 0666, }, 2628476273adSChristoph Hellwig { "tid", &spufs_tid_fops, 0444, }, 2629e9f8a0b6SChristoph Hellwig { "stat", &spufs_stat_fops, 0444, }, 26302c3e4787SJeremy Kerr {}, 26312c3e4787SJeremy Kerr }; 26322c3e4787SJeremy Kerr 263374254647SJeremy Kerr const struct spufs_tree_descr spufs_dir_debug_contents[] = { 263446deed69SLuke Browning { ".ctx", &spufs_ctx_fops, 0444, }, 26355737edd1SMark Nutter {}, 26365737edd1SMark Nutter }; 2637bf1ab978SDwayne Grant McConnell 263874254647SJeremy Kerr const struct spufs_coredump_reader spufs_coredump_read[] = { 26394fca9c42SMichael Ellerman { "regs", __spufs_regs_read, NULL, sizeof(struct spu_reg128[128])}, 26404fca9c42SMichael Ellerman { "fpcr", __spufs_fpcr_read, NULL, sizeof(struct spu_reg128) }, 2641104f0cc2SMichael Ellerman { "lslr", NULL, spufs_lslr_get, 19 }, 2642104f0cc2SMichael Ellerman { "decr", NULL, spufs_decr_get, 19 }, 2643104f0cc2SMichael Ellerman { "decr_status", NULL, spufs_decr_status_get, 19 }, 26444fca9c42SMichael Ellerman { "mem", __spufs_mem_read, NULL, LS_SIZE, }, 26454fca9c42SMichael Ellerman { "signal1", __spufs_signal1_read, NULL, sizeof(u32) }, 2646104f0cc2SMichael Ellerman { "signal1_type", NULL, spufs_signal1_type_get, 19 }, 26474fca9c42SMichael Ellerman { "signal2", __spufs_signal2_read, NULL, sizeof(u32) }, 2648104f0cc2SMichael Ellerman { "signal2_type", NULL, spufs_signal2_type_get, 19 }, 2649104f0cc2SMichael Ellerman { "event_mask", NULL, spufs_event_mask_get, 19 }, 2650104f0cc2SMichael Ellerman { "event_status", NULL, spufs_event_status_get, 19 }, 26514fca9c42SMichael Ellerman { "mbox_info", __spufs_mbox_info_read, NULL, sizeof(u32) }, 26524fca9c42SMichael Ellerman { "ibox_info", __spufs_ibox_info_read, NULL, sizeof(u32) }, 26534fca9c42SMichael Ellerman { "wbox_info", __spufs_wbox_info_read, NULL, 4 * sizeof(u32)}, 26544fca9c42SMichael Ellerman { "dma_info", __spufs_dma_info_read, NULL, sizeof(struct spu_dma_info)}, 26554fca9c42SMichael Ellerman { "proxydma_info", __spufs_proxydma_info_read, 26564fca9c42SMichael Ellerman NULL, sizeof(struct spu_proxydma_info)}, 2657104f0cc2SMichael Ellerman { "object-id", NULL, spufs_object_id_get, 19 }, 2658104f0cc2SMichael Ellerman { "npc", NULL, spufs_npc_get, 19 }, 2659936d5bf1SMichael Ellerman { NULL }, 2660bf1ab978SDwayne Grant McConnell }; 2661