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> 2767207b96SArnd Bergmann #include <linux/module.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> 3267207b96SArnd Bergmann 3367207b96SArnd Bergmann #include <asm/io.h> 3467207b96SArnd Bergmann #include <asm/semaphore.h> 3567207b96SArnd Bergmann #include <asm/spu.h> 36b9e3bd77SDwayne Grant McConnell #include <asm/spu_info.h> 3767207b96SArnd Bergmann #include <asm/uaccess.h> 3867207b96SArnd Bergmann 3967207b96SArnd Bergmann #include "spufs.h" 4067207b96SArnd Bergmann 4127d5bf2aSBenjamin Herrenschmidt #define SPUFS_MMAP_4K (PAGE_SIZE == 0x1000) 4227d5bf2aSBenjamin Herrenschmidt 43cbe709c1SBenjamin Herrenschmidt 4467207b96SArnd Bergmann static int 4567207b96SArnd Bergmann spufs_mem_open(struct inode *inode, struct file *file) 4667207b96SArnd Bergmann { 4767207b96SArnd Bergmann struct spufs_inode_info *i = SPUFS_I(inode); 486df10a82SMark Nutter struct spu_context *ctx = i->i_ctx; 4943c2bbd9SChristoph Hellwig 5047d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 516df10a82SMark Nutter file->private_data = ctx; 5243c2bbd9SChristoph Hellwig if (!i->i_openers++) 536df10a82SMark Nutter ctx->local_store = inode->i_mapping; 5447d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 5543c2bbd9SChristoph Hellwig return 0; 5643c2bbd9SChristoph Hellwig } 5743c2bbd9SChristoph Hellwig 5843c2bbd9SChristoph Hellwig static int 5943c2bbd9SChristoph Hellwig spufs_mem_release(struct inode *inode, struct file *file) 6043c2bbd9SChristoph Hellwig { 6143c2bbd9SChristoph Hellwig struct spufs_inode_info *i = SPUFS_I(inode); 6243c2bbd9SChristoph Hellwig struct spu_context *ctx = i->i_ctx; 6343c2bbd9SChristoph Hellwig 6447d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 6543c2bbd9SChristoph Hellwig if (!--i->i_openers) 6643c2bbd9SChristoph Hellwig ctx->local_store = NULL; 6747d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 6867207b96SArnd Bergmann return 0; 6967207b96SArnd Bergmann } 7067207b96SArnd Bergmann 7167207b96SArnd Bergmann static ssize_t 72bf1ab978SDwayne Grant McConnell __spufs_mem_read(struct spu_context *ctx, char __user *buffer, 73bf1ab978SDwayne Grant McConnell size_t size, loff_t *pos) 74bf1ab978SDwayne Grant McConnell { 75bf1ab978SDwayne Grant McConnell char *local_store = ctx->ops->get_ls(ctx); 76bf1ab978SDwayne Grant McConnell return simple_read_from_buffer(buffer, size, pos, local_store, 77bf1ab978SDwayne Grant McConnell LS_SIZE); 78bf1ab978SDwayne Grant McConnell } 79bf1ab978SDwayne Grant McConnell 80bf1ab978SDwayne Grant McConnell static ssize_t 8167207b96SArnd Bergmann spufs_mem_read(struct file *file, char __user *buffer, 8267207b96SArnd Bergmann size_t size, loff_t *pos) 8367207b96SArnd Bergmann { 84bf1ab978SDwayne Grant McConnell struct spu_context *ctx = file->private_data; 85aa0ed2bdSArnd Bergmann ssize_t ret; 8667207b96SArnd Bergmann 878b3d6663SArnd Bergmann spu_acquire(ctx); 88bf1ab978SDwayne Grant McConnell ret = __spufs_mem_read(ctx, buffer, size, pos); 898b3d6663SArnd Bergmann spu_release(ctx); 9067207b96SArnd Bergmann return ret; 9167207b96SArnd Bergmann } 9267207b96SArnd Bergmann 9367207b96SArnd Bergmann static ssize_t 9467207b96SArnd Bergmann spufs_mem_write(struct file *file, const char __user *buffer, 95aa0ed2bdSArnd Bergmann size_t size, loff_t *ppos) 9667207b96SArnd Bergmann { 9767207b96SArnd Bergmann struct spu_context *ctx = file->private_data; 988b3d6663SArnd Bergmann char *local_store; 99aa0ed2bdSArnd Bergmann loff_t pos = *ppos; 1008b3d6663SArnd Bergmann int ret; 10167207b96SArnd Bergmann 102aa0ed2bdSArnd Bergmann if (pos < 0) 103aa0ed2bdSArnd Bergmann return -EINVAL; 104aa0ed2bdSArnd Bergmann if (pos > LS_SIZE) 10567207b96SArnd Bergmann return -EFBIG; 106aa0ed2bdSArnd Bergmann if (size > LS_SIZE - pos) 107aa0ed2bdSArnd Bergmann size = LS_SIZE - pos; 1088b3d6663SArnd Bergmann 1098b3d6663SArnd Bergmann spu_acquire(ctx); 1108b3d6663SArnd Bergmann local_store = ctx->ops->get_ls(ctx); 111aa0ed2bdSArnd Bergmann ret = copy_from_user(local_store + pos, buffer, size); 1128b3d6663SArnd Bergmann spu_release(ctx); 113aa0ed2bdSArnd Bergmann 114aa0ed2bdSArnd Bergmann if (ret) 115aa0ed2bdSArnd Bergmann return -EFAULT; 116aa0ed2bdSArnd Bergmann *ppos = pos + size; 117aa0ed2bdSArnd Bergmann return size; 11867207b96SArnd Bergmann } 11967207b96SArnd Bergmann 12078bde53eSBenjamin Herrenschmidt static unsigned long spufs_mem_mmap_nopfn(struct vm_area_struct *vma, 12178bde53eSBenjamin Herrenschmidt unsigned long address) 1228b3d6663SArnd Bergmann { 1238b3d6663SArnd Bergmann struct spu_context *ctx = vma->vm_file->private_data; 124f1fa74f4SBenjamin Herrenschmidt unsigned long pfn, offset, addr0 = address; 125f1fa74f4SBenjamin Herrenschmidt #ifdef CONFIG_SPU_FS_64K_LS 126f1fa74f4SBenjamin Herrenschmidt struct spu_state *csa = &ctx->csa; 127f1fa74f4SBenjamin Herrenschmidt int psize; 12878bde53eSBenjamin Herrenschmidt 129f1fa74f4SBenjamin Herrenschmidt /* Check what page size we are using */ 130f1fa74f4SBenjamin Herrenschmidt psize = get_slice_psize(vma->vm_mm, address); 1318b3d6663SArnd Bergmann 132f1fa74f4SBenjamin Herrenschmidt /* Some sanity checking */ 133f1fa74f4SBenjamin Herrenschmidt BUG_ON(csa->use_big_pages != (psize == MMU_PAGE_64K)); 134f1fa74f4SBenjamin Herrenschmidt 135f1fa74f4SBenjamin Herrenschmidt /* Wow, 64K, cool, we need to align the address though */ 136f1fa74f4SBenjamin Herrenschmidt if (csa->use_big_pages) { 137f1fa74f4SBenjamin Herrenschmidt BUG_ON(vma->vm_start & 0xffff); 138f1fa74f4SBenjamin Herrenschmidt address &= ~0xfffful; 139f1fa74f4SBenjamin Herrenschmidt } 140f1fa74f4SBenjamin Herrenschmidt #endif /* CONFIG_SPU_FS_64K_LS */ 141f1fa74f4SBenjamin Herrenschmidt 142f1fa74f4SBenjamin Herrenschmidt offset = (address - vma->vm_start) + (vma->vm_pgoff << PAGE_SHIFT); 143128b8546SMasato Noguchi if (offset >= LS_SIZE) 144128b8546SMasato Noguchi return NOPFN_SIGBUS; 145128b8546SMasato Noguchi 146f1fa74f4SBenjamin Herrenschmidt pr_debug("spufs_mem_mmap_nopfn address=0x%lx -> 0x%lx, offset=0x%lx\n", 147f1fa74f4SBenjamin Herrenschmidt addr0, address, offset); 148f1fa74f4SBenjamin Herrenschmidt 1498b3d6663SArnd Bergmann spu_acquire(ctx); 1508b3d6663SArnd Bergmann 151ac91cb8dSArnd Bergmann if (ctx->state == SPU_STATE_SAVED) { 152ac91cb8dSArnd Bergmann vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot) 153932f535dSArnd Bergmann & ~_PAGE_NO_CACHE); 15478bde53eSBenjamin Herrenschmidt pfn = vmalloc_to_pfn(ctx->csa.lscsa->ls + offset); 155ac91cb8dSArnd Bergmann } else { 156ac91cb8dSArnd Bergmann vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot) 157932f535dSArnd Bergmann | _PAGE_NO_CACHE); 15878bde53eSBenjamin Herrenschmidt pfn = (ctx->spu->local_store_phys + offset) >> PAGE_SHIFT; 159ac91cb8dSArnd Bergmann } 16078bde53eSBenjamin Herrenschmidt vm_insert_pfn(vma, address, pfn); 16178bde53eSBenjamin Herrenschmidt 1628b3d6663SArnd Bergmann spu_release(ctx); 1638b3d6663SArnd Bergmann 16478bde53eSBenjamin Herrenschmidt return NOPFN_REFAULT; 1658b3d6663SArnd Bergmann } 1668b3d6663SArnd Bergmann 16778bde53eSBenjamin Herrenschmidt 1688b3d6663SArnd Bergmann static struct vm_operations_struct spufs_mem_mmap_vmops = { 16978bde53eSBenjamin Herrenschmidt .nopfn = spufs_mem_mmap_nopfn, 1708b3d6663SArnd Bergmann }; 1718b3d6663SArnd Bergmann 172f1fa74f4SBenjamin Herrenschmidt static int spufs_mem_mmap(struct file *file, struct vm_area_struct *vma) 17367207b96SArnd Bergmann { 174f1fa74f4SBenjamin Herrenschmidt #ifdef CONFIG_SPU_FS_64K_LS 175f1fa74f4SBenjamin Herrenschmidt struct spu_context *ctx = file->private_data; 176f1fa74f4SBenjamin Herrenschmidt struct spu_state *csa = &ctx->csa; 177f1fa74f4SBenjamin Herrenschmidt 178f1fa74f4SBenjamin Herrenschmidt /* Sanity check VMA alignment */ 179f1fa74f4SBenjamin Herrenschmidt if (csa->use_big_pages) { 180f1fa74f4SBenjamin Herrenschmidt pr_debug("spufs_mem_mmap 64K, start=0x%lx, end=0x%lx," 181f1fa74f4SBenjamin Herrenschmidt " pgoff=0x%lx\n", vma->vm_start, vma->vm_end, 182f1fa74f4SBenjamin Herrenschmidt vma->vm_pgoff); 183f1fa74f4SBenjamin Herrenschmidt if (vma->vm_start & 0xffff) 184f1fa74f4SBenjamin Herrenschmidt return -EINVAL; 185f1fa74f4SBenjamin Herrenschmidt if (vma->vm_pgoff & 0xf) 186f1fa74f4SBenjamin Herrenschmidt return -EINVAL; 187f1fa74f4SBenjamin Herrenschmidt } 188f1fa74f4SBenjamin Herrenschmidt #endif /* CONFIG_SPU_FS_64K_LS */ 189f1fa74f4SBenjamin Herrenschmidt 1908b3d6663SArnd Bergmann if (!(vma->vm_flags & VM_SHARED)) 1918b3d6663SArnd Bergmann return -EINVAL; 19267207b96SArnd Bergmann 19378bde53eSBenjamin Herrenschmidt vma->vm_flags |= VM_IO | VM_PFNMAP; 19467207b96SArnd Bergmann vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot) 19567207b96SArnd Bergmann | _PAGE_NO_CACHE); 1968b3d6663SArnd Bergmann 1978b3d6663SArnd Bergmann vma->vm_ops = &spufs_mem_mmap_vmops; 19867207b96SArnd Bergmann return 0; 19967207b96SArnd Bergmann } 20067207b96SArnd Bergmann 201f1fa74f4SBenjamin Herrenschmidt #ifdef CONFIG_SPU_FS_64K_LS 2021238819aSSebastian Siewior static unsigned long spufs_get_unmapped_area(struct file *file, 2031238819aSSebastian Siewior unsigned long addr, unsigned long len, unsigned long pgoff, 204f1fa74f4SBenjamin Herrenschmidt unsigned long flags) 205f1fa74f4SBenjamin Herrenschmidt { 206f1fa74f4SBenjamin Herrenschmidt struct spu_context *ctx = file->private_data; 207f1fa74f4SBenjamin Herrenschmidt struct spu_state *csa = &ctx->csa; 208f1fa74f4SBenjamin Herrenschmidt 209f1fa74f4SBenjamin Herrenschmidt /* If not using big pages, fallback to normal MM g_u_a */ 210f1fa74f4SBenjamin Herrenschmidt if (!csa->use_big_pages) 211f1fa74f4SBenjamin Herrenschmidt return current->mm->get_unmapped_area(file, addr, len, 212f1fa74f4SBenjamin Herrenschmidt pgoff, flags); 213f1fa74f4SBenjamin Herrenschmidt 214f1fa74f4SBenjamin Herrenschmidt /* Else, try to obtain a 64K pages slice */ 215f1fa74f4SBenjamin Herrenschmidt return slice_get_unmapped_area(addr, len, flags, 216f1fa74f4SBenjamin Herrenschmidt MMU_PAGE_64K, 1, 0); 217f1fa74f4SBenjamin Herrenschmidt } 218f1fa74f4SBenjamin Herrenschmidt #endif /* CONFIG_SPU_FS_64K_LS */ 219f1fa74f4SBenjamin Herrenschmidt 2205dfe4c96SArjan van de Ven static const struct file_operations spufs_mem_fops = { 22167207b96SArnd Bergmann .open = spufs_mem_open, 222ce92987bSChristoph Hellwig .release = spufs_mem_release, 22367207b96SArnd Bergmann .read = spufs_mem_read, 22467207b96SArnd Bergmann .write = spufs_mem_write, 2258b3d6663SArnd Bergmann .llseek = generic_file_llseek, 22667207b96SArnd Bergmann .mmap = spufs_mem_mmap, 227f1fa74f4SBenjamin Herrenschmidt #ifdef CONFIG_SPU_FS_64K_LS 228f1fa74f4SBenjamin Herrenschmidt .get_unmapped_area = spufs_get_unmapped_area, 229f1fa74f4SBenjamin Herrenschmidt #endif 2308b3d6663SArnd Bergmann }; 2318b3d6663SArnd Bergmann 23278bde53eSBenjamin Herrenschmidt static unsigned long spufs_ps_nopfn(struct vm_area_struct *vma, 2336df10a82SMark Nutter unsigned long address, 23478bde53eSBenjamin Herrenschmidt unsigned long ps_offs, 23527d5bf2aSBenjamin Herrenschmidt unsigned long ps_size) 2366df10a82SMark Nutter { 2376df10a82SMark Nutter struct spu_context *ctx = vma->vm_file->private_data; 23878bde53eSBenjamin Herrenschmidt unsigned long area, offset = address - vma->vm_start; 2396df10a82SMark Nutter 2406df10a82SMark Nutter offset += vma->vm_pgoff << PAGE_SHIFT; 24127d5bf2aSBenjamin Herrenschmidt if (offset >= ps_size) 24278bde53eSBenjamin Herrenschmidt return NOPFN_SIGBUS; 2436df10a82SMark Nutter 24433bfd7a7SArnd Bergmann /* 24533bfd7a7SArnd Bergmann * We have to wait for context to be loaded before we have 24633bfd7a7SArnd Bergmann * pages to hand out to the user, but we don't want to wait 24733bfd7a7SArnd Bergmann * with the mmap_sem held. 24833bfd7a7SArnd Bergmann * It is possible to drop the mmap_sem here, but then we need 24933bfd7a7SArnd Bergmann * to return NOPFN_REFAULT because the mappings may have 25033bfd7a7SArnd Bergmann * hanged. 25178bde53eSBenjamin Herrenschmidt */ 25233bfd7a7SArnd Bergmann spu_acquire(ctx); 25333bfd7a7SArnd Bergmann if (ctx->state == SPU_STATE_SAVED) { 25433bfd7a7SArnd Bergmann up_read(¤t->mm->mmap_sem); 25533bfd7a7SArnd Bergmann spufs_wait(ctx->run_wq, ctx->state == SPU_STATE_RUNNABLE); 25633bfd7a7SArnd Bergmann down_read(¤t->mm->mmap_sem); 25733bfd7a7SArnd Bergmann goto out; 25833bfd7a7SArnd Bergmann } 2596df10a82SMark Nutter 2606df10a82SMark Nutter area = ctx->spu->problem_phys + ps_offs; 26178bde53eSBenjamin Herrenschmidt vm_insert_pfn(vma, address, (area + offset) >> PAGE_SHIFT); 26233bfd7a7SArnd Bergmann 26333bfd7a7SArnd Bergmann out: 2646df10a82SMark Nutter spu_release(ctx); 2656df10a82SMark Nutter 26678bde53eSBenjamin Herrenschmidt return NOPFN_REFAULT; 2676df10a82SMark Nutter } 2686df10a82SMark Nutter 26927d5bf2aSBenjamin Herrenschmidt #if SPUFS_MMAP_4K 27078bde53eSBenjamin Herrenschmidt static unsigned long spufs_cntl_mmap_nopfn(struct vm_area_struct *vma, 27178bde53eSBenjamin Herrenschmidt unsigned long address) 2726df10a82SMark Nutter { 27378bde53eSBenjamin Herrenschmidt return spufs_ps_nopfn(vma, address, 0x4000, 0x1000); 2746df10a82SMark Nutter } 2756df10a82SMark Nutter 2766df10a82SMark Nutter static struct vm_operations_struct spufs_cntl_mmap_vmops = { 27778bde53eSBenjamin Herrenschmidt .nopfn = spufs_cntl_mmap_nopfn, 2786df10a82SMark Nutter }; 2796df10a82SMark Nutter 2806df10a82SMark Nutter /* 2816df10a82SMark Nutter * mmap support for problem state control area [0x4000 - 0x4fff]. 2826df10a82SMark Nutter */ 2836df10a82SMark Nutter static int spufs_cntl_mmap(struct file *file, struct vm_area_struct *vma) 2846df10a82SMark Nutter { 2856df10a82SMark Nutter if (!(vma->vm_flags & VM_SHARED)) 2866df10a82SMark Nutter return -EINVAL; 2876df10a82SMark Nutter 28878bde53eSBenjamin Herrenschmidt vma->vm_flags |= VM_IO | VM_PFNMAP; 2896df10a82SMark Nutter vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot) 29023cc7701SBenjamin Herrenschmidt | _PAGE_NO_CACHE | _PAGE_GUARDED); 2916df10a82SMark Nutter 2926df10a82SMark Nutter vma->vm_ops = &spufs_cntl_mmap_vmops; 2936df10a82SMark Nutter return 0; 2946df10a82SMark Nutter } 29527d5bf2aSBenjamin Herrenschmidt #else /* SPUFS_MMAP_4K */ 29627d5bf2aSBenjamin Herrenschmidt #define spufs_cntl_mmap NULL 29727d5bf2aSBenjamin Herrenschmidt #endif /* !SPUFS_MMAP_4K */ 2986df10a82SMark Nutter 299e1dbff2bSArnd Bergmann static u64 spufs_cntl_get(void *data) 300e1dbff2bSArnd Bergmann { 301e1dbff2bSArnd Bergmann struct spu_context *ctx = data; 302e1dbff2bSArnd Bergmann u64 val; 303e1dbff2bSArnd Bergmann 304e1dbff2bSArnd Bergmann spu_acquire(ctx); 305e1dbff2bSArnd Bergmann val = ctx->ops->status_read(ctx); 306e1dbff2bSArnd Bergmann spu_release(ctx); 307e1dbff2bSArnd Bergmann 308e1dbff2bSArnd Bergmann return val; 309e1dbff2bSArnd Bergmann } 310e1dbff2bSArnd Bergmann 311e1dbff2bSArnd Bergmann static void spufs_cntl_set(void *data, u64 val) 312e1dbff2bSArnd Bergmann { 313e1dbff2bSArnd Bergmann struct spu_context *ctx = data; 314e1dbff2bSArnd Bergmann 315e1dbff2bSArnd Bergmann spu_acquire(ctx); 316e1dbff2bSArnd Bergmann ctx->ops->runcntl_write(ctx, val); 317e1dbff2bSArnd Bergmann spu_release(ctx); 318e1dbff2bSArnd Bergmann } 319e1dbff2bSArnd Bergmann 3206df10a82SMark Nutter static int spufs_cntl_open(struct inode *inode, struct file *file) 3216df10a82SMark Nutter { 3226df10a82SMark Nutter struct spufs_inode_info *i = SPUFS_I(inode); 3236df10a82SMark Nutter struct spu_context *ctx = i->i_ctx; 3246df10a82SMark Nutter 32547d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 3266df10a82SMark Nutter file->private_data = ctx; 32743c2bbd9SChristoph Hellwig if (!i->i_openers++) 3286df10a82SMark Nutter ctx->cntl = inode->i_mapping; 32947d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 330e1dbff2bSArnd Bergmann return simple_attr_open(inode, file, spufs_cntl_get, 331e1dbff2bSArnd Bergmann spufs_cntl_set, "0x%08lx"); 3326df10a82SMark Nutter } 3336df10a82SMark Nutter 33443c2bbd9SChristoph Hellwig static int 33543c2bbd9SChristoph Hellwig spufs_cntl_release(struct inode *inode, struct file *file) 33643c2bbd9SChristoph Hellwig { 33743c2bbd9SChristoph Hellwig struct spufs_inode_info *i = SPUFS_I(inode); 33843c2bbd9SChristoph Hellwig struct spu_context *ctx = i->i_ctx; 33943c2bbd9SChristoph Hellwig 34043c2bbd9SChristoph Hellwig simple_attr_close(inode, file); 34143c2bbd9SChristoph Hellwig 34247d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 34343c2bbd9SChristoph Hellwig if (!--i->i_openers) 34443c2bbd9SChristoph Hellwig ctx->cntl = NULL; 34547d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 34643c2bbd9SChristoph Hellwig return 0; 34743c2bbd9SChristoph Hellwig } 34843c2bbd9SChristoph Hellwig 3495dfe4c96SArjan van de Ven static const struct file_operations spufs_cntl_fops = { 3506df10a82SMark Nutter .open = spufs_cntl_open, 35143c2bbd9SChristoph Hellwig .release = spufs_cntl_release, 352e1dbff2bSArnd Bergmann .read = simple_attr_read, 353e1dbff2bSArnd Bergmann .write = simple_attr_write, 3546df10a82SMark Nutter .mmap = spufs_cntl_mmap, 3556df10a82SMark Nutter }; 3566df10a82SMark Nutter 3578b3d6663SArnd Bergmann static int 3588b3d6663SArnd Bergmann spufs_regs_open(struct inode *inode, struct file *file) 3598b3d6663SArnd Bergmann { 3608b3d6663SArnd Bergmann struct spufs_inode_info *i = SPUFS_I(inode); 3618b3d6663SArnd Bergmann file->private_data = i->i_ctx; 3628b3d6663SArnd Bergmann return 0; 3638b3d6663SArnd Bergmann } 3648b3d6663SArnd Bergmann 3658b3d6663SArnd Bergmann static ssize_t 366bf1ab978SDwayne Grant McConnell __spufs_regs_read(struct spu_context *ctx, char __user *buffer, 367bf1ab978SDwayne Grant McConnell size_t size, loff_t *pos) 368bf1ab978SDwayne Grant McConnell { 369bf1ab978SDwayne Grant McConnell struct spu_lscsa *lscsa = ctx->csa.lscsa; 370bf1ab978SDwayne Grant McConnell return simple_read_from_buffer(buffer, size, pos, 371bf1ab978SDwayne Grant McConnell lscsa->gprs, sizeof lscsa->gprs); 372bf1ab978SDwayne Grant McConnell } 373bf1ab978SDwayne Grant McConnell 374bf1ab978SDwayne Grant McConnell static ssize_t 3758b3d6663SArnd Bergmann spufs_regs_read(struct file *file, char __user *buffer, 3768b3d6663SArnd Bergmann size_t size, loff_t *pos) 3778b3d6663SArnd Bergmann { 3788b3d6663SArnd Bergmann int ret; 379bf1ab978SDwayne Grant McConnell struct spu_context *ctx = file->private_data; 3808b3d6663SArnd Bergmann 3818b3d6663SArnd Bergmann spu_acquire_saved(ctx); 382bf1ab978SDwayne Grant McConnell ret = __spufs_regs_read(ctx, buffer, size, pos); 38327b1ea09SChristoph Hellwig spu_release_saved(ctx); 3848b3d6663SArnd Bergmann return ret; 3858b3d6663SArnd Bergmann } 3868b3d6663SArnd Bergmann 3878b3d6663SArnd Bergmann static ssize_t 3888b3d6663SArnd Bergmann spufs_regs_write(struct file *file, const char __user *buffer, 3898b3d6663SArnd Bergmann size_t size, loff_t *pos) 3908b3d6663SArnd Bergmann { 3918b3d6663SArnd Bergmann struct spu_context *ctx = file->private_data; 3928b3d6663SArnd Bergmann struct spu_lscsa *lscsa = ctx->csa.lscsa; 3938b3d6663SArnd Bergmann int ret; 3948b3d6663SArnd Bergmann 3958b3d6663SArnd Bergmann size = min_t(ssize_t, sizeof lscsa->gprs - *pos, size); 3968b3d6663SArnd Bergmann if (size <= 0) 3978b3d6663SArnd Bergmann return -EFBIG; 3988b3d6663SArnd Bergmann *pos += size; 3998b3d6663SArnd Bergmann 4008b3d6663SArnd Bergmann spu_acquire_saved(ctx); 4018b3d6663SArnd Bergmann 4028b3d6663SArnd Bergmann ret = copy_from_user(lscsa->gprs + *pos - size, 4038b3d6663SArnd Bergmann buffer, size) ? -EFAULT : size; 4048b3d6663SArnd Bergmann 40527b1ea09SChristoph Hellwig spu_release_saved(ctx); 4068b3d6663SArnd Bergmann return ret; 4078b3d6663SArnd Bergmann } 4088b3d6663SArnd Bergmann 4095dfe4c96SArjan van de Ven static const struct file_operations spufs_regs_fops = { 4108b3d6663SArnd Bergmann .open = spufs_regs_open, 4118b3d6663SArnd Bergmann .read = spufs_regs_read, 4128b3d6663SArnd Bergmann .write = spufs_regs_write, 4138b3d6663SArnd Bergmann .llseek = generic_file_llseek, 4148b3d6663SArnd Bergmann }; 4158b3d6663SArnd Bergmann 4168b3d6663SArnd Bergmann static ssize_t 417bf1ab978SDwayne Grant McConnell __spufs_fpcr_read(struct spu_context *ctx, char __user * buffer, 418bf1ab978SDwayne Grant McConnell size_t size, loff_t * pos) 419bf1ab978SDwayne Grant McConnell { 420bf1ab978SDwayne Grant McConnell struct spu_lscsa *lscsa = ctx->csa.lscsa; 421bf1ab978SDwayne Grant McConnell return simple_read_from_buffer(buffer, size, pos, 422bf1ab978SDwayne Grant McConnell &lscsa->fpcr, sizeof(lscsa->fpcr)); 423bf1ab978SDwayne Grant McConnell } 424bf1ab978SDwayne Grant McConnell 425bf1ab978SDwayne Grant McConnell static ssize_t 4268b3d6663SArnd Bergmann spufs_fpcr_read(struct file *file, char __user * buffer, 4278b3d6663SArnd Bergmann size_t size, loff_t * pos) 4288b3d6663SArnd Bergmann { 4298b3d6663SArnd Bergmann int ret; 430bf1ab978SDwayne Grant McConnell struct spu_context *ctx = file->private_data; 4318b3d6663SArnd Bergmann 4328b3d6663SArnd Bergmann spu_acquire_saved(ctx); 433bf1ab978SDwayne Grant McConnell ret = __spufs_fpcr_read(ctx, buffer, size, pos); 43427b1ea09SChristoph Hellwig spu_release_saved(ctx); 4358b3d6663SArnd Bergmann return ret; 4368b3d6663SArnd Bergmann } 4378b3d6663SArnd Bergmann 4388b3d6663SArnd Bergmann static ssize_t 4398b3d6663SArnd Bergmann spufs_fpcr_write(struct file *file, const char __user * buffer, 4408b3d6663SArnd Bergmann size_t size, loff_t * pos) 4418b3d6663SArnd Bergmann { 4428b3d6663SArnd Bergmann struct spu_context *ctx = file->private_data; 4438b3d6663SArnd Bergmann struct spu_lscsa *lscsa = ctx->csa.lscsa; 4448b3d6663SArnd Bergmann int ret; 4458b3d6663SArnd Bergmann 4468b3d6663SArnd Bergmann size = min_t(ssize_t, sizeof(lscsa->fpcr) - *pos, size); 4478b3d6663SArnd Bergmann if (size <= 0) 4488b3d6663SArnd Bergmann return -EFBIG; 4498b3d6663SArnd Bergmann *pos += size; 4508b3d6663SArnd Bergmann 4518b3d6663SArnd Bergmann spu_acquire_saved(ctx); 4528b3d6663SArnd Bergmann 4538b3d6663SArnd Bergmann ret = copy_from_user((char *)&lscsa->fpcr + *pos - size, 4548b3d6663SArnd Bergmann buffer, size) ? -EFAULT : size; 4558b3d6663SArnd Bergmann 45627b1ea09SChristoph Hellwig spu_release_saved(ctx); 4578b3d6663SArnd Bergmann return ret; 4588b3d6663SArnd Bergmann } 4598b3d6663SArnd Bergmann 4605dfe4c96SArjan van de Ven static const struct file_operations spufs_fpcr_fops = { 4618b3d6663SArnd Bergmann .open = spufs_regs_open, 4628b3d6663SArnd Bergmann .read = spufs_fpcr_read, 4638b3d6663SArnd Bergmann .write = spufs_fpcr_write, 46467207b96SArnd Bergmann .llseek = generic_file_llseek, 46567207b96SArnd Bergmann }; 46667207b96SArnd Bergmann 46767207b96SArnd Bergmann /* generic open function for all pipe-like files */ 46867207b96SArnd Bergmann static int spufs_pipe_open(struct inode *inode, struct file *file) 46967207b96SArnd Bergmann { 47067207b96SArnd Bergmann struct spufs_inode_info *i = SPUFS_I(inode); 47167207b96SArnd Bergmann file->private_data = i->i_ctx; 47267207b96SArnd Bergmann 47367207b96SArnd Bergmann return nonseekable_open(inode, file); 47467207b96SArnd Bergmann } 47567207b96SArnd Bergmann 476cdcc89bbSArnd Bergmann /* 477cdcc89bbSArnd Bergmann * Read as many bytes from the mailbox as possible, until 478cdcc89bbSArnd Bergmann * one of the conditions becomes true: 479cdcc89bbSArnd Bergmann * 480cdcc89bbSArnd Bergmann * - no more data available in the mailbox 481cdcc89bbSArnd Bergmann * - end of the user provided buffer 482cdcc89bbSArnd Bergmann * - end of the mapped area 483cdcc89bbSArnd Bergmann */ 48467207b96SArnd Bergmann static ssize_t spufs_mbox_read(struct file *file, char __user *buf, 48567207b96SArnd Bergmann size_t len, loff_t *pos) 48667207b96SArnd Bergmann { 4878b3d6663SArnd Bergmann struct spu_context *ctx = file->private_data; 488cdcc89bbSArnd Bergmann u32 mbox_data, __user *udata; 489cdcc89bbSArnd Bergmann ssize_t count; 49067207b96SArnd Bergmann 49167207b96SArnd Bergmann if (len < 4) 49267207b96SArnd Bergmann return -EINVAL; 49367207b96SArnd Bergmann 494cdcc89bbSArnd Bergmann if (!access_ok(VERIFY_WRITE, buf, len)) 49567207b96SArnd Bergmann return -EFAULT; 49667207b96SArnd Bergmann 497cdcc89bbSArnd Bergmann udata = (void __user *)buf; 498cdcc89bbSArnd Bergmann 499cdcc89bbSArnd Bergmann spu_acquire(ctx); 500274cef5eSArnd Bergmann for (count = 0; (count + 4) <= len; count += 4, udata++) { 501cdcc89bbSArnd Bergmann int ret; 502cdcc89bbSArnd Bergmann ret = ctx->ops->mbox_read(ctx, &mbox_data); 503cdcc89bbSArnd Bergmann if (ret == 0) 504cdcc89bbSArnd Bergmann break; 505cdcc89bbSArnd Bergmann 506cdcc89bbSArnd Bergmann /* 507cdcc89bbSArnd Bergmann * at the end of the mapped area, we can fault 508cdcc89bbSArnd Bergmann * but still need to return the data we have 509cdcc89bbSArnd Bergmann * read successfully so far. 510cdcc89bbSArnd Bergmann */ 511cdcc89bbSArnd Bergmann ret = __put_user(mbox_data, udata); 512cdcc89bbSArnd Bergmann if (ret) { 513cdcc89bbSArnd Bergmann if (!count) 514cdcc89bbSArnd Bergmann count = -EFAULT; 515cdcc89bbSArnd Bergmann break; 516cdcc89bbSArnd Bergmann } 517cdcc89bbSArnd Bergmann } 518cdcc89bbSArnd Bergmann spu_release(ctx); 519cdcc89bbSArnd Bergmann 520cdcc89bbSArnd Bergmann if (!count) 521cdcc89bbSArnd Bergmann count = -EAGAIN; 522cdcc89bbSArnd Bergmann 523cdcc89bbSArnd Bergmann return count; 52467207b96SArnd Bergmann } 52567207b96SArnd Bergmann 5265dfe4c96SArjan van de Ven static const struct file_operations spufs_mbox_fops = { 52767207b96SArnd Bergmann .open = spufs_pipe_open, 52867207b96SArnd Bergmann .read = spufs_mbox_read, 52967207b96SArnd Bergmann }; 53067207b96SArnd Bergmann 53167207b96SArnd Bergmann static ssize_t spufs_mbox_stat_read(struct file *file, char __user *buf, 53267207b96SArnd Bergmann size_t len, loff_t *pos) 53367207b96SArnd Bergmann { 5348b3d6663SArnd Bergmann struct spu_context *ctx = file->private_data; 53567207b96SArnd Bergmann u32 mbox_stat; 53667207b96SArnd Bergmann 53767207b96SArnd Bergmann if (len < 4) 53867207b96SArnd Bergmann return -EINVAL; 53967207b96SArnd Bergmann 5408b3d6663SArnd Bergmann spu_acquire(ctx); 5418b3d6663SArnd Bergmann 5428b3d6663SArnd Bergmann mbox_stat = ctx->ops->mbox_stat_read(ctx) & 0xff; 5438b3d6663SArnd Bergmann 5448b3d6663SArnd Bergmann spu_release(ctx); 54567207b96SArnd Bergmann 54667207b96SArnd Bergmann if (copy_to_user(buf, &mbox_stat, sizeof mbox_stat)) 54767207b96SArnd Bergmann return -EFAULT; 54867207b96SArnd Bergmann 54967207b96SArnd Bergmann return 4; 55067207b96SArnd Bergmann } 55167207b96SArnd Bergmann 5525dfe4c96SArjan van de Ven static const struct file_operations spufs_mbox_stat_fops = { 55367207b96SArnd Bergmann .open = spufs_pipe_open, 55467207b96SArnd Bergmann .read = spufs_mbox_stat_read, 55567207b96SArnd Bergmann }; 55667207b96SArnd Bergmann 55767207b96SArnd Bergmann /* low-level ibox access function */ 5588b3d6663SArnd Bergmann size_t spu_ibox_read(struct spu_context *ctx, u32 *data) 55967207b96SArnd Bergmann { 5608b3d6663SArnd Bergmann return ctx->ops->ibox_read(ctx, data); 56167207b96SArnd Bergmann } 56267207b96SArnd Bergmann 56367207b96SArnd Bergmann static int spufs_ibox_fasync(int fd, struct file *file, int on) 56467207b96SArnd Bergmann { 5658b3d6663SArnd Bergmann struct spu_context *ctx = file->private_data; 5668b3d6663SArnd Bergmann 5678b3d6663SArnd Bergmann return fasync_helper(fd, file, on, &ctx->ibox_fasync); 5688b3d6663SArnd Bergmann } 5698b3d6663SArnd Bergmann 5708b3d6663SArnd Bergmann /* interrupt-level ibox callback function. */ 5718b3d6663SArnd Bergmann void spufs_ibox_callback(struct spu *spu) 5728b3d6663SArnd Bergmann { 5738b3d6663SArnd Bergmann struct spu_context *ctx = spu->ctx; 5748b3d6663SArnd Bergmann 5758b3d6663SArnd Bergmann wake_up_all(&ctx->ibox_wq); 5768b3d6663SArnd Bergmann kill_fasync(&ctx->ibox_fasync, SIGIO, POLLIN); 57767207b96SArnd Bergmann } 57867207b96SArnd Bergmann 579cdcc89bbSArnd Bergmann /* 580cdcc89bbSArnd Bergmann * Read as many bytes from the interrupt mailbox as possible, until 581cdcc89bbSArnd Bergmann * one of the conditions becomes true: 582cdcc89bbSArnd Bergmann * 583cdcc89bbSArnd Bergmann * - no more data available in the mailbox 584cdcc89bbSArnd Bergmann * - end of the user provided buffer 585cdcc89bbSArnd Bergmann * - end of the mapped area 586cdcc89bbSArnd Bergmann * 587cdcc89bbSArnd Bergmann * If the file is opened without O_NONBLOCK, we wait here until 588cdcc89bbSArnd Bergmann * any data is available, but return when we have been able to 589cdcc89bbSArnd Bergmann * read something. 590cdcc89bbSArnd Bergmann */ 59167207b96SArnd Bergmann static ssize_t spufs_ibox_read(struct file *file, char __user *buf, 59267207b96SArnd Bergmann size_t len, loff_t *pos) 59367207b96SArnd Bergmann { 5948b3d6663SArnd Bergmann struct spu_context *ctx = file->private_data; 595cdcc89bbSArnd Bergmann u32 ibox_data, __user *udata; 596cdcc89bbSArnd Bergmann ssize_t count; 59767207b96SArnd Bergmann 59867207b96SArnd Bergmann if (len < 4) 59967207b96SArnd Bergmann return -EINVAL; 60067207b96SArnd Bergmann 601cdcc89bbSArnd Bergmann if (!access_ok(VERIFY_WRITE, buf, len)) 602cdcc89bbSArnd Bergmann return -EFAULT; 603cdcc89bbSArnd Bergmann 604cdcc89bbSArnd Bergmann udata = (void __user *)buf; 605cdcc89bbSArnd Bergmann 6068b3d6663SArnd Bergmann spu_acquire(ctx); 60767207b96SArnd Bergmann 608cdcc89bbSArnd Bergmann /* wait only for the first element */ 609cdcc89bbSArnd Bergmann count = 0; 61067207b96SArnd Bergmann if (file->f_flags & O_NONBLOCK) { 6118b3d6663SArnd Bergmann if (!spu_ibox_read(ctx, &ibox_data)) 612cdcc89bbSArnd Bergmann count = -EAGAIN; 61367207b96SArnd Bergmann } else { 614cdcc89bbSArnd Bergmann count = spufs_wait(ctx->ibox_wq, spu_ibox_read(ctx, &ibox_data)); 615cdcc89bbSArnd Bergmann } 616cdcc89bbSArnd Bergmann if (count) 617cdcc89bbSArnd Bergmann goto out; 618cdcc89bbSArnd Bergmann 619cdcc89bbSArnd Bergmann /* if we can't write at all, return -EFAULT */ 620cdcc89bbSArnd Bergmann count = __put_user(ibox_data, udata); 621cdcc89bbSArnd Bergmann if (count) 622cdcc89bbSArnd Bergmann goto out; 623cdcc89bbSArnd Bergmann 624cdcc89bbSArnd Bergmann for (count = 4, udata++; (count + 4) <= len; count += 4, udata++) { 625cdcc89bbSArnd Bergmann int ret; 626cdcc89bbSArnd Bergmann ret = ctx->ops->ibox_read(ctx, &ibox_data); 627cdcc89bbSArnd Bergmann if (ret == 0) 628cdcc89bbSArnd Bergmann break; 629cdcc89bbSArnd Bergmann /* 630cdcc89bbSArnd Bergmann * at the end of the mapped area, we can fault 631cdcc89bbSArnd Bergmann * but still need to return the data we have 632cdcc89bbSArnd Bergmann * read successfully so far. 633cdcc89bbSArnd Bergmann */ 634cdcc89bbSArnd Bergmann ret = __put_user(ibox_data, udata); 635cdcc89bbSArnd Bergmann if (ret) 636cdcc89bbSArnd Bergmann break; 63767207b96SArnd Bergmann } 63867207b96SArnd Bergmann 639cdcc89bbSArnd Bergmann out: 6408b3d6663SArnd Bergmann spu_release(ctx); 6418b3d6663SArnd Bergmann 642cdcc89bbSArnd Bergmann return count; 64367207b96SArnd Bergmann } 64467207b96SArnd Bergmann 64567207b96SArnd Bergmann static unsigned int spufs_ibox_poll(struct file *file, poll_table *wait) 64667207b96SArnd Bergmann { 6478b3d6663SArnd Bergmann struct spu_context *ctx = file->private_data; 64867207b96SArnd Bergmann unsigned int mask; 64967207b96SArnd Bergmann 6508b3d6663SArnd Bergmann poll_wait(file, &ctx->ibox_wq, wait); 65167207b96SArnd Bergmann 6523a843d7cSArnd Bergmann spu_acquire(ctx); 6533a843d7cSArnd Bergmann mask = ctx->ops->mbox_stat_poll(ctx, POLLIN | POLLRDNORM); 6543a843d7cSArnd Bergmann spu_release(ctx); 65567207b96SArnd Bergmann 65667207b96SArnd Bergmann return mask; 65767207b96SArnd Bergmann } 65867207b96SArnd Bergmann 6595dfe4c96SArjan van de Ven static const struct file_operations spufs_ibox_fops = { 66067207b96SArnd Bergmann .open = spufs_pipe_open, 66167207b96SArnd Bergmann .read = spufs_ibox_read, 66267207b96SArnd Bergmann .poll = spufs_ibox_poll, 66367207b96SArnd Bergmann .fasync = spufs_ibox_fasync, 66467207b96SArnd Bergmann }; 66567207b96SArnd Bergmann 66667207b96SArnd Bergmann static ssize_t spufs_ibox_stat_read(struct file *file, char __user *buf, 66767207b96SArnd Bergmann size_t len, loff_t *pos) 66867207b96SArnd Bergmann { 6698b3d6663SArnd Bergmann struct spu_context *ctx = file->private_data; 67067207b96SArnd Bergmann u32 ibox_stat; 67167207b96SArnd Bergmann 67267207b96SArnd Bergmann if (len < 4) 67367207b96SArnd Bergmann return -EINVAL; 67467207b96SArnd Bergmann 6758b3d6663SArnd Bergmann spu_acquire(ctx); 6768b3d6663SArnd Bergmann ibox_stat = (ctx->ops->mbox_stat_read(ctx) >> 16) & 0xff; 6778b3d6663SArnd Bergmann spu_release(ctx); 67867207b96SArnd Bergmann 67967207b96SArnd Bergmann if (copy_to_user(buf, &ibox_stat, sizeof ibox_stat)) 68067207b96SArnd Bergmann return -EFAULT; 68167207b96SArnd Bergmann 68267207b96SArnd Bergmann return 4; 68367207b96SArnd Bergmann } 68467207b96SArnd Bergmann 6855dfe4c96SArjan van de Ven static const struct file_operations spufs_ibox_stat_fops = { 68667207b96SArnd Bergmann .open = spufs_pipe_open, 68767207b96SArnd Bergmann .read = spufs_ibox_stat_read, 68867207b96SArnd Bergmann }; 68967207b96SArnd Bergmann 69067207b96SArnd Bergmann /* low-level mailbox write */ 6918b3d6663SArnd Bergmann size_t spu_wbox_write(struct spu_context *ctx, u32 data) 69267207b96SArnd Bergmann { 6938b3d6663SArnd Bergmann return ctx->ops->wbox_write(ctx, data); 69467207b96SArnd Bergmann } 69567207b96SArnd Bergmann 69667207b96SArnd Bergmann static int spufs_wbox_fasync(int fd, struct file *file, int on) 69767207b96SArnd Bergmann { 6988b3d6663SArnd Bergmann struct spu_context *ctx = file->private_data; 6998b3d6663SArnd Bergmann int ret; 7008b3d6663SArnd Bergmann 7018b3d6663SArnd Bergmann ret = fasync_helper(fd, file, on, &ctx->wbox_fasync); 7028b3d6663SArnd Bergmann 7038b3d6663SArnd Bergmann return ret; 7048b3d6663SArnd Bergmann } 7058b3d6663SArnd Bergmann 7068b3d6663SArnd Bergmann /* interrupt-level wbox callback function. */ 7078b3d6663SArnd Bergmann void spufs_wbox_callback(struct spu *spu) 7088b3d6663SArnd Bergmann { 7098b3d6663SArnd Bergmann struct spu_context *ctx = spu->ctx; 7108b3d6663SArnd Bergmann 7118b3d6663SArnd Bergmann wake_up_all(&ctx->wbox_wq); 7128b3d6663SArnd Bergmann kill_fasync(&ctx->wbox_fasync, SIGIO, POLLOUT); 71367207b96SArnd Bergmann } 71467207b96SArnd Bergmann 715cdcc89bbSArnd Bergmann /* 716cdcc89bbSArnd Bergmann * Write as many bytes to the interrupt mailbox as possible, until 717cdcc89bbSArnd Bergmann * one of the conditions becomes true: 718cdcc89bbSArnd Bergmann * 719cdcc89bbSArnd Bergmann * - the mailbox is full 720cdcc89bbSArnd Bergmann * - end of the user provided buffer 721cdcc89bbSArnd Bergmann * - end of the mapped area 722cdcc89bbSArnd Bergmann * 723cdcc89bbSArnd Bergmann * If the file is opened without O_NONBLOCK, we wait here until 724cdcc89bbSArnd Bergmann * space is availabyl, but return when we have been able to 725cdcc89bbSArnd Bergmann * write something. 726cdcc89bbSArnd Bergmann */ 72767207b96SArnd Bergmann static ssize_t spufs_wbox_write(struct file *file, const char __user *buf, 72867207b96SArnd Bergmann size_t len, loff_t *pos) 72967207b96SArnd Bergmann { 7308b3d6663SArnd Bergmann struct spu_context *ctx = file->private_data; 731cdcc89bbSArnd Bergmann u32 wbox_data, __user *udata; 732cdcc89bbSArnd Bergmann ssize_t count; 73367207b96SArnd Bergmann 73467207b96SArnd Bergmann if (len < 4) 73567207b96SArnd Bergmann return -EINVAL; 73667207b96SArnd Bergmann 737cdcc89bbSArnd Bergmann udata = (void __user *)buf; 738cdcc89bbSArnd Bergmann if (!access_ok(VERIFY_READ, buf, len)) 739cdcc89bbSArnd Bergmann return -EFAULT; 740cdcc89bbSArnd Bergmann 741cdcc89bbSArnd Bergmann if (__get_user(wbox_data, udata)) 74267207b96SArnd Bergmann return -EFAULT; 74367207b96SArnd Bergmann 7448b3d6663SArnd Bergmann spu_acquire(ctx); 7458b3d6663SArnd Bergmann 746cdcc89bbSArnd Bergmann /* 747cdcc89bbSArnd Bergmann * make sure we can at least write one element, by waiting 748cdcc89bbSArnd Bergmann * in case of !O_NONBLOCK 749cdcc89bbSArnd Bergmann */ 750cdcc89bbSArnd Bergmann count = 0; 75167207b96SArnd Bergmann if (file->f_flags & O_NONBLOCK) { 7528b3d6663SArnd Bergmann if (!spu_wbox_write(ctx, wbox_data)) 753cdcc89bbSArnd Bergmann count = -EAGAIN; 75467207b96SArnd Bergmann } else { 755cdcc89bbSArnd Bergmann count = spufs_wait(ctx->wbox_wq, spu_wbox_write(ctx, wbox_data)); 75667207b96SArnd Bergmann } 75767207b96SArnd Bergmann 758cdcc89bbSArnd Bergmann if (count) 759cdcc89bbSArnd Bergmann goto out; 7608b3d6663SArnd Bergmann 76196de0e25SJan Engelhardt /* write as much as possible */ 762cdcc89bbSArnd Bergmann for (count = 4, udata++; (count + 4) <= len; count += 4, udata++) { 763cdcc89bbSArnd Bergmann int ret; 764cdcc89bbSArnd Bergmann ret = __get_user(wbox_data, udata); 765cdcc89bbSArnd Bergmann if (ret) 766cdcc89bbSArnd Bergmann break; 767cdcc89bbSArnd Bergmann 768cdcc89bbSArnd Bergmann ret = spu_wbox_write(ctx, wbox_data); 769cdcc89bbSArnd Bergmann if (ret == 0) 770cdcc89bbSArnd Bergmann break; 771cdcc89bbSArnd Bergmann } 772cdcc89bbSArnd Bergmann 773cdcc89bbSArnd Bergmann out: 774cdcc89bbSArnd Bergmann spu_release(ctx); 775cdcc89bbSArnd Bergmann return count; 77667207b96SArnd Bergmann } 77767207b96SArnd Bergmann 77867207b96SArnd Bergmann static unsigned int spufs_wbox_poll(struct file *file, poll_table *wait) 77967207b96SArnd Bergmann { 7808b3d6663SArnd Bergmann struct spu_context *ctx = file->private_data; 78167207b96SArnd Bergmann unsigned int mask; 78267207b96SArnd Bergmann 7838b3d6663SArnd Bergmann poll_wait(file, &ctx->wbox_wq, wait); 78467207b96SArnd Bergmann 7853a843d7cSArnd Bergmann spu_acquire(ctx); 7863a843d7cSArnd Bergmann mask = ctx->ops->mbox_stat_poll(ctx, POLLOUT | POLLWRNORM); 7873a843d7cSArnd Bergmann spu_release(ctx); 78867207b96SArnd Bergmann 78967207b96SArnd Bergmann return mask; 79067207b96SArnd Bergmann } 79167207b96SArnd Bergmann 7925dfe4c96SArjan van de Ven static const struct file_operations spufs_wbox_fops = { 79367207b96SArnd Bergmann .open = spufs_pipe_open, 79467207b96SArnd Bergmann .write = spufs_wbox_write, 79567207b96SArnd Bergmann .poll = spufs_wbox_poll, 79667207b96SArnd Bergmann .fasync = spufs_wbox_fasync, 79767207b96SArnd Bergmann }; 79867207b96SArnd Bergmann 79967207b96SArnd Bergmann static ssize_t spufs_wbox_stat_read(struct file *file, char __user *buf, 80067207b96SArnd Bergmann size_t len, loff_t *pos) 80167207b96SArnd Bergmann { 8028b3d6663SArnd Bergmann struct spu_context *ctx = file->private_data; 80367207b96SArnd Bergmann u32 wbox_stat; 80467207b96SArnd Bergmann 80567207b96SArnd Bergmann if (len < 4) 80667207b96SArnd Bergmann return -EINVAL; 80767207b96SArnd Bergmann 8088b3d6663SArnd Bergmann spu_acquire(ctx); 8098b3d6663SArnd Bergmann wbox_stat = (ctx->ops->mbox_stat_read(ctx) >> 8) & 0xff; 8108b3d6663SArnd Bergmann spu_release(ctx); 81167207b96SArnd Bergmann 81267207b96SArnd Bergmann if (copy_to_user(buf, &wbox_stat, sizeof wbox_stat)) 81367207b96SArnd Bergmann return -EFAULT; 81467207b96SArnd Bergmann 81567207b96SArnd Bergmann return 4; 81667207b96SArnd Bergmann } 81767207b96SArnd Bergmann 8185dfe4c96SArjan van de Ven static const struct file_operations spufs_wbox_stat_fops = { 81967207b96SArnd Bergmann .open = spufs_pipe_open, 82067207b96SArnd Bergmann .read = spufs_wbox_stat_read, 82167207b96SArnd Bergmann }; 82267207b96SArnd Bergmann 8236df10a82SMark Nutter static int spufs_signal1_open(struct inode *inode, struct file *file) 8246df10a82SMark Nutter { 8256df10a82SMark Nutter struct spufs_inode_info *i = SPUFS_I(inode); 8266df10a82SMark Nutter struct spu_context *ctx = i->i_ctx; 82743c2bbd9SChristoph Hellwig 82847d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 8296df10a82SMark Nutter file->private_data = ctx; 83043c2bbd9SChristoph Hellwig if (!i->i_openers++) 8316df10a82SMark Nutter ctx->signal1 = inode->i_mapping; 83247d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 8336df10a82SMark Nutter return nonseekable_open(inode, file); 8346df10a82SMark Nutter } 8356df10a82SMark Nutter 83643c2bbd9SChristoph Hellwig static int 83743c2bbd9SChristoph Hellwig spufs_signal1_release(struct inode *inode, struct file *file) 83843c2bbd9SChristoph Hellwig { 83943c2bbd9SChristoph Hellwig struct spufs_inode_info *i = SPUFS_I(inode); 84043c2bbd9SChristoph Hellwig struct spu_context *ctx = i->i_ctx; 84143c2bbd9SChristoph Hellwig 84247d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 84343c2bbd9SChristoph Hellwig if (!--i->i_openers) 84443c2bbd9SChristoph Hellwig ctx->signal1 = NULL; 84547d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 84643c2bbd9SChristoph Hellwig return 0; 84743c2bbd9SChristoph Hellwig } 84843c2bbd9SChristoph Hellwig 849bf1ab978SDwayne Grant McConnell static ssize_t __spufs_signal1_read(struct spu_context *ctx, char __user *buf, 85067207b96SArnd Bergmann size_t len, loff_t *pos) 85167207b96SArnd Bergmann { 85217f88cebSDwayne Grant McConnell int ret = 0; 85367207b96SArnd Bergmann u32 data; 85467207b96SArnd Bergmann 85567207b96SArnd Bergmann if (len < 4) 85667207b96SArnd Bergmann return -EINVAL; 85767207b96SArnd Bergmann 85817f88cebSDwayne Grant McConnell if (ctx->csa.spu_chnlcnt_RW[3]) { 85917f88cebSDwayne Grant McConnell data = ctx->csa.spu_chnldata_RW[3]; 86017f88cebSDwayne Grant McConnell ret = 4; 86117f88cebSDwayne Grant McConnell } 8628b3d6663SArnd Bergmann 86317f88cebSDwayne Grant McConnell if (!ret) 86417f88cebSDwayne Grant McConnell goto out; 86517f88cebSDwayne Grant McConnell 86667207b96SArnd Bergmann if (copy_to_user(buf, &data, 4)) 86767207b96SArnd Bergmann return -EFAULT; 86867207b96SArnd Bergmann 86917f88cebSDwayne Grant McConnell out: 87017f88cebSDwayne Grant McConnell return ret; 87167207b96SArnd Bergmann } 87267207b96SArnd Bergmann 873bf1ab978SDwayne Grant McConnell static ssize_t spufs_signal1_read(struct file *file, char __user *buf, 874bf1ab978SDwayne Grant McConnell size_t len, loff_t *pos) 875bf1ab978SDwayne Grant McConnell { 876bf1ab978SDwayne Grant McConnell int ret; 877bf1ab978SDwayne Grant McConnell struct spu_context *ctx = file->private_data; 878bf1ab978SDwayne Grant McConnell 879bf1ab978SDwayne Grant McConnell spu_acquire_saved(ctx); 880bf1ab978SDwayne Grant McConnell ret = __spufs_signal1_read(ctx, buf, len, pos); 88127b1ea09SChristoph Hellwig spu_release_saved(ctx); 882bf1ab978SDwayne Grant McConnell 883bf1ab978SDwayne Grant McConnell return ret; 884bf1ab978SDwayne Grant McConnell } 885bf1ab978SDwayne Grant McConnell 88667207b96SArnd Bergmann static ssize_t spufs_signal1_write(struct file *file, const char __user *buf, 88767207b96SArnd Bergmann size_t len, loff_t *pos) 88867207b96SArnd Bergmann { 88967207b96SArnd Bergmann struct spu_context *ctx; 89067207b96SArnd Bergmann u32 data; 89167207b96SArnd Bergmann 89267207b96SArnd Bergmann ctx = file->private_data; 89367207b96SArnd Bergmann 89467207b96SArnd Bergmann if (len < 4) 89567207b96SArnd Bergmann return -EINVAL; 89667207b96SArnd Bergmann 89767207b96SArnd Bergmann if (copy_from_user(&data, buf, 4)) 89867207b96SArnd Bergmann return -EFAULT; 89967207b96SArnd Bergmann 9008b3d6663SArnd Bergmann spu_acquire(ctx); 9018b3d6663SArnd Bergmann ctx->ops->signal1_write(ctx, data); 9028b3d6663SArnd Bergmann spu_release(ctx); 90367207b96SArnd Bergmann 90467207b96SArnd Bergmann return 4; 90567207b96SArnd Bergmann } 90667207b96SArnd Bergmann 90778bde53eSBenjamin Herrenschmidt static unsigned long spufs_signal1_mmap_nopfn(struct vm_area_struct *vma, 90878bde53eSBenjamin Herrenschmidt unsigned long address) 9096df10a82SMark Nutter { 91027d5bf2aSBenjamin Herrenschmidt #if PAGE_SIZE == 0x1000 91178bde53eSBenjamin Herrenschmidt return spufs_ps_nopfn(vma, address, 0x14000, 0x1000); 91227d5bf2aSBenjamin Herrenschmidt #elif PAGE_SIZE == 0x10000 91327d5bf2aSBenjamin Herrenschmidt /* For 64k pages, both signal1 and signal2 can be used to mmap the whole 91427d5bf2aSBenjamin Herrenschmidt * signal 1 and 2 area 91527d5bf2aSBenjamin Herrenschmidt */ 91678bde53eSBenjamin Herrenschmidt return spufs_ps_nopfn(vma, address, 0x10000, 0x10000); 91727d5bf2aSBenjamin Herrenschmidt #else 91827d5bf2aSBenjamin Herrenschmidt #error unsupported page size 91927d5bf2aSBenjamin Herrenschmidt #endif 9206df10a82SMark Nutter } 9216df10a82SMark Nutter 9226df10a82SMark Nutter static struct vm_operations_struct spufs_signal1_mmap_vmops = { 92378bde53eSBenjamin Herrenschmidt .nopfn = spufs_signal1_mmap_nopfn, 9246df10a82SMark Nutter }; 9256df10a82SMark Nutter 9266df10a82SMark Nutter static int spufs_signal1_mmap(struct file *file, struct vm_area_struct *vma) 9276df10a82SMark Nutter { 9286df10a82SMark Nutter if (!(vma->vm_flags & VM_SHARED)) 9296df10a82SMark Nutter return -EINVAL; 9306df10a82SMark Nutter 93178bde53eSBenjamin Herrenschmidt vma->vm_flags |= VM_IO | VM_PFNMAP; 9326df10a82SMark Nutter vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot) 93323cc7701SBenjamin Herrenschmidt | _PAGE_NO_CACHE | _PAGE_GUARDED); 9346df10a82SMark Nutter 9356df10a82SMark Nutter vma->vm_ops = &spufs_signal1_mmap_vmops; 9366df10a82SMark Nutter return 0; 9376df10a82SMark Nutter } 9386df10a82SMark Nutter 9395dfe4c96SArjan van de Ven static const struct file_operations spufs_signal1_fops = { 9406df10a82SMark Nutter .open = spufs_signal1_open, 94143c2bbd9SChristoph Hellwig .release = spufs_signal1_release, 94267207b96SArnd Bergmann .read = spufs_signal1_read, 94367207b96SArnd Bergmann .write = spufs_signal1_write, 9446df10a82SMark Nutter .mmap = spufs_signal1_mmap, 94567207b96SArnd Bergmann }; 94667207b96SArnd Bergmann 947d054b36fSJeremy Kerr static const struct file_operations spufs_signal1_nosched_fops = { 948d054b36fSJeremy Kerr .open = spufs_signal1_open, 949d054b36fSJeremy Kerr .release = spufs_signal1_release, 950d054b36fSJeremy Kerr .write = spufs_signal1_write, 951d054b36fSJeremy Kerr .mmap = spufs_signal1_mmap, 952d054b36fSJeremy Kerr }; 953d054b36fSJeremy Kerr 9546df10a82SMark Nutter static int spufs_signal2_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->signal2 = 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_signal2_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->signal2 = NULL; 97647d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 97743c2bbd9SChristoph Hellwig return 0; 97843c2bbd9SChristoph Hellwig } 97943c2bbd9SChristoph Hellwig 980bf1ab978SDwayne Grant McConnell static ssize_t __spufs_signal2_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[4]) { 99017f88cebSDwayne Grant McConnell data = ctx->csa.spu_chnldata_RW[4]; 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: 1001bf1ab978SDwayne Grant McConnell return ret; 1002bf1ab978SDwayne Grant McConnell } 1003bf1ab978SDwayne Grant McConnell 1004bf1ab978SDwayne Grant McConnell static ssize_t spufs_signal2_read(struct file *file, char __user *buf, 1005bf1ab978SDwayne Grant McConnell size_t len, loff_t *pos) 1006bf1ab978SDwayne Grant McConnell { 1007bf1ab978SDwayne Grant McConnell struct spu_context *ctx = file->private_data; 1008bf1ab978SDwayne Grant McConnell int ret; 1009bf1ab978SDwayne Grant McConnell 1010bf1ab978SDwayne Grant McConnell spu_acquire_saved(ctx); 1011bf1ab978SDwayne Grant McConnell ret = __spufs_signal2_read(ctx, buf, len, pos); 101227b1ea09SChristoph Hellwig spu_release_saved(ctx); 1013bf1ab978SDwayne Grant McConnell 1014bf1ab978SDwayne Grant McConnell return ret; 101567207b96SArnd Bergmann } 101667207b96SArnd Bergmann 101767207b96SArnd Bergmann static ssize_t spufs_signal2_write(struct file *file, const char __user *buf, 101867207b96SArnd Bergmann size_t len, loff_t *pos) 101967207b96SArnd Bergmann { 102067207b96SArnd Bergmann struct spu_context *ctx; 102167207b96SArnd Bergmann u32 data; 102267207b96SArnd Bergmann 102367207b96SArnd Bergmann ctx = file->private_data; 102467207b96SArnd Bergmann 102567207b96SArnd Bergmann if (len < 4) 102667207b96SArnd Bergmann return -EINVAL; 102767207b96SArnd Bergmann 102867207b96SArnd Bergmann if (copy_from_user(&data, buf, 4)) 102967207b96SArnd Bergmann return -EFAULT; 103067207b96SArnd Bergmann 10318b3d6663SArnd Bergmann spu_acquire(ctx); 10328b3d6663SArnd Bergmann ctx->ops->signal2_write(ctx, data); 10338b3d6663SArnd Bergmann spu_release(ctx); 103467207b96SArnd Bergmann 103567207b96SArnd Bergmann return 4; 103667207b96SArnd Bergmann } 103767207b96SArnd Bergmann 103827d5bf2aSBenjamin Herrenschmidt #if SPUFS_MMAP_4K 103978bde53eSBenjamin Herrenschmidt static unsigned long spufs_signal2_mmap_nopfn(struct vm_area_struct *vma, 104078bde53eSBenjamin Herrenschmidt unsigned long address) 10416df10a82SMark Nutter { 104227d5bf2aSBenjamin Herrenschmidt #if PAGE_SIZE == 0x1000 104378bde53eSBenjamin Herrenschmidt return spufs_ps_nopfn(vma, address, 0x1c000, 0x1000); 104427d5bf2aSBenjamin Herrenschmidt #elif PAGE_SIZE == 0x10000 104527d5bf2aSBenjamin Herrenschmidt /* For 64k pages, both signal1 and signal2 can be used to mmap the whole 104627d5bf2aSBenjamin Herrenschmidt * signal 1 and 2 area 104727d5bf2aSBenjamin Herrenschmidt */ 104878bde53eSBenjamin Herrenschmidt return spufs_ps_nopfn(vma, address, 0x10000, 0x10000); 104927d5bf2aSBenjamin Herrenschmidt #else 105027d5bf2aSBenjamin Herrenschmidt #error unsupported page size 105127d5bf2aSBenjamin Herrenschmidt #endif 10526df10a82SMark Nutter } 10536df10a82SMark Nutter 10546df10a82SMark Nutter static struct vm_operations_struct spufs_signal2_mmap_vmops = { 105578bde53eSBenjamin Herrenschmidt .nopfn = spufs_signal2_mmap_nopfn, 10566df10a82SMark Nutter }; 10576df10a82SMark Nutter 10586df10a82SMark Nutter static int spufs_signal2_mmap(struct file *file, struct vm_area_struct *vma) 10596df10a82SMark Nutter { 10606df10a82SMark Nutter if (!(vma->vm_flags & VM_SHARED)) 10616df10a82SMark Nutter return -EINVAL; 10626df10a82SMark Nutter 106378bde53eSBenjamin Herrenschmidt vma->vm_flags |= VM_IO | VM_PFNMAP; 10646df10a82SMark Nutter vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot) 106523cc7701SBenjamin Herrenschmidt | _PAGE_NO_CACHE | _PAGE_GUARDED); 10666df10a82SMark Nutter 10676df10a82SMark Nutter vma->vm_ops = &spufs_signal2_mmap_vmops; 10686df10a82SMark Nutter return 0; 10696df10a82SMark Nutter } 107027d5bf2aSBenjamin Herrenschmidt #else /* SPUFS_MMAP_4K */ 107127d5bf2aSBenjamin Herrenschmidt #define spufs_signal2_mmap NULL 107227d5bf2aSBenjamin Herrenschmidt #endif /* !SPUFS_MMAP_4K */ 10736df10a82SMark Nutter 10745dfe4c96SArjan van de Ven static const struct file_operations spufs_signal2_fops = { 10756df10a82SMark Nutter .open = spufs_signal2_open, 107643c2bbd9SChristoph Hellwig .release = spufs_signal2_release, 107767207b96SArnd Bergmann .read = spufs_signal2_read, 107867207b96SArnd Bergmann .write = spufs_signal2_write, 10796df10a82SMark Nutter .mmap = spufs_signal2_mmap, 108067207b96SArnd Bergmann }; 108167207b96SArnd Bergmann 1082d054b36fSJeremy Kerr static const struct file_operations spufs_signal2_nosched_fops = { 1083d054b36fSJeremy Kerr .open = spufs_signal2_open, 1084d054b36fSJeremy Kerr .release = spufs_signal2_release, 1085d054b36fSJeremy Kerr .write = spufs_signal2_write, 1086d054b36fSJeremy Kerr .mmap = spufs_signal2_mmap, 1087d054b36fSJeremy Kerr }; 1088d054b36fSJeremy Kerr 1089104f0cc2SMichael Ellerman /* 1090104f0cc2SMichael Ellerman * This is a wrapper around DEFINE_SIMPLE_ATTRIBUTE which does the 1091104f0cc2SMichael Ellerman * work of acquiring (or not) the SPU context before calling through 1092104f0cc2SMichael Ellerman * to the actual get routine. The set routine is called directly. 1093104f0cc2SMichael Ellerman */ 1094104f0cc2SMichael Ellerman #define SPU_ATTR_NOACQUIRE 0 1095104f0cc2SMichael Ellerman #define SPU_ATTR_ACQUIRE 1 1096104f0cc2SMichael Ellerman #define SPU_ATTR_ACQUIRE_SAVED 2 1097104f0cc2SMichael Ellerman 1098104f0cc2SMichael Ellerman #define DEFINE_SPUFS_ATTRIBUTE(__name, __get, __set, __fmt, __acquire) \ 1099104f0cc2SMichael Ellerman static u64 __##__get(void *data) \ 1100104f0cc2SMichael Ellerman { \ 1101104f0cc2SMichael Ellerman struct spu_context *ctx = data; \ 1102104f0cc2SMichael Ellerman u64 ret; \ 1103104f0cc2SMichael Ellerman \ 1104104f0cc2SMichael Ellerman if (__acquire == SPU_ATTR_ACQUIRE) { \ 1105104f0cc2SMichael Ellerman spu_acquire(ctx); \ 1106104f0cc2SMichael Ellerman ret = __get(ctx); \ 1107104f0cc2SMichael Ellerman spu_release(ctx); \ 1108104f0cc2SMichael Ellerman } else if (__acquire == SPU_ATTR_ACQUIRE_SAVED) { \ 1109104f0cc2SMichael Ellerman spu_acquire_saved(ctx); \ 1110104f0cc2SMichael Ellerman ret = __get(ctx); \ 1111104f0cc2SMichael Ellerman spu_release_saved(ctx); \ 1112104f0cc2SMichael Ellerman } else \ 1113104f0cc2SMichael Ellerman ret = __get(ctx); \ 1114104f0cc2SMichael Ellerman \ 1115104f0cc2SMichael Ellerman return ret; \ 1116104f0cc2SMichael Ellerman } \ 1117104f0cc2SMichael Ellerman DEFINE_SIMPLE_ATTRIBUTE(__name, __##__get, __set, __fmt); 1118104f0cc2SMichael Ellerman 111967207b96SArnd Bergmann static void spufs_signal1_type_set(void *data, u64 val) 112067207b96SArnd Bergmann { 112167207b96SArnd Bergmann struct spu_context *ctx = data; 112267207b96SArnd Bergmann 11238b3d6663SArnd Bergmann spu_acquire(ctx); 11248b3d6663SArnd Bergmann ctx->ops->signal1_type_set(ctx, val); 11258b3d6663SArnd Bergmann spu_release(ctx); 112667207b96SArnd Bergmann } 112767207b96SArnd Bergmann 1128104f0cc2SMichael Ellerman static u64 spufs_signal1_type_get(struct spu_context *ctx) 1129bf1ab978SDwayne Grant McConnell { 1130bf1ab978SDwayne Grant McConnell return ctx->ops->signal1_type_get(ctx); 1131bf1ab978SDwayne Grant McConnell } 1132104f0cc2SMichael Ellerman DEFINE_SPUFS_ATTRIBUTE(spufs_signal1_type, spufs_signal1_type_get, 1133104f0cc2SMichael Ellerman spufs_signal1_type_set, "%llu", SPU_ATTR_ACQUIRE); 1134bf1ab978SDwayne Grant McConnell 113567207b96SArnd Bergmann 113667207b96SArnd Bergmann static void spufs_signal2_type_set(void *data, u64 val) 113767207b96SArnd Bergmann { 113867207b96SArnd Bergmann struct spu_context *ctx = data; 113967207b96SArnd Bergmann 11408b3d6663SArnd Bergmann spu_acquire(ctx); 11418b3d6663SArnd Bergmann ctx->ops->signal2_type_set(ctx, val); 11428b3d6663SArnd Bergmann spu_release(ctx); 114367207b96SArnd Bergmann } 114467207b96SArnd Bergmann 1145104f0cc2SMichael Ellerman static u64 spufs_signal2_type_get(struct spu_context *ctx) 1146bf1ab978SDwayne Grant McConnell { 1147bf1ab978SDwayne Grant McConnell return ctx->ops->signal2_type_get(ctx); 1148bf1ab978SDwayne Grant McConnell } 1149104f0cc2SMichael Ellerman DEFINE_SPUFS_ATTRIBUTE(spufs_signal2_type, spufs_signal2_type_get, 1150104f0cc2SMichael Ellerman spufs_signal2_type_set, "%llu", SPU_ATTR_ACQUIRE); 115167207b96SArnd Bergmann 115227d5bf2aSBenjamin Herrenschmidt #if SPUFS_MMAP_4K 115378bde53eSBenjamin Herrenschmidt static unsigned long spufs_mss_mmap_nopfn(struct vm_area_struct *vma, 115478bde53eSBenjamin Herrenschmidt unsigned long address) 1155d9379c4bSarnd@arndb.de { 115678bde53eSBenjamin Herrenschmidt return spufs_ps_nopfn(vma, address, 0x0000, 0x1000); 1157d9379c4bSarnd@arndb.de } 1158d9379c4bSarnd@arndb.de 1159d9379c4bSarnd@arndb.de static struct vm_operations_struct spufs_mss_mmap_vmops = { 116078bde53eSBenjamin Herrenschmidt .nopfn = spufs_mss_mmap_nopfn, 1161d9379c4bSarnd@arndb.de }; 1162d9379c4bSarnd@arndb.de 1163d9379c4bSarnd@arndb.de /* 1164d9379c4bSarnd@arndb.de * mmap support for problem state MFC DMA area [0x0000 - 0x0fff]. 1165d9379c4bSarnd@arndb.de */ 1166d9379c4bSarnd@arndb.de static int spufs_mss_mmap(struct file *file, struct vm_area_struct *vma) 1167d9379c4bSarnd@arndb.de { 1168d9379c4bSarnd@arndb.de if (!(vma->vm_flags & VM_SHARED)) 1169d9379c4bSarnd@arndb.de return -EINVAL; 1170d9379c4bSarnd@arndb.de 117178bde53eSBenjamin Herrenschmidt vma->vm_flags |= VM_IO | VM_PFNMAP; 1172d9379c4bSarnd@arndb.de vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot) 117323cc7701SBenjamin Herrenschmidt | _PAGE_NO_CACHE | _PAGE_GUARDED); 1174d9379c4bSarnd@arndb.de 1175d9379c4bSarnd@arndb.de vma->vm_ops = &spufs_mss_mmap_vmops; 1176d9379c4bSarnd@arndb.de return 0; 1177d9379c4bSarnd@arndb.de } 117827d5bf2aSBenjamin Herrenschmidt #else /* SPUFS_MMAP_4K */ 117927d5bf2aSBenjamin Herrenschmidt #define spufs_mss_mmap NULL 118027d5bf2aSBenjamin Herrenschmidt #endif /* !SPUFS_MMAP_4K */ 1181d9379c4bSarnd@arndb.de 1182d9379c4bSarnd@arndb.de static int spufs_mss_open(struct inode *inode, struct file *file) 1183d9379c4bSarnd@arndb.de { 1184d9379c4bSarnd@arndb.de struct spufs_inode_info *i = SPUFS_I(inode); 118517e0e270SBenjamin Herrenschmidt struct spu_context *ctx = i->i_ctx; 1186d9379c4bSarnd@arndb.de 1187d9379c4bSarnd@arndb.de file->private_data = i->i_ctx; 118843c2bbd9SChristoph Hellwig 118947d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 119043c2bbd9SChristoph Hellwig if (!i->i_openers++) 119117e0e270SBenjamin Herrenschmidt ctx->mss = inode->i_mapping; 119247d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 1193d9379c4bSarnd@arndb.de return nonseekable_open(inode, file); 1194d9379c4bSarnd@arndb.de } 1195d9379c4bSarnd@arndb.de 119643c2bbd9SChristoph Hellwig static int 119743c2bbd9SChristoph Hellwig spufs_mss_release(struct inode *inode, struct file *file) 119843c2bbd9SChristoph Hellwig { 119943c2bbd9SChristoph Hellwig struct spufs_inode_info *i = SPUFS_I(inode); 120043c2bbd9SChristoph Hellwig struct spu_context *ctx = i->i_ctx; 120143c2bbd9SChristoph Hellwig 120247d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 120343c2bbd9SChristoph Hellwig if (!--i->i_openers) 120443c2bbd9SChristoph Hellwig ctx->mss = NULL; 120547d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 120643c2bbd9SChristoph Hellwig return 0; 120743c2bbd9SChristoph Hellwig } 120843c2bbd9SChristoph Hellwig 12095dfe4c96SArjan van de Ven static const struct file_operations spufs_mss_fops = { 1210d9379c4bSarnd@arndb.de .open = spufs_mss_open, 121143c2bbd9SChristoph Hellwig .release = spufs_mss_release, 1212d9379c4bSarnd@arndb.de .mmap = spufs_mss_mmap, 121327d5bf2aSBenjamin Herrenschmidt }; 121427d5bf2aSBenjamin Herrenschmidt 121578bde53eSBenjamin Herrenschmidt static unsigned long spufs_psmap_mmap_nopfn(struct vm_area_struct *vma, 121678bde53eSBenjamin Herrenschmidt unsigned long address) 121727d5bf2aSBenjamin Herrenschmidt { 121878bde53eSBenjamin Herrenschmidt return spufs_ps_nopfn(vma, address, 0x0000, 0x20000); 121927d5bf2aSBenjamin Herrenschmidt } 122027d5bf2aSBenjamin Herrenschmidt 122127d5bf2aSBenjamin Herrenschmidt static struct vm_operations_struct spufs_psmap_mmap_vmops = { 122278bde53eSBenjamin Herrenschmidt .nopfn = spufs_psmap_mmap_nopfn, 122327d5bf2aSBenjamin Herrenschmidt }; 122427d5bf2aSBenjamin Herrenschmidt 122527d5bf2aSBenjamin Herrenschmidt /* 122627d5bf2aSBenjamin Herrenschmidt * mmap support for full problem state area [0x00000 - 0x1ffff]. 122727d5bf2aSBenjamin Herrenschmidt */ 122827d5bf2aSBenjamin Herrenschmidt static int spufs_psmap_mmap(struct file *file, struct vm_area_struct *vma) 122927d5bf2aSBenjamin Herrenschmidt { 123027d5bf2aSBenjamin Herrenschmidt if (!(vma->vm_flags & VM_SHARED)) 123127d5bf2aSBenjamin Herrenschmidt return -EINVAL; 123227d5bf2aSBenjamin Herrenschmidt 123378bde53eSBenjamin Herrenschmidt vma->vm_flags |= VM_IO | VM_PFNMAP; 123427d5bf2aSBenjamin Herrenschmidt vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot) 123527d5bf2aSBenjamin Herrenschmidt | _PAGE_NO_CACHE | _PAGE_GUARDED); 123627d5bf2aSBenjamin Herrenschmidt 123727d5bf2aSBenjamin Herrenschmidt vma->vm_ops = &spufs_psmap_mmap_vmops; 123827d5bf2aSBenjamin Herrenschmidt return 0; 123927d5bf2aSBenjamin Herrenschmidt } 124027d5bf2aSBenjamin Herrenschmidt 124127d5bf2aSBenjamin Herrenschmidt static int spufs_psmap_open(struct inode *inode, struct file *file) 124227d5bf2aSBenjamin Herrenschmidt { 124327d5bf2aSBenjamin Herrenschmidt struct spufs_inode_info *i = SPUFS_I(inode); 124417e0e270SBenjamin Herrenschmidt struct spu_context *ctx = i->i_ctx; 124527d5bf2aSBenjamin Herrenschmidt 124647d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 124727d5bf2aSBenjamin Herrenschmidt file->private_data = i->i_ctx; 124843c2bbd9SChristoph Hellwig if (!i->i_openers++) 124917e0e270SBenjamin Herrenschmidt ctx->psmap = inode->i_mapping; 125047d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 125127d5bf2aSBenjamin Herrenschmidt return nonseekable_open(inode, file); 125227d5bf2aSBenjamin Herrenschmidt } 125327d5bf2aSBenjamin Herrenschmidt 125443c2bbd9SChristoph Hellwig static int 125543c2bbd9SChristoph Hellwig spufs_psmap_release(struct inode *inode, struct file *file) 125643c2bbd9SChristoph Hellwig { 125743c2bbd9SChristoph Hellwig struct spufs_inode_info *i = SPUFS_I(inode); 125843c2bbd9SChristoph Hellwig struct spu_context *ctx = i->i_ctx; 125943c2bbd9SChristoph Hellwig 126047d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 126143c2bbd9SChristoph Hellwig if (!--i->i_openers) 126243c2bbd9SChristoph Hellwig ctx->psmap = NULL; 126347d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 126443c2bbd9SChristoph Hellwig return 0; 126543c2bbd9SChristoph Hellwig } 126643c2bbd9SChristoph Hellwig 12675dfe4c96SArjan van de Ven static const struct file_operations spufs_psmap_fops = { 126827d5bf2aSBenjamin Herrenschmidt .open = spufs_psmap_open, 126943c2bbd9SChristoph Hellwig .release = spufs_psmap_release, 127027d5bf2aSBenjamin Herrenschmidt .mmap = spufs_psmap_mmap, 1271d9379c4bSarnd@arndb.de }; 1272d9379c4bSarnd@arndb.de 1273d9379c4bSarnd@arndb.de 127427d5bf2aSBenjamin Herrenschmidt #if SPUFS_MMAP_4K 127578bde53eSBenjamin Herrenschmidt static unsigned long spufs_mfc_mmap_nopfn(struct vm_area_struct *vma, 127678bde53eSBenjamin Herrenschmidt unsigned long address) 12776df10a82SMark Nutter { 127878bde53eSBenjamin Herrenschmidt return spufs_ps_nopfn(vma, address, 0x3000, 0x1000); 12796df10a82SMark Nutter } 12806df10a82SMark Nutter 12816df10a82SMark Nutter static struct vm_operations_struct spufs_mfc_mmap_vmops = { 128278bde53eSBenjamin Herrenschmidt .nopfn = spufs_mfc_mmap_nopfn, 12836df10a82SMark Nutter }; 12846df10a82SMark Nutter 12856df10a82SMark Nutter /* 12866df10a82SMark Nutter * mmap support for problem state MFC DMA area [0x0000 - 0x0fff]. 12876df10a82SMark Nutter */ 12886df10a82SMark Nutter static int spufs_mfc_mmap(struct file *file, struct vm_area_struct *vma) 12896df10a82SMark Nutter { 12906df10a82SMark Nutter if (!(vma->vm_flags & VM_SHARED)) 12916df10a82SMark Nutter return -EINVAL; 12926df10a82SMark Nutter 129378bde53eSBenjamin Herrenschmidt vma->vm_flags |= VM_IO | VM_PFNMAP; 12946df10a82SMark Nutter vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot) 129523cc7701SBenjamin Herrenschmidt | _PAGE_NO_CACHE | _PAGE_GUARDED); 12966df10a82SMark Nutter 12976df10a82SMark Nutter vma->vm_ops = &spufs_mfc_mmap_vmops; 12986df10a82SMark Nutter return 0; 12996df10a82SMark Nutter } 130027d5bf2aSBenjamin Herrenschmidt #else /* SPUFS_MMAP_4K */ 130127d5bf2aSBenjamin Herrenschmidt #define spufs_mfc_mmap NULL 130227d5bf2aSBenjamin Herrenschmidt #endif /* !SPUFS_MMAP_4K */ 1303a33a7d73SArnd Bergmann 1304a33a7d73SArnd Bergmann static int spufs_mfc_open(struct inode *inode, struct file *file) 1305a33a7d73SArnd Bergmann { 1306a33a7d73SArnd Bergmann struct spufs_inode_info *i = SPUFS_I(inode); 1307a33a7d73SArnd Bergmann struct spu_context *ctx = i->i_ctx; 1308a33a7d73SArnd Bergmann 1309a33a7d73SArnd Bergmann /* we don't want to deal with DMA into other processes */ 1310a33a7d73SArnd Bergmann if (ctx->owner != current->mm) 1311a33a7d73SArnd Bergmann return -EINVAL; 1312a33a7d73SArnd Bergmann 1313a33a7d73SArnd Bergmann if (atomic_read(&inode->i_count) != 1) 1314a33a7d73SArnd Bergmann return -EBUSY; 1315a33a7d73SArnd Bergmann 131647d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 1317a33a7d73SArnd Bergmann file->private_data = ctx; 131843c2bbd9SChristoph Hellwig if (!i->i_openers++) 131917e0e270SBenjamin Herrenschmidt ctx->mfc = inode->i_mapping; 132047d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 1321a33a7d73SArnd Bergmann return nonseekable_open(inode, file); 1322a33a7d73SArnd Bergmann } 1323a33a7d73SArnd Bergmann 132443c2bbd9SChristoph Hellwig static int 132543c2bbd9SChristoph Hellwig spufs_mfc_release(struct inode *inode, struct file *file) 132643c2bbd9SChristoph Hellwig { 132743c2bbd9SChristoph Hellwig struct spufs_inode_info *i = SPUFS_I(inode); 132843c2bbd9SChristoph Hellwig struct spu_context *ctx = i->i_ctx; 132943c2bbd9SChristoph Hellwig 133047d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 133143c2bbd9SChristoph Hellwig if (!--i->i_openers) 133243c2bbd9SChristoph Hellwig ctx->mfc = NULL; 133347d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 133443c2bbd9SChristoph Hellwig return 0; 133543c2bbd9SChristoph Hellwig } 133643c2bbd9SChristoph Hellwig 1337a33a7d73SArnd Bergmann /* interrupt-level mfc callback function. */ 1338a33a7d73SArnd Bergmann void spufs_mfc_callback(struct spu *spu) 1339a33a7d73SArnd Bergmann { 1340a33a7d73SArnd Bergmann struct spu_context *ctx = spu->ctx; 1341a33a7d73SArnd Bergmann 1342a33a7d73SArnd Bergmann wake_up_all(&ctx->mfc_wq); 1343a33a7d73SArnd Bergmann 1344a33a7d73SArnd Bergmann pr_debug("%s %s\n", __FUNCTION__, spu->name); 1345a33a7d73SArnd Bergmann if (ctx->mfc_fasync) { 1346a33a7d73SArnd Bergmann u32 free_elements, tagstatus; 1347a33a7d73SArnd Bergmann unsigned int mask; 1348a33a7d73SArnd Bergmann 1349a33a7d73SArnd Bergmann /* no need for spu_acquire in interrupt context */ 1350a33a7d73SArnd Bergmann free_elements = ctx->ops->get_mfc_free_elements(ctx); 1351a33a7d73SArnd Bergmann tagstatus = ctx->ops->read_mfc_tagstatus(ctx); 1352a33a7d73SArnd Bergmann 1353a33a7d73SArnd Bergmann mask = 0; 1354a33a7d73SArnd Bergmann if (free_elements & 0xffff) 1355a33a7d73SArnd Bergmann mask |= POLLOUT; 1356a33a7d73SArnd Bergmann if (tagstatus & ctx->tagwait) 1357a33a7d73SArnd Bergmann mask |= POLLIN; 1358a33a7d73SArnd Bergmann 1359a33a7d73SArnd Bergmann kill_fasync(&ctx->mfc_fasync, SIGIO, mask); 1360a33a7d73SArnd Bergmann } 1361a33a7d73SArnd Bergmann } 1362a33a7d73SArnd Bergmann 1363a33a7d73SArnd Bergmann static int spufs_read_mfc_tagstatus(struct spu_context *ctx, u32 *status) 1364a33a7d73SArnd Bergmann { 1365a33a7d73SArnd Bergmann /* See if there is one tag group is complete */ 1366a33a7d73SArnd Bergmann /* FIXME we need locking around tagwait */ 1367a33a7d73SArnd Bergmann *status = ctx->ops->read_mfc_tagstatus(ctx) & ctx->tagwait; 1368a33a7d73SArnd Bergmann ctx->tagwait &= ~*status; 1369a33a7d73SArnd Bergmann if (*status) 1370a33a7d73SArnd Bergmann return 1; 1371a33a7d73SArnd Bergmann 1372a33a7d73SArnd Bergmann /* enable interrupt waiting for any tag group, 1373a33a7d73SArnd Bergmann may silently fail if interrupts are already enabled */ 1374a33a7d73SArnd Bergmann ctx->ops->set_mfc_query(ctx, ctx->tagwait, 1); 1375a33a7d73SArnd Bergmann return 0; 1376a33a7d73SArnd Bergmann } 1377a33a7d73SArnd Bergmann 1378a33a7d73SArnd Bergmann static ssize_t spufs_mfc_read(struct file *file, char __user *buffer, 1379a33a7d73SArnd Bergmann size_t size, loff_t *pos) 1380a33a7d73SArnd Bergmann { 1381a33a7d73SArnd Bergmann struct spu_context *ctx = file->private_data; 1382a33a7d73SArnd Bergmann int ret = -EINVAL; 1383a33a7d73SArnd Bergmann u32 status; 1384a33a7d73SArnd Bergmann 1385a33a7d73SArnd Bergmann if (size != 4) 1386a33a7d73SArnd Bergmann goto out; 1387a33a7d73SArnd Bergmann 1388a33a7d73SArnd Bergmann spu_acquire(ctx); 1389a33a7d73SArnd Bergmann if (file->f_flags & O_NONBLOCK) { 1390a33a7d73SArnd Bergmann status = ctx->ops->read_mfc_tagstatus(ctx); 1391a33a7d73SArnd Bergmann if (!(status & ctx->tagwait)) 1392a33a7d73SArnd Bergmann ret = -EAGAIN; 1393a33a7d73SArnd Bergmann else 1394a33a7d73SArnd Bergmann ctx->tagwait &= ~status; 1395a33a7d73SArnd Bergmann } else { 1396a33a7d73SArnd Bergmann ret = spufs_wait(ctx->mfc_wq, 1397a33a7d73SArnd Bergmann spufs_read_mfc_tagstatus(ctx, &status)); 1398a33a7d73SArnd Bergmann } 1399a33a7d73SArnd Bergmann spu_release(ctx); 1400a33a7d73SArnd Bergmann 1401a33a7d73SArnd Bergmann if (ret) 1402a33a7d73SArnd Bergmann goto out; 1403a33a7d73SArnd Bergmann 1404a33a7d73SArnd Bergmann ret = 4; 1405a33a7d73SArnd Bergmann if (copy_to_user(buffer, &status, 4)) 1406a33a7d73SArnd Bergmann ret = -EFAULT; 1407a33a7d73SArnd Bergmann 1408a33a7d73SArnd Bergmann out: 1409a33a7d73SArnd Bergmann return ret; 1410a33a7d73SArnd Bergmann } 1411a33a7d73SArnd Bergmann 1412a33a7d73SArnd Bergmann static int spufs_check_valid_dma(struct mfc_dma_command *cmd) 1413a33a7d73SArnd Bergmann { 1414a33a7d73SArnd Bergmann pr_debug("queueing DMA %x %lx %x %x %x\n", cmd->lsa, 1415a33a7d73SArnd Bergmann cmd->ea, cmd->size, cmd->tag, cmd->cmd); 1416a33a7d73SArnd Bergmann 1417a33a7d73SArnd Bergmann switch (cmd->cmd) { 1418a33a7d73SArnd Bergmann case MFC_PUT_CMD: 1419a33a7d73SArnd Bergmann case MFC_PUTF_CMD: 1420a33a7d73SArnd Bergmann case MFC_PUTB_CMD: 1421a33a7d73SArnd Bergmann case MFC_GET_CMD: 1422a33a7d73SArnd Bergmann case MFC_GETF_CMD: 1423a33a7d73SArnd Bergmann case MFC_GETB_CMD: 1424a33a7d73SArnd Bergmann break; 1425a33a7d73SArnd Bergmann default: 1426a33a7d73SArnd Bergmann pr_debug("invalid DMA opcode %x\n", cmd->cmd); 1427a33a7d73SArnd Bergmann return -EIO; 1428a33a7d73SArnd Bergmann } 1429a33a7d73SArnd Bergmann 1430a33a7d73SArnd Bergmann if ((cmd->lsa & 0xf) != (cmd->ea &0xf)) { 1431a33a7d73SArnd Bergmann pr_debug("invalid DMA alignment, ea %lx lsa %x\n", 1432a33a7d73SArnd Bergmann cmd->ea, cmd->lsa); 1433a33a7d73SArnd Bergmann return -EIO; 1434a33a7d73SArnd Bergmann } 1435a33a7d73SArnd Bergmann 1436a33a7d73SArnd Bergmann switch (cmd->size & 0xf) { 1437a33a7d73SArnd Bergmann case 1: 1438a33a7d73SArnd Bergmann break; 1439a33a7d73SArnd Bergmann case 2: 1440a33a7d73SArnd Bergmann if (cmd->lsa & 1) 1441a33a7d73SArnd Bergmann goto error; 1442a33a7d73SArnd Bergmann break; 1443a33a7d73SArnd Bergmann case 4: 1444a33a7d73SArnd Bergmann if (cmd->lsa & 3) 1445a33a7d73SArnd Bergmann goto error; 1446a33a7d73SArnd Bergmann break; 1447a33a7d73SArnd Bergmann case 8: 1448a33a7d73SArnd Bergmann if (cmd->lsa & 7) 1449a33a7d73SArnd Bergmann goto error; 1450a33a7d73SArnd Bergmann break; 1451a33a7d73SArnd Bergmann case 0: 1452a33a7d73SArnd Bergmann if (cmd->lsa & 15) 1453a33a7d73SArnd Bergmann goto error; 1454a33a7d73SArnd Bergmann break; 1455a33a7d73SArnd Bergmann error: 1456a33a7d73SArnd Bergmann default: 1457a33a7d73SArnd Bergmann pr_debug("invalid DMA alignment %x for size %x\n", 1458a33a7d73SArnd Bergmann cmd->lsa & 0xf, cmd->size); 1459a33a7d73SArnd Bergmann return -EIO; 1460a33a7d73SArnd Bergmann } 1461a33a7d73SArnd Bergmann 1462a33a7d73SArnd Bergmann if (cmd->size > 16 * 1024) { 1463a33a7d73SArnd Bergmann pr_debug("invalid DMA size %x\n", cmd->size); 1464a33a7d73SArnd Bergmann return -EIO; 1465a33a7d73SArnd Bergmann } 1466a33a7d73SArnd Bergmann 1467a33a7d73SArnd Bergmann if (cmd->tag & 0xfff0) { 1468a33a7d73SArnd Bergmann /* we reserve the higher tag numbers for kernel use */ 1469a33a7d73SArnd Bergmann pr_debug("invalid DMA tag\n"); 1470a33a7d73SArnd Bergmann return -EIO; 1471a33a7d73SArnd Bergmann } 1472a33a7d73SArnd Bergmann 1473a33a7d73SArnd Bergmann if (cmd->class) { 1474a33a7d73SArnd Bergmann /* not supported in this version */ 1475a33a7d73SArnd Bergmann pr_debug("invalid DMA class\n"); 1476a33a7d73SArnd Bergmann return -EIO; 1477a33a7d73SArnd Bergmann } 1478a33a7d73SArnd Bergmann 1479a33a7d73SArnd Bergmann return 0; 1480a33a7d73SArnd Bergmann } 1481a33a7d73SArnd Bergmann 1482a33a7d73SArnd Bergmann static int spu_send_mfc_command(struct spu_context *ctx, 1483a33a7d73SArnd Bergmann struct mfc_dma_command cmd, 1484a33a7d73SArnd Bergmann int *error) 1485a33a7d73SArnd Bergmann { 1486a33a7d73SArnd Bergmann *error = ctx->ops->send_mfc_command(ctx, &cmd); 1487a33a7d73SArnd Bergmann if (*error == -EAGAIN) { 1488a33a7d73SArnd Bergmann /* wait for any tag group to complete 1489a33a7d73SArnd Bergmann so we have space for the new command */ 1490a33a7d73SArnd Bergmann ctx->ops->set_mfc_query(ctx, ctx->tagwait, 1); 1491a33a7d73SArnd Bergmann /* try again, because the queue might be 1492a33a7d73SArnd Bergmann empty again */ 1493a33a7d73SArnd Bergmann *error = ctx->ops->send_mfc_command(ctx, &cmd); 1494a33a7d73SArnd Bergmann if (*error == -EAGAIN) 1495a33a7d73SArnd Bergmann return 0; 1496a33a7d73SArnd Bergmann } 1497a33a7d73SArnd Bergmann return 1; 1498a33a7d73SArnd Bergmann } 1499a33a7d73SArnd Bergmann 1500a33a7d73SArnd Bergmann static ssize_t spufs_mfc_write(struct file *file, const char __user *buffer, 1501a33a7d73SArnd Bergmann size_t size, loff_t *pos) 1502a33a7d73SArnd Bergmann { 1503a33a7d73SArnd Bergmann struct spu_context *ctx = file->private_data; 1504a33a7d73SArnd Bergmann struct mfc_dma_command cmd; 1505a33a7d73SArnd Bergmann int ret = -EINVAL; 1506a33a7d73SArnd Bergmann 1507a33a7d73SArnd Bergmann if (size != sizeof cmd) 1508a33a7d73SArnd Bergmann goto out; 1509a33a7d73SArnd Bergmann 1510a33a7d73SArnd Bergmann ret = -EFAULT; 1511a33a7d73SArnd Bergmann if (copy_from_user(&cmd, buffer, sizeof cmd)) 1512a33a7d73SArnd Bergmann goto out; 1513a33a7d73SArnd Bergmann 1514a33a7d73SArnd Bergmann ret = spufs_check_valid_dma(&cmd); 1515a33a7d73SArnd Bergmann if (ret) 1516a33a7d73SArnd Bergmann goto out; 1517a33a7d73SArnd Bergmann 151833bfd7a7SArnd Bergmann spu_acquire(ctx); 151933bfd7a7SArnd Bergmann ret = spufs_wait(ctx->run_wq, ctx->state == SPU_STATE_RUNNABLE); 1520577f8f10SAkinobu Mita if (ret) 1521577f8f10SAkinobu Mita goto out; 1522577f8f10SAkinobu Mita 1523a33a7d73SArnd Bergmann if (file->f_flags & O_NONBLOCK) { 1524a33a7d73SArnd Bergmann ret = ctx->ops->send_mfc_command(ctx, &cmd); 1525a33a7d73SArnd Bergmann } else { 1526a33a7d73SArnd Bergmann int status; 1527a33a7d73SArnd Bergmann ret = spufs_wait(ctx->mfc_wq, 1528a33a7d73SArnd Bergmann spu_send_mfc_command(ctx, cmd, &status)); 1529a33a7d73SArnd Bergmann if (status) 1530a33a7d73SArnd Bergmann ret = status; 1531a33a7d73SArnd Bergmann } 1532a33a7d73SArnd Bergmann 1533a33a7d73SArnd Bergmann if (ret) 1534933b0e35SKazunori Asayama goto out_unlock; 1535a33a7d73SArnd Bergmann 1536a33a7d73SArnd Bergmann ctx->tagwait |= 1 << cmd.tag; 15373692dc66SMasato Noguchi ret = size; 1538a33a7d73SArnd Bergmann 1539933b0e35SKazunori Asayama out_unlock: 1540933b0e35SKazunori Asayama spu_release(ctx); 1541a33a7d73SArnd Bergmann out: 1542a33a7d73SArnd Bergmann return ret; 1543a33a7d73SArnd Bergmann } 1544a33a7d73SArnd Bergmann 1545a33a7d73SArnd Bergmann static unsigned int spufs_mfc_poll(struct file *file,poll_table *wait) 1546a33a7d73SArnd Bergmann { 1547a33a7d73SArnd Bergmann struct spu_context *ctx = file->private_data; 1548a33a7d73SArnd Bergmann u32 free_elements, tagstatus; 1549a33a7d73SArnd Bergmann unsigned int mask; 1550a33a7d73SArnd Bergmann 1551933b0e35SKazunori Asayama poll_wait(file, &ctx->mfc_wq, wait); 1552933b0e35SKazunori Asayama 1553a33a7d73SArnd Bergmann spu_acquire(ctx); 1554a33a7d73SArnd Bergmann ctx->ops->set_mfc_query(ctx, ctx->tagwait, 2); 1555a33a7d73SArnd Bergmann free_elements = ctx->ops->get_mfc_free_elements(ctx); 1556a33a7d73SArnd Bergmann tagstatus = ctx->ops->read_mfc_tagstatus(ctx); 1557a33a7d73SArnd Bergmann spu_release(ctx); 1558a33a7d73SArnd Bergmann 1559a33a7d73SArnd Bergmann mask = 0; 1560a33a7d73SArnd Bergmann if (free_elements & 0xffff) 1561a33a7d73SArnd Bergmann mask |= POLLOUT | POLLWRNORM; 1562a33a7d73SArnd Bergmann if (tagstatus & ctx->tagwait) 1563a33a7d73SArnd Bergmann mask |= POLLIN | POLLRDNORM; 1564a33a7d73SArnd Bergmann 1565a33a7d73SArnd Bergmann pr_debug("%s: free %d tagstatus %d tagwait %d\n", __FUNCTION__, 1566a33a7d73SArnd Bergmann free_elements, tagstatus, ctx->tagwait); 1567a33a7d73SArnd Bergmann 1568a33a7d73SArnd Bergmann return mask; 1569a33a7d73SArnd Bergmann } 1570a33a7d73SArnd Bergmann 157173b6af8aSAl Viro static int spufs_mfc_flush(struct file *file, fl_owner_t id) 1572a33a7d73SArnd Bergmann { 1573a33a7d73SArnd Bergmann struct spu_context *ctx = file->private_data; 1574a33a7d73SArnd Bergmann int ret; 1575a33a7d73SArnd Bergmann 1576a33a7d73SArnd Bergmann spu_acquire(ctx); 1577a33a7d73SArnd Bergmann #if 0 1578a33a7d73SArnd Bergmann /* this currently hangs */ 1579a33a7d73SArnd Bergmann ret = spufs_wait(ctx->mfc_wq, 1580a33a7d73SArnd Bergmann ctx->ops->set_mfc_query(ctx, ctx->tagwait, 2)); 1581a33a7d73SArnd Bergmann if (ret) 1582a33a7d73SArnd Bergmann goto out; 1583a33a7d73SArnd Bergmann ret = spufs_wait(ctx->mfc_wq, 1584a33a7d73SArnd Bergmann ctx->ops->read_mfc_tagstatus(ctx) == ctx->tagwait); 1585a33a7d73SArnd Bergmann out: 1586a33a7d73SArnd Bergmann #else 1587a33a7d73SArnd Bergmann ret = 0; 1588a33a7d73SArnd Bergmann #endif 1589a33a7d73SArnd Bergmann spu_release(ctx); 1590a33a7d73SArnd Bergmann 1591a33a7d73SArnd Bergmann return ret; 1592a33a7d73SArnd Bergmann } 1593a33a7d73SArnd Bergmann 1594a33a7d73SArnd Bergmann static int spufs_mfc_fsync(struct file *file, struct dentry *dentry, 1595a33a7d73SArnd Bergmann int datasync) 1596a33a7d73SArnd Bergmann { 159773b6af8aSAl Viro return spufs_mfc_flush(file, NULL); 1598a33a7d73SArnd Bergmann } 1599a33a7d73SArnd Bergmann 1600a33a7d73SArnd Bergmann static int spufs_mfc_fasync(int fd, struct file *file, int on) 1601a33a7d73SArnd Bergmann { 1602a33a7d73SArnd Bergmann struct spu_context *ctx = file->private_data; 1603a33a7d73SArnd Bergmann 1604a33a7d73SArnd Bergmann return fasync_helper(fd, file, on, &ctx->mfc_fasync); 1605a33a7d73SArnd Bergmann } 1606a33a7d73SArnd Bergmann 16075dfe4c96SArjan van de Ven static const struct file_operations spufs_mfc_fops = { 1608a33a7d73SArnd Bergmann .open = spufs_mfc_open, 160943c2bbd9SChristoph Hellwig .release = spufs_mfc_release, 1610a33a7d73SArnd Bergmann .read = spufs_mfc_read, 1611a33a7d73SArnd Bergmann .write = spufs_mfc_write, 1612a33a7d73SArnd Bergmann .poll = spufs_mfc_poll, 1613a33a7d73SArnd Bergmann .flush = spufs_mfc_flush, 1614a33a7d73SArnd Bergmann .fsync = spufs_mfc_fsync, 1615a33a7d73SArnd Bergmann .fasync = spufs_mfc_fasync, 16166df10a82SMark Nutter .mmap = spufs_mfc_mmap, 1617a33a7d73SArnd Bergmann }; 1618a33a7d73SArnd Bergmann 161967207b96SArnd Bergmann static void spufs_npc_set(void *data, u64 val) 162067207b96SArnd Bergmann { 162167207b96SArnd Bergmann struct spu_context *ctx = data; 16228b3d6663SArnd Bergmann spu_acquire(ctx); 16238b3d6663SArnd Bergmann ctx->ops->npc_write(ctx, val); 16248b3d6663SArnd Bergmann spu_release(ctx); 162567207b96SArnd Bergmann } 162667207b96SArnd Bergmann 1627104f0cc2SMichael Ellerman static u64 spufs_npc_get(struct spu_context *ctx) 162878810ff6SMichael Ellerman { 162978810ff6SMichael Ellerman return ctx->ops->npc_read(ctx); 163078810ff6SMichael Ellerman } 1631104f0cc2SMichael Ellerman DEFINE_SPUFS_ATTRIBUTE(spufs_npc_ops, spufs_npc_get, spufs_npc_set, 1632104f0cc2SMichael Ellerman "0x%llx\n", SPU_ATTR_ACQUIRE); 163367207b96SArnd Bergmann 16348b3d6663SArnd Bergmann static void spufs_decr_set(void *data, u64 val) 16358b3d6663SArnd Bergmann { 16368b3d6663SArnd Bergmann struct spu_context *ctx = data; 16378b3d6663SArnd Bergmann struct spu_lscsa *lscsa = ctx->csa.lscsa; 16388b3d6663SArnd Bergmann spu_acquire_saved(ctx); 16398b3d6663SArnd Bergmann lscsa->decr.slot[0] = (u32) val; 164027b1ea09SChristoph Hellwig spu_release_saved(ctx); 16418b3d6663SArnd Bergmann } 16428b3d6663SArnd Bergmann 1643104f0cc2SMichael Ellerman static u64 spufs_decr_get(struct spu_context *ctx) 16448b3d6663SArnd Bergmann { 16458b3d6663SArnd Bergmann struct spu_lscsa *lscsa = ctx->csa.lscsa; 1646bf1ab978SDwayne Grant McConnell return lscsa->decr.slot[0]; 1647bf1ab978SDwayne Grant McConnell } 1648104f0cc2SMichael Ellerman DEFINE_SPUFS_ATTRIBUTE(spufs_decr_ops, spufs_decr_get, spufs_decr_set, 1649104f0cc2SMichael Ellerman "0x%llx\n", SPU_ATTR_ACQUIRE_SAVED); 16508b3d6663SArnd Bergmann 16518b3d6663SArnd Bergmann static void spufs_decr_status_set(void *data, u64 val) 16528b3d6663SArnd Bergmann { 16538b3d6663SArnd Bergmann struct spu_context *ctx = data; 16548b3d6663SArnd Bergmann spu_acquire_saved(ctx); 1655d40a01d4SMasato Noguchi if (val) 1656d40a01d4SMasato Noguchi ctx->csa.priv2.mfc_control_RW |= MFC_CNTL_DECREMENTER_RUNNING; 1657d40a01d4SMasato Noguchi else 1658d40a01d4SMasato Noguchi ctx->csa.priv2.mfc_control_RW &= ~MFC_CNTL_DECREMENTER_RUNNING; 165927b1ea09SChristoph Hellwig spu_release_saved(ctx); 16608b3d6663SArnd Bergmann } 16618b3d6663SArnd Bergmann 1662104f0cc2SMichael Ellerman static u64 spufs_decr_status_get(struct spu_context *ctx) 16638b3d6663SArnd Bergmann { 1664d40a01d4SMasato Noguchi if (ctx->csa.priv2.mfc_control_RW & MFC_CNTL_DECREMENTER_RUNNING) 1665d40a01d4SMasato Noguchi return SPU_DECR_STATUS_RUNNING; 1666d40a01d4SMasato Noguchi else 1667d40a01d4SMasato Noguchi return 0; 1668bf1ab978SDwayne Grant McConnell } 1669104f0cc2SMichael Ellerman DEFINE_SPUFS_ATTRIBUTE(spufs_decr_status_ops, spufs_decr_status_get, 1670104f0cc2SMichael Ellerman spufs_decr_status_set, "0x%llx\n", 1671104f0cc2SMichael Ellerman SPU_ATTR_ACQUIRE_SAVED); 16728b3d6663SArnd Bergmann 16738b3d6663SArnd Bergmann static void spufs_event_mask_set(void *data, u64 val) 16748b3d6663SArnd Bergmann { 16758b3d6663SArnd Bergmann struct spu_context *ctx = data; 16768b3d6663SArnd Bergmann struct spu_lscsa *lscsa = ctx->csa.lscsa; 16778b3d6663SArnd Bergmann spu_acquire_saved(ctx); 16788b3d6663SArnd Bergmann lscsa->event_mask.slot[0] = (u32) val; 167927b1ea09SChristoph Hellwig spu_release_saved(ctx); 16808b3d6663SArnd Bergmann } 16818b3d6663SArnd Bergmann 1682104f0cc2SMichael Ellerman static u64 spufs_event_mask_get(struct spu_context *ctx) 16838b3d6663SArnd Bergmann { 16848b3d6663SArnd Bergmann struct spu_lscsa *lscsa = ctx->csa.lscsa; 1685bf1ab978SDwayne Grant McConnell return lscsa->event_mask.slot[0]; 1686bf1ab978SDwayne Grant McConnell } 1687bf1ab978SDwayne Grant McConnell 1688104f0cc2SMichael Ellerman DEFINE_SPUFS_ATTRIBUTE(spufs_event_mask_ops, spufs_event_mask_get, 1689104f0cc2SMichael Ellerman spufs_event_mask_set, "0x%llx\n", 1690104f0cc2SMichael Ellerman SPU_ATTR_ACQUIRE_SAVED); 16918b3d6663SArnd Bergmann 1692104f0cc2SMichael Ellerman static u64 spufs_event_status_get(struct spu_context *ctx) 1693b9e3bd77SDwayne Grant McConnell { 1694b9e3bd77SDwayne Grant McConnell struct spu_state *state = &ctx->csa; 1695b9e3bd77SDwayne Grant McConnell u64 stat; 1696b9e3bd77SDwayne Grant McConnell stat = state->spu_chnlcnt_RW[0]; 1697b9e3bd77SDwayne Grant McConnell if (stat) 1698bf1ab978SDwayne Grant McConnell return state->spu_chnldata_RW[0]; 1699bf1ab978SDwayne Grant McConnell return 0; 1700bf1ab978SDwayne Grant McConnell } 1701104f0cc2SMichael Ellerman DEFINE_SPUFS_ATTRIBUTE(spufs_event_status_ops, spufs_event_status_get, 1702104f0cc2SMichael Ellerman NULL, "0x%llx\n", SPU_ATTR_ACQUIRE_SAVED) 1703b9e3bd77SDwayne Grant McConnell 17048b3d6663SArnd Bergmann static void spufs_srr0_set(void *data, u64 val) 17058b3d6663SArnd Bergmann { 17068b3d6663SArnd Bergmann struct spu_context *ctx = data; 17078b3d6663SArnd Bergmann struct spu_lscsa *lscsa = ctx->csa.lscsa; 17088b3d6663SArnd Bergmann spu_acquire_saved(ctx); 17098b3d6663SArnd Bergmann lscsa->srr0.slot[0] = (u32) val; 171027b1ea09SChristoph Hellwig spu_release_saved(ctx); 17118b3d6663SArnd Bergmann } 17128b3d6663SArnd Bergmann 1713104f0cc2SMichael Ellerman static u64 spufs_srr0_get(struct spu_context *ctx) 17148b3d6663SArnd Bergmann { 17158b3d6663SArnd Bergmann struct spu_lscsa *lscsa = ctx->csa.lscsa; 1716104f0cc2SMichael Ellerman return lscsa->srr0.slot[0]; 17178b3d6663SArnd Bergmann } 1718104f0cc2SMichael Ellerman DEFINE_SPUFS_ATTRIBUTE(spufs_srr0_ops, spufs_srr0_get, spufs_srr0_set, 1719104f0cc2SMichael Ellerman "0x%llx\n", SPU_ATTR_ACQUIRE_SAVED) 17208b3d6663SArnd Bergmann 1721104f0cc2SMichael Ellerman static u64 spufs_id_get(struct spu_context *ctx) 17227b1a7014Sarnd@arndb.de { 17237b1a7014Sarnd@arndb.de u64 num; 17247b1a7014Sarnd@arndb.de 17257b1a7014Sarnd@arndb.de if (ctx->state == SPU_STATE_RUNNABLE) 17267b1a7014Sarnd@arndb.de num = ctx->spu->number; 17277b1a7014Sarnd@arndb.de else 17287b1a7014Sarnd@arndb.de num = (unsigned int)-1; 17297b1a7014Sarnd@arndb.de 17307b1a7014Sarnd@arndb.de return num; 17317b1a7014Sarnd@arndb.de } 1732104f0cc2SMichael Ellerman DEFINE_SPUFS_ATTRIBUTE(spufs_id_ops, spufs_id_get, NULL, "0x%llx\n", 1733104f0cc2SMichael Ellerman SPU_ATTR_ACQUIRE) 17347b1a7014Sarnd@arndb.de 1735104f0cc2SMichael Ellerman static u64 spufs_object_id_get(struct spu_context *ctx) 1736bf1ab978SDwayne Grant McConnell { 1737bf1ab978SDwayne Grant McConnell /* FIXME: Should there really be no locking here? */ 1738104f0cc2SMichael Ellerman return ctx->object_id; 1739bf1ab978SDwayne Grant McConnell } 1740bf1ab978SDwayne Grant McConnell 174186767277SArnd Bergmann static void spufs_object_id_set(void *data, u64 id) 174286767277SArnd Bergmann { 174386767277SArnd Bergmann struct spu_context *ctx = data; 174486767277SArnd Bergmann ctx->object_id = id; 174586767277SArnd Bergmann } 174686767277SArnd Bergmann 1747104f0cc2SMichael Ellerman DEFINE_SPUFS_ATTRIBUTE(spufs_object_id_ops, spufs_object_id_get, 1748104f0cc2SMichael Ellerman spufs_object_id_set, "0x%llx\n", SPU_ATTR_NOACQUIRE); 174986767277SArnd Bergmann 1750104f0cc2SMichael Ellerman static u64 spufs_lslr_get(struct spu_context *ctx) 1751bf1ab978SDwayne Grant McConnell { 1752bf1ab978SDwayne Grant McConnell return ctx->csa.priv2.spu_lslr_RW; 1753bf1ab978SDwayne Grant McConnell } 1754104f0cc2SMichael Ellerman DEFINE_SPUFS_ATTRIBUTE(spufs_lslr_ops, spufs_lslr_get, NULL, "0x%llx\n", 1755104f0cc2SMichael Ellerman SPU_ATTR_ACQUIRE_SAVED); 1756b9e3bd77SDwayne Grant McConnell 1757b9e3bd77SDwayne Grant McConnell static int spufs_info_open(struct inode *inode, struct file *file) 1758b9e3bd77SDwayne Grant McConnell { 1759b9e3bd77SDwayne Grant McConnell struct spufs_inode_info *i = SPUFS_I(inode); 1760b9e3bd77SDwayne Grant McConnell struct spu_context *ctx = i->i_ctx; 1761b9e3bd77SDwayne Grant McConnell file->private_data = ctx; 1762b9e3bd77SDwayne Grant McConnell return 0; 1763b9e3bd77SDwayne Grant McConnell } 1764b9e3bd77SDwayne Grant McConnell 1765cbe709c1SBenjamin Herrenschmidt static int spufs_caps_show(struct seq_file *s, void *private) 1766cbe709c1SBenjamin Herrenschmidt { 1767cbe709c1SBenjamin Herrenschmidt struct spu_context *ctx = s->private; 1768cbe709c1SBenjamin Herrenschmidt 1769cbe709c1SBenjamin Herrenschmidt if (!(ctx->flags & SPU_CREATE_NOSCHED)) 1770cbe709c1SBenjamin Herrenschmidt seq_puts(s, "sched\n"); 1771cbe709c1SBenjamin Herrenschmidt if (!(ctx->flags & SPU_CREATE_ISOLATE)) 1772cbe709c1SBenjamin Herrenschmidt seq_puts(s, "step\n"); 1773cbe709c1SBenjamin Herrenschmidt return 0; 1774cbe709c1SBenjamin Herrenschmidt } 1775cbe709c1SBenjamin Herrenschmidt 1776cbe709c1SBenjamin Herrenschmidt static int spufs_caps_open(struct inode *inode, struct file *file) 1777cbe709c1SBenjamin Herrenschmidt { 1778cbe709c1SBenjamin Herrenschmidt return single_open(file, spufs_caps_show, SPUFS_I(inode)->i_ctx); 1779cbe709c1SBenjamin Herrenschmidt } 1780cbe709c1SBenjamin Herrenschmidt 1781cbe709c1SBenjamin Herrenschmidt static const struct file_operations spufs_caps_fops = { 1782cbe709c1SBenjamin Herrenschmidt .open = spufs_caps_open, 1783cbe709c1SBenjamin Herrenschmidt .read = seq_read, 1784cbe709c1SBenjamin Herrenschmidt .llseek = seq_lseek, 1785cbe709c1SBenjamin Herrenschmidt .release = single_release, 1786cbe709c1SBenjamin Herrenschmidt }; 1787cbe709c1SBenjamin Herrenschmidt 1788bf1ab978SDwayne Grant McConnell static ssize_t __spufs_mbox_info_read(struct spu_context *ctx, 1789bf1ab978SDwayne Grant McConnell char __user *buf, size_t len, loff_t *pos) 1790bf1ab978SDwayne Grant McConnell { 1791bf1ab978SDwayne Grant McConnell u32 mbox_stat; 1792bf1ab978SDwayne Grant McConnell u32 data; 1793bf1ab978SDwayne Grant McConnell 1794bf1ab978SDwayne Grant McConnell mbox_stat = ctx->csa.prob.mb_stat_R; 1795bf1ab978SDwayne Grant McConnell if (mbox_stat & 0x0000ff) { 1796bf1ab978SDwayne Grant McConnell data = ctx->csa.prob.pu_mb_R; 1797bf1ab978SDwayne Grant McConnell } 1798bf1ab978SDwayne Grant McConnell 1799bf1ab978SDwayne Grant McConnell return simple_read_from_buffer(buf, len, pos, &data, sizeof data); 1800bf1ab978SDwayne Grant McConnell } 1801bf1ab978SDwayne Grant McConnell 180269a2f00cSDwayne Grant McConnell static ssize_t spufs_mbox_info_read(struct file *file, char __user *buf, 180369a2f00cSDwayne Grant McConnell size_t len, loff_t *pos) 180469a2f00cSDwayne Grant McConnell { 1805bf1ab978SDwayne Grant McConnell int ret; 180669a2f00cSDwayne Grant McConnell struct spu_context *ctx = file->private_data; 180769a2f00cSDwayne Grant McConnell 180869a2f00cSDwayne Grant McConnell if (!access_ok(VERIFY_WRITE, buf, len)) 180969a2f00cSDwayne Grant McConnell return -EFAULT; 181069a2f00cSDwayne Grant McConnell 181169a2f00cSDwayne Grant McConnell spu_acquire_saved(ctx); 181269a2f00cSDwayne Grant McConnell spin_lock(&ctx->csa.register_lock); 1813bf1ab978SDwayne Grant McConnell ret = __spufs_mbox_info_read(ctx, buf, len, pos); 181469a2f00cSDwayne Grant McConnell spin_unlock(&ctx->csa.register_lock); 181527b1ea09SChristoph Hellwig spu_release_saved(ctx); 181669a2f00cSDwayne Grant McConnell 1817bf1ab978SDwayne Grant McConnell return ret; 181869a2f00cSDwayne Grant McConnell } 181969a2f00cSDwayne Grant McConnell 18205dfe4c96SArjan van de Ven static const struct file_operations spufs_mbox_info_fops = { 182169a2f00cSDwayne Grant McConnell .open = spufs_info_open, 182269a2f00cSDwayne Grant McConnell .read = spufs_mbox_info_read, 182369a2f00cSDwayne Grant McConnell .llseek = generic_file_llseek, 182469a2f00cSDwayne Grant McConnell }; 182569a2f00cSDwayne Grant McConnell 1826bf1ab978SDwayne Grant McConnell static ssize_t __spufs_ibox_info_read(struct spu_context *ctx, 1827bf1ab978SDwayne Grant McConnell char __user *buf, size_t len, loff_t *pos) 1828bf1ab978SDwayne Grant McConnell { 1829bf1ab978SDwayne Grant McConnell u32 ibox_stat; 1830bf1ab978SDwayne Grant McConnell u32 data; 1831bf1ab978SDwayne Grant McConnell 1832bf1ab978SDwayne Grant McConnell ibox_stat = ctx->csa.prob.mb_stat_R; 1833bf1ab978SDwayne Grant McConnell if (ibox_stat & 0xff0000) { 1834bf1ab978SDwayne Grant McConnell data = ctx->csa.priv2.puint_mb_R; 1835bf1ab978SDwayne Grant McConnell } 1836bf1ab978SDwayne Grant McConnell 1837bf1ab978SDwayne Grant McConnell return simple_read_from_buffer(buf, len, pos, &data, sizeof data); 1838bf1ab978SDwayne Grant McConnell } 1839bf1ab978SDwayne Grant McConnell 184069a2f00cSDwayne Grant McConnell static ssize_t spufs_ibox_info_read(struct file *file, char __user *buf, 184169a2f00cSDwayne Grant McConnell size_t len, loff_t *pos) 184269a2f00cSDwayne Grant McConnell { 184369a2f00cSDwayne Grant McConnell struct spu_context *ctx = file->private_data; 1844bf1ab978SDwayne Grant McConnell int ret; 184569a2f00cSDwayne Grant McConnell 184669a2f00cSDwayne Grant McConnell if (!access_ok(VERIFY_WRITE, buf, len)) 184769a2f00cSDwayne Grant McConnell return -EFAULT; 184869a2f00cSDwayne Grant McConnell 184969a2f00cSDwayne Grant McConnell spu_acquire_saved(ctx); 185069a2f00cSDwayne Grant McConnell spin_lock(&ctx->csa.register_lock); 1851bf1ab978SDwayne Grant McConnell ret = __spufs_ibox_info_read(ctx, buf, len, pos); 185269a2f00cSDwayne Grant McConnell spin_unlock(&ctx->csa.register_lock); 185327b1ea09SChristoph Hellwig spu_release_saved(ctx); 185469a2f00cSDwayne Grant McConnell 1855bf1ab978SDwayne Grant McConnell return ret; 185669a2f00cSDwayne Grant McConnell } 185769a2f00cSDwayne Grant McConnell 18585dfe4c96SArjan van de Ven static const struct file_operations spufs_ibox_info_fops = { 185969a2f00cSDwayne Grant McConnell .open = spufs_info_open, 186069a2f00cSDwayne Grant McConnell .read = spufs_ibox_info_read, 186169a2f00cSDwayne Grant McConnell .llseek = generic_file_llseek, 186269a2f00cSDwayne Grant McConnell }; 186369a2f00cSDwayne Grant McConnell 1864bf1ab978SDwayne Grant McConnell static ssize_t __spufs_wbox_info_read(struct spu_context *ctx, 1865bf1ab978SDwayne Grant McConnell char __user *buf, size_t len, loff_t *pos) 1866bf1ab978SDwayne Grant McConnell { 1867bf1ab978SDwayne Grant McConnell int i, cnt; 1868bf1ab978SDwayne Grant McConnell u32 data[4]; 1869bf1ab978SDwayne Grant McConnell u32 wbox_stat; 1870bf1ab978SDwayne Grant McConnell 1871bf1ab978SDwayne Grant McConnell wbox_stat = ctx->csa.prob.mb_stat_R; 1872bf1ab978SDwayne Grant McConnell cnt = 4 - ((wbox_stat & 0x00ff00) >> 8); 1873bf1ab978SDwayne Grant McConnell for (i = 0; i < cnt; i++) { 1874bf1ab978SDwayne Grant McConnell data[i] = ctx->csa.spu_mailbox_data[i]; 1875bf1ab978SDwayne Grant McConnell } 1876bf1ab978SDwayne Grant McConnell 1877bf1ab978SDwayne Grant McConnell return simple_read_from_buffer(buf, len, pos, &data, 1878bf1ab978SDwayne Grant McConnell cnt * sizeof(u32)); 1879bf1ab978SDwayne Grant McConnell } 1880bf1ab978SDwayne Grant McConnell 188169a2f00cSDwayne Grant McConnell static ssize_t spufs_wbox_info_read(struct file *file, char __user *buf, 188269a2f00cSDwayne Grant McConnell size_t len, loff_t *pos) 188369a2f00cSDwayne Grant McConnell { 188469a2f00cSDwayne Grant McConnell struct spu_context *ctx = file->private_data; 1885bf1ab978SDwayne Grant McConnell int ret; 188669a2f00cSDwayne Grant McConnell 188769a2f00cSDwayne Grant McConnell if (!access_ok(VERIFY_WRITE, buf, len)) 188869a2f00cSDwayne Grant McConnell return -EFAULT; 188969a2f00cSDwayne Grant McConnell 189069a2f00cSDwayne Grant McConnell spu_acquire_saved(ctx); 189169a2f00cSDwayne Grant McConnell spin_lock(&ctx->csa.register_lock); 1892bf1ab978SDwayne Grant McConnell ret = __spufs_wbox_info_read(ctx, buf, len, pos); 189369a2f00cSDwayne Grant McConnell spin_unlock(&ctx->csa.register_lock); 189427b1ea09SChristoph Hellwig spu_release_saved(ctx); 189569a2f00cSDwayne Grant McConnell 1896bf1ab978SDwayne Grant McConnell return ret; 189769a2f00cSDwayne Grant McConnell } 189869a2f00cSDwayne Grant McConnell 18995dfe4c96SArjan van de Ven static const struct file_operations spufs_wbox_info_fops = { 190069a2f00cSDwayne Grant McConnell .open = spufs_info_open, 190169a2f00cSDwayne Grant McConnell .read = spufs_wbox_info_read, 190269a2f00cSDwayne Grant McConnell .llseek = generic_file_llseek, 190369a2f00cSDwayne Grant McConnell }; 190469a2f00cSDwayne Grant McConnell 1905bf1ab978SDwayne Grant McConnell static ssize_t __spufs_dma_info_read(struct spu_context *ctx, 1906bf1ab978SDwayne Grant McConnell char __user *buf, size_t len, loff_t *pos) 1907b9e3bd77SDwayne Grant McConnell { 1908b9e3bd77SDwayne Grant McConnell struct spu_dma_info info; 1909b9e3bd77SDwayne Grant McConnell struct mfc_cq_sr *qp, *spuqp; 1910b9e3bd77SDwayne Grant McConnell int i; 1911b9e3bd77SDwayne Grant McConnell 1912b9e3bd77SDwayne Grant McConnell info.dma_info_type = ctx->csa.priv2.spu_tag_status_query_RW; 1913b9e3bd77SDwayne Grant McConnell info.dma_info_mask = ctx->csa.lscsa->tag_mask.slot[0]; 1914b9e3bd77SDwayne Grant McConnell info.dma_info_status = ctx->csa.spu_chnldata_RW[24]; 1915b9e3bd77SDwayne Grant McConnell info.dma_info_stall_and_notify = ctx->csa.spu_chnldata_RW[25]; 1916b9e3bd77SDwayne Grant McConnell info.dma_info_atomic_command_status = ctx->csa.spu_chnldata_RW[27]; 1917b9e3bd77SDwayne Grant McConnell for (i = 0; i < 16; i++) { 1918b9e3bd77SDwayne Grant McConnell qp = &info.dma_info_command_data[i]; 1919b9e3bd77SDwayne Grant McConnell spuqp = &ctx->csa.priv2.spuq[i]; 1920b9e3bd77SDwayne Grant McConnell 1921b9e3bd77SDwayne Grant McConnell qp->mfc_cq_data0_RW = spuqp->mfc_cq_data0_RW; 1922b9e3bd77SDwayne Grant McConnell qp->mfc_cq_data1_RW = spuqp->mfc_cq_data1_RW; 1923b9e3bd77SDwayne Grant McConnell qp->mfc_cq_data2_RW = spuqp->mfc_cq_data2_RW; 1924b9e3bd77SDwayne Grant McConnell qp->mfc_cq_data3_RW = spuqp->mfc_cq_data3_RW; 1925b9e3bd77SDwayne Grant McConnell } 1926b9e3bd77SDwayne Grant McConnell 1927b9e3bd77SDwayne Grant McConnell return simple_read_from_buffer(buf, len, pos, &info, 1928b9e3bd77SDwayne Grant McConnell sizeof info); 1929b9e3bd77SDwayne Grant McConnell } 1930b9e3bd77SDwayne Grant McConnell 1931bf1ab978SDwayne Grant McConnell static ssize_t spufs_dma_info_read(struct file *file, char __user *buf, 1932bf1ab978SDwayne Grant McConnell size_t len, loff_t *pos) 1933bf1ab978SDwayne Grant McConnell { 1934bf1ab978SDwayne Grant McConnell struct spu_context *ctx = file->private_data; 1935bf1ab978SDwayne Grant McConnell int ret; 1936bf1ab978SDwayne Grant McConnell 1937bf1ab978SDwayne Grant McConnell if (!access_ok(VERIFY_WRITE, buf, len)) 1938bf1ab978SDwayne Grant McConnell return -EFAULT; 1939bf1ab978SDwayne Grant McConnell 1940bf1ab978SDwayne Grant McConnell spu_acquire_saved(ctx); 1941bf1ab978SDwayne Grant McConnell spin_lock(&ctx->csa.register_lock); 1942bf1ab978SDwayne Grant McConnell ret = __spufs_dma_info_read(ctx, buf, len, pos); 1943bf1ab978SDwayne Grant McConnell spin_unlock(&ctx->csa.register_lock); 194427b1ea09SChristoph Hellwig spu_release_saved(ctx); 1945bf1ab978SDwayne Grant McConnell 1946bf1ab978SDwayne Grant McConnell return ret; 1947bf1ab978SDwayne Grant McConnell } 1948bf1ab978SDwayne Grant McConnell 19495dfe4c96SArjan van de Ven static const struct file_operations spufs_dma_info_fops = { 1950b9e3bd77SDwayne Grant McConnell .open = spufs_info_open, 1951b9e3bd77SDwayne Grant McConnell .read = spufs_dma_info_read, 1952b9e3bd77SDwayne Grant McConnell }; 1953b9e3bd77SDwayne Grant McConnell 1954bf1ab978SDwayne Grant McConnell static ssize_t __spufs_proxydma_info_read(struct spu_context *ctx, 1955bf1ab978SDwayne Grant McConnell char __user *buf, size_t len, loff_t *pos) 1956b9e3bd77SDwayne Grant McConnell { 1957b9e3bd77SDwayne Grant McConnell struct spu_proxydma_info info; 1958b9e3bd77SDwayne Grant McConnell struct mfc_cq_sr *qp, *puqp; 1959bf1ab978SDwayne Grant McConnell int ret = sizeof info; 1960b9e3bd77SDwayne Grant McConnell int i; 1961b9e3bd77SDwayne Grant McConnell 1962b9e3bd77SDwayne Grant McConnell if (len < ret) 1963b9e3bd77SDwayne Grant McConnell return -EINVAL; 1964b9e3bd77SDwayne Grant McConnell 1965b9e3bd77SDwayne Grant McConnell if (!access_ok(VERIFY_WRITE, buf, len)) 1966b9e3bd77SDwayne Grant McConnell return -EFAULT; 1967b9e3bd77SDwayne Grant McConnell 1968b9e3bd77SDwayne Grant McConnell info.proxydma_info_type = ctx->csa.prob.dma_querytype_RW; 1969b9e3bd77SDwayne Grant McConnell info.proxydma_info_mask = ctx->csa.prob.dma_querymask_RW; 1970b9e3bd77SDwayne Grant McConnell info.proxydma_info_status = ctx->csa.prob.dma_tagstatus_R; 1971b9e3bd77SDwayne Grant McConnell for (i = 0; i < 8; i++) { 1972b9e3bd77SDwayne Grant McConnell qp = &info.proxydma_info_command_data[i]; 1973b9e3bd77SDwayne Grant McConnell puqp = &ctx->csa.priv2.puq[i]; 1974b9e3bd77SDwayne Grant McConnell 1975b9e3bd77SDwayne Grant McConnell qp->mfc_cq_data0_RW = puqp->mfc_cq_data0_RW; 1976b9e3bd77SDwayne Grant McConnell qp->mfc_cq_data1_RW = puqp->mfc_cq_data1_RW; 1977b9e3bd77SDwayne Grant McConnell qp->mfc_cq_data2_RW = puqp->mfc_cq_data2_RW; 1978b9e3bd77SDwayne Grant McConnell qp->mfc_cq_data3_RW = puqp->mfc_cq_data3_RW; 1979b9e3bd77SDwayne Grant McConnell } 1980bf1ab978SDwayne Grant McConnell 1981bf1ab978SDwayne Grant McConnell return simple_read_from_buffer(buf, len, pos, &info, 1982bf1ab978SDwayne Grant McConnell sizeof info); 1983bf1ab978SDwayne Grant McConnell } 1984bf1ab978SDwayne Grant McConnell 1985bf1ab978SDwayne Grant McConnell static ssize_t spufs_proxydma_info_read(struct file *file, char __user *buf, 1986bf1ab978SDwayne Grant McConnell size_t len, loff_t *pos) 1987bf1ab978SDwayne Grant McConnell { 1988bf1ab978SDwayne Grant McConnell struct spu_context *ctx = file->private_data; 1989bf1ab978SDwayne Grant McConnell int ret; 1990bf1ab978SDwayne Grant McConnell 1991bf1ab978SDwayne Grant McConnell spu_acquire_saved(ctx); 1992bf1ab978SDwayne Grant McConnell spin_lock(&ctx->csa.register_lock); 1993bf1ab978SDwayne Grant McConnell ret = __spufs_proxydma_info_read(ctx, buf, len, pos); 1994b9e3bd77SDwayne Grant McConnell spin_unlock(&ctx->csa.register_lock); 199527b1ea09SChristoph Hellwig spu_release_saved(ctx); 1996b9e3bd77SDwayne Grant McConnell 1997b9e3bd77SDwayne Grant McConnell return ret; 1998b9e3bd77SDwayne Grant McConnell } 1999b9e3bd77SDwayne Grant McConnell 20005dfe4c96SArjan van de Ven static const struct file_operations spufs_proxydma_info_fops = { 2001b9e3bd77SDwayne Grant McConnell .open = spufs_info_open, 2002b9e3bd77SDwayne Grant McConnell .read = spufs_proxydma_info_read, 2003b9e3bd77SDwayne Grant McConnell }; 2004b9e3bd77SDwayne Grant McConnell 2005476273adSChristoph Hellwig static int spufs_show_tid(struct seq_file *s, void *private) 2006476273adSChristoph Hellwig { 2007476273adSChristoph Hellwig struct spu_context *ctx = s->private; 2008476273adSChristoph Hellwig 2009476273adSChristoph Hellwig seq_printf(s, "%d\n", ctx->tid); 2010476273adSChristoph Hellwig return 0; 2011476273adSChristoph Hellwig } 2012476273adSChristoph Hellwig 2013476273adSChristoph Hellwig static int spufs_tid_open(struct inode *inode, struct file *file) 2014476273adSChristoph Hellwig { 2015476273adSChristoph Hellwig return single_open(file, spufs_show_tid, SPUFS_I(inode)->i_ctx); 2016476273adSChristoph Hellwig } 2017476273adSChristoph Hellwig 2018476273adSChristoph Hellwig static const struct file_operations spufs_tid_fops = { 2019476273adSChristoph Hellwig .open = spufs_tid_open, 2020476273adSChristoph Hellwig .read = seq_read, 2021476273adSChristoph Hellwig .llseek = seq_lseek, 2022476273adSChristoph Hellwig .release = single_release, 2023476273adSChristoph Hellwig }; 2024476273adSChristoph Hellwig 2025e9f8a0b6SChristoph Hellwig static const char *ctx_state_names[] = { 2026e9f8a0b6SChristoph Hellwig "user", "system", "iowait", "loaded" 2027e9f8a0b6SChristoph Hellwig }; 2028e9f8a0b6SChristoph Hellwig 2029e9f8a0b6SChristoph Hellwig static unsigned long long spufs_acct_time(struct spu_context *ctx, 203027ec41d3SAndre Detsch enum spu_utilization_state state) 2031e9f8a0b6SChristoph Hellwig { 203227ec41d3SAndre Detsch struct timespec ts; 203327ec41d3SAndre Detsch unsigned long long time = ctx->stats.times[state]; 2034e9f8a0b6SChristoph Hellwig 203527ec41d3SAndre Detsch /* 203627ec41d3SAndre Detsch * In general, utilization statistics are updated by the controlling 203727ec41d3SAndre Detsch * thread as the spu context moves through various well defined 203827ec41d3SAndre Detsch * state transitions, but if the context is lazily loaded its 203927ec41d3SAndre Detsch * utilization statistics are not updated as the controlling thread 204027ec41d3SAndre Detsch * is not tightly coupled with the execution of the spu context. We 204127ec41d3SAndre Detsch * calculate and apply the time delta from the last recorded state 204227ec41d3SAndre Detsch * of the spu context. 204327ec41d3SAndre Detsch */ 204427ec41d3SAndre Detsch if (ctx->spu && ctx->stats.util_state == state) { 204527ec41d3SAndre Detsch ktime_get_ts(&ts); 204627ec41d3SAndre Detsch time += timespec_to_ns(&ts) - ctx->stats.tstamp; 204727ec41d3SAndre Detsch } 2048e9f8a0b6SChristoph Hellwig 204927ec41d3SAndre Detsch return time / NSEC_PER_MSEC; 2050e9f8a0b6SChristoph Hellwig } 2051e9f8a0b6SChristoph Hellwig 2052e9f8a0b6SChristoph Hellwig static unsigned long long spufs_slb_flts(struct spu_context *ctx) 2053e9f8a0b6SChristoph Hellwig { 2054e9f8a0b6SChristoph Hellwig unsigned long long slb_flts = ctx->stats.slb_flt; 2055e9f8a0b6SChristoph Hellwig 2056e9f8a0b6SChristoph Hellwig if (ctx->state == SPU_STATE_RUNNABLE) { 2057e9f8a0b6SChristoph Hellwig slb_flts += (ctx->spu->stats.slb_flt - 2058e9f8a0b6SChristoph Hellwig ctx->stats.slb_flt_base); 2059e9f8a0b6SChristoph Hellwig } 2060e9f8a0b6SChristoph Hellwig 2061e9f8a0b6SChristoph Hellwig return slb_flts; 2062e9f8a0b6SChristoph Hellwig } 2063e9f8a0b6SChristoph Hellwig 2064e9f8a0b6SChristoph Hellwig static unsigned long long spufs_class2_intrs(struct spu_context *ctx) 2065e9f8a0b6SChristoph Hellwig { 2066e9f8a0b6SChristoph Hellwig unsigned long long class2_intrs = ctx->stats.class2_intr; 2067e9f8a0b6SChristoph Hellwig 2068e9f8a0b6SChristoph Hellwig if (ctx->state == SPU_STATE_RUNNABLE) { 2069e9f8a0b6SChristoph Hellwig class2_intrs += (ctx->spu->stats.class2_intr - 2070e9f8a0b6SChristoph Hellwig ctx->stats.class2_intr_base); 2071e9f8a0b6SChristoph Hellwig } 2072e9f8a0b6SChristoph Hellwig 2073e9f8a0b6SChristoph Hellwig return class2_intrs; 2074e9f8a0b6SChristoph Hellwig } 2075e9f8a0b6SChristoph Hellwig 2076e9f8a0b6SChristoph Hellwig 2077e9f8a0b6SChristoph Hellwig static int spufs_show_stat(struct seq_file *s, void *private) 2078e9f8a0b6SChristoph Hellwig { 2079e9f8a0b6SChristoph Hellwig struct spu_context *ctx = s->private; 2080e9f8a0b6SChristoph Hellwig 2081e9f8a0b6SChristoph Hellwig spu_acquire(ctx); 2082e9f8a0b6SChristoph Hellwig seq_printf(s, "%s %llu %llu %llu %llu " 2083e9f8a0b6SChristoph Hellwig "%llu %llu %llu %llu %llu %llu %llu %llu\n", 208427ec41d3SAndre Detsch ctx_state_names[ctx->stats.util_state], 208527ec41d3SAndre Detsch spufs_acct_time(ctx, SPU_UTIL_USER), 208627ec41d3SAndre Detsch spufs_acct_time(ctx, SPU_UTIL_SYSTEM), 208727ec41d3SAndre Detsch spufs_acct_time(ctx, SPU_UTIL_IOWAIT), 208827ec41d3SAndre Detsch spufs_acct_time(ctx, SPU_UTIL_IDLE_LOADED), 2089e9f8a0b6SChristoph Hellwig ctx->stats.vol_ctx_switch, 2090e9f8a0b6SChristoph Hellwig ctx->stats.invol_ctx_switch, 2091e9f8a0b6SChristoph Hellwig spufs_slb_flts(ctx), 2092e9f8a0b6SChristoph Hellwig ctx->stats.hash_flt, 2093e9f8a0b6SChristoph Hellwig ctx->stats.min_flt, 2094e9f8a0b6SChristoph Hellwig ctx->stats.maj_flt, 2095e9f8a0b6SChristoph Hellwig spufs_class2_intrs(ctx), 2096e9f8a0b6SChristoph Hellwig ctx->stats.libassist); 2097e9f8a0b6SChristoph Hellwig spu_release(ctx); 2098e9f8a0b6SChristoph Hellwig return 0; 2099e9f8a0b6SChristoph Hellwig } 2100e9f8a0b6SChristoph Hellwig 2101e9f8a0b6SChristoph Hellwig static int spufs_stat_open(struct inode *inode, struct file *file) 2102e9f8a0b6SChristoph Hellwig { 2103e9f8a0b6SChristoph Hellwig return single_open(file, spufs_show_stat, SPUFS_I(inode)->i_ctx); 2104e9f8a0b6SChristoph Hellwig } 2105e9f8a0b6SChristoph Hellwig 2106e9f8a0b6SChristoph Hellwig static const struct file_operations spufs_stat_fops = { 2107e9f8a0b6SChristoph Hellwig .open = spufs_stat_open, 2108e9f8a0b6SChristoph Hellwig .read = seq_read, 2109e9f8a0b6SChristoph Hellwig .llseek = seq_lseek, 2110e9f8a0b6SChristoph Hellwig .release = single_release, 2111e9f8a0b6SChristoph Hellwig }; 2112e9f8a0b6SChristoph Hellwig 2113e9f8a0b6SChristoph Hellwig 211467207b96SArnd Bergmann struct tree_descr spufs_dir_contents[] = { 2115cbe709c1SBenjamin Herrenschmidt { "capabilities", &spufs_caps_fops, 0444, }, 211667207b96SArnd Bergmann { "mem", &spufs_mem_fops, 0666, }, 21178b3d6663SArnd Bergmann { "regs", &spufs_regs_fops, 0666, }, 211867207b96SArnd Bergmann { "mbox", &spufs_mbox_fops, 0444, }, 211967207b96SArnd Bergmann { "ibox", &spufs_ibox_fops, 0444, }, 212067207b96SArnd Bergmann { "wbox", &spufs_wbox_fops, 0222, }, 212167207b96SArnd Bergmann { "mbox_stat", &spufs_mbox_stat_fops, 0444, }, 212267207b96SArnd Bergmann { "ibox_stat", &spufs_ibox_stat_fops, 0444, }, 212367207b96SArnd Bergmann { "wbox_stat", &spufs_wbox_stat_fops, 0444, }, 2124603c4612SJeremy Kerr { "signal1", &spufs_signal1_fops, 0666, }, 2125603c4612SJeremy Kerr { "signal2", &spufs_signal2_fops, 0666, }, 212667207b96SArnd Bergmann { "signal1_type", &spufs_signal1_type, 0666, }, 212767207b96SArnd Bergmann { "signal2_type", &spufs_signal2_type, 0666, }, 21286df10a82SMark Nutter { "cntl", &spufs_cntl_fops, 0666, }, 21298b3d6663SArnd Bergmann { "fpcr", &spufs_fpcr_fops, 0666, }, 2130b9e3bd77SDwayne Grant McConnell { "lslr", &spufs_lslr_ops, 0444, }, 2131b9e3bd77SDwayne Grant McConnell { "mfc", &spufs_mfc_fops, 0666, }, 2132b9e3bd77SDwayne Grant McConnell { "mss", &spufs_mss_fops, 0666, }, 2133b9e3bd77SDwayne Grant McConnell { "npc", &spufs_npc_ops, 0666, }, 2134b9e3bd77SDwayne Grant McConnell { "srr0", &spufs_srr0_ops, 0666, }, 21358b3d6663SArnd Bergmann { "decr", &spufs_decr_ops, 0666, }, 21368b3d6663SArnd Bergmann { "decr_status", &spufs_decr_status_ops, 0666, }, 21378b3d6663SArnd Bergmann { "event_mask", &spufs_event_mask_ops, 0666, }, 2138b9e3bd77SDwayne Grant McConnell { "event_status", &spufs_event_status_ops, 0444, }, 213927d5bf2aSBenjamin Herrenschmidt { "psmap", &spufs_psmap_fops, 0666, }, 214086767277SArnd Bergmann { "phys-id", &spufs_id_ops, 0666, }, 214186767277SArnd Bergmann { "object-id", &spufs_object_id_ops, 0666, }, 214269a2f00cSDwayne Grant McConnell { "mbox_info", &spufs_mbox_info_fops, 0444, }, 214369a2f00cSDwayne Grant McConnell { "ibox_info", &spufs_ibox_info_fops, 0444, }, 214469a2f00cSDwayne Grant McConnell { "wbox_info", &spufs_wbox_info_fops, 0444, }, 2145b9e3bd77SDwayne Grant McConnell { "dma_info", &spufs_dma_info_fops, 0444, }, 2146b9e3bd77SDwayne Grant McConnell { "proxydma_info", &spufs_proxydma_info_fops, 0444, }, 2147476273adSChristoph Hellwig { "tid", &spufs_tid_fops, 0444, }, 2148e9f8a0b6SChristoph Hellwig { "stat", &spufs_stat_fops, 0444, }, 214967207b96SArnd Bergmann {}, 215067207b96SArnd Bergmann }; 21515737edd1SMark Nutter 21525737edd1SMark Nutter struct tree_descr spufs_dir_nosched_contents[] = { 2153cbe709c1SBenjamin Herrenschmidt { "capabilities", &spufs_caps_fops, 0444, }, 21545737edd1SMark Nutter { "mem", &spufs_mem_fops, 0666, }, 21555737edd1SMark Nutter { "mbox", &spufs_mbox_fops, 0444, }, 21565737edd1SMark Nutter { "ibox", &spufs_ibox_fops, 0444, }, 21575737edd1SMark Nutter { "wbox", &spufs_wbox_fops, 0222, }, 21585737edd1SMark Nutter { "mbox_stat", &spufs_mbox_stat_fops, 0444, }, 21595737edd1SMark Nutter { "ibox_stat", &spufs_ibox_stat_fops, 0444, }, 21605737edd1SMark Nutter { "wbox_stat", &spufs_wbox_stat_fops, 0444, }, 2161d054b36fSJeremy Kerr { "signal1", &spufs_signal1_nosched_fops, 0222, }, 2162d054b36fSJeremy Kerr { "signal2", &spufs_signal2_nosched_fops, 0222, }, 21635737edd1SMark Nutter { "signal1_type", &spufs_signal1_type, 0666, }, 21645737edd1SMark Nutter { "signal2_type", &spufs_signal2_type, 0666, }, 21655737edd1SMark Nutter { "mss", &spufs_mss_fops, 0666, }, 21665737edd1SMark Nutter { "mfc", &spufs_mfc_fops, 0666, }, 21675737edd1SMark Nutter { "cntl", &spufs_cntl_fops, 0666, }, 21685737edd1SMark Nutter { "npc", &spufs_npc_ops, 0666, }, 21695737edd1SMark Nutter { "psmap", &spufs_psmap_fops, 0666, }, 21705737edd1SMark Nutter { "phys-id", &spufs_id_ops, 0666, }, 21715737edd1SMark Nutter { "object-id", &spufs_object_id_ops, 0666, }, 2172476273adSChristoph Hellwig { "tid", &spufs_tid_fops, 0444, }, 2173e9f8a0b6SChristoph Hellwig { "stat", &spufs_stat_fops, 0444, }, 21745737edd1SMark Nutter {}, 21755737edd1SMark Nutter }; 2176bf1ab978SDwayne Grant McConnell 2177bf1ab978SDwayne Grant McConnell struct spufs_coredump_reader spufs_coredump_read[] = { 21784fca9c42SMichael Ellerman { "regs", __spufs_regs_read, NULL, sizeof(struct spu_reg128[128])}, 21794fca9c42SMichael Ellerman { "fpcr", __spufs_fpcr_read, NULL, sizeof(struct spu_reg128) }, 2180104f0cc2SMichael Ellerman { "lslr", NULL, spufs_lslr_get, 19 }, 2181104f0cc2SMichael Ellerman { "decr", NULL, spufs_decr_get, 19 }, 2182104f0cc2SMichael Ellerman { "decr_status", NULL, spufs_decr_status_get, 19 }, 21834fca9c42SMichael Ellerman { "mem", __spufs_mem_read, NULL, LS_SIZE, }, 21844fca9c42SMichael Ellerman { "signal1", __spufs_signal1_read, NULL, sizeof(u32) }, 2185104f0cc2SMichael Ellerman { "signal1_type", NULL, spufs_signal1_type_get, 19 }, 21864fca9c42SMichael Ellerman { "signal2", __spufs_signal2_read, NULL, sizeof(u32) }, 2187104f0cc2SMichael Ellerman { "signal2_type", NULL, spufs_signal2_type_get, 19 }, 2188104f0cc2SMichael Ellerman { "event_mask", NULL, spufs_event_mask_get, 19 }, 2189104f0cc2SMichael Ellerman { "event_status", NULL, spufs_event_status_get, 19 }, 21904fca9c42SMichael Ellerman { "mbox_info", __spufs_mbox_info_read, NULL, sizeof(u32) }, 21914fca9c42SMichael Ellerman { "ibox_info", __spufs_ibox_info_read, NULL, sizeof(u32) }, 21924fca9c42SMichael Ellerman { "wbox_info", __spufs_wbox_info_read, NULL, 4 * sizeof(u32)}, 21934fca9c42SMichael Ellerman { "dma_info", __spufs_dma_info_read, NULL, sizeof(struct spu_dma_info)}, 21944fca9c42SMichael Ellerman { "proxydma_info", __spufs_proxydma_info_read, 21954fca9c42SMichael Ellerman NULL, sizeof(struct spu_proxydma_info)}, 2196104f0cc2SMichael Ellerman { "object-id", NULL, spufs_object_id_get, 19 }, 2197104f0cc2SMichael Ellerman { "npc", NULL, spufs_npc_get, 19 }, 2198936d5bf1SMichael Ellerman { NULL }, 2199bf1ab978SDwayne Grant McConnell }; 2200