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> 3167207b96SArnd Bergmann 3267207b96SArnd Bergmann #include <asm/io.h> 3367207b96SArnd Bergmann #include <asm/semaphore.h> 3467207b96SArnd Bergmann #include <asm/spu.h> 35b9e3bd77SDwayne Grant McConnell #include <asm/spu_info.h> 3667207b96SArnd Bergmann #include <asm/uaccess.h> 3767207b96SArnd Bergmann 3867207b96SArnd Bergmann #include "spufs.h" 3967207b96SArnd Bergmann 4027d5bf2aSBenjamin Herrenschmidt #define SPUFS_MMAP_4K (PAGE_SIZE == 0x1000) 4127d5bf2aSBenjamin Herrenschmidt 4267207b96SArnd Bergmann static int 4367207b96SArnd Bergmann spufs_mem_open(struct inode *inode, struct file *file) 4467207b96SArnd Bergmann { 4567207b96SArnd Bergmann struct spufs_inode_info *i = SPUFS_I(inode); 466df10a82SMark Nutter struct spu_context *ctx = i->i_ctx; 4743c2bbd9SChristoph Hellwig 4847d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 496df10a82SMark Nutter file->private_data = ctx; 5043c2bbd9SChristoph Hellwig if (!i->i_openers++) 516df10a82SMark Nutter ctx->local_store = inode->i_mapping; 5247d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 5343c2bbd9SChristoph Hellwig return 0; 5443c2bbd9SChristoph Hellwig } 5543c2bbd9SChristoph Hellwig 5643c2bbd9SChristoph Hellwig static int 5743c2bbd9SChristoph Hellwig spufs_mem_release(struct inode *inode, struct file *file) 5843c2bbd9SChristoph Hellwig { 5943c2bbd9SChristoph Hellwig struct spufs_inode_info *i = SPUFS_I(inode); 6043c2bbd9SChristoph Hellwig struct spu_context *ctx = i->i_ctx; 6143c2bbd9SChristoph Hellwig 6247d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 6343c2bbd9SChristoph Hellwig if (!--i->i_openers) 6443c2bbd9SChristoph Hellwig ctx->local_store = NULL; 6547d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 6667207b96SArnd Bergmann return 0; 6767207b96SArnd Bergmann } 6867207b96SArnd Bergmann 6967207b96SArnd Bergmann static ssize_t 70bf1ab978SDwayne Grant McConnell __spufs_mem_read(struct spu_context *ctx, char __user *buffer, 71bf1ab978SDwayne Grant McConnell size_t size, loff_t *pos) 72bf1ab978SDwayne Grant McConnell { 73bf1ab978SDwayne Grant McConnell char *local_store = ctx->ops->get_ls(ctx); 74bf1ab978SDwayne Grant McConnell return simple_read_from_buffer(buffer, size, pos, local_store, 75bf1ab978SDwayne Grant McConnell LS_SIZE); 76bf1ab978SDwayne Grant McConnell } 77bf1ab978SDwayne Grant McConnell 78bf1ab978SDwayne Grant McConnell static ssize_t 7967207b96SArnd Bergmann spufs_mem_read(struct file *file, char __user *buffer, 8067207b96SArnd Bergmann size_t size, loff_t *pos) 8167207b96SArnd Bergmann { 82bf1ab978SDwayne Grant McConnell struct spu_context *ctx = file->private_data; 83aa0ed2bdSArnd Bergmann ssize_t ret; 8467207b96SArnd Bergmann 858b3d6663SArnd Bergmann spu_acquire(ctx); 86bf1ab978SDwayne Grant McConnell ret = __spufs_mem_read(ctx, buffer, size, pos); 878b3d6663SArnd Bergmann spu_release(ctx); 8867207b96SArnd Bergmann return ret; 8967207b96SArnd Bergmann } 9067207b96SArnd Bergmann 9167207b96SArnd Bergmann static ssize_t 9267207b96SArnd Bergmann spufs_mem_write(struct file *file, const char __user *buffer, 93aa0ed2bdSArnd Bergmann size_t size, loff_t *ppos) 9467207b96SArnd Bergmann { 9567207b96SArnd Bergmann struct spu_context *ctx = file->private_data; 968b3d6663SArnd Bergmann char *local_store; 97aa0ed2bdSArnd Bergmann loff_t pos = *ppos; 988b3d6663SArnd Bergmann int ret; 9967207b96SArnd Bergmann 100aa0ed2bdSArnd Bergmann if (pos < 0) 101aa0ed2bdSArnd Bergmann return -EINVAL; 102aa0ed2bdSArnd Bergmann if (pos > LS_SIZE) 10367207b96SArnd Bergmann return -EFBIG; 104aa0ed2bdSArnd Bergmann if (size > LS_SIZE - pos) 105aa0ed2bdSArnd Bergmann size = LS_SIZE - pos; 1068b3d6663SArnd Bergmann 1078b3d6663SArnd Bergmann spu_acquire(ctx); 1088b3d6663SArnd Bergmann local_store = ctx->ops->get_ls(ctx); 109aa0ed2bdSArnd Bergmann ret = copy_from_user(local_store + pos, buffer, size); 1108b3d6663SArnd Bergmann spu_release(ctx); 111aa0ed2bdSArnd Bergmann 112aa0ed2bdSArnd Bergmann if (ret) 113aa0ed2bdSArnd Bergmann return -EFAULT; 114aa0ed2bdSArnd Bergmann *ppos = pos + size; 115aa0ed2bdSArnd Bergmann return size; 11667207b96SArnd Bergmann } 11767207b96SArnd Bergmann 11878bde53eSBenjamin Herrenschmidt static unsigned long spufs_mem_mmap_nopfn(struct vm_area_struct *vma, 11978bde53eSBenjamin Herrenschmidt unsigned long address) 1208b3d6663SArnd Bergmann { 1218b3d6663SArnd Bergmann struct spu_context *ctx = vma->vm_file->private_data; 122f1fa74f4SBenjamin Herrenschmidt unsigned long pfn, offset, addr0 = address; 123f1fa74f4SBenjamin Herrenschmidt #ifdef CONFIG_SPU_FS_64K_LS 124f1fa74f4SBenjamin Herrenschmidt struct spu_state *csa = &ctx->csa; 125f1fa74f4SBenjamin Herrenschmidt int psize; 12678bde53eSBenjamin Herrenschmidt 127f1fa74f4SBenjamin Herrenschmidt /* Check what page size we are using */ 128f1fa74f4SBenjamin Herrenschmidt psize = get_slice_psize(vma->vm_mm, address); 1298b3d6663SArnd Bergmann 130f1fa74f4SBenjamin Herrenschmidt /* Some sanity checking */ 131f1fa74f4SBenjamin Herrenschmidt BUG_ON(csa->use_big_pages != (psize == MMU_PAGE_64K)); 132f1fa74f4SBenjamin Herrenschmidt 133f1fa74f4SBenjamin Herrenschmidt /* Wow, 64K, cool, we need to align the address though */ 134f1fa74f4SBenjamin Herrenschmidt if (csa->use_big_pages) { 135f1fa74f4SBenjamin Herrenschmidt BUG_ON(vma->vm_start & 0xffff); 136f1fa74f4SBenjamin Herrenschmidt address &= ~0xfffful; 137f1fa74f4SBenjamin Herrenschmidt } 138f1fa74f4SBenjamin Herrenschmidt #endif /* CONFIG_SPU_FS_64K_LS */ 139f1fa74f4SBenjamin Herrenschmidt 140f1fa74f4SBenjamin Herrenschmidt offset = (address - vma->vm_start) + (vma->vm_pgoff << PAGE_SHIFT); 141128b8546SMasato Noguchi if (offset >= LS_SIZE) 142128b8546SMasato Noguchi return NOPFN_SIGBUS; 143128b8546SMasato Noguchi 144f1fa74f4SBenjamin Herrenschmidt pr_debug("spufs_mem_mmap_nopfn address=0x%lx -> 0x%lx, offset=0x%lx\n", 145f1fa74f4SBenjamin Herrenschmidt addr0, address, offset); 146f1fa74f4SBenjamin Herrenschmidt 1478b3d6663SArnd Bergmann spu_acquire(ctx); 1488b3d6663SArnd Bergmann 149ac91cb8dSArnd Bergmann if (ctx->state == SPU_STATE_SAVED) { 150ac91cb8dSArnd Bergmann vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot) 151932f535dSArnd Bergmann & ~_PAGE_NO_CACHE); 15278bde53eSBenjamin Herrenschmidt pfn = vmalloc_to_pfn(ctx->csa.lscsa->ls + offset); 153ac91cb8dSArnd Bergmann } else { 154ac91cb8dSArnd Bergmann vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot) 155932f535dSArnd Bergmann | _PAGE_NO_CACHE); 15678bde53eSBenjamin Herrenschmidt pfn = (ctx->spu->local_store_phys + offset) >> PAGE_SHIFT; 157ac91cb8dSArnd Bergmann } 15878bde53eSBenjamin Herrenschmidt vm_insert_pfn(vma, address, pfn); 15978bde53eSBenjamin Herrenschmidt 1608b3d6663SArnd Bergmann spu_release(ctx); 1618b3d6663SArnd Bergmann 16278bde53eSBenjamin Herrenschmidt return NOPFN_REFAULT; 1638b3d6663SArnd Bergmann } 1648b3d6663SArnd Bergmann 16578bde53eSBenjamin Herrenschmidt 1668b3d6663SArnd Bergmann static struct vm_operations_struct spufs_mem_mmap_vmops = { 16778bde53eSBenjamin Herrenschmidt .nopfn = spufs_mem_mmap_nopfn, 1688b3d6663SArnd Bergmann }; 1698b3d6663SArnd Bergmann 170f1fa74f4SBenjamin Herrenschmidt static int spufs_mem_mmap(struct file *file, struct vm_area_struct *vma) 17167207b96SArnd Bergmann { 172f1fa74f4SBenjamin Herrenschmidt #ifdef CONFIG_SPU_FS_64K_LS 173f1fa74f4SBenjamin Herrenschmidt struct spu_context *ctx = file->private_data; 174f1fa74f4SBenjamin Herrenschmidt struct spu_state *csa = &ctx->csa; 175f1fa74f4SBenjamin Herrenschmidt 176f1fa74f4SBenjamin Herrenschmidt /* Sanity check VMA alignment */ 177f1fa74f4SBenjamin Herrenschmidt if (csa->use_big_pages) { 178f1fa74f4SBenjamin Herrenschmidt pr_debug("spufs_mem_mmap 64K, start=0x%lx, end=0x%lx," 179f1fa74f4SBenjamin Herrenschmidt " pgoff=0x%lx\n", vma->vm_start, vma->vm_end, 180f1fa74f4SBenjamin Herrenschmidt vma->vm_pgoff); 181f1fa74f4SBenjamin Herrenschmidt if (vma->vm_start & 0xffff) 182f1fa74f4SBenjamin Herrenschmidt return -EINVAL; 183f1fa74f4SBenjamin Herrenschmidt if (vma->vm_pgoff & 0xf) 184f1fa74f4SBenjamin Herrenschmidt return -EINVAL; 185f1fa74f4SBenjamin Herrenschmidt } 186f1fa74f4SBenjamin Herrenschmidt #endif /* CONFIG_SPU_FS_64K_LS */ 187f1fa74f4SBenjamin Herrenschmidt 1888b3d6663SArnd Bergmann if (!(vma->vm_flags & VM_SHARED)) 1898b3d6663SArnd Bergmann return -EINVAL; 19067207b96SArnd Bergmann 19178bde53eSBenjamin Herrenschmidt vma->vm_flags |= VM_IO | VM_PFNMAP; 19267207b96SArnd Bergmann vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot) 19367207b96SArnd Bergmann | _PAGE_NO_CACHE); 1948b3d6663SArnd Bergmann 1958b3d6663SArnd Bergmann vma->vm_ops = &spufs_mem_mmap_vmops; 19667207b96SArnd Bergmann return 0; 19767207b96SArnd Bergmann } 19867207b96SArnd Bergmann 199f1fa74f4SBenjamin Herrenschmidt #ifdef CONFIG_SPU_FS_64K_LS 200f1fa74f4SBenjamin Herrenschmidt unsigned long spufs_get_unmapped_area(struct file *file, unsigned long addr, 201f1fa74f4SBenjamin Herrenschmidt unsigned long len, unsigned long pgoff, 202f1fa74f4SBenjamin Herrenschmidt unsigned long flags) 203f1fa74f4SBenjamin Herrenschmidt { 204f1fa74f4SBenjamin Herrenschmidt struct spu_context *ctx = file->private_data; 205f1fa74f4SBenjamin Herrenschmidt struct spu_state *csa = &ctx->csa; 206f1fa74f4SBenjamin Herrenschmidt 207f1fa74f4SBenjamin Herrenschmidt /* If not using big pages, fallback to normal MM g_u_a */ 208f1fa74f4SBenjamin Herrenschmidt if (!csa->use_big_pages) 209f1fa74f4SBenjamin Herrenschmidt return current->mm->get_unmapped_area(file, addr, len, 210f1fa74f4SBenjamin Herrenschmidt pgoff, flags); 211f1fa74f4SBenjamin Herrenschmidt 212f1fa74f4SBenjamin Herrenschmidt /* Else, try to obtain a 64K pages slice */ 213f1fa74f4SBenjamin Herrenschmidt return slice_get_unmapped_area(addr, len, flags, 214f1fa74f4SBenjamin Herrenschmidt MMU_PAGE_64K, 1, 0); 215f1fa74f4SBenjamin Herrenschmidt } 216f1fa74f4SBenjamin Herrenschmidt #endif /* CONFIG_SPU_FS_64K_LS */ 217f1fa74f4SBenjamin Herrenschmidt 2185dfe4c96SArjan van de Ven static const struct file_operations spufs_mem_fops = { 21967207b96SArnd Bergmann .open = spufs_mem_open, 220ce92987bSChristoph Hellwig .release = spufs_mem_release, 22167207b96SArnd Bergmann .read = spufs_mem_read, 22267207b96SArnd Bergmann .write = spufs_mem_write, 2238b3d6663SArnd Bergmann .llseek = generic_file_llseek, 22467207b96SArnd Bergmann .mmap = spufs_mem_mmap, 225f1fa74f4SBenjamin Herrenschmidt #ifdef CONFIG_SPU_FS_64K_LS 226f1fa74f4SBenjamin Herrenschmidt .get_unmapped_area = spufs_get_unmapped_area, 227f1fa74f4SBenjamin Herrenschmidt #endif 2288b3d6663SArnd Bergmann }; 2298b3d6663SArnd Bergmann 23078bde53eSBenjamin Herrenschmidt static unsigned long spufs_ps_nopfn(struct vm_area_struct *vma, 2316df10a82SMark Nutter unsigned long address, 23278bde53eSBenjamin Herrenschmidt unsigned long ps_offs, 23327d5bf2aSBenjamin Herrenschmidt unsigned long ps_size) 2346df10a82SMark Nutter { 2356df10a82SMark Nutter struct spu_context *ctx = vma->vm_file->private_data; 23678bde53eSBenjamin Herrenschmidt unsigned long area, offset = address - vma->vm_start; 2376df10a82SMark Nutter int ret; 2386df10a82SMark Nutter 2396df10a82SMark Nutter offset += vma->vm_pgoff << PAGE_SHIFT; 24027d5bf2aSBenjamin Herrenschmidt if (offset >= ps_size) 24178bde53eSBenjamin Herrenschmidt return NOPFN_SIGBUS; 2426df10a82SMark Nutter 24378bde53eSBenjamin Herrenschmidt /* error here usually means a signal.. we might want to test 24478bde53eSBenjamin Herrenschmidt * the error code more precisely though 24578bde53eSBenjamin Herrenschmidt */ 24626bec673SChristoph Hellwig ret = spu_acquire_runnable(ctx, 0); 2476df10a82SMark Nutter if (ret) 24878bde53eSBenjamin Herrenschmidt return NOPFN_REFAULT; 2496df10a82SMark Nutter 2506df10a82SMark Nutter area = ctx->spu->problem_phys + ps_offs; 25178bde53eSBenjamin Herrenschmidt vm_insert_pfn(vma, address, (area + offset) >> PAGE_SHIFT); 2526df10a82SMark Nutter spu_release(ctx); 2536df10a82SMark Nutter 25478bde53eSBenjamin Herrenschmidt return NOPFN_REFAULT; 2556df10a82SMark Nutter } 2566df10a82SMark Nutter 25727d5bf2aSBenjamin Herrenschmidt #if SPUFS_MMAP_4K 25878bde53eSBenjamin Herrenschmidt static unsigned long spufs_cntl_mmap_nopfn(struct vm_area_struct *vma, 25978bde53eSBenjamin Herrenschmidt unsigned long address) 2606df10a82SMark Nutter { 26178bde53eSBenjamin Herrenschmidt return spufs_ps_nopfn(vma, address, 0x4000, 0x1000); 2626df10a82SMark Nutter } 2636df10a82SMark Nutter 2646df10a82SMark Nutter static struct vm_operations_struct spufs_cntl_mmap_vmops = { 26578bde53eSBenjamin Herrenschmidt .nopfn = spufs_cntl_mmap_nopfn, 2666df10a82SMark Nutter }; 2676df10a82SMark Nutter 2686df10a82SMark Nutter /* 2696df10a82SMark Nutter * mmap support for problem state control area [0x4000 - 0x4fff]. 2706df10a82SMark Nutter */ 2716df10a82SMark Nutter static int spufs_cntl_mmap(struct file *file, struct vm_area_struct *vma) 2726df10a82SMark Nutter { 2736df10a82SMark Nutter if (!(vma->vm_flags & VM_SHARED)) 2746df10a82SMark Nutter return -EINVAL; 2756df10a82SMark Nutter 27678bde53eSBenjamin Herrenschmidt vma->vm_flags |= VM_IO | VM_PFNMAP; 2776df10a82SMark Nutter vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot) 27823cc7701SBenjamin Herrenschmidt | _PAGE_NO_CACHE | _PAGE_GUARDED); 2796df10a82SMark Nutter 2806df10a82SMark Nutter vma->vm_ops = &spufs_cntl_mmap_vmops; 2816df10a82SMark Nutter return 0; 2826df10a82SMark Nutter } 28327d5bf2aSBenjamin Herrenschmidt #else /* SPUFS_MMAP_4K */ 28427d5bf2aSBenjamin Herrenschmidt #define spufs_cntl_mmap NULL 28527d5bf2aSBenjamin Herrenschmidt #endif /* !SPUFS_MMAP_4K */ 2866df10a82SMark Nutter 287e1dbff2bSArnd Bergmann static u64 spufs_cntl_get(void *data) 288e1dbff2bSArnd Bergmann { 289e1dbff2bSArnd Bergmann struct spu_context *ctx = data; 290e1dbff2bSArnd Bergmann u64 val; 291e1dbff2bSArnd Bergmann 292e1dbff2bSArnd Bergmann spu_acquire(ctx); 293e1dbff2bSArnd Bergmann val = ctx->ops->status_read(ctx); 294e1dbff2bSArnd Bergmann spu_release(ctx); 295e1dbff2bSArnd Bergmann 296e1dbff2bSArnd Bergmann return val; 297e1dbff2bSArnd Bergmann } 298e1dbff2bSArnd Bergmann 299e1dbff2bSArnd Bergmann static void spufs_cntl_set(void *data, u64 val) 300e1dbff2bSArnd Bergmann { 301e1dbff2bSArnd Bergmann struct spu_context *ctx = data; 302e1dbff2bSArnd Bergmann 303e1dbff2bSArnd Bergmann spu_acquire(ctx); 304e1dbff2bSArnd Bergmann ctx->ops->runcntl_write(ctx, val); 305e1dbff2bSArnd Bergmann spu_release(ctx); 306e1dbff2bSArnd Bergmann } 307e1dbff2bSArnd Bergmann 3086df10a82SMark Nutter static int spufs_cntl_open(struct inode *inode, struct file *file) 3096df10a82SMark Nutter { 3106df10a82SMark Nutter struct spufs_inode_info *i = SPUFS_I(inode); 3116df10a82SMark Nutter struct spu_context *ctx = i->i_ctx; 3126df10a82SMark Nutter 31347d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 3146df10a82SMark Nutter file->private_data = ctx; 31543c2bbd9SChristoph Hellwig if (!i->i_openers++) 3166df10a82SMark Nutter ctx->cntl = inode->i_mapping; 31747d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 318e1dbff2bSArnd Bergmann return simple_attr_open(inode, file, spufs_cntl_get, 319e1dbff2bSArnd Bergmann spufs_cntl_set, "0x%08lx"); 3206df10a82SMark Nutter } 3216df10a82SMark Nutter 32243c2bbd9SChristoph Hellwig static int 32343c2bbd9SChristoph Hellwig spufs_cntl_release(struct inode *inode, struct file *file) 32443c2bbd9SChristoph Hellwig { 32543c2bbd9SChristoph Hellwig struct spufs_inode_info *i = SPUFS_I(inode); 32643c2bbd9SChristoph Hellwig struct spu_context *ctx = i->i_ctx; 32743c2bbd9SChristoph Hellwig 32843c2bbd9SChristoph Hellwig simple_attr_close(inode, file); 32943c2bbd9SChristoph Hellwig 33047d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 33143c2bbd9SChristoph Hellwig if (!--i->i_openers) 33243c2bbd9SChristoph Hellwig ctx->cntl = NULL; 33347d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 33443c2bbd9SChristoph Hellwig return 0; 33543c2bbd9SChristoph Hellwig } 33643c2bbd9SChristoph Hellwig 3375dfe4c96SArjan van de Ven static const struct file_operations spufs_cntl_fops = { 3386df10a82SMark Nutter .open = spufs_cntl_open, 33943c2bbd9SChristoph Hellwig .release = spufs_cntl_release, 340e1dbff2bSArnd Bergmann .read = simple_attr_read, 341e1dbff2bSArnd Bergmann .write = simple_attr_write, 3426df10a82SMark Nutter .mmap = spufs_cntl_mmap, 3436df10a82SMark Nutter }; 3446df10a82SMark Nutter 3458b3d6663SArnd Bergmann static int 3468b3d6663SArnd Bergmann spufs_regs_open(struct inode *inode, struct file *file) 3478b3d6663SArnd Bergmann { 3488b3d6663SArnd Bergmann struct spufs_inode_info *i = SPUFS_I(inode); 3498b3d6663SArnd Bergmann file->private_data = i->i_ctx; 3508b3d6663SArnd Bergmann return 0; 3518b3d6663SArnd Bergmann } 3528b3d6663SArnd Bergmann 3538b3d6663SArnd Bergmann static ssize_t 354bf1ab978SDwayne Grant McConnell __spufs_regs_read(struct spu_context *ctx, char __user *buffer, 355bf1ab978SDwayne Grant McConnell size_t size, loff_t *pos) 356bf1ab978SDwayne Grant McConnell { 357bf1ab978SDwayne Grant McConnell struct spu_lscsa *lscsa = ctx->csa.lscsa; 358bf1ab978SDwayne Grant McConnell return simple_read_from_buffer(buffer, size, pos, 359bf1ab978SDwayne Grant McConnell lscsa->gprs, sizeof lscsa->gprs); 360bf1ab978SDwayne Grant McConnell } 361bf1ab978SDwayne Grant McConnell 362bf1ab978SDwayne Grant McConnell static ssize_t 3638b3d6663SArnd Bergmann spufs_regs_read(struct file *file, char __user *buffer, 3648b3d6663SArnd Bergmann size_t size, loff_t *pos) 3658b3d6663SArnd Bergmann { 3668b3d6663SArnd Bergmann int ret; 367bf1ab978SDwayne Grant McConnell struct spu_context *ctx = file->private_data; 3688b3d6663SArnd Bergmann 3698b3d6663SArnd Bergmann spu_acquire_saved(ctx); 370bf1ab978SDwayne Grant McConnell ret = __spufs_regs_read(ctx, buffer, size, pos); 3718b3d6663SArnd Bergmann spu_release(ctx); 3728b3d6663SArnd Bergmann return ret; 3738b3d6663SArnd Bergmann } 3748b3d6663SArnd Bergmann 3758b3d6663SArnd Bergmann static ssize_t 3768b3d6663SArnd Bergmann spufs_regs_write(struct file *file, const char __user *buffer, 3778b3d6663SArnd Bergmann size_t size, loff_t *pos) 3788b3d6663SArnd Bergmann { 3798b3d6663SArnd Bergmann struct spu_context *ctx = file->private_data; 3808b3d6663SArnd Bergmann struct spu_lscsa *lscsa = ctx->csa.lscsa; 3818b3d6663SArnd Bergmann int ret; 3828b3d6663SArnd Bergmann 3838b3d6663SArnd Bergmann size = min_t(ssize_t, sizeof lscsa->gprs - *pos, size); 3848b3d6663SArnd Bergmann if (size <= 0) 3858b3d6663SArnd Bergmann return -EFBIG; 3868b3d6663SArnd Bergmann *pos += size; 3878b3d6663SArnd Bergmann 3888b3d6663SArnd Bergmann spu_acquire_saved(ctx); 3898b3d6663SArnd Bergmann 3908b3d6663SArnd Bergmann ret = copy_from_user(lscsa->gprs + *pos - size, 3918b3d6663SArnd Bergmann buffer, size) ? -EFAULT : size; 3928b3d6663SArnd Bergmann 3938b3d6663SArnd Bergmann spu_release(ctx); 3948b3d6663SArnd Bergmann return ret; 3958b3d6663SArnd Bergmann } 3968b3d6663SArnd Bergmann 3975dfe4c96SArjan van de Ven static const struct file_operations spufs_regs_fops = { 3988b3d6663SArnd Bergmann .open = spufs_regs_open, 3998b3d6663SArnd Bergmann .read = spufs_regs_read, 4008b3d6663SArnd Bergmann .write = spufs_regs_write, 4018b3d6663SArnd Bergmann .llseek = generic_file_llseek, 4028b3d6663SArnd Bergmann }; 4038b3d6663SArnd Bergmann 4048b3d6663SArnd Bergmann static ssize_t 405bf1ab978SDwayne Grant McConnell __spufs_fpcr_read(struct spu_context *ctx, char __user * buffer, 406bf1ab978SDwayne Grant McConnell size_t size, loff_t * pos) 407bf1ab978SDwayne Grant McConnell { 408bf1ab978SDwayne Grant McConnell struct spu_lscsa *lscsa = ctx->csa.lscsa; 409bf1ab978SDwayne Grant McConnell return simple_read_from_buffer(buffer, size, pos, 410bf1ab978SDwayne Grant McConnell &lscsa->fpcr, sizeof(lscsa->fpcr)); 411bf1ab978SDwayne Grant McConnell } 412bf1ab978SDwayne Grant McConnell 413bf1ab978SDwayne Grant McConnell static ssize_t 4148b3d6663SArnd Bergmann spufs_fpcr_read(struct file *file, char __user * buffer, 4158b3d6663SArnd Bergmann size_t size, loff_t * pos) 4168b3d6663SArnd Bergmann { 4178b3d6663SArnd Bergmann int ret; 418bf1ab978SDwayne Grant McConnell struct spu_context *ctx = file->private_data; 4198b3d6663SArnd Bergmann 4208b3d6663SArnd Bergmann spu_acquire_saved(ctx); 421bf1ab978SDwayne Grant McConnell ret = __spufs_fpcr_read(ctx, buffer, size, pos); 4228b3d6663SArnd Bergmann spu_release(ctx); 4238b3d6663SArnd Bergmann return ret; 4248b3d6663SArnd Bergmann } 4258b3d6663SArnd Bergmann 4268b3d6663SArnd Bergmann static ssize_t 4278b3d6663SArnd Bergmann spufs_fpcr_write(struct file *file, const char __user * buffer, 4288b3d6663SArnd Bergmann size_t size, loff_t * pos) 4298b3d6663SArnd Bergmann { 4308b3d6663SArnd Bergmann struct spu_context *ctx = file->private_data; 4318b3d6663SArnd Bergmann struct spu_lscsa *lscsa = ctx->csa.lscsa; 4328b3d6663SArnd Bergmann int ret; 4338b3d6663SArnd Bergmann 4348b3d6663SArnd Bergmann size = min_t(ssize_t, sizeof(lscsa->fpcr) - *pos, size); 4358b3d6663SArnd Bergmann if (size <= 0) 4368b3d6663SArnd Bergmann return -EFBIG; 4378b3d6663SArnd Bergmann *pos += size; 4388b3d6663SArnd Bergmann 4398b3d6663SArnd Bergmann spu_acquire_saved(ctx); 4408b3d6663SArnd Bergmann 4418b3d6663SArnd Bergmann ret = copy_from_user((char *)&lscsa->fpcr + *pos - size, 4428b3d6663SArnd Bergmann buffer, size) ? -EFAULT : size; 4438b3d6663SArnd Bergmann 4448b3d6663SArnd Bergmann spu_release(ctx); 4458b3d6663SArnd Bergmann return ret; 4468b3d6663SArnd Bergmann } 4478b3d6663SArnd Bergmann 4485dfe4c96SArjan van de Ven static const struct file_operations spufs_fpcr_fops = { 4498b3d6663SArnd Bergmann .open = spufs_regs_open, 4508b3d6663SArnd Bergmann .read = spufs_fpcr_read, 4518b3d6663SArnd Bergmann .write = spufs_fpcr_write, 45267207b96SArnd Bergmann .llseek = generic_file_llseek, 45367207b96SArnd Bergmann }; 45467207b96SArnd Bergmann 45567207b96SArnd Bergmann /* generic open function for all pipe-like files */ 45667207b96SArnd Bergmann static int spufs_pipe_open(struct inode *inode, struct file *file) 45767207b96SArnd Bergmann { 45867207b96SArnd Bergmann struct spufs_inode_info *i = SPUFS_I(inode); 45967207b96SArnd Bergmann file->private_data = i->i_ctx; 46067207b96SArnd Bergmann 46167207b96SArnd Bergmann return nonseekable_open(inode, file); 46267207b96SArnd Bergmann } 46367207b96SArnd Bergmann 464cdcc89bbSArnd Bergmann /* 465cdcc89bbSArnd Bergmann * Read as many bytes from the mailbox as possible, until 466cdcc89bbSArnd Bergmann * one of the conditions becomes true: 467cdcc89bbSArnd Bergmann * 468cdcc89bbSArnd Bergmann * - no more data available in the mailbox 469cdcc89bbSArnd Bergmann * - end of the user provided buffer 470cdcc89bbSArnd Bergmann * - end of the mapped area 471cdcc89bbSArnd Bergmann */ 47267207b96SArnd Bergmann static ssize_t spufs_mbox_read(struct file *file, char __user *buf, 47367207b96SArnd Bergmann size_t len, loff_t *pos) 47467207b96SArnd Bergmann { 4758b3d6663SArnd Bergmann struct spu_context *ctx = file->private_data; 476cdcc89bbSArnd Bergmann u32 mbox_data, __user *udata; 477cdcc89bbSArnd Bergmann ssize_t count; 47867207b96SArnd Bergmann 47967207b96SArnd Bergmann if (len < 4) 48067207b96SArnd Bergmann return -EINVAL; 48167207b96SArnd Bergmann 482cdcc89bbSArnd Bergmann if (!access_ok(VERIFY_WRITE, buf, len)) 48367207b96SArnd Bergmann return -EFAULT; 48467207b96SArnd Bergmann 485cdcc89bbSArnd Bergmann udata = (void __user *)buf; 486cdcc89bbSArnd Bergmann 487cdcc89bbSArnd Bergmann spu_acquire(ctx); 488274cef5eSArnd Bergmann for (count = 0; (count + 4) <= len; count += 4, udata++) { 489cdcc89bbSArnd Bergmann int ret; 490cdcc89bbSArnd Bergmann ret = ctx->ops->mbox_read(ctx, &mbox_data); 491cdcc89bbSArnd Bergmann if (ret == 0) 492cdcc89bbSArnd Bergmann break; 493cdcc89bbSArnd Bergmann 494cdcc89bbSArnd Bergmann /* 495cdcc89bbSArnd Bergmann * at the end of the mapped area, we can fault 496cdcc89bbSArnd Bergmann * but still need to return the data we have 497cdcc89bbSArnd Bergmann * read successfully so far. 498cdcc89bbSArnd Bergmann */ 499cdcc89bbSArnd Bergmann ret = __put_user(mbox_data, udata); 500cdcc89bbSArnd Bergmann if (ret) { 501cdcc89bbSArnd Bergmann if (!count) 502cdcc89bbSArnd Bergmann count = -EFAULT; 503cdcc89bbSArnd Bergmann break; 504cdcc89bbSArnd Bergmann } 505cdcc89bbSArnd Bergmann } 506cdcc89bbSArnd Bergmann spu_release(ctx); 507cdcc89bbSArnd Bergmann 508cdcc89bbSArnd Bergmann if (!count) 509cdcc89bbSArnd Bergmann count = -EAGAIN; 510cdcc89bbSArnd Bergmann 511cdcc89bbSArnd Bergmann return count; 51267207b96SArnd Bergmann } 51367207b96SArnd Bergmann 5145dfe4c96SArjan van de Ven static const struct file_operations spufs_mbox_fops = { 51567207b96SArnd Bergmann .open = spufs_pipe_open, 51667207b96SArnd Bergmann .read = spufs_mbox_read, 51767207b96SArnd Bergmann }; 51867207b96SArnd Bergmann 51967207b96SArnd Bergmann static ssize_t spufs_mbox_stat_read(struct file *file, char __user *buf, 52067207b96SArnd Bergmann size_t len, loff_t *pos) 52167207b96SArnd Bergmann { 5228b3d6663SArnd Bergmann struct spu_context *ctx = file->private_data; 52367207b96SArnd Bergmann u32 mbox_stat; 52467207b96SArnd Bergmann 52567207b96SArnd Bergmann if (len < 4) 52667207b96SArnd Bergmann return -EINVAL; 52767207b96SArnd Bergmann 5288b3d6663SArnd Bergmann spu_acquire(ctx); 5298b3d6663SArnd Bergmann 5308b3d6663SArnd Bergmann mbox_stat = ctx->ops->mbox_stat_read(ctx) & 0xff; 5318b3d6663SArnd Bergmann 5328b3d6663SArnd Bergmann spu_release(ctx); 53367207b96SArnd Bergmann 53467207b96SArnd Bergmann if (copy_to_user(buf, &mbox_stat, sizeof mbox_stat)) 53567207b96SArnd Bergmann return -EFAULT; 53667207b96SArnd Bergmann 53767207b96SArnd Bergmann return 4; 53867207b96SArnd Bergmann } 53967207b96SArnd Bergmann 5405dfe4c96SArjan van de Ven static const struct file_operations spufs_mbox_stat_fops = { 54167207b96SArnd Bergmann .open = spufs_pipe_open, 54267207b96SArnd Bergmann .read = spufs_mbox_stat_read, 54367207b96SArnd Bergmann }; 54467207b96SArnd Bergmann 54567207b96SArnd Bergmann /* low-level ibox access function */ 5468b3d6663SArnd Bergmann size_t spu_ibox_read(struct spu_context *ctx, u32 *data) 54767207b96SArnd Bergmann { 5488b3d6663SArnd Bergmann return ctx->ops->ibox_read(ctx, data); 54967207b96SArnd Bergmann } 55067207b96SArnd Bergmann 55167207b96SArnd Bergmann static int spufs_ibox_fasync(int fd, struct file *file, int on) 55267207b96SArnd Bergmann { 5538b3d6663SArnd Bergmann struct spu_context *ctx = file->private_data; 5548b3d6663SArnd Bergmann 5558b3d6663SArnd Bergmann return fasync_helper(fd, file, on, &ctx->ibox_fasync); 5568b3d6663SArnd Bergmann } 5578b3d6663SArnd Bergmann 5588b3d6663SArnd Bergmann /* interrupt-level ibox callback function. */ 5598b3d6663SArnd Bergmann void spufs_ibox_callback(struct spu *spu) 5608b3d6663SArnd Bergmann { 5618b3d6663SArnd Bergmann struct spu_context *ctx = spu->ctx; 5628b3d6663SArnd Bergmann 5638b3d6663SArnd Bergmann wake_up_all(&ctx->ibox_wq); 5648b3d6663SArnd Bergmann kill_fasync(&ctx->ibox_fasync, SIGIO, POLLIN); 56567207b96SArnd Bergmann } 56667207b96SArnd Bergmann 567cdcc89bbSArnd Bergmann /* 568cdcc89bbSArnd Bergmann * Read as many bytes from the interrupt mailbox as possible, until 569cdcc89bbSArnd Bergmann * one of the conditions becomes true: 570cdcc89bbSArnd Bergmann * 571cdcc89bbSArnd Bergmann * - no more data available in the mailbox 572cdcc89bbSArnd Bergmann * - end of the user provided buffer 573cdcc89bbSArnd Bergmann * - end of the mapped area 574cdcc89bbSArnd Bergmann * 575cdcc89bbSArnd Bergmann * If the file is opened without O_NONBLOCK, we wait here until 576cdcc89bbSArnd Bergmann * any data is available, but return when we have been able to 577cdcc89bbSArnd Bergmann * read something. 578cdcc89bbSArnd Bergmann */ 57967207b96SArnd Bergmann static ssize_t spufs_ibox_read(struct file *file, char __user *buf, 58067207b96SArnd Bergmann size_t len, loff_t *pos) 58167207b96SArnd Bergmann { 5828b3d6663SArnd Bergmann struct spu_context *ctx = file->private_data; 583cdcc89bbSArnd Bergmann u32 ibox_data, __user *udata; 584cdcc89bbSArnd Bergmann ssize_t count; 58567207b96SArnd Bergmann 58667207b96SArnd Bergmann if (len < 4) 58767207b96SArnd Bergmann return -EINVAL; 58867207b96SArnd Bergmann 589cdcc89bbSArnd Bergmann if (!access_ok(VERIFY_WRITE, buf, len)) 590cdcc89bbSArnd Bergmann return -EFAULT; 591cdcc89bbSArnd Bergmann 592cdcc89bbSArnd Bergmann udata = (void __user *)buf; 593cdcc89bbSArnd Bergmann 5948b3d6663SArnd Bergmann spu_acquire(ctx); 59567207b96SArnd Bergmann 596cdcc89bbSArnd Bergmann /* wait only for the first element */ 597cdcc89bbSArnd Bergmann count = 0; 59867207b96SArnd Bergmann if (file->f_flags & O_NONBLOCK) { 5998b3d6663SArnd Bergmann if (!spu_ibox_read(ctx, &ibox_data)) 600cdcc89bbSArnd Bergmann count = -EAGAIN; 60167207b96SArnd Bergmann } else { 602cdcc89bbSArnd Bergmann count = spufs_wait(ctx->ibox_wq, spu_ibox_read(ctx, &ibox_data)); 603cdcc89bbSArnd Bergmann } 604cdcc89bbSArnd Bergmann if (count) 605cdcc89bbSArnd Bergmann goto out; 606cdcc89bbSArnd Bergmann 607cdcc89bbSArnd Bergmann /* if we can't write at all, return -EFAULT */ 608cdcc89bbSArnd Bergmann count = __put_user(ibox_data, udata); 609cdcc89bbSArnd Bergmann if (count) 610cdcc89bbSArnd Bergmann goto out; 611cdcc89bbSArnd Bergmann 612cdcc89bbSArnd Bergmann for (count = 4, udata++; (count + 4) <= len; count += 4, udata++) { 613cdcc89bbSArnd Bergmann int ret; 614cdcc89bbSArnd Bergmann ret = ctx->ops->ibox_read(ctx, &ibox_data); 615cdcc89bbSArnd Bergmann if (ret == 0) 616cdcc89bbSArnd Bergmann break; 617cdcc89bbSArnd Bergmann /* 618cdcc89bbSArnd Bergmann * at the end of the mapped area, we can fault 619cdcc89bbSArnd Bergmann * but still need to return the data we have 620cdcc89bbSArnd Bergmann * read successfully so far. 621cdcc89bbSArnd Bergmann */ 622cdcc89bbSArnd Bergmann ret = __put_user(ibox_data, udata); 623cdcc89bbSArnd Bergmann if (ret) 624cdcc89bbSArnd Bergmann break; 62567207b96SArnd Bergmann } 62667207b96SArnd Bergmann 627cdcc89bbSArnd Bergmann out: 6288b3d6663SArnd Bergmann spu_release(ctx); 6298b3d6663SArnd Bergmann 630cdcc89bbSArnd Bergmann return count; 63167207b96SArnd Bergmann } 63267207b96SArnd Bergmann 63367207b96SArnd Bergmann static unsigned int spufs_ibox_poll(struct file *file, poll_table *wait) 63467207b96SArnd Bergmann { 6358b3d6663SArnd Bergmann struct spu_context *ctx = file->private_data; 63667207b96SArnd Bergmann unsigned int mask; 63767207b96SArnd Bergmann 6388b3d6663SArnd Bergmann poll_wait(file, &ctx->ibox_wq, wait); 63967207b96SArnd Bergmann 6403a843d7cSArnd Bergmann spu_acquire(ctx); 6413a843d7cSArnd Bergmann mask = ctx->ops->mbox_stat_poll(ctx, POLLIN | POLLRDNORM); 6423a843d7cSArnd Bergmann spu_release(ctx); 64367207b96SArnd Bergmann 64467207b96SArnd Bergmann return mask; 64567207b96SArnd Bergmann } 64667207b96SArnd Bergmann 6475dfe4c96SArjan van de Ven static const struct file_operations spufs_ibox_fops = { 64867207b96SArnd Bergmann .open = spufs_pipe_open, 64967207b96SArnd Bergmann .read = spufs_ibox_read, 65067207b96SArnd Bergmann .poll = spufs_ibox_poll, 65167207b96SArnd Bergmann .fasync = spufs_ibox_fasync, 65267207b96SArnd Bergmann }; 65367207b96SArnd Bergmann 65467207b96SArnd Bergmann static ssize_t spufs_ibox_stat_read(struct file *file, char __user *buf, 65567207b96SArnd Bergmann size_t len, loff_t *pos) 65667207b96SArnd Bergmann { 6578b3d6663SArnd Bergmann struct spu_context *ctx = file->private_data; 65867207b96SArnd Bergmann u32 ibox_stat; 65967207b96SArnd Bergmann 66067207b96SArnd Bergmann if (len < 4) 66167207b96SArnd Bergmann return -EINVAL; 66267207b96SArnd Bergmann 6638b3d6663SArnd Bergmann spu_acquire(ctx); 6648b3d6663SArnd Bergmann ibox_stat = (ctx->ops->mbox_stat_read(ctx) >> 16) & 0xff; 6658b3d6663SArnd Bergmann spu_release(ctx); 66667207b96SArnd Bergmann 66767207b96SArnd Bergmann if (copy_to_user(buf, &ibox_stat, sizeof ibox_stat)) 66867207b96SArnd Bergmann return -EFAULT; 66967207b96SArnd Bergmann 67067207b96SArnd Bergmann return 4; 67167207b96SArnd Bergmann } 67267207b96SArnd Bergmann 6735dfe4c96SArjan van de Ven static const struct file_operations spufs_ibox_stat_fops = { 67467207b96SArnd Bergmann .open = spufs_pipe_open, 67567207b96SArnd Bergmann .read = spufs_ibox_stat_read, 67667207b96SArnd Bergmann }; 67767207b96SArnd Bergmann 67867207b96SArnd Bergmann /* low-level mailbox write */ 6798b3d6663SArnd Bergmann size_t spu_wbox_write(struct spu_context *ctx, u32 data) 68067207b96SArnd Bergmann { 6818b3d6663SArnd Bergmann return ctx->ops->wbox_write(ctx, data); 68267207b96SArnd Bergmann } 68367207b96SArnd Bergmann 68467207b96SArnd Bergmann static int spufs_wbox_fasync(int fd, struct file *file, int on) 68567207b96SArnd Bergmann { 6868b3d6663SArnd Bergmann struct spu_context *ctx = file->private_data; 6878b3d6663SArnd Bergmann int ret; 6888b3d6663SArnd Bergmann 6898b3d6663SArnd Bergmann ret = fasync_helper(fd, file, on, &ctx->wbox_fasync); 6908b3d6663SArnd Bergmann 6918b3d6663SArnd Bergmann return ret; 6928b3d6663SArnd Bergmann } 6938b3d6663SArnd Bergmann 6948b3d6663SArnd Bergmann /* interrupt-level wbox callback function. */ 6958b3d6663SArnd Bergmann void spufs_wbox_callback(struct spu *spu) 6968b3d6663SArnd Bergmann { 6978b3d6663SArnd Bergmann struct spu_context *ctx = spu->ctx; 6988b3d6663SArnd Bergmann 6998b3d6663SArnd Bergmann wake_up_all(&ctx->wbox_wq); 7008b3d6663SArnd Bergmann kill_fasync(&ctx->wbox_fasync, SIGIO, POLLOUT); 70167207b96SArnd Bergmann } 70267207b96SArnd Bergmann 703cdcc89bbSArnd Bergmann /* 704cdcc89bbSArnd Bergmann * Write as many bytes to the interrupt mailbox as possible, until 705cdcc89bbSArnd Bergmann * one of the conditions becomes true: 706cdcc89bbSArnd Bergmann * 707cdcc89bbSArnd Bergmann * - the mailbox is full 708cdcc89bbSArnd Bergmann * - end of the user provided buffer 709cdcc89bbSArnd Bergmann * - end of the mapped area 710cdcc89bbSArnd Bergmann * 711cdcc89bbSArnd Bergmann * If the file is opened without O_NONBLOCK, we wait here until 712cdcc89bbSArnd Bergmann * space is availabyl, but return when we have been able to 713cdcc89bbSArnd Bergmann * write something. 714cdcc89bbSArnd Bergmann */ 71567207b96SArnd Bergmann static ssize_t spufs_wbox_write(struct file *file, const char __user *buf, 71667207b96SArnd Bergmann size_t len, loff_t *pos) 71767207b96SArnd Bergmann { 7188b3d6663SArnd Bergmann struct spu_context *ctx = file->private_data; 719cdcc89bbSArnd Bergmann u32 wbox_data, __user *udata; 720cdcc89bbSArnd Bergmann ssize_t count; 72167207b96SArnd Bergmann 72267207b96SArnd Bergmann if (len < 4) 72367207b96SArnd Bergmann return -EINVAL; 72467207b96SArnd Bergmann 725cdcc89bbSArnd Bergmann udata = (void __user *)buf; 726cdcc89bbSArnd Bergmann if (!access_ok(VERIFY_READ, buf, len)) 727cdcc89bbSArnd Bergmann return -EFAULT; 728cdcc89bbSArnd Bergmann 729cdcc89bbSArnd Bergmann if (__get_user(wbox_data, udata)) 73067207b96SArnd Bergmann return -EFAULT; 73167207b96SArnd Bergmann 7328b3d6663SArnd Bergmann spu_acquire(ctx); 7338b3d6663SArnd Bergmann 734cdcc89bbSArnd Bergmann /* 735cdcc89bbSArnd Bergmann * make sure we can at least write one element, by waiting 736cdcc89bbSArnd Bergmann * in case of !O_NONBLOCK 737cdcc89bbSArnd Bergmann */ 738cdcc89bbSArnd Bergmann count = 0; 73967207b96SArnd Bergmann if (file->f_flags & O_NONBLOCK) { 7408b3d6663SArnd Bergmann if (!spu_wbox_write(ctx, wbox_data)) 741cdcc89bbSArnd Bergmann count = -EAGAIN; 74267207b96SArnd Bergmann } else { 743cdcc89bbSArnd Bergmann count = spufs_wait(ctx->wbox_wq, spu_wbox_write(ctx, wbox_data)); 74467207b96SArnd Bergmann } 74567207b96SArnd Bergmann 746cdcc89bbSArnd Bergmann if (count) 747cdcc89bbSArnd Bergmann goto out; 7488b3d6663SArnd Bergmann 749cdcc89bbSArnd Bergmann /* write aѕ much as possible */ 750cdcc89bbSArnd Bergmann for (count = 4, udata++; (count + 4) <= len; count += 4, udata++) { 751cdcc89bbSArnd Bergmann int ret; 752cdcc89bbSArnd Bergmann ret = __get_user(wbox_data, udata); 753cdcc89bbSArnd Bergmann if (ret) 754cdcc89bbSArnd Bergmann break; 755cdcc89bbSArnd Bergmann 756cdcc89bbSArnd Bergmann ret = spu_wbox_write(ctx, wbox_data); 757cdcc89bbSArnd Bergmann if (ret == 0) 758cdcc89bbSArnd Bergmann break; 759cdcc89bbSArnd Bergmann } 760cdcc89bbSArnd Bergmann 761cdcc89bbSArnd Bergmann out: 762cdcc89bbSArnd Bergmann spu_release(ctx); 763cdcc89bbSArnd Bergmann return count; 76467207b96SArnd Bergmann } 76567207b96SArnd Bergmann 76667207b96SArnd Bergmann static unsigned int spufs_wbox_poll(struct file *file, poll_table *wait) 76767207b96SArnd Bergmann { 7688b3d6663SArnd Bergmann struct spu_context *ctx = file->private_data; 76967207b96SArnd Bergmann unsigned int mask; 77067207b96SArnd Bergmann 7718b3d6663SArnd Bergmann poll_wait(file, &ctx->wbox_wq, wait); 77267207b96SArnd Bergmann 7733a843d7cSArnd Bergmann spu_acquire(ctx); 7743a843d7cSArnd Bergmann mask = ctx->ops->mbox_stat_poll(ctx, POLLOUT | POLLWRNORM); 7753a843d7cSArnd Bergmann spu_release(ctx); 77667207b96SArnd Bergmann 77767207b96SArnd Bergmann return mask; 77867207b96SArnd Bergmann } 77967207b96SArnd Bergmann 7805dfe4c96SArjan van de Ven static const struct file_operations spufs_wbox_fops = { 78167207b96SArnd Bergmann .open = spufs_pipe_open, 78267207b96SArnd Bergmann .write = spufs_wbox_write, 78367207b96SArnd Bergmann .poll = spufs_wbox_poll, 78467207b96SArnd Bergmann .fasync = spufs_wbox_fasync, 78567207b96SArnd Bergmann }; 78667207b96SArnd Bergmann 78767207b96SArnd Bergmann static ssize_t spufs_wbox_stat_read(struct file *file, char __user *buf, 78867207b96SArnd Bergmann size_t len, loff_t *pos) 78967207b96SArnd Bergmann { 7908b3d6663SArnd Bergmann struct spu_context *ctx = file->private_data; 79167207b96SArnd Bergmann u32 wbox_stat; 79267207b96SArnd Bergmann 79367207b96SArnd Bergmann if (len < 4) 79467207b96SArnd Bergmann return -EINVAL; 79567207b96SArnd Bergmann 7968b3d6663SArnd Bergmann spu_acquire(ctx); 7978b3d6663SArnd Bergmann wbox_stat = (ctx->ops->mbox_stat_read(ctx) >> 8) & 0xff; 7988b3d6663SArnd Bergmann spu_release(ctx); 79967207b96SArnd Bergmann 80067207b96SArnd Bergmann if (copy_to_user(buf, &wbox_stat, sizeof wbox_stat)) 80167207b96SArnd Bergmann return -EFAULT; 80267207b96SArnd Bergmann 80367207b96SArnd Bergmann return 4; 80467207b96SArnd Bergmann } 80567207b96SArnd Bergmann 8065dfe4c96SArjan van de Ven static const struct file_operations spufs_wbox_stat_fops = { 80767207b96SArnd Bergmann .open = spufs_pipe_open, 80867207b96SArnd Bergmann .read = spufs_wbox_stat_read, 80967207b96SArnd Bergmann }; 81067207b96SArnd Bergmann 8116df10a82SMark Nutter static int spufs_signal1_open(struct inode *inode, struct file *file) 8126df10a82SMark Nutter { 8136df10a82SMark Nutter struct spufs_inode_info *i = SPUFS_I(inode); 8146df10a82SMark Nutter struct spu_context *ctx = i->i_ctx; 81543c2bbd9SChristoph Hellwig 81647d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 8176df10a82SMark Nutter file->private_data = ctx; 81843c2bbd9SChristoph Hellwig if (!i->i_openers++) 8196df10a82SMark Nutter ctx->signal1 = inode->i_mapping; 82047d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 8216df10a82SMark Nutter return nonseekable_open(inode, file); 8226df10a82SMark Nutter } 8236df10a82SMark Nutter 82443c2bbd9SChristoph Hellwig static int 82543c2bbd9SChristoph Hellwig spufs_signal1_release(struct inode *inode, struct file *file) 82643c2bbd9SChristoph Hellwig { 82743c2bbd9SChristoph Hellwig struct spufs_inode_info *i = SPUFS_I(inode); 82843c2bbd9SChristoph Hellwig struct spu_context *ctx = i->i_ctx; 82943c2bbd9SChristoph Hellwig 83047d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 83143c2bbd9SChristoph Hellwig if (!--i->i_openers) 83243c2bbd9SChristoph Hellwig ctx->signal1 = NULL; 83347d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 83443c2bbd9SChristoph Hellwig return 0; 83543c2bbd9SChristoph Hellwig } 83643c2bbd9SChristoph Hellwig 837bf1ab978SDwayne Grant McConnell static ssize_t __spufs_signal1_read(struct spu_context *ctx, char __user *buf, 83867207b96SArnd Bergmann size_t len, loff_t *pos) 83967207b96SArnd Bergmann { 84017f88cebSDwayne Grant McConnell int ret = 0; 84167207b96SArnd Bergmann u32 data; 84267207b96SArnd Bergmann 84367207b96SArnd Bergmann if (len < 4) 84467207b96SArnd Bergmann return -EINVAL; 84567207b96SArnd Bergmann 84617f88cebSDwayne Grant McConnell if (ctx->csa.spu_chnlcnt_RW[3]) { 84717f88cebSDwayne Grant McConnell data = ctx->csa.spu_chnldata_RW[3]; 84817f88cebSDwayne Grant McConnell ret = 4; 84917f88cebSDwayne Grant McConnell } 8508b3d6663SArnd Bergmann 85117f88cebSDwayne Grant McConnell if (!ret) 85217f88cebSDwayne Grant McConnell goto out; 85317f88cebSDwayne Grant McConnell 85467207b96SArnd Bergmann if (copy_to_user(buf, &data, 4)) 85567207b96SArnd Bergmann return -EFAULT; 85667207b96SArnd Bergmann 85717f88cebSDwayne Grant McConnell out: 85817f88cebSDwayne Grant McConnell return ret; 85967207b96SArnd Bergmann } 86067207b96SArnd Bergmann 861bf1ab978SDwayne Grant McConnell static ssize_t spufs_signal1_read(struct file *file, char __user *buf, 862bf1ab978SDwayne Grant McConnell size_t len, loff_t *pos) 863bf1ab978SDwayne Grant McConnell { 864bf1ab978SDwayne Grant McConnell int ret; 865bf1ab978SDwayne Grant McConnell struct spu_context *ctx = file->private_data; 866bf1ab978SDwayne Grant McConnell 867bf1ab978SDwayne Grant McConnell spu_acquire_saved(ctx); 868bf1ab978SDwayne Grant McConnell ret = __spufs_signal1_read(ctx, buf, len, pos); 869bf1ab978SDwayne Grant McConnell spu_release(ctx); 870bf1ab978SDwayne Grant McConnell 871bf1ab978SDwayne Grant McConnell return ret; 872bf1ab978SDwayne Grant McConnell } 873bf1ab978SDwayne Grant McConnell 87467207b96SArnd Bergmann static ssize_t spufs_signal1_write(struct file *file, const char __user *buf, 87567207b96SArnd Bergmann size_t len, loff_t *pos) 87667207b96SArnd Bergmann { 87767207b96SArnd Bergmann struct spu_context *ctx; 87867207b96SArnd Bergmann u32 data; 87967207b96SArnd Bergmann 88067207b96SArnd Bergmann ctx = file->private_data; 88167207b96SArnd Bergmann 88267207b96SArnd Bergmann if (len < 4) 88367207b96SArnd Bergmann return -EINVAL; 88467207b96SArnd Bergmann 88567207b96SArnd Bergmann if (copy_from_user(&data, buf, 4)) 88667207b96SArnd Bergmann return -EFAULT; 88767207b96SArnd Bergmann 8888b3d6663SArnd Bergmann spu_acquire(ctx); 8898b3d6663SArnd Bergmann ctx->ops->signal1_write(ctx, data); 8908b3d6663SArnd Bergmann spu_release(ctx); 89167207b96SArnd Bergmann 89267207b96SArnd Bergmann return 4; 89367207b96SArnd Bergmann } 89467207b96SArnd Bergmann 89578bde53eSBenjamin Herrenschmidt static unsigned long spufs_signal1_mmap_nopfn(struct vm_area_struct *vma, 89678bde53eSBenjamin Herrenschmidt unsigned long address) 8976df10a82SMark Nutter { 89827d5bf2aSBenjamin Herrenschmidt #if PAGE_SIZE == 0x1000 89978bde53eSBenjamin Herrenschmidt return spufs_ps_nopfn(vma, address, 0x14000, 0x1000); 90027d5bf2aSBenjamin Herrenschmidt #elif PAGE_SIZE == 0x10000 90127d5bf2aSBenjamin Herrenschmidt /* For 64k pages, both signal1 and signal2 can be used to mmap the whole 90227d5bf2aSBenjamin Herrenschmidt * signal 1 and 2 area 90327d5bf2aSBenjamin Herrenschmidt */ 90478bde53eSBenjamin Herrenschmidt return spufs_ps_nopfn(vma, address, 0x10000, 0x10000); 90527d5bf2aSBenjamin Herrenschmidt #else 90627d5bf2aSBenjamin Herrenschmidt #error unsupported page size 90727d5bf2aSBenjamin Herrenschmidt #endif 9086df10a82SMark Nutter } 9096df10a82SMark Nutter 9106df10a82SMark Nutter static struct vm_operations_struct spufs_signal1_mmap_vmops = { 91178bde53eSBenjamin Herrenschmidt .nopfn = spufs_signal1_mmap_nopfn, 9126df10a82SMark Nutter }; 9136df10a82SMark Nutter 9146df10a82SMark Nutter static int spufs_signal1_mmap(struct file *file, struct vm_area_struct *vma) 9156df10a82SMark Nutter { 9166df10a82SMark Nutter if (!(vma->vm_flags & VM_SHARED)) 9176df10a82SMark Nutter return -EINVAL; 9186df10a82SMark Nutter 91978bde53eSBenjamin Herrenschmidt vma->vm_flags |= VM_IO | VM_PFNMAP; 9206df10a82SMark Nutter vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot) 92123cc7701SBenjamin Herrenschmidt | _PAGE_NO_CACHE | _PAGE_GUARDED); 9226df10a82SMark Nutter 9236df10a82SMark Nutter vma->vm_ops = &spufs_signal1_mmap_vmops; 9246df10a82SMark Nutter return 0; 9256df10a82SMark Nutter } 9266df10a82SMark Nutter 9275dfe4c96SArjan van de Ven static const struct file_operations spufs_signal1_fops = { 9286df10a82SMark Nutter .open = spufs_signal1_open, 92943c2bbd9SChristoph Hellwig .release = spufs_signal1_release, 93067207b96SArnd Bergmann .read = spufs_signal1_read, 93167207b96SArnd Bergmann .write = spufs_signal1_write, 9326df10a82SMark Nutter .mmap = spufs_signal1_mmap, 93367207b96SArnd Bergmann }; 93467207b96SArnd Bergmann 9356df10a82SMark Nutter static int spufs_signal2_open(struct inode *inode, struct file *file) 9366df10a82SMark Nutter { 9376df10a82SMark Nutter struct spufs_inode_info *i = SPUFS_I(inode); 9386df10a82SMark Nutter struct spu_context *ctx = i->i_ctx; 93943c2bbd9SChristoph Hellwig 94047d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 9416df10a82SMark Nutter file->private_data = ctx; 94243c2bbd9SChristoph Hellwig if (!i->i_openers++) 9436df10a82SMark Nutter ctx->signal2 = inode->i_mapping; 94447d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 9456df10a82SMark Nutter return nonseekable_open(inode, file); 9466df10a82SMark Nutter } 9476df10a82SMark Nutter 94843c2bbd9SChristoph Hellwig static int 94943c2bbd9SChristoph Hellwig spufs_signal2_release(struct inode *inode, struct file *file) 95043c2bbd9SChristoph Hellwig { 95143c2bbd9SChristoph Hellwig struct spufs_inode_info *i = SPUFS_I(inode); 95243c2bbd9SChristoph Hellwig struct spu_context *ctx = i->i_ctx; 95343c2bbd9SChristoph Hellwig 95447d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 95543c2bbd9SChristoph Hellwig if (!--i->i_openers) 95643c2bbd9SChristoph Hellwig ctx->signal2 = NULL; 95747d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 95843c2bbd9SChristoph Hellwig return 0; 95943c2bbd9SChristoph Hellwig } 96043c2bbd9SChristoph Hellwig 961bf1ab978SDwayne Grant McConnell static ssize_t __spufs_signal2_read(struct spu_context *ctx, char __user *buf, 96267207b96SArnd Bergmann size_t len, loff_t *pos) 96367207b96SArnd Bergmann { 96417f88cebSDwayne Grant McConnell int ret = 0; 96567207b96SArnd Bergmann u32 data; 96667207b96SArnd Bergmann 96767207b96SArnd Bergmann if (len < 4) 96867207b96SArnd Bergmann return -EINVAL; 96967207b96SArnd Bergmann 97017f88cebSDwayne Grant McConnell if (ctx->csa.spu_chnlcnt_RW[4]) { 97117f88cebSDwayne Grant McConnell data = ctx->csa.spu_chnldata_RW[4]; 97217f88cebSDwayne Grant McConnell ret = 4; 97317f88cebSDwayne Grant McConnell } 9748b3d6663SArnd Bergmann 97517f88cebSDwayne Grant McConnell if (!ret) 97617f88cebSDwayne Grant McConnell goto out; 97717f88cebSDwayne Grant McConnell 97867207b96SArnd Bergmann if (copy_to_user(buf, &data, 4)) 97967207b96SArnd Bergmann return -EFAULT; 98067207b96SArnd Bergmann 98117f88cebSDwayne Grant McConnell out: 982bf1ab978SDwayne Grant McConnell return ret; 983bf1ab978SDwayne Grant McConnell } 984bf1ab978SDwayne Grant McConnell 985bf1ab978SDwayne Grant McConnell static ssize_t spufs_signal2_read(struct file *file, char __user *buf, 986bf1ab978SDwayne Grant McConnell size_t len, loff_t *pos) 987bf1ab978SDwayne Grant McConnell { 988bf1ab978SDwayne Grant McConnell struct spu_context *ctx = file->private_data; 989bf1ab978SDwayne Grant McConnell int ret; 990bf1ab978SDwayne Grant McConnell 991bf1ab978SDwayne Grant McConnell spu_acquire_saved(ctx); 992bf1ab978SDwayne Grant McConnell ret = __spufs_signal2_read(ctx, buf, len, pos); 993bf1ab978SDwayne Grant McConnell spu_release(ctx); 994bf1ab978SDwayne Grant McConnell 995bf1ab978SDwayne Grant McConnell return ret; 99667207b96SArnd Bergmann } 99767207b96SArnd Bergmann 99867207b96SArnd Bergmann static ssize_t spufs_signal2_write(struct file *file, const char __user *buf, 99967207b96SArnd Bergmann size_t len, loff_t *pos) 100067207b96SArnd Bergmann { 100167207b96SArnd Bergmann struct spu_context *ctx; 100267207b96SArnd Bergmann u32 data; 100367207b96SArnd Bergmann 100467207b96SArnd Bergmann ctx = file->private_data; 100567207b96SArnd Bergmann 100667207b96SArnd Bergmann if (len < 4) 100767207b96SArnd Bergmann return -EINVAL; 100867207b96SArnd Bergmann 100967207b96SArnd Bergmann if (copy_from_user(&data, buf, 4)) 101067207b96SArnd Bergmann return -EFAULT; 101167207b96SArnd Bergmann 10128b3d6663SArnd Bergmann spu_acquire(ctx); 10138b3d6663SArnd Bergmann ctx->ops->signal2_write(ctx, data); 10148b3d6663SArnd Bergmann spu_release(ctx); 101567207b96SArnd Bergmann 101667207b96SArnd Bergmann return 4; 101767207b96SArnd Bergmann } 101867207b96SArnd Bergmann 101927d5bf2aSBenjamin Herrenschmidt #if SPUFS_MMAP_4K 102078bde53eSBenjamin Herrenschmidt static unsigned long spufs_signal2_mmap_nopfn(struct vm_area_struct *vma, 102178bde53eSBenjamin Herrenschmidt unsigned long address) 10226df10a82SMark Nutter { 102327d5bf2aSBenjamin Herrenschmidt #if PAGE_SIZE == 0x1000 102478bde53eSBenjamin Herrenschmidt return spufs_ps_nopfn(vma, address, 0x1c000, 0x1000); 102527d5bf2aSBenjamin Herrenschmidt #elif PAGE_SIZE == 0x10000 102627d5bf2aSBenjamin Herrenschmidt /* For 64k pages, both signal1 and signal2 can be used to mmap the whole 102727d5bf2aSBenjamin Herrenschmidt * signal 1 and 2 area 102827d5bf2aSBenjamin Herrenschmidt */ 102978bde53eSBenjamin Herrenschmidt return spufs_ps_nopfn(vma, address, 0x10000, 0x10000); 103027d5bf2aSBenjamin Herrenschmidt #else 103127d5bf2aSBenjamin Herrenschmidt #error unsupported page size 103227d5bf2aSBenjamin Herrenschmidt #endif 10336df10a82SMark Nutter } 10346df10a82SMark Nutter 10356df10a82SMark Nutter static struct vm_operations_struct spufs_signal2_mmap_vmops = { 103678bde53eSBenjamin Herrenschmidt .nopfn = spufs_signal2_mmap_nopfn, 10376df10a82SMark Nutter }; 10386df10a82SMark Nutter 10396df10a82SMark Nutter static int spufs_signal2_mmap(struct file *file, struct vm_area_struct *vma) 10406df10a82SMark Nutter { 10416df10a82SMark Nutter if (!(vma->vm_flags & VM_SHARED)) 10426df10a82SMark Nutter return -EINVAL; 10436df10a82SMark Nutter 104478bde53eSBenjamin Herrenschmidt vma->vm_flags |= VM_IO | VM_PFNMAP; 10456df10a82SMark Nutter vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot) 104623cc7701SBenjamin Herrenschmidt | _PAGE_NO_CACHE | _PAGE_GUARDED); 10476df10a82SMark Nutter 10486df10a82SMark Nutter vma->vm_ops = &spufs_signal2_mmap_vmops; 10496df10a82SMark Nutter return 0; 10506df10a82SMark Nutter } 105127d5bf2aSBenjamin Herrenschmidt #else /* SPUFS_MMAP_4K */ 105227d5bf2aSBenjamin Herrenschmidt #define spufs_signal2_mmap NULL 105327d5bf2aSBenjamin Herrenschmidt #endif /* !SPUFS_MMAP_4K */ 10546df10a82SMark Nutter 10555dfe4c96SArjan van de Ven static const struct file_operations spufs_signal2_fops = { 10566df10a82SMark Nutter .open = spufs_signal2_open, 105743c2bbd9SChristoph Hellwig .release = spufs_signal2_release, 105867207b96SArnd Bergmann .read = spufs_signal2_read, 105967207b96SArnd Bergmann .write = spufs_signal2_write, 10606df10a82SMark Nutter .mmap = spufs_signal2_mmap, 106167207b96SArnd Bergmann }; 106267207b96SArnd Bergmann 106367207b96SArnd Bergmann static void spufs_signal1_type_set(void *data, u64 val) 106467207b96SArnd Bergmann { 106567207b96SArnd Bergmann struct spu_context *ctx = data; 106667207b96SArnd Bergmann 10678b3d6663SArnd Bergmann spu_acquire(ctx); 10688b3d6663SArnd Bergmann ctx->ops->signal1_type_set(ctx, val); 10698b3d6663SArnd Bergmann spu_release(ctx); 107067207b96SArnd Bergmann } 107167207b96SArnd Bergmann 1072bf1ab978SDwayne Grant McConnell static u64 __spufs_signal1_type_get(void *data) 1073bf1ab978SDwayne Grant McConnell { 1074bf1ab978SDwayne Grant McConnell struct spu_context *ctx = data; 1075bf1ab978SDwayne Grant McConnell return ctx->ops->signal1_type_get(ctx); 1076bf1ab978SDwayne Grant McConnell } 1077bf1ab978SDwayne Grant McConnell 107867207b96SArnd Bergmann static u64 spufs_signal1_type_get(void *data) 107967207b96SArnd Bergmann { 108067207b96SArnd Bergmann struct spu_context *ctx = data; 10818b3d6663SArnd Bergmann u64 ret; 10828b3d6663SArnd Bergmann 10838b3d6663SArnd Bergmann spu_acquire(ctx); 1084bf1ab978SDwayne Grant McConnell ret = __spufs_signal1_type_get(data); 10858b3d6663SArnd Bergmann spu_release(ctx); 10868b3d6663SArnd Bergmann 10878b3d6663SArnd Bergmann return ret; 108867207b96SArnd Bergmann } 108967207b96SArnd Bergmann DEFINE_SIMPLE_ATTRIBUTE(spufs_signal1_type, spufs_signal1_type_get, 109067207b96SArnd Bergmann spufs_signal1_type_set, "%llu"); 109167207b96SArnd Bergmann 109267207b96SArnd Bergmann static void spufs_signal2_type_set(void *data, u64 val) 109367207b96SArnd Bergmann { 109467207b96SArnd Bergmann struct spu_context *ctx = data; 109567207b96SArnd Bergmann 10968b3d6663SArnd Bergmann spu_acquire(ctx); 10978b3d6663SArnd Bergmann ctx->ops->signal2_type_set(ctx, val); 10988b3d6663SArnd Bergmann spu_release(ctx); 109967207b96SArnd Bergmann } 110067207b96SArnd Bergmann 1101bf1ab978SDwayne Grant McConnell static u64 __spufs_signal2_type_get(void *data) 1102bf1ab978SDwayne Grant McConnell { 1103bf1ab978SDwayne Grant McConnell struct spu_context *ctx = data; 1104bf1ab978SDwayne Grant McConnell return ctx->ops->signal2_type_get(ctx); 1105bf1ab978SDwayne Grant McConnell } 1106bf1ab978SDwayne Grant McConnell 110767207b96SArnd Bergmann static u64 spufs_signal2_type_get(void *data) 110867207b96SArnd Bergmann { 110967207b96SArnd Bergmann struct spu_context *ctx = data; 11108b3d6663SArnd Bergmann u64 ret; 11118b3d6663SArnd Bergmann 11128b3d6663SArnd Bergmann spu_acquire(ctx); 1113bf1ab978SDwayne Grant McConnell ret = __spufs_signal2_type_get(data); 11148b3d6663SArnd Bergmann spu_release(ctx); 11158b3d6663SArnd Bergmann 11168b3d6663SArnd Bergmann return ret; 111767207b96SArnd Bergmann } 111867207b96SArnd Bergmann DEFINE_SIMPLE_ATTRIBUTE(spufs_signal2_type, spufs_signal2_type_get, 111967207b96SArnd Bergmann spufs_signal2_type_set, "%llu"); 112067207b96SArnd Bergmann 112127d5bf2aSBenjamin Herrenschmidt #if SPUFS_MMAP_4K 112278bde53eSBenjamin Herrenschmidt static unsigned long spufs_mss_mmap_nopfn(struct vm_area_struct *vma, 112378bde53eSBenjamin Herrenschmidt unsigned long address) 1124d9379c4bSarnd@arndb.de { 112578bde53eSBenjamin Herrenschmidt return spufs_ps_nopfn(vma, address, 0x0000, 0x1000); 1126d9379c4bSarnd@arndb.de } 1127d9379c4bSarnd@arndb.de 1128d9379c4bSarnd@arndb.de static struct vm_operations_struct spufs_mss_mmap_vmops = { 112978bde53eSBenjamin Herrenschmidt .nopfn = spufs_mss_mmap_nopfn, 1130d9379c4bSarnd@arndb.de }; 1131d9379c4bSarnd@arndb.de 1132d9379c4bSarnd@arndb.de /* 1133d9379c4bSarnd@arndb.de * mmap support for problem state MFC DMA area [0x0000 - 0x0fff]. 1134d9379c4bSarnd@arndb.de */ 1135d9379c4bSarnd@arndb.de static int spufs_mss_mmap(struct file *file, struct vm_area_struct *vma) 1136d9379c4bSarnd@arndb.de { 1137d9379c4bSarnd@arndb.de if (!(vma->vm_flags & VM_SHARED)) 1138d9379c4bSarnd@arndb.de return -EINVAL; 1139d9379c4bSarnd@arndb.de 114078bde53eSBenjamin Herrenschmidt vma->vm_flags |= VM_IO | VM_PFNMAP; 1141d9379c4bSarnd@arndb.de vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot) 114223cc7701SBenjamin Herrenschmidt | _PAGE_NO_CACHE | _PAGE_GUARDED); 1143d9379c4bSarnd@arndb.de 1144d9379c4bSarnd@arndb.de vma->vm_ops = &spufs_mss_mmap_vmops; 1145d9379c4bSarnd@arndb.de return 0; 1146d9379c4bSarnd@arndb.de } 114727d5bf2aSBenjamin Herrenschmidt #else /* SPUFS_MMAP_4K */ 114827d5bf2aSBenjamin Herrenschmidt #define spufs_mss_mmap NULL 114927d5bf2aSBenjamin Herrenschmidt #endif /* !SPUFS_MMAP_4K */ 1150d9379c4bSarnd@arndb.de 1151d9379c4bSarnd@arndb.de static int spufs_mss_open(struct inode *inode, struct file *file) 1152d9379c4bSarnd@arndb.de { 1153d9379c4bSarnd@arndb.de struct spufs_inode_info *i = SPUFS_I(inode); 115417e0e270SBenjamin Herrenschmidt struct spu_context *ctx = i->i_ctx; 1155d9379c4bSarnd@arndb.de 1156d9379c4bSarnd@arndb.de file->private_data = i->i_ctx; 115743c2bbd9SChristoph Hellwig 115847d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 115943c2bbd9SChristoph Hellwig if (!i->i_openers++) 116017e0e270SBenjamin Herrenschmidt ctx->mss = inode->i_mapping; 116147d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 1162d9379c4bSarnd@arndb.de return nonseekable_open(inode, file); 1163d9379c4bSarnd@arndb.de } 1164d9379c4bSarnd@arndb.de 116543c2bbd9SChristoph Hellwig static int 116643c2bbd9SChristoph Hellwig spufs_mss_release(struct inode *inode, struct file *file) 116743c2bbd9SChristoph Hellwig { 116843c2bbd9SChristoph Hellwig struct spufs_inode_info *i = SPUFS_I(inode); 116943c2bbd9SChristoph Hellwig struct spu_context *ctx = i->i_ctx; 117043c2bbd9SChristoph Hellwig 117147d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 117243c2bbd9SChristoph Hellwig if (!--i->i_openers) 117343c2bbd9SChristoph Hellwig ctx->mss = NULL; 117447d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 117543c2bbd9SChristoph Hellwig return 0; 117643c2bbd9SChristoph Hellwig } 117743c2bbd9SChristoph Hellwig 11785dfe4c96SArjan van de Ven static const struct file_operations spufs_mss_fops = { 1179d9379c4bSarnd@arndb.de .open = spufs_mss_open, 118043c2bbd9SChristoph Hellwig .release = spufs_mss_release, 1181d9379c4bSarnd@arndb.de .mmap = spufs_mss_mmap, 118227d5bf2aSBenjamin Herrenschmidt }; 118327d5bf2aSBenjamin Herrenschmidt 118478bde53eSBenjamin Herrenschmidt static unsigned long spufs_psmap_mmap_nopfn(struct vm_area_struct *vma, 118578bde53eSBenjamin Herrenschmidt unsigned long address) 118627d5bf2aSBenjamin Herrenschmidt { 118778bde53eSBenjamin Herrenschmidt return spufs_ps_nopfn(vma, address, 0x0000, 0x20000); 118827d5bf2aSBenjamin Herrenschmidt } 118927d5bf2aSBenjamin Herrenschmidt 119027d5bf2aSBenjamin Herrenschmidt static struct vm_operations_struct spufs_psmap_mmap_vmops = { 119178bde53eSBenjamin Herrenschmidt .nopfn = spufs_psmap_mmap_nopfn, 119227d5bf2aSBenjamin Herrenschmidt }; 119327d5bf2aSBenjamin Herrenschmidt 119427d5bf2aSBenjamin Herrenschmidt /* 119527d5bf2aSBenjamin Herrenschmidt * mmap support for full problem state area [0x00000 - 0x1ffff]. 119627d5bf2aSBenjamin Herrenschmidt */ 119727d5bf2aSBenjamin Herrenschmidt static int spufs_psmap_mmap(struct file *file, struct vm_area_struct *vma) 119827d5bf2aSBenjamin Herrenschmidt { 119927d5bf2aSBenjamin Herrenschmidt if (!(vma->vm_flags & VM_SHARED)) 120027d5bf2aSBenjamin Herrenschmidt return -EINVAL; 120127d5bf2aSBenjamin Herrenschmidt 120278bde53eSBenjamin Herrenschmidt vma->vm_flags |= VM_IO | VM_PFNMAP; 120327d5bf2aSBenjamin Herrenschmidt vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot) 120427d5bf2aSBenjamin Herrenschmidt | _PAGE_NO_CACHE | _PAGE_GUARDED); 120527d5bf2aSBenjamin Herrenschmidt 120627d5bf2aSBenjamin Herrenschmidt vma->vm_ops = &spufs_psmap_mmap_vmops; 120727d5bf2aSBenjamin Herrenschmidt return 0; 120827d5bf2aSBenjamin Herrenschmidt } 120927d5bf2aSBenjamin Herrenschmidt 121027d5bf2aSBenjamin Herrenschmidt static int spufs_psmap_open(struct inode *inode, struct file *file) 121127d5bf2aSBenjamin Herrenschmidt { 121227d5bf2aSBenjamin Herrenschmidt struct spufs_inode_info *i = SPUFS_I(inode); 121317e0e270SBenjamin Herrenschmidt struct spu_context *ctx = i->i_ctx; 121427d5bf2aSBenjamin Herrenschmidt 121547d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 121627d5bf2aSBenjamin Herrenschmidt file->private_data = i->i_ctx; 121743c2bbd9SChristoph Hellwig if (!i->i_openers++) 121817e0e270SBenjamin Herrenschmidt ctx->psmap = inode->i_mapping; 121947d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 122027d5bf2aSBenjamin Herrenschmidt return nonseekable_open(inode, file); 122127d5bf2aSBenjamin Herrenschmidt } 122227d5bf2aSBenjamin Herrenschmidt 122343c2bbd9SChristoph Hellwig static int 122443c2bbd9SChristoph Hellwig spufs_psmap_release(struct inode *inode, struct file *file) 122543c2bbd9SChristoph Hellwig { 122643c2bbd9SChristoph Hellwig struct spufs_inode_info *i = SPUFS_I(inode); 122743c2bbd9SChristoph Hellwig struct spu_context *ctx = i->i_ctx; 122843c2bbd9SChristoph Hellwig 122947d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 123043c2bbd9SChristoph Hellwig if (!--i->i_openers) 123143c2bbd9SChristoph Hellwig ctx->psmap = NULL; 123247d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 123343c2bbd9SChristoph Hellwig return 0; 123443c2bbd9SChristoph Hellwig } 123543c2bbd9SChristoph Hellwig 12365dfe4c96SArjan van de Ven static const struct file_operations spufs_psmap_fops = { 123727d5bf2aSBenjamin Herrenschmidt .open = spufs_psmap_open, 123843c2bbd9SChristoph Hellwig .release = spufs_psmap_release, 123927d5bf2aSBenjamin Herrenschmidt .mmap = spufs_psmap_mmap, 1240d9379c4bSarnd@arndb.de }; 1241d9379c4bSarnd@arndb.de 1242d9379c4bSarnd@arndb.de 124327d5bf2aSBenjamin Herrenschmidt #if SPUFS_MMAP_4K 124478bde53eSBenjamin Herrenschmidt static unsigned long spufs_mfc_mmap_nopfn(struct vm_area_struct *vma, 124578bde53eSBenjamin Herrenschmidt unsigned long address) 12466df10a82SMark Nutter { 124778bde53eSBenjamin Herrenschmidt return spufs_ps_nopfn(vma, address, 0x3000, 0x1000); 12486df10a82SMark Nutter } 12496df10a82SMark Nutter 12506df10a82SMark Nutter static struct vm_operations_struct spufs_mfc_mmap_vmops = { 125178bde53eSBenjamin Herrenschmidt .nopfn = spufs_mfc_mmap_nopfn, 12526df10a82SMark Nutter }; 12536df10a82SMark Nutter 12546df10a82SMark Nutter /* 12556df10a82SMark Nutter * mmap support for problem state MFC DMA area [0x0000 - 0x0fff]. 12566df10a82SMark Nutter */ 12576df10a82SMark Nutter static int spufs_mfc_mmap(struct file *file, struct vm_area_struct *vma) 12586df10a82SMark Nutter { 12596df10a82SMark Nutter if (!(vma->vm_flags & VM_SHARED)) 12606df10a82SMark Nutter return -EINVAL; 12616df10a82SMark Nutter 126278bde53eSBenjamin Herrenschmidt vma->vm_flags |= VM_IO | VM_PFNMAP; 12636df10a82SMark Nutter vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot) 126423cc7701SBenjamin Herrenschmidt | _PAGE_NO_CACHE | _PAGE_GUARDED); 12656df10a82SMark Nutter 12666df10a82SMark Nutter vma->vm_ops = &spufs_mfc_mmap_vmops; 12676df10a82SMark Nutter return 0; 12686df10a82SMark Nutter } 126927d5bf2aSBenjamin Herrenschmidt #else /* SPUFS_MMAP_4K */ 127027d5bf2aSBenjamin Herrenschmidt #define spufs_mfc_mmap NULL 127127d5bf2aSBenjamin Herrenschmidt #endif /* !SPUFS_MMAP_4K */ 1272a33a7d73SArnd Bergmann 1273a33a7d73SArnd Bergmann static int spufs_mfc_open(struct inode *inode, struct file *file) 1274a33a7d73SArnd Bergmann { 1275a33a7d73SArnd Bergmann struct spufs_inode_info *i = SPUFS_I(inode); 1276a33a7d73SArnd Bergmann struct spu_context *ctx = i->i_ctx; 1277a33a7d73SArnd Bergmann 1278a33a7d73SArnd Bergmann /* we don't want to deal with DMA into other processes */ 1279a33a7d73SArnd Bergmann if (ctx->owner != current->mm) 1280a33a7d73SArnd Bergmann return -EINVAL; 1281a33a7d73SArnd Bergmann 1282a33a7d73SArnd Bergmann if (atomic_read(&inode->i_count) != 1) 1283a33a7d73SArnd Bergmann return -EBUSY; 1284a33a7d73SArnd Bergmann 128547d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 1286a33a7d73SArnd Bergmann file->private_data = ctx; 128743c2bbd9SChristoph Hellwig if (!i->i_openers++) 128817e0e270SBenjamin Herrenschmidt ctx->mfc = inode->i_mapping; 128947d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 1290a33a7d73SArnd Bergmann return nonseekable_open(inode, file); 1291a33a7d73SArnd Bergmann } 1292a33a7d73SArnd Bergmann 129343c2bbd9SChristoph Hellwig static int 129443c2bbd9SChristoph Hellwig spufs_mfc_release(struct inode *inode, struct file *file) 129543c2bbd9SChristoph Hellwig { 129643c2bbd9SChristoph Hellwig struct spufs_inode_info *i = SPUFS_I(inode); 129743c2bbd9SChristoph Hellwig struct spu_context *ctx = i->i_ctx; 129843c2bbd9SChristoph Hellwig 129947d3a5faSChristoph Hellwig mutex_lock(&ctx->mapping_lock); 130043c2bbd9SChristoph Hellwig if (!--i->i_openers) 130143c2bbd9SChristoph Hellwig ctx->mfc = NULL; 130247d3a5faSChristoph Hellwig mutex_unlock(&ctx->mapping_lock); 130343c2bbd9SChristoph Hellwig return 0; 130443c2bbd9SChristoph Hellwig } 130543c2bbd9SChristoph Hellwig 1306a33a7d73SArnd Bergmann /* interrupt-level mfc callback function. */ 1307a33a7d73SArnd Bergmann void spufs_mfc_callback(struct spu *spu) 1308a33a7d73SArnd Bergmann { 1309a33a7d73SArnd Bergmann struct spu_context *ctx = spu->ctx; 1310a33a7d73SArnd Bergmann 1311a33a7d73SArnd Bergmann wake_up_all(&ctx->mfc_wq); 1312a33a7d73SArnd Bergmann 1313a33a7d73SArnd Bergmann pr_debug("%s %s\n", __FUNCTION__, spu->name); 1314a33a7d73SArnd Bergmann if (ctx->mfc_fasync) { 1315a33a7d73SArnd Bergmann u32 free_elements, tagstatus; 1316a33a7d73SArnd Bergmann unsigned int mask; 1317a33a7d73SArnd Bergmann 1318a33a7d73SArnd Bergmann /* no need for spu_acquire in interrupt context */ 1319a33a7d73SArnd Bergmann free_elements = ctx->ops->get_mfc_free_elements(ctx); 1320a33a7d73SArnd Bergmann tagstatus = ctx->ops->read_mfc_tagstatus(ctx); 1321a33a7d73SArnd Bergmann 1322a33a7d73SArnd Bergmann mask = 0; 1323a33a7d73SArnd Bergmann if (free_elements & 0xffff) 1324a33a7d73SArnd Bergmann mask |= POLLOUT; 1325a33a7d73SArnd Bergmann if (tagstatus & ctx->tagwait) 1326a33a7d73SArnd Bergmann mask |= POLLIN; 1327a33a7d73SArnd Bergmann 1328a33a7d73SArnd Bergmann kill_fasync(&ctx->mfc_fasync, SIGIO, mask); 1329a33a7d73SArnd Bergmann } 1330a33a7d73SArnd Bergmann } 1331a33a7d73SArnd Bergmann 1332a33a7d73SArnd Bergmann static int spufs_read_mfc_tagstatus(struct spu_context *ctx, u32 *status) 1333a33a7d73SArnd Bergmann { 1334a33a7d73SArnd Bergmann /* See if there is one tag group is complete */ 1335a33a7d73SArnd Bergmann /* FIXME we need locking around tagwait */ 1336a33a7d73SArnd Bergmann *status = ctx->ops->read_mfc_tagstatus(ctx) & ctx->tagwait; 1337a33a7d73SArnd Bergmann ctx->tagwait &= ~*status; 1338a33a7d73SArnd Bergmann if (*status) 1339a33a7d73SArnd Bergmann return 1; 1340a33a7d73SArnd Bergmann 1341a33a7d73SArnd Bergmann /* enable interrupt waiting for any tag group, 1342a33a7d73SArnd Bergmann may silently fail if interrupts are already enabled */ 1343a33a7d73SArnd Bergmann ctx->ops->set_mfc_query(ctx, ctx->tagwait, 1); 1344a33a7d73SArnd Bergmann return 0; 1345a33a7d73SArnd Bergmann } 1346a33a7d73SArnd Bergmann 1347a33a7d73SArnd Bergmann static ssize_t spufs_mfc_read(struct file *file, char __user *buffer, 1348a33a7d73SArnd Bergmann size_t size, loff_t *pos) 1349a33a7d73SArnd Bergmann { 1350a33a7d73SArnd Bergmann struct spu_context *ctx = file->private_data; 1351a33a7d73SArnd Bergmann int ret = -EINVAL; 1352a33a7d73SArnd Bergmann u32 status; 1353a33a7d73SArnd Bergmann 1354a33a7d73SArnd Bergmann if (size != 4) 1355a33a7d73SArnd Bergmann goto out; 1356a33a7d73SArnd Bergmann 1357a33a7d73SArnd Bergmann spu_acquire(ctx); 1358a33a7d73SArnd Bergmann if (file->f_flags & O_NONBLOCK) { 1359a33a7d73SArnd Bergmann status = ctx->ops->read_mfc_tagstatus(ctx); 1360a33a7d73SArnd Bergmann if (!(status & ctx->tagwait)) 1361a33a7d73SArnd Bergmann ret = -EAGAIN; 1362a33a7d73SArnd Bergmann else 1363a33a7d73SArnd Bergmann ctx->tagwait &= ~status; 1364a33a7d73SArnd Bergmann } else { 1365a33a7d73SArnd Bergmann ret = spufs_wait(ctx->mfc_wq, 1366a33a7d73SArnd Bergmann spufs_read_mfc_tagstatus(ctx, &status)); 1367a33a7d73SArnd Bergmann } 1368a33a7d73SArnd Bergmann spu_release(ctx); 1369a33a7d73SArnd Bergmann 1370a33a7d73SArnd Bergmann if (ret) 1371a33a7d73SArnd Bergmann goto out; 1372a33a7d73SArnd Bergmann 1373a33a7d73SArnd Bergmann ret = 4; 1374a33a7d73SArnd Bergmann if (copy_to_user(buffer, &status, 4)) 1375a33a7d73SArnd Bergmann ret = -EFAULT; 1376a33a7d73SArnd Bergmann 1377a33a7d73SArnd Bergmann out: 1378a33a7d73SArnd Bergmann return ret; 1379a33a7d73SArnd Bergmann } 1380a33a7d73SArnd Bergmann 1381a33a7d73SArnd Bergmann static int spufs_check_valid_dma(struct mfc_dma_command *cmd) 1382a33a7d73SArnd Bergmann { 1383a33a7d73SArnd Bergmann pr_debug("queueing DMA %x %lx %x %x %x\n", cmd->lsa, 1384a33a7d73SArnd Bergmann cmd->ea, cmd->size, cmd->tag, cmd->cmd); 1385a33a7d73SArnd Bergmann 1386a33a7d73SArnd Bergmann switch (cmd->cmd) { 1387a33a7d73SArnd Bergmann case MFC_PUT_CMD: 1388a33a7d73SArnd Bergmann case MFC_PUTF_CMD: 1389a33a7d73SArnd Bergmann case MFC_PUTB_CMD: 1390a33a7d73SArnd Bergmann case MFC_GET_CMD: 1391a33a7d73SArnd Bergmann case MFC_GETF_CMD: 1392a33a7d73SArnd Bergmann case MFC_GETB_CMD: 1393a33a7d73SArnd Bergmann break; 1394a33a7d73SArnd Bergmann default: 1395a33a7d73SArnd Bergmann pr_debug("invalid DMA opcode %x\n", cmd->cmd); 1396a33a7d73SArnd Bergmann return -EIO; 1397a33a7d73SArnd Bergmann } 1398a33a7d73SArnd Bergmann 1399a33a7d73SArnd Bergmann if ((cmd->lsa & 0xf) != (cmd->ea &0xf)) { 1400a33a7d73SArnd Bergmann pr_debug("invalid DMA alignment, ea %lx lsa %x\n", 1401a33a7d73SArnd Bergmann cmd->ea, cmd->lsa); 1402a33a7d73SArnd Bergmann return -EIO; 1403a33a7d73SArnd Bergmann } 1404a33a7d73SArnd Bergmann 1405a33a7d73SArnd Bergmann switch (cmd->size & 0xf) { 1406a33a7d73SArnd Bergmann case 1: 1407a33a7d73SArnd Bergmann break; 1408a33a7d73SArnd Bergmann case 2: 1409a33a7d73SArnd Bergmann if (cmd->lsa & 1) 1410a33a7d73SArnd Bergmann goto error; 1411a33a7d73SArnd Bergmann break; 1412a33a7d73SArnd Bergmann case 4: 1413a33a7d73SArnd Bergmann if (cmd->lsa & 3) 1414a33a7d73SArnd Bergmann goto error; 1415a33a7d73SArnd Bergmann break; 1416a33a7d73SArnd Bergmann case 8: 1417a33a7d73SArnd Bergmann if (cmd->lsa & 7) 1418a33a7d73SArnd Bergmann goto error; 1419a33a7d73SArnd Bergmann break; 1420a33a7d73SArnd Bergmann case 0: 1421a33a7d73SArnd Bergmann if (cmd->lsa & 15) 1422a33a7d73SArnd Bergmann goto error; 1423a33a7d73SArnd Bergmann break; 1424a33a7d73SArnd Bergmann error: 1425a33a7d73SArnd Bergmann default: 1426a33a7d73SArnd Bergmann pr_debug("invalid DMA alignment %x for size %x\n", 1427a33a7d73SArnd Bergmann cmd->lsa & 0xf, cmd->size); 1428a33a7d73SArnd Bergmann return -EIO; 1429a33a7d73SArnd Bergmann } 1430a33a7d73SArnd Bergmann 1431a33a7d73SArnd Bergmann if (cmd->size > 16 * 1024) { 1432a33a7d73SArnd Bergmann pr_debug("invalid DMA size %x\n", cmd->size); 1433a33a7d73SArnd Bergmann return -EIO; 1434a33a7d73SArnd Bergmann } 1435a33a7d73SArnd Bergmann 1436a33a7d73SArnd Bergmann if (cmd->tag & 0xfff0) { 1437a33a7d73SArnd Bergmann /* we reserve the higher tag numbers for kernel use */ 1438a33a7d73SArnd Bergmann pr_debug("invalid DMA tag\n"); 1439a33a7d73SArnd Bergmann return -EIO; 1440a33a7d73SArnd Bergmann } 1441a33a7d73SArnd Bergmann 1442a33a7d73SArnd Bergmann if (cmd->class) { 1443a33a7d73SArnd Bergmann /* not supported in this version */ 1444a33a7d73SArnd Bergmann pr_debug("invalid DMA class\n"); 1445a33a7d73SArnd Bergmann return -EIO; 1446a33a7d73SArnd Bergmann } 1447a33a7d73SArnd Bergmann 1448a33a7d73SArnd Bergmann return 0; 1449a33a7d73SArnd Bergmann } 1450a33a7d73SArnd Bergmann 1451a33a7d73SArnd Bergmann static int spu_send_mfc_command(struct spu_context *ctx, 1452a33a7d73SArnd Bergmann struct mfc_dma_command cmd, 1453a33a7d73SArnd Bergmann int *error) 1454a33a7d73SArnd Bergmann { 1455a33a7d73SArnd Bergmann *error = ctx->ops->send_mfc_command(ctx, &cmd); 1456a33a7d73SArnd Bergmann if (*error == -EAGAIN) { 1457a33a7d73SArnd Bergmann /* wait for any tag group to complete 1458a33a7d73SArnd Bergmann so we have space for the new command */ 1459a33a7d73SArnd Bergmann ctx->ops->set_mfc_query(ctx, ctx->tagwait, 1); 1460a33a7d73SArnd Bergmann /* try again, because the queue might be 1461a33a7d73SArnd Bergmann empty again */ 1462a33a7d73SArnd Bergmann *error = ctx->ops->send_mfc_command(ctx, &cmd); 1463a33a7d73SArnd Bergmann if (*error == -EAGAIN) 1464a33a7d73SArnd Bergmann return 0; 1465a33a7d73SArnd Bergmann } 1466a33a7d73SArnd Bergmann return 1; 1467a33a7d73SArnd Bergmann } 1468a33a7d73SArnd Bergmann 1469a33a7d73SArnd Bergmann static ssize_t spufs_mfc_write(struct file *file, const char __user *buffer, 1470a33a7d73SArnd Bergmann size_t size, loff_t *pos) 1471a33a7d73SArnd Bergmann { 1472a33a7d73SArnd Bergmann struct spu_context *ctx = file->private_data; 1473a33a7d73SArnd Bergmann struct mfc_dma_command cmd; 1474a33a7d73SArnd Bergmann int ret = -EINVAL; 1475a33a7d73SArnd Bergmann 1476a33a7d73SArnd Bergmann if (size != sizeof cmd) 1477a33a7d73SArnd Bergmann goto out; 1478a33a7d73SArnd Bergmann 1479a33a7d73SArnd Bergmann ret = -EFAULT; 1480a33a7d73SArnd Bergmann if (copy_from_user(&cmd, buffer, sizeof cmd)) 1481a33a7d73SArnd Bergmann goto out; 1482a33a7d73SArnd Bergmann 1483a33a7d73SArnd Bergmann ret = spufs_check_valid_dma(&cmd); 1484a33a7d73SArnd Bergmann if (ret) 1485a33a7d73SArnd Bergmann goto out; 1486a33a7d73SArnd Bergmann 1487577f8f10SAkinobu Mita ret = spu_acquire_runnable(ctx, 0); 1488577f8f10SAkinobu Mita if (ret) 1489577f8f10SAkinobu Mita goto out; 1490577f8f10SAkinobu Mita 1491a33a7d73SArnd Bergmann if (file->f_flags & O_NONBLOCK) { 1492a33a7d73SArnd Bergmann ret = ctx->ops->send_mfc_command(ctx, &cmd); 1493a33a7d73SArnd Bergmann } else { 1494a33a7d73SArnd Bergmann int status; 1495a33a7d73SArnd Bergmann ret = spufs_wait(ctx->mfc_wq, 1496a33a7d73SArnd Bergmann spu_send_mfc_command(ctx, cmd, &status)); 1497a33a7d73SArnd Bergmann if (status) 1498a33a7d73SArnd Bergmann ret = status; 1499a33a7d73SArnd Bergmann } 1500a33a7d73SArnd Bergmann spu_release(ctx); 1501a33a7d73SArnd Bergmann 1502a33a7d73SArnd Bergmann if (ret) 1503a33a7d73SArnd Bergmann goto out; 1504a33a7d73SArnd Bergmann 1505a33a7d73SArnd Bergmann ctx->tagwait |= 1 << cmd.tag; 15063692dc66SMasato Noguchi ret = size; 1507a33a7d73SArnd Bergmann 1508a33a7d73SArnd Bergmann out: 1509a33a7d73SArnd Bergmann return ret; 1510a33a7d73SArnd Bergmann } 1511a33a7d73SArnd Bergmann 1512a33a7d73SArnd Bergmann static unsigned int spufs_mfc_poll(struct file *file,poll_table *wait) 1513a33a7d73SArnd Bergmann { 1514a33a7d73SArnd Bergmann struct spu_context *ctx = file->private_data; 1515a33a7d73SArnd Bergmann u32 free_elements, tagstatus; 1516a33a7d73SArnd Bergmann unsigned int mask; 1517a33a7d73SArnd Bergmann 1518a33a7d73SArnd Bergmann spu_acquire(ctx); 1519a33a7d73SArnd Bergmann ctx->ops->set_mfc_query(ctx, ctx->tagwait, 2); 1520a33a7d73SArnd Bergmann free_elements = ctx->ops->get_mfc_free_elements(ctx); 1521a33a7d73SArnd Bergmann tagstatus = ctx->ops->read_mfc_tagstatus(ctx); 1522a33a7d73SArnd Bergmann spu_release(ctx); 1523a33a7d73SArnd Bergmann 1524a33a7d73SArnd Bergmann poll_wait(file, &ctx->mfc_wq, wait); 1525a33a7d73SArnd Bergmann 1526a33a7d73SArnd Bergmann mask = 0; 1527a33a7d73SArnd Bergmann if (free_elements & 0xffff) 1528a33a7d73SArnd Bergmann mask |= POLLOUT | POLLWRNORM; 1529a33a7d73SArnd Bergmann if (tagstatus & ctx->tagwait) 1530a33a7d73SArnd Bergmann mask |= POLLIN | POLLRDNORM; 1531a33a7d73SArnd Bergmann 1532a33a7d73SArnd Bergmann pr_debug("%s: free %d tagstatus %d tagwait %d\n", __FUNCTION__, 1533a33a7d73SArnd Bergmann free_elements, tagstatus, ctx->tagwait); 1534a33a7d73SArnd Bergmann 1535a33a7d73SArnd Bergmann return mask; 1536a33a7d73SArnd Bergmann } 1537a33a7d73SArnd Bergmann 153873b6af8aSAl Viro static int spufs_mfc_flush(struct file *file, fl_owner_t id) 1539a33a7d73SArnd Bergmann { 1540a33a7d73SArnd Bergmann struct spu_context *ctx = file->private_data; 1541a33a7d73SArnd Bergmann int ret; 1542a33a7d73SArnd Bergmann 1543a33a7d73SArnd Bergmann spu_acquire(ctx); 1544a33a7d73SArnd Bergmann #if 0 1545a33a7d73SArnd Bergmann /* this currently hangs */ 1546a33a7d73SArnd Bergmann ret = spufs_wait(ctx->mfc_wq, 1547a33a7d73SArnd Bergmann ctx->ops->set_mfc_query(ctx, ctx->tagwait, 2)); 1548a33a7d73SArnd Bergmann if (ret) 1549a33a7d73SArnd Bergmann goto out; 1550a33a7d73SArnd Bergmann ret = spufs_wait(ctx->mfc_wq, 1551a33a7d73SArnd Bergmann ctx->ops->read_mfc_tagstatus(ctx) == ctx->tagwait); 1552a33a7d73SArnd Bergmann out: 1553a33a7d73SArnd Bergmann #else 1554a33a7d73SArnd Bergmann ret = 0; 1555a33a7d73SArnd Bergmann #endif 1556a33a7d73SArnd Bergmann spu_release(ctx); 1557a33a7d73SArnd Bergmann 1558a33a7d73SArnd Bergmann return ret; 1559a33a7d73SArnd Bergmann } 1560a33a7d73SArnd Bergmann 1561a33a7d73SArnd Bergmann static int spufs_mfc_fsync(struct file *file, struct dentry *dentry, 1562a33a7d73SArnd Bergmann int datasync) 1563a33a7d73SArnd Bergmann { 156473b6af8aSAl Viro return spufs_mfc_flush(file, NULL); 1565a33a7d73SArnd Bergmann } 1566a33a7d73SArnd Bergmann 1567a33a7d73SArnd Bergmann static int spufs_mfc_fasync(int fd, struct file *file, int on) 1568a33a7d73SArnd Bergmann { 1569a33a7d73SArnd Bergmann struct spu_context *ctx = file->private_data; 1570a33a7d73SArnd Bergmann 1571a33a7d73SArnd Bergmann return fasync_helper(fd, file, on, &ctx->mfc_fasync); 1572a33a7d73SArnd Bergmann } 1573a33a7d73SArnd Bergmann 15745dfe4c96SArjan van de Ven static const struct file_operations spufs_mfc_fops = { 1575a33a7d73SArnd Bergmann .open = spufs_mfc_open, 157643c2bbd9SChristoph Hellwig .release = spufs_mfc_release, 1577a33a7d73SArnd Bergmann .read = spufs_mfc_read, 1578a33a7d73SArnd Bergmann .write = spufs_mfc_write, 1579a33a7d73SArnd Bergmann .poll = spufs_mfc_poll, 1580a33a7d73SArnd Bergmann .flush = spufs_mfc_flush, 1581a33a7d73SArnd Bergmann .fsync = spufs_mfc_fsync, 1582a33a7d73SArnd Bergmann .fasync = spufs_mfc_fasync, 15836df10a82SMark Nutter .mmap = spufs_mfc_mmap, 1584a33a7d73SArnd Bergmann }; 1585a33a7d73SArnd Bergmann 158667207b96SArnd Bergmann static void spufs_npc_set(void *data, u64 val) 158767207b96SArnd Bergmann { 158867207b96SArnd Bergmann struct spu_context *ctx = data; 15898b3d6663SArnd Bergmann spu_acquire(ctx); 15908b3d6663SArnd Bergmann ctx->ops->npc_write(ctx, val); 15918b3d6663SArnd Bergmann spu_release(ctx); 159267207b96SArnd Bergmann } 159367207b96SArnd Bergmann 159467207b96SArnd Bergmann static u64 spufs_npc_get(void *data) 159567207b96SArnd Bergmann { 159667207b96SArnd Bergmann struct spu_context *ctx = data; 159767207b96SArnd Bergmann u64 ret; 15988b3d6663SArnd Bergmann spu_acquire(ctx); 15998b3d6663SArnd Bergmann ret = ctx->ops->npc_read(ctx); 16008b3d6663SArnd Bergmann spu_release(ctx); 160167207b96SArnd Bergmann return ret; 160267207b96SArnd Bergmann } 16039b5047e2SDwayne Grant McConnell DEFINE_SIMPLE_ATTRIBUTE(spufs_npc_ops, spufs_npc_get, spufs_npc_set, 16049b5047e2SDwayne Grant McConnell "0x%llx\n") 160567207b96SArnd Bergmann 16068b3d6663SArnd Bergmann static void spufs_decr_set(void *data, u64 val) 16078b3d6663SArnd Bergmann { 16088b3d6663SArnd Bergmann struct spu_context *ctx = data; 16098b3d6663SArnd Bergmann struct spu_lscsa *lscsa = ctx->csa.lscsa; 16108b3d6663SArnd Bergmann spu_acquire_saved(ctx); 16118b3d6663SArnd Bergmann lscsa->decr.slot[0] = (u32) val; 16128b3d6663SArnd Bergmann spu_release(ctx); 16138b3d6663SArnd Bergmann } 16148b3d6663SArnd Bergmann 1615bf1ab978SDwayne Grant McConnell static u64 __spufs_decr_get(void *data) 16168b3d6663SArnd Bergmann { 16178b3d6663SArnd Bergmann struct spu_context *ctx = data; 16188b3d6663SArnd Bergmann struct spu_lscsa *lscsa = ctx->csa.lscsa; 1619bf1ab978SDwayne Grant McConnell return lscsa->decr.slot[0]; 1620bf1ab978SDwayne Grant McConnell } 1621bf1ab978SDwayne Grant McConnell 1622bf1ab978SDwayne Grant McConnell static u64 spufs_decr_get(void *data) 1623bf1ab978SDwayne Grant McConnell { 1624bf1ab978SDwayne Grant McConnell struct spu_context *ctx = data; 16258b3d6663SArnd Bergmann u64 ret; 16268b3d6663SArnd Bergmann spu_acquire_saved(ctx); 1627bf1ab978SDwayne Grant McConnell ret = __spufs_decr_get(data); 16288b3d6663SArnd Bergmann spu_release(ctx); 16298b3d6663SArnd Bergmann return ret; 16308b3d6663SArnd Bergmann } 16318b3d6663SArnd Bergmann DEFINE_SIMPLE_ATTRIBUTE(spufs_decr_ops, spufs_decr_get, spufs_decr_set, 16329b5047e2SDwayne Grant McConnell "0x%llx\n") 16338b3d6663SArnd Bergmann 16348b3d6663SArnd Bergmann static void spufs_decr_status_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_status.slot[0] = (u32) val; 16408b3d6663SArnd Bergmann spu_release(ctx); 16418b3d6663SArnd Bergmann } 16428b3d6663SArnd Bergmann 1643bf1ab978SDwayne Grant McConnell static u64 __spufs_decr_status_get(void *data) 16448b3d6663SArnd Bergmann { 16458b3d6663SArnd Bergmann struct spu_context *ctx = data; 16468b3d6663SArnd Bergmann struct spu_lscsa *lscsa = ctx->csa.lscsa; 1647bf1ab978SDwayne Grant McConnell return lscsa->decr_status.slot[0]; 1648bf1ab978SDwayne Grant McConnell } 1649bf1ab978SDwayne Grant McConnell 1650bf1ab978SDwayne Grant McConnell static u64 spufs_decr_status_get(void *data) 1651bf1ab978SDwayne Grant McConnell { 1652bf1ab978SDwayne Grant McConnell struct spu_context *ctx = data; 16538b3d6663SArnd Bergmann u64 ret; 16548b3d6663SArnd Bergmann spu_acquire_saved(ctx); 1655bf1ab978SDwayne Grant McConnell ret = __spufs_decr_status_get(data); 16568b3d6663SArnd Bergmann spu_release(ctx); 16578b3d6663SArnd Bergmann return ret; 16588b3d6663SArnd Bergmann } 16598b3d6663SArnd Bergmann DEFINE_SIMPLE_ATTRIBUTE(spufs_decr_status_ops, spufs_decr_status_get, 16609b5047e2SDwayne Grant McConnell spufs_decr_status_set, "0x%llx\n") 16618b3d6663SArnd Bergmann 16628b3d6663SArnd Bergmann static void spufs_event_mask_set(void *data, u64 val) 16638b3d6663SArnd Bergmann { 16648b3d6663SArnd Bergmann struct spu_context *ctx = data; 16658b3d6663SArnd Bergmann struct spu_lscsa *lscsa = ctx->csa.lscsa; 16668b3d6663SArnd Bergmann spu_acquire_saved(ctx); 16678b3d6663SArnd Bergmann lscsa->event_mask.slot[0] = (u32) val; 16688b3d6663SArnd Bergmann spu_release(ctx); 16698b3d6663SArnd Bergmann } 16708b3d6663SArnd Bergmann 1671bf1ab978SDwayne Grant McConnell static u64 __spufs_event_mask_get(void *data) 16728b3d6663SArnd Bergmann { 16738b3d6663SArnd Bergmann struct spu_context *ctx = data; 16748b3d6663SArnd Bergmann struct spu_lscsa *lscsa = ctx->csa.lscsa; 1675bf1ab978SDwayne Grant McConnell return lscsa->event_mask.slot[0]; 1676bf1ab978SDwayne Grant McConnell } 1677bf1ab978SDwayne Grant McConnell 1678bf1ab978SDwayne Grant McConnell static u64 spufs_event_mask_get(void *data) 1679bf1ab978SDwayne Grant McConnell { 1680bf1ab978SDwayne Grant McConnell struct spu_context *ctx = data; 16818b3d6663SArnd Bergmann u64 ret; 16828b3d6663SArnd Bergmann spu_acquire_saved(ctx); 1683bf1ab978SDwayne Grant McConnell ret = __spufs_event_mask_get(data); 16848b3d6663SArnd Bergmann spu_release(ctx); 16858b3d6663SArnd Bergmann return ret; 16868b3d6663SArnd Bergmann } 16878b3d6663SArnd Bergmann DEFINE_SIMPLE_ATTRIBUTE(spufs_event_mask_ops, spufs_event_mask_get, 16889b5047e2SDwayne Grant McConnell spufs_event_mask_set, "0x%llx\n") 16898b3d6663SArnd Bergmann 1690bf1ab978SDwayne Grant McConnell static u64 __spufs_event_status_get(void *data) 1691b9e3bd77SDwayne Grant McConnell { 1692b9e3bd77SDwayne Grant McConnell struct spu_context *ctx = data; 1693b9e3bd77SDwayne Grant McConnell struct spu_state *state = &ctx->csa; 1694b9e3bd77SDwayne Grant McConnell u64 stat; 1695b9e3bd77SDwayne Grant McConnell stat = state->spu_chnlcnt_RW[0]; 1696b9e3bd77SDwayne Grant McConnell if (stat) 1697bf1ab978SDwayne Grant McConnell return state->spu_chnldata_RW[0]; 1698bf1ab978SDwayne Grant McConnell return 0; 1699bf1ab978SDwayne Grant McConnell } 1700bf1ab978SDwayne Grant McConnell 1701bf1ab978SDwayne Grant McConnell static u64 spufs_event_status_get(void *data) 1702bf1ab978SDwayne Grant McConnell { 1703bf1ab978SDwayne Grant McConnell struct spu_context *ctx = data; 1704bf1ab978SDwayne Grant McConnell u64 ret = 0; 1705bf1ab978SDwayne Grant McConnell 1706bf1ab978SDwayne Grant McConnell spu_acquire_saved(ctx); 1707bf1ab978SDwayne Grant McConnell ret = __spufs_event_status_get(data); 1708b9e3bd77SDwayne Grant McConnell spu_release(ctx); 1709b9e3bd77SDwayne Grant McConnell return ret; 1710b9e3bd77SDwayne Grant McConnell } 1711b9e3bd77SDwayne Grant McConnell DEFINE_SIMPLE_ATTRIBUTE(spufs_event_status_ops, spufs_event_status_get, 1712b9e3bd77SDwayne Grant McConnell NULL, "0x%llx\n") 1713b9e3bd77SDwayne Grant McConnell 17148b3d6663SArnd Bergmann static void spufs_srr0_set(void *data, u64 val) 17158b3d6663SArnd Bergmann { 17168b3d6663SArnd Bergmann struct spu_context *ctx = data; 17178b3d6663SArnd Bergmann struct spu_lscsa *lscsa = ctx->csa.lscsa; 17188b3d6663SArnd Bergmann spu_acquire_saved(ctx); 17198b3d6663SArnd Bergmann lscsa->srr0.slot[0] = (u32) val; 17208b3d6663SArnd Bergmann spu_release(ctx); 17218b3d6663SArnd Bergmann } 17228b3d6663SArnd Bergmann 17238b3d6663SArnd Bergmann static u64 spufs_srr0_get(void *data) 17248b3d6663SArnd Bergmann { 17258b3d6663SArnd Bergmann struct spu_context *ctx = data; 17268b3d6663SArnd Bergmann struct spu_lscsa *lscsa = ctx->csa.lscsa; 17278b3d6663SArnd Bergmann u64 ret; 17288b3d6663SArnd Bergmann spu_acquire_saved(ctx); 17298b3d6663SArnd Bergmann ret = lscsa->srr0.slot[0]; 17308b3d6663SArnd Bergmann spu_release(ctx); 17318b3d6663SArnd Bergmann return ret; 17328b3d6663SArnd Bergmann } 17338b3d6663SArnd Bergmann DEFINE_SIMPLE_ATTRIBUTE(spufs_srr0_ops, spufs_srr0_get, spufs_srr0_set, 17349b5047e2SDwayne Grant McConnell "0x%llx\n") 17358b3d6663SArnd Bergmann 17367b1a7014Sarnd@arndb.de static u64 spufs_id_get(void *data) 17377b1a7014Sarnd@arndb.de { 17387b1a7014Sarnd@arndb.de struct spu_context *ctx = data; 17397b1a7014Sarnd@arndb.de u64 num; 17407b1a7014Sarnd@arndb.de 17417b1a7014Sarnd@arndb.de spu_acquire(ctx); 17427b1a7014Sarnd@arndb.de if (ctx->state == SPU_STATE_RUNNABLE) 17437b1a7014Sarnd@arndb.de num = ctx->spu->number; 17447b1a7014Sarnd@arndb.de else 17457b1a7014Sarnd@arndb.de num = (unsigned int)-1; 17467b1a7014Sarnd@arndb.de spu_release(ctx); 17477b1a7014Sarnd@arndb.de 17487b1a7014Sarnd@arndb.de return num; 17497b1a7014Sarnd@arndb.de } 1750e45d6634SAl Viro DEFINE_SIMPLE_ATTRIBUTE(spufs_id_ops, spufs_id_get, NULL, "0x%llx\n") 17517b1a7014Sarnd@arndb.de 1752bf1ab978SDwayne Grant McConnell static u64 __spufs_object_id_get(void *data) 175386767277SArnd Bergmann { 175486767277SArnd Bergmann struct spu_context *ctx = data; 175586767277SArnd Bergmann return ctx->object_id; 175686767277SArnd Bergmann } 175786767277SArnd Bergmann 1758bf1ab978SDwayne Grant McConnell static u64 spufs_object_id_get(void *data) 1759bf1ab978SDwayne Grant McConnell { 1760bf1ab978SDwayne Grant McConnell /* FIXME: Should there really be no locking here? */ 1761bf1ab978SDwayne Grant McConnell return __spufs_object_id_get(data); 1762bf1ab978SDwayne Grant McConnell } 1763bf1ab978SDwayne Grant McConnell 176486767277SArnd Bergmann static void spufs_object_id_set(void *data, u64 id) 176586767277SArnd Bergmann { 176686767277SArnd Bergmann struct spu_context *ctx = data; 176786767277SArnd Bergmann ctx->object_id = id; 176886767277SArnd Bergmann } 176986767277SArnd Bergmann 177086767277SArnd Bergmann DEFINE_SIMPLE_ATTRIBUTE(spufs_object_id_ops, spufs_object_id_get, 177186767277SArnd Bergmann spufs_object_id_set, "0x%llx\n"); 177286767277SArnd Bergmann 1773bf1ab978SDwayne Grant McConnell static u64 __spufs_lslr_get(void *data) 1774bf1ab978SDwayne Grant McConnell { 1775bf1ab978SDwayne Grant McConnell struct spu_context *ctx = data; 1776bf1ab978SDwayne Grant McConnell return ctx->csa.priv2.spu_lslr_RW; 1777bf1ab978SDwayne Grant McConnell } 1778bf1ab978SDwayne Grant McConnell 1779b9e3bd77SDwayne Grant McConnell static u64 spufs_lslr_get(void *data) 1780b9e3bd77SDwayne Grant McConnell { 1781b9e3bd77SDwayne Grant McConnell struct spu_context *ctx = data; 1782b9e3bd77SDwayne Grant McConnell u64 ret; 1783b9e3bd77SDwayne Grant McConnell 1784b9e3bd77SDwayne Grant McConnell spu_acquire_saved(ctx); 1785bf1ab978SDwayne Grant McConnell ret = __spufs_lslr_get(data); 1786b9e3bd77SDwayne Grant McConnell spu_release(ctx); 1787b9e3bd77SDwayne Grant McConnell 1788b9e3bd77SDwayne Grant McConnell return ret; 1789b9e3bd77SDwayne Grant McConnell } 1790b9e3bd77SDwayne Grant McConnell DEFINE_SIMPLE_ATTRIBUTE(spufs_lslr_ops, spufs_lslr_get, NULL, "0x%llx\n") 1791b9e3bd77SDwayne Grant McConnell 1792b9e3bd77SDwayne Grant McConnell static int spufs_info_open(struct inode *inode, struct file *file) 1793b9e3bd77SDwayne Grant McConnell { 1794b9e3bd77SDwayne Grant McConnell struct spufs_inode_info *i = SPUFS_I(inode); 1795b9e3bd77SDwayne Grant McConnell struct spu_context *ctx = i->i_ctx; 1796b9e3bd77SDwayne Grant McConnell file->private_data = ctx; 1797b9e3bd77SDwayne Grant McConnell return 0; 1798b9e3bd77SDwayne Grant McConnell } 1799b9e3bd77SDwayne Grant McConnell 1800bf1ab978SDwayne Grant McConnell static ssize_t __spufs_mbox_info_read(struct spu_context *ctx, 1801bf1ab978SDwayne Grant McConnell char __user *buf, size_t len, loff_t *pos) 1802bf1ab978SDwayne Grant McConnell { 1803bf1ab978SDwayne Grant McConnell u32 mbox_stat; 1804bf1ab978SDwayne Grant McConnell u32 data; 1805bf1ab978SDwayne Grant McConnell 1806bf1ab978SDwayne Grant McConnell mbox_stat = ctx->csa.prob.mb_stat_R; 1807bf1ab978SDwayne Grant McConnell if (mbox_stat & 0x0000ff) { 1808bf1ab978SDwayne Grant McConnell data = ctx->csa.prob.pu_mb_R; 1809bf1ab978SDwayne Grant McConnell } 1810bf1ab978SDwayne Grant McConnell 1811bf1ab978SDwayne Grant McConnell return simple_read_from_buffer(buf, len, pos, &data, sizeof data); 1812bf1ab978SDwayne Grant McConnell } 1813bf1ab978SDwayne Grant McConnell 181469a2f00cSDwayne Grant McConnell static ssize_t spufs_mbox_info_read(struct file *file, char __user *buf, 181569a2f00cSDwayne Grant McConnell size_t len, loff_t *pos) 181669a2f00cSDwayne Grant McConnell { 1817bf1ab978SDwayne Grant McConnell int ret; 181869a2f00cSDwayne Grant McConnell struct spu_context *ctx = file->private_data; 181969a2f00cSDwayne Grant McConnell 182069a2f00cSDwayne Grant McConnell if (!access_ok(VERIFY_WRITE, buf, len)) 182169a2f00cSDwayne Grant McConnell return -EFAULT; 182269a2f00cSDwayne Grant McConnell 182369a2f00cSDwayne Grant McConnell spu_acquire_saved(ctx); 182469a2f00cSDwayne Grant McConnell spin_lock(&ctx->csa.register_lock); 1825bf1ab978SDwayne Grant McConnell ret = __spufs_mbox_info_read(ctx, buf, len, pos); 182669a2f00cSDwayne Grant McConnell spin_unlock(&ctx->csa.register_lock); 182769a2f00cSDwayne Grant McConnell spu_release(ctx); 182869a2f00cSDwayne Grant McConnell 1829bf1ab978SDwayne Grant McConnell return ret; 183069a2f00cSDwayne Grant McConnell } 183169a2f00cSDwayne Grant McConnell 18325dfe4c96SArjan van de Ven static const struct file_operations spufs_mbox_info_fops = { 183369a2f00cSDwayne Grant McConnell .open = spufs_info_open, 183469a2f00cSDwayne Grant McConnell .read = spufs_mbox_info_read, 183569a2f00cSDwayne Grant McConnell .llseek = generic_file_llseek, 183669a2f00cSDwayne Grant McConnell }; 183769a2f00cSDwayne Grant McConnell 1838bf1ab978SDwayne Grant McConnell static ssize_t __spufs_ibox_info_read(struct spu_context *ctx, 1839bf1ab978SDwayne Grant McConnell char __user *buf, size_t len, loff_t *pos) 1840bf1ab978SDwayne Grant McConnell { 1841bf1ab978SDwayne Grant McConnell u32 ibox_stat; 1842bf1ab978SDwayne Grant McConnell u32 data; 1843bf1ab978SDwayne Grant McConnell 1844bf1ab978SDwayne Grant McConnell ibox_stat = ctx->csa.prob.mb_stat_R; 1845bf1ab978SDwayne Grant McConnell if (ibox_stat & 0xff0000) { 1846bf1ab978SDwayne Grant McConnell data = ctx->csa.priv2.puint_mb_R; 1847bf1ab978SDwayne Grant McConnell } 1848bf1ab978SDwayne Grant McConnell 1849bf1ab978SDwayne Grant McConnell return simple_read_from_buffer(buf, len, pos, &data, sizeof data); 1850bf1ab978SDwayne Grant McConnell } 1851bf1ab978SDwayne Grant McConnell 185269a2f00cSDwayne Grant McConnell static ssize_t spufs_ibox_info_read(struct file *file, char __user *buf, 185369a2f00cSDwayne Grant McConnell size_t len, loff_t *pos) 185469a2f00cSDwayne Grant McConnell { 185569a2f00cSDwayne Grant McConnell struct spu_context *ctx = file->private_data; 1856bf1ab978SDwayne Grant McConnell int ret; 185769a2f00cSDwayne Grant McConnell 185869a2f00cSDwayne Grant McConnell if (!access_ok(VERIFY_WRITE, buf, len)) 185969a2f00cSDwayne Grant McConnell return -EFAULT; 186069a2f00cSDwayne Grant McConnell 186169a2f00cSDwayne Grant McConnell spu_acquire_saved(ctx); 186269a2f00cSDwayne Grant McConnell spin_lock(&ctx->csa.register_lock); 1863bf1ab978SDwayne Grant McConnell ret = __spufs_ibox_info_read(ctx, buf, len, pos); 186469a2f00cSDwayne Grant McConnell spin_unlock(&ctx->csa.register_lock); 186569a2f00cSDwayne Grant McConnell spu_release(ctx); 186669a2f00cSDwayne Grant McConnell 1867bf1ab978SDwayne Grant McConnell return ret; 186869a2f00cSDwayne Grant McConnell } 186969a2f00cSDwayne Grant McConnell 18705dfe4c96SArjan van de Ven static const struct file_operations spufs_ibox_info_fops = { 187169a2f00cSDwayne Grant McConnell .open = spufs_info_open, 187269a2f00cSDwayne Grant McConnell .read = spufs_ibox_info_read, 187369a2f00cSDwayne Grant McConnell .llseek = generic_file_llseek, 187469a2f00cSDwayne Grant McConnell }; 187569a2f00cSDwayne Grant McConnell 1876bf1ab978SDwayne Grant McConnell static ssize_t __spufs_wbox_info_read(struct spu_context *ctx, 1877bf1ab978SDwayne Grant McConnell char __user *buf, size_t len, loff_t *pos) 1878bf1ab978SDwayne Grant McConnell { 1879bf1ab978SDwayne Grant McConnell int i, cnt; 1880bf1ab978SDwayne Grant McConnell u32 data[4]; 1881bf1ab978SDwayne Grant McConnell u32 wbox_stat; 1882bf1ab978SDwayne Grant McConnell 1883bf1ab978SDwayne Grant McConnell wbox_stat = ctx->csa.prob.mb_stat_R; 1884bf1ab978SDwayne Grant McConnell cnt = 4 - ((wbox_stat & 0x00ff00) >> 8); 1885bf1ab978SDwayne Grant McConnell for (i = 0; i < cnt; i++) { 1886bf1ab978SDwayne Grant McConnell data[i] = ctx->csa.spu_mailbox_data[i]; 1887bf1ab978SDwayne Grant McConnell } 1888bf1ab978SDwayne Grant McConnell 1889bf1ab978SDwayne Grant McConnell return simple_read_from_buffer(buf, len, pos, &data, 1890bf1ab978SDwayne Grant McConnell cnt * sizeof(u32)); 1891bf1ab978SDwayne Grant McConnell } 1892bf1ab978SDwayne Grant McConnell 189369a2f00cSDwayne Grant McConnell static ssize_t spufs_wbox_info_read(struct file *file, char __user *buf, 189469a2f00cSDwayne Grant McConnell size_t len, loff_t *pos) 189569a2f00cSDwayne Grant McConnell { 189669a2f00cSDwayne Grant McConnell struct spu_context *ctx = file->private_data; 1897bf1ab978SDwayne Grant McConnell int ret; 189869a2f00cSDwayne Grant McConnell 189969a2f00cSDwayne Grant McConnell if (!access_ok(VERIFY_WRITE, buf, len)) 190069a2f00cSDwayne Grant McConnell return -EFAULT; 190169a2f00cSDwayne Grant McConnell 190269a2f00cSDwayne Grant McConnell spu_acquire_saved(ctx); 190369a2f00cSDwayne Grant McConnell spin_lock(&ctx->csa.register_lock); 1904bf1ab978SDwayne Grant McConnell ret = __spufs_wbox_info_read(ctx, buf, len, pos); 190569a2f00cSDwayne Grant McConnell spin_unlock(&ctx->csa.register_lock); 190669a2f00cSDwayne Grant McConnell spu_release(ctx); 190769a2f00cSDwayne Grant McConnell 1908bf1ab978SDwayne Grant McConnell return ret; 190969a2f00cSDwayne Grant McConnell } 191069a2f00cSDwayne Grant McConnell 19115dfe4c96SArjan van de Ven static const struct file_operations spufs_wbox_info_fops = { 191269a2f00cSDwayne Grant McConnell .open = spufs_info_open, 191369a2f00cSDwayne Grant McConnell .read = spufs_wbox_info_read, 191469a2f00cSDwayne Grant McConnell .llseek = generic_file_llseek, 191569a2f00cSDwayne Grant McConnell }; 191669a2f00cSDwayne Grant McConnell 1917bf1ab978SDwayne Grant McConnell static ssize_t __spufs_dma_info_read(struct spu_context *ctx, 1918bf1ab978SDwayne Grant McConnell char __user *buf, size_t len, loff_t *pos) 1919b9e3bd77SDwayne Grant McConnell { 1920b9e3bd77SDwayne Grant McConnell struct spu_dma_info info; 1921b9e3bd77SDwayne Grant McConnell struct mfc_cq_sr *qp, *spuqp; 1922b9e3bd77SDwayne Grant McConnell int i; 1923b9e3bd77SDwayne Grant McConnell 1924b9e3bd77SDwayne Grant McConnell info.dma_info_type = ctx->csa.priv2.spu_tag_status_query_RW; 1925b9e3bd77SDwayne Grant McConnell info.dma_info_mask = ctx->csa.lscsa->tag_mask.slot[0]; 1926b9e3bd77SDwayne Grant McConnell info.dma_info_status = ctx->csa.spu_chnldata_RW[24]; 1927b9e3bd77SDwayne Grant McConnell info.dma_info_stall_and_notify = ctx->csa.spu_chnldata_RW[25]; 1928b9e3bd77SDwayne Grant McConnell info.dma_info_atomic_command_status = ctx->csa.spu_chnldata_RW[27]; 1929b9e3bd77SDwayne Grant McConnell for (i = 0; i < 16; i++) { 1930b9e3bd77SDwayne Grant McConnell qp = &info.dma_info_command_data[i]; 1931b9e3bd77SDwayne Grant McConnell spuqp = &ctx->csa.priv2.spuq[i]; 1932b9e3bd77SDwayne Grant McConnell 1933b9e3bd77SDwayne Grant McConnell qp->mfc_cq_data0_RW = spuqp->mfc_cq_data0_RW; 1934b9e3bd77SDwayne Grant McConnell qp->mfc_cq_data1_RW = spuqp->mfc_cq_data1_RW; 1935b9e3bd77SDwayne Grant McConnell qp->mfc_cq_data2_RW = spuqp->mfc_cq_data2_RW; 1936b9e3bd77SDwayne Grant McConnell qp->mfc_cq_data3_RW = spuqp->mfc_cq_data3_RW; 1937b9e3bd77SDwayne Grant McConnell } 1938b9e3bd77SDwayne Grant McConnell 1939b9e3bd77SDwayne Grant McConnell return simple_read_from_buffer(buf, len, pos, &info, 1940b9e3bd77SDwayne Grant McConnell sizeof info); 1941b9e3bd77SDwayne Grant McConnell } 1942b9e3bd77SDwayne Grant McConnell 1943bf1ab978SDwayne Grant McConnell static ssize_t spufs_dma_info_read(struct file *file, char __user *buf, 1944bf1ab978SDwayne Grant McConnell size_t len, loff_t *pos) 1945bf1ab978SDwayne Grant McConnell { 1946bf1ab978SDwayne Grant McConnell struct spu_context *ctx = file->private_data; 1947bf1ab978SDwayne Grant McConnell int ret; 1948bf1ab978SDwayne Grant McConnell 1949bf1ab978SDwayne Grant McConnell if (!access_ok(VERIFY_WRITE, buf, len)) 1950bf1ab978SDwayne Grant McConnell return -EFAULT; 1951bf1ab978SDwayne Grant McConnell 1952bf1ab978SDwayne Grant McConnell spu_acquire_saved(ctx); 1953bf1ab978SDwayne Grant McConnell spin_lock(&ctx->csa.register_lock); 1954bf1ab978SDwayne Grant McConnell ret = __spufs_dma_info_read(ctx, buf, len, pos); 1955bf1ab978SDwayne Grant McConnell spin_unlock(&ctx->csa.register_lock); 1956bf1ab978SDwayne Grant McConnell spu_release(ctx); 1957bf1ab978SDwayne Grant McConnell 1958bf1ab978SDwayne Grant McConnell return ret; 1959bf1ab978SDwayne Grant McConnell } 1960bf1ab978SDwayne Grant McConnell 19615dfe4c96SArjan van de Ven static const struct file_operations spufs_dma_info_fops = { 1962b9e3bd77SDwayne Grant McConnell .open = spufs_info_open, 1963b9e3bd77SDwayne Grant McConnell .read = spufs_dma_info_read, 1964b9e3bd77SDwayne Grant McConnell }; 1965b9e3bd77SDwayne Grant McConnell 1966bf1ab978SDwayne Grant McConnell static ssize_t __spufs_proxydma_info_read(struct spu_context *ctx, 1967bf1ab978SDwayne Grant McConnell char __user *buf, size_t len, loff_t *pos) 1968b9e3bd77SDwayne Grant McConnell { 1969b9e3bd77SDwayne Grant McConnell struct spu_proxydma_info info; 1970b9e3bd77SDwayne Grant McConnell struct mfc_cq_sr *qp, *puqp; 1971bf1ab978SDwayne Grant McConnell int ret = sizeof info; 1972b9e3bd77SDwayne Grant McConnell int i; 1973b9e3bd77SDwayne Grant McConnell 1974b9e3bd77SDwayne Grant McConnell if (len < ret) 1975b9e3bd77SDwayne Grant McConnell return -EINVAL; 1976b9e3bd77SDwayne Grant McConnell 1977b9e3bd77SDwayne Grant McConnell if (!access_ok(VERIFY_WRITE, buf, len)) 1978b9e3bd77SDwayne Grant McConnell return -EFAULT; 1979b9e3bd77SDwayne Grant McConnell 1980b9e3bd77SDwayne Grant McConnell info.proxydma_info_type = ctx->csa.prob.dma_querytype_RW; 1981b9e3bd77SDwayne Grant McConnell info.proxydma_info_mask = ctx->csa.prob.dma_querymask_RW; 1982b9e3bd77SDwayne Grant McConnell info.proxydma_info_status = ctx->csa.prob.dma_tagstatus_R; 1983b9e3bd77SDwayne Grant McConnell for (i = 0; i < 8; i++) { 1984b9e3bd77SDwayne Grant McConnell qp = &info.proxydma_info_command_data[i]; 1985b9e3bd77SDwayne Grant McConnell puqp = &ctx->csa.priv2.puq[i]; 1986b9e3bd77SDwayne Grant McConnell 1987b9e3bd77SDwayne Grant McConnell qp->mfc_cq_data0_RW = puqp->mfc_cq_data0_RW; 1988b9e3bd77SDwayne Grant McConnell qp->mfc_cq_data1_RW = puqp->mfc_cq_data1_RW; 1989b9e3bd77SDwayne Grant McConnell qp->mfc_cq_data2_RW = puqp->mfc_cq_data2_RW; 1990b9e3bd77SDwayne Grant McConnell qp->mfc_cq_data3_RW = puqp->mfc_cq_data3_RW; 1991b9e3bd77SDwayne Grant McConnell } 1992bf1ab978SDwayne Grant McConnell 1993bf1ab978SDwayne Grant McConnell return simple_read_from_buffer(buf, len, pos, &info, 1994bf1ab978SDwayne Grant McConnell sizeof info); 1995bf1ab978SDwayne Grant McConnell } 1996bf1ab978SDwayne Grant McConnell 1997bf1ab978SDwayne Grant McConnell static ssize_t spufs_proxydma_info_read(struct file *file, char __user *buf, 1998bf1ab978SDwayne Grant McConnell size_t len, loff_t *pos) 1999bf1ab978SDwayne Grant McConnell { 2000bf1ab978SDwayne Grant McConnell struct spu_context *ctx = file->private_data; 2001bf1ab978SDwayne Grant McConnell int ret; 2002bf1ab978SDwayne Grant McConnell 2003bf1ab978SDwayne Grant McConnell spu_acquire_saved(ctx); 2004bf1ab978SDwayne Grant McConnell spin_lock(&ctx->csa.register_lock); 2005bf1ab978SDwayne Grant McConnell ret = __spufs_proxydma_info_read(ctx, buf, len, pos); 2006b9e3bd77SDwayne Grant McConnell spin_unlock(&ctx->csa.register_lock); 2007b9e3bd77SDwayne Grant McConnell spu_release(ctx); 2008b9e3bd77SDwayne Grant McConnell 2009b9e3bd77SDwayne Grant McConnell return ret; 2010b9e3bd77SDwayne Grant McConnell } 2011b9e3bd77SDwayne Grant McConnell 20125dfe4c96SArjan van de Ven static const struct file_operations spufs_proxydma_info_fops = { 2013b9e3bd77SDwayne Grant McConnell .open = spufs_info_open, 2014b9e3bd77SDwayne Grant McConnell .read = spufs_proxydma_info_read, 2015b9e3bd77SDwayne Grant McConnell }; 2016b9e3bd77SDwayne Grant McConnell 201767207b96SArnd Bergmann struct tree_descr spufs_dir_contents[] = { 201867207b96SArnd Bergmann { "mem", &spufs_mem_fops, 0666, }, 20198b3d6663SArnd Bergmann { "regs", &spufs_regs_fops, 0666, }, 202067207b96SArnd Bergmann { "mbox", &spufs_mbox_fops, 0444, }, 202167207b96SArnd Bergmann { "ibox", &spufs_ibox_fops, 0444, }, 202267207b96SArnd Bergmann { "wbox", &spufs_wbox_fops, 0222, }, 202367207b96SArnd Bergmann { "mbox_stat", &spufs_mbox_stat_fops, 0444, }, 202467207b96SArnd Bergmann { "ibox_stat", &spufs_ibox_stat_fops, 0444, }, 202567207b96SArnd Bergmann { "wbox_stat", &spufs_wbox_stat_fops, 0444, }, 202667207b96SArnd Bergmann { "signal1", &spufs_signal1_fops, 0666, }, 202767207b96SArnd Bergmann { "signal2", &spufs_signal2_fops, 0666, }, 202867207b96SArnd Bergmann { "signal1_type", &spufs_signal1_type, 0666, }, 202967207b96SArnd Bergmann { "signal2_type", &spufs_signal2_type, 0666, }, 20306df10a82SMark Nutter { "cntl", &spufs_cntl_fops, 0666, }, 20318b3d6663SArnd Bergmann { "fpcr", &spufs_fpcr_fops, 0666, }, 2032b9e3bd77SDwayne Grant McConnell { "lslr", &spufs_lslr_ops, 0444, }, 2033b9e3bd77SDwayne Grant McConnell { "mfc", &spufs_mfc_fops, 0666, }, 2034b9e3bd77SDwayne Grant McConnell { "mss", &spufs_mss_fops, 0666, }, 2035b9e3bd77SDwayne Grant McConnell { "npc", &spufs_npc_ops, 0666, }, 2036b9e3bd77SDwayne Grant McConnell { "srr0", &spufs_srr0_ops, 0666, }, 20378b3d6663SArnd Bergmann { "decr", &spufs_decr_ops, 0666, }, 20388b3d6663SArnd Bergmann { "decr_status", &spufs_decr_status_ops, 0666, }, 20398b3d6663SArnd Bergmann { "event_mask", &spufs_event_mask_ops, 0666, }, 2040b9e3bd77SDwayne Grant McConnell { "event_status", &spufs_event_status_ops, 0444, }, 204127d5bf2aSBenjamin Herrenschmidt { "psmap", &spufs_psmap_fops, 0666, }, 204286767277SArnd Bergmann { "phys-id", &spufs_id_ops, 0666, }, 204386767277SArnd Bergmann { "object-id", &spufs_object_id_ops, 0666, }, 204469a2f00cSDwayne Grant McConnell { "mbox_info", &spufs_mbox_info_fops, 0444, }, 204569a2f00cSDwayne Grant McConnell { "ibox_info", &spufs_ibox_info_fops, 0444, }, 204669a2f00cSDwayne Grant McConnell { "wbox_info", &spufs_wbox_info_fops, 0444, }, 2047b9e3bd77SDwayne Grant McConnell { "dma_info", &spufs_dma_info_fops, 0444, }, 2048b9e3bd77SDwayne Grant McConnell { "proxydma_info", &spufs_proxydma_info_fops, 0444, }, 204967207b96SArnd Bergmann {}, 205067207b96SArnd Bergmann }; 20515737edd1SMark Nutter 20525737edd1SMark Nutter struct tree_descr spufs_dir_nosched_contents[] = { 20535737edd1SMark Nutter { "mem", &spufs_mem_fops, 0666, }, 20545737edd1SMark Nutter { "mbox", &spufs_mbox_fops, 0444, }, 20555737edd1SMark Nutter { "ibox", &spufs_ibox_fops, 0444, }, 20565737edd1SMark Nutter { "wbox", &spufs_wbox_fops, 0222, }, 20575737edd1SMark Nutter { "mbox_stat", &spufs_mbox_stat_fops, 0444, }, 20585737edd1SMark Nutter { "ibox_stat", &spufs_ibox_stat_fops, 0444, }, 20595737edd1SMark Nutter { "wbox_stat", &spufs_wbox_stat_fops, 0444, }, 20605737edd1SMark Nutter { "signal1", &spufs_signal1_fops, 0666, }, 20615737edd1SMark Nutter { "signal2", &spufs_signal2_fops, 0666, }, 20625737edd1SMark Nutter { "signal1_type", &spufs_signal1_type, 0666, }, 20635737edd1SMark Nutter { "signal2_type", &spufs_signal2_type, 0666, }, 20645737edd1SMark Nutter { "mss", &spufs_mss_fops, 0666, }, 20655737edd1SMark Nutter { "mfc", &spufs_mfc_fops, 0666, }, 20665737edd1SMark Nutter { "cntl", &spufs_cntl_fops, 0666, }, 20675737edd1SMark Nutter { "npc", &spufs_npc_ops, 0666, }, 20685737edd1SMark Nutter { "psmap", &spufs_psmap_fops, 0666, }, 20695737edd1SMark Nutter { "phys-id", &spufs_id_ops, 0666, }, 20705737edd1SMark Nutter { "object-id", &spufs_object_id_ops, 0666, }, 20715737edd1SMark Nutter {}, 20725737edd1SMark Nutter }; 2073bf1ab978SDwayne Grant McConnell 2074bf1ab978SDwayne Grant McConnell struct spufs_coredump_reader spufs_coredump_read[] = { 2075bf1ab978SDwayne Grant McConnell { "regs", __spufs_regs_read, NULL, 128 * 16 }, 2076bf1ab978SDwayne Grant McConnell { "fpcr", __spufs_fpcr_read, NULL, 16 }, 2077bf1ab978SDwayne Grant McConnell { "lslr", NULL, __spufs_lslr_get, 11 }, 2078bf1ab978SDwayne Grant McConnell { "decr", NULL, __spufs_decr_get, 11 }, 2079bf1ab978SDwayne Grant McConnell { "decr_status", NULL, __spufs_decr_status_get, 11 }, 2080bf1ab978SDwayne Grant McConnell { "mem", __spufs_mem_read, NULL, 256 * 1024, }, 2081bf1ab978SDwayne Grant McConnell { "signal1", __spufs_signal1_read, NULL, 4 }, 2082bf1ab978SDwayne Grant McConnell { "signal1_type", NULL, __spufs_signal1_type_get, 2 }, 2083bf1ab978SDwayne Grant McConnell { "signal2", __spufs_signal2_read, NULL, 4 }, 2084bf1ab978SDwayne Grant McConnell { "signal2_type", NULL, __spufs_signal2_type_get, 2 }, 2085bf1ab978SDwayne Grant McConnell { "event_mask", NULL, __spufs_event_mask_get, 8 }, 2086bf1ab978SDwayne Grant McConnell { "event_status", NULL, __spufs_event_status_get, 8 }, 2087bf1ab978SDwayne Grant McConnell { "mbox_info", __spufs_mbox_info_read, NULL, 4 }, 2088bf1ab978SDwayne Grant McConnell { "ibox_info", __spufs_ibox_info_read, NULL, 4 }, 2089bf1ab978SDwayne Grant McConnell { "wbox_info", __spufs_wbox_info_read, NULL, 16 }, 2090bf1ab978SDwayne Grant McConnell { "dma_info", __spufs_dma_info_read, NULL, 69 * 8 }, 2091bf1ab978SDwayne Grant McConnell { "proxydma_info", __spufs_proxydma_info_read, NULL, 35 * 8 }, 2092bf1ab978SDwayne Grant McConnell { "object-id", NULL, __spufs_object_id_get, 19 }, 2093bf1ab978SDwayne Grant McConnell { }, 2094bf1ab978SDwayne Grant McConnell }; 2095bf1ab978SDwayne Grant McConnell int spufs_coredump_num_notes = ARRAY_SIZE(spufs_coredump_read) - 1; 2096bf1ab978SDwayne Grant McConnell 2097