blob: c2814ea96af2599c0ab32a080bbf06a0e50d948f [file] [log] [blame]
Arnd Bergmann67207b92005-11-15 15:53:48 -05001/*
2 * SPU file system -- file contents
3 *
4 * (C) Copyright IBM Deutschland Entwicklung GmbH 2005
5 *
6 * Author: Arnd Bergmann <arndb@de.ibm.com>
7 *
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2, or (at your option)
11 * any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 */
22
Arnd Bergmanna33a7d72006-03-23 00:00:11 +010023#undef DEBUG
24
Arnd Bergmann67207b92005-11-15 15:53:48 -050025#include <linux/fs.h>
26#include <linux/ioctl.h>
27#include <linux/module.h>
Arnd Bergmannd88cfff2005-12-05 22:52:22 -050028#include <linux/pagemap.h>
Arnd Bergmann67207b92005-11-15 15:53:48 -050029#include <linux/poll.h>
Arnd Bergmann51104592005-12-05 22:52:25 -050030#include <linux/ptrace.h>
Benjamin Herrenschmidtcbe709c2007-06-04 15:15:38 +100031#include <linux/seq_file.h>
Arnd Bergmann67207b92005-11-15 15:53:48 -050032
33#include <asm/io.h>
34#include <asm/semaphore.h>
35#include <asm/spu.h>
Dwayne Grant McConnellb9e3bd72006-11-20 18:44:58 +010036#include <asm/spu_info.h>
Arnd Bergmann67207b92005-11-15 15:53:48 -050037#include <asm/uaccess.h>
38
39#include "spufs.h"
40
Benjamin Herrenschmidt27d5bf22006-10-04 17:26:11 +020041#define SPUFS_MMAP_4K (PAGE_SIZE == 0x1000)
42
Benjamin Herrenschmidtcbe709c2007-06-04 15:15:38 +100043
Arnd Bergmann67207b92005-11-15 15:53:48 -050044static int
45spufs_mem_open(struct inode *inode, struct file *file)
46{
47 struct spufs_inode_info *i = SPUFS_I(inode);
Mark Nutter6df10a82006-03-23 00:00:12 +010048 struct spu_context *ctx = i->i_ctx;
Christoph Hellwig43c2bbd2007-04-23 21:08:07 +020049
Christoph Hellwig47d3a5f2007-06-04 23:26:51 +100050 mutex_lock(&ctx->mapping_lock);
Mark Nutter6df10a82006-03-23 00:00:12 +010051 file->private_data = ctx;
Christoph Hellwig43c2bbd2007-04-23 21:08:07 +020052 if (!i->i_openers++)
53 ctx->local_store = inode->i_mapping;
Christoph Hellwig47d3a5f2007-06-04 23:26:51 +100054 mutex_unlock(&ctx->mapping_lock);
Christoph Hellwig43c2bbd2007-04-23 21:08:07 +020055 return 0;
56}
57
58static int
59spufs_mem_release(struct inode *inode, struct file *file)
60{
61 struct spufs_inode_info *i = SPUFS_I(inode);
62 struct spu_context *ctx = i->i_ctx;
63
Christoph Hellwig47d3a5f2007-06-04 23:26:51 +100064 mutex_lock(&ctx->mapping_lock);
Christoph Hellwig43c2bbd2007-04-23 21:08:07 +020065 if (!--i->i_openers)
66 ctx->local_store = NULL;
Christoph Hellwig47d3a5f2007-06-04 23:26:51 +100067 mutex_unlock(&ctx->mapping_lock);
Arnd Bergmann67207b92005-11-15 15:53:48 -050068 return 0;
69}
70
71static ssize_t
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +010072__spufs_mem_read(struct spu_context *ctx, char __user *buffer,
73 size_t size, loff_t *pos)
74{
75 char *local_store = ctx->ops->get_ls(ctx);
76 return simple_read_from_buffer(buffer, size, pos, local_store,
77 LS_SIZE);
78}
79
80static ssize_t
Arnd Bergmann67207b92005-11-15 15:53:48 -050081spufs_mem_read(struct file *file, char __user *buffer,
82 size_t size, loff_t *pos)
83{
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +010084 struct spu_context *ctx = file->private_data;
Arnd Bergmannaa0ed2b2007-03-10 00:05:35 +010085 ssize_t ret;
Arnd Bergmann67207b92005-11-15 15:53:48 -050086
Arnd Bergmann8b3d6662005-11-15 15:53:52 -050087 spu_acquire(ctx);
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +010088 ret = __spufs_mem_read(ctx, buffer, size, pos);
Arnd Bergmann8b3d6662005-11-15 15:53:52 -050089 spu_release(ctx);
Arnd Bergmann67207b92005-11-15 15:53:48 -050090 return ret;
91}
92
93static ssize_t
94spufs_mem_write(struct file *file, const char __user *buffer,
Arnd Bergmannaa0ed2b2007-03-10 00:05:35 +010095 size_t size, loff_t *ppos)
Arnd Bergmann67207b92005-11-15 15:53:48 -050096{
97 struct spu_context *ctx = file->private_data;
Arnd Bergmann8b3d6662005-11-15 15:53:52 -050098 char *local_store;
Arnd Bergmannaa0ed2b2007-03-10 00:05:35 +010099 loff_t pos = *ppos;
Arnd Bergmann8b3d6662005-11-15 15:53:52 -0500100 int ret;
Arnd Bergmann67207b92005-11-15 15:53:48 -0500101
Arnd Bergmannaa0ed2b2007-03-10 00:05:35 +0100102 if (pos < 0)
103 return -EINVAL;
104 if (pos > LS_SIZE)
Arnd Bergmann67207b92005-11-15 15:53:48 -0500105 return -EFBIG;
Arnd Bergmannaa0ed2b2007-03-10 00:05:35 +0100106 if (size > LS_SIZE - pos)
107 size = LS_SIZE - pos;
Arnd Bergmann8b3d6662005-11-15 15:53:52 -0500108
109 spu_acquire(ctx);
Arnd Bergmann8b3d6662005-11-15 15:53:52 -0500110 local_store = ctx->ops->get_ls(ctx);
Arnd Bergmannaa0ed2b2007-03-10 00:05:35 +0100111 ret = copy_from_user(local_store + pos, buffer, size);
Arnd Bergmann8b3d6662005-11-15 15:53:52 -0500112 spu_release(ctx);
Arnd Bergmannaa0ed2b2007-03-10 00:05:35 +0100113
114 if (ret)
115 return -EFAULT;
116 *ppos = pos + size;
117 return size;
Arnd Bergmann67207b92005-11-15 15:53:48 -0500118}
119
Benjamin Herrenschmidt78bde532007-02-13 11:46:06 +1100120static unsigned long spufs_mem_mmap_nopfn(struct vm_area_struct *vma,
121 unsigned long address)
Arnd Bergmann8b3d6662005-11-15 15:53:52 -0500122{
Benjamin Herrenschmidtf1fa74f2007-05-08 16:27:29 +1000123 struct spu_context *ctx = vma->vm_file->private_data;
124 unsigned long pfn, offset, addr0 = address;
125#ifdef CONFIG_SPU_FS_64K_LS
126 struct spu_state *csa = &ctx->csa;
127 int psize;
Benjamin Herrenschmidt78bde532007-02-13 11:46:06 +1100128
Benjamin Herrenschmidtf1fa74f2007-05-08 16:27:29 +1000129 /* Check what page size we are using */
130 psize = get_slice_psize(vma->vm_mm, address);
Arnd Bergmann8b3d6662005-11-15 15:53:52 -0500131
Benjamin Herrenschmidtf1fa74f2007-05-08 16:27:29 +1000132 /* Some sanity checking */
133 BUG_ON(csa->use_big_pages != (psize == MMU_PAGE_64K));
134
135 /* Wow, 64K, cool, we need to align the address though */
136 if (csa->use_big_pages) {
137 BUG_ON(vma->vm_start & 0xffff);
138 address &= ~0xfffful;
139 }
140#endif /* CONFIG_SPU_FS_64K_LS */
141
142 offset = (address - vma->vm_start) + (vma->vm_pgoff << PAGE_SHIFT);
Masato Noguchi128b8542007-02-13 21:54:30 +0100143 if (offset >= LS_SIZE)
144 return NOPFN_SIGBUS;
145
Benjamin Herrenschmidtf1fa74f2007-05-08 16:27:29 +1000146 pr_debug("spufs_mem_mmap_nopfn address=0x%lx -> 0x%lx, offset=0x%lx\n",
147 addr0, address, offset);
148
Arnd Bergmann8b3d6662005-11-15 15:53:52 -0500149 spu_acquire(ctx);
150
Arnd Bergmannac91cb82006-10-04 17:26:16 +0200151 if (ctx->state == SPU_STATE_SAVED) {
152 vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot)
Arnd Bergmann932f5352006-11-20 18:45:06 +0100153 & ~_PAGE_NO_CACHE);
Benjamin Herrenschmidt78bde532007-02-13 11:46:06 +1100154 pfn = vmalloc_to_pfn(ctx->csa.lscsa->ls + offset);
Arnd Bergmannac91cb82006-10-04 17:26:16 +0200155 } else {
156 vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot)
Benjamin Herrenschmidt78bde532007-02-13 11:46:06 +1100157 | _PAGE_NO_CACHE);
158 pfn = (ctx->spu->local_store_phys + offset) >> PAGE_SHIFT;
Arnd Bergmannac91cb82006-10-04 17:26:16 +0200159 }
Benjamin Herrenschmidt78bde532007-02-13 11:46:06 +1100160 vm_insert_pfn(vma, address, pfn);
161
Arnd Bergmann8b3d6662005-11-15 15:53:52 -0500162 spu_release(ctx);
163
Benjamin Herrenschmidt78bde532007-02-13 11:46:06 +1100164 return NOPFN_REFAULT;
Arnd Bergmann8b3d6662005-11-15 15:53:52 -0500165}
166
Benjamin Herrenschmidt78bde532007-02-13 11:46:06 +1100167
Arnd Bergmann8b3d6662005-11-15 15:53:52 -0500168static struct vm_operations_struct spufs_mem_mmap_vmops = {
Benjamin Herrenschmidt78bde532007-02-13 11:46:06 +1100169 .nopfn = spufs_mem_mmap_nopfn,
Arnd Bergmann8b3d6662005-11-15 15:53:52 -0500170};
171
Benjamin Herrenschmidtf1fa74f2007-05-08 16:27:29 +1000172static int spufs_mem_mmap(struct file *file, struct vm_area_struct *vma)
Arnd Bergmann67207b92005-11-15 15:53:48 -0500173{
Benjamin Herrenschmidtf1fa74f2007-05-08 16:27:29 +1000174#ifdef CONFIG_SPU_FS_64K_LS
175 struct spu_context *ctx = file->private_data;
176 struct spu_state *csa = &ctx->csa;
177
178 /* Sanity check VMA alignment */
179 if (csa->use_big_pages) {
180 pr_debug("spufs_mem_mmap 64K, start=0x%lx, end=0x%lx,"
181 " pgoff=0x%lx\n", vma->vm_start, vma->vm_end,
182 vma->vm_pgoff);
183 if (vma->vm_start & 0xffff)
184 return -EINVAL;
185 if (vma->vm_pgoff & 0xf)
186 return -EINVAL;
187 }
188#endif /* CONFIG_SPU_FS_64K_LS */
189
Arnd Bergmann8b3d6662005-11-15 15:53:52 -0500190 if (!(vma->vm_flags & VM_SHARED))
191 return -EINVAL;
Arnd Bergmann67207b92005-11-15 15:53:48 -0500192
Benjamin Herrenschmidt78bde532007-02-13 11:46:06 +1100193 vma->vm_flags |= VM_IO | VM_PFNMAP;
Arnd Bergmann8b3d6662005-11-15 15:53:52 -0500194 vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot)
195 | _PAGE_NO_CACHE);
196
197 vma->vm_ops = &spufs_mem_mmap_vmops;
Arnd Bergmann67207b92005-11-15 15:53:48 -0500198 return 0;
199}
200
Benjamin Herrenschmidtf1fa74f2007-05-08 16:27:29 +1000201#ifdef CONFIG_SPU_FS_64K_LS
202unsigned long spufs_get_unmapped_area(struct file *file, unsigned long addr,
203 unsigned long len, unsigned long pgoff,
204 unsigned long flags)
205{
206 struct spu_context *ctx = file->private_data;
207 struct spu_state *csa = &ctx->csa;
208
209 /* If not using big pages, fallback to normal MM g_u_a */
210 if (!csa->use_big_pages)
211 return current->mm->get_unmapped_area(file, addr, len,
212 pgoff, flags);
213
214 /* Else, try to obtain a 64K pages slice */
215 return slice_get_unmapped_area(addr, len, flags,
216 MMU_PAGE_64K, 1, 0);
217}
218#endif /* CONFIG_SPU_FS_64K_LS */
219
Arjan van de Ven5dfe4c92007-02-12 00:55:31 -0800220static const struct file_operations spufs_mem_fops = {
Jeremy Kerr70225432007-06-29 10:58:00 +1000221 .open = spufs_mem_open,
222 .release = spufs_mem_release,
223 .read = spufs_mem_read,
224 .write = spufs_mem_write,
225 .llseek = generic_file_llseek,
226 .mmap = spufs_mem_mmap,
Benjamin Herrenschmidtf1fa74f2007-05-08 16:27:29 +1000227#ifdef CONFIG_SPU_FS_64K_LS
228 .get_unmapped_area = spufs_get_unmapped_area,
229#endif
Arnd Bergmann8b3d6662005-11-15 15:53:52 -0500230};
231
Benjamin Herrenschmidt78bde532007-02-13 11:46:06 +1100232static unsigned long spufs_ps_nopfn(struct vm_area_struct *vma,
Mark Nutter6df10a82006-03-23 00:00:12 +0100233 unsigned long address,
Benjamin Herrenschmidt78bde532007-02-13 11:46:06 +1100234 unsigned long ps_offs,
Benjamin Herrenschmidt27d5bf22006-10-04 17:26:11 +0200235 unsigned long ps_size)
Mark Nutter6df10a82006-03-23 00:00:12 +0100236{
Mark Nutter6df10a82006-03-23 00:00:12 +0100237 struct spu_context *ctx = vma->vm_file->private_data;
Benjamin Herrenschmidt78bde532007-02-13 11:46:06 +1100238 unsigned long area, offset = address - vma->vm_start;
Mark Nutter6df10a82006-03-23 00:00:12 +0100239 int ret;
240
241 offset += vma->vm_pgoff << PAGE_SHIFT;
Benjamin Herrenschmidt27d5bf22006-10-04 17:26:11 +0200242 if (offset >= ps_size)
Benjamin Herrenschmidt78bde532007-02-13 11:46:06 +1100243 return NOPFN_SIGBUS;
Mark Nutter6df10a82006-03-23 00:00:12 +0100244
Benjamin Herrenschmidt78bde532007-02-13 11:46:06 +1100245 /* error here usually means a signal.. we might want to test
246 * the error code more precisely though
247 */
Christoph Hellwig26bec672007-02-13 21:54:24 +0100248 ret = spu_acquire_runnable(ctx, 0);
Mark Nutter6df10a82006-03-23 00:00:12 +0100249 if (ret)
Benjamin Herrenschmidt78bde532007-02-13 11:46:06 +1100250 return NOPFN_REFAULT;
Mark Nutter6df10a82006-03-23 00:00:12 +0100251
252 area = ctx->spu->problem_phys + ps_offs;
Benjamin Herrenschmidt78bde532007-02-13 11:46:06 +1100253 vm_insert_pfn(vma, address, (area + offset) >> PAGE_SHIFT);
Mark Nutter6df10a82006-03-23 00:00:12 +0100254 spu_release(ctx);
255
Benjamin Herrenschmidt78bde532007-02-13 11:46:06 +1100256 return NOPFN_REFAULT;
Mark Nutter6df10a82006-03-23 00:00:12 +0100257}
258
Benjamin Herrenschmidt27d5bf22006-10-04 17:26:11 +0200259#if SPUFS_MMAP_4K
Benjamin Herrenschmidt78bde532007-02-13 11:46:06 +1100260static unsigned long spufs_cntl_mmap_nopfn(struct vm_area_struct *vma,
261 unsigned long address)
Mark Nutter6df10a82006-03-23 00:00:12 +0100262{
Benjamin Herrenschmidt78bde532007-02-13 11:46:06 +1100263 return spufs_ps_nopfn(vma, address, 0x4000, 0x1000);
Mark Nutter6df10a82006-03-23 00:00:12 +0100264}
265
266static struct vm_operations_struct spufs_cntl_mmap_vmops = {
Benjamin Herrenschmidt78bde532007-02-13 11:46:06 +1100267 .nopfn = spufs_cntl_mmap_nopfn,
Mark Nutter6df10a82006-03-23 00:00:12 +0100268};
269
270/*
271 * mmap support for problem state control area [0x4000 - 0x4fff].
Mark Nutter6df10a82006-03-23 00:00:12 +0100272 */
273static int spufs_cntl_mmap(struct file *file, struct vm_area_struct *vma)
274{
275 if (!(vma->vm_flags & VM_SHARED))
276 return -EINVAL;
277
Benjamin Herrenschmidt78bde532007-02-13 11:46:06 +1100278 vma->vm_flags |= VM_IO | VM_PFNMAP;
Mark Nutter6df10a82006-03-23 00:00:12 +0100279 vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot)
Benjamin Herrenschmidt23cc7702006-06-23 20:57:47 +0200280 | _PAGE_NO_CACHE | _PAGE_GUARDED);
Mark Nutter6df10a82006-03-23 00:00:12 +0100281
282 vma->vm_ops = &spufs_cntl_mmap_vmops;
283 return 0;
284}
Benjamin Herrenschmidt27d5bf22006-10-04 17:26:11 +0200285#else /* SPUFS_MMAP_4K */
286#define spufs_cntl_mmap NULL
287#endif /* !SPUFS_MMAP_4K */
Mark Nutter6df10a82006-03-23 00:00:12 +0100288
Arnd Bergmanne1dbff22006-10-04 17:26:19 +0200289static u64 spufs_cntl_get(void *data)
290{
291 struct spu_context *ctx = data;
292 u64 val;
293
294 spu_acquire(ctx);
295 val = ctx->ops->status_read(ctx);
296 spu_release(ctx);
297
298 return val;
299}
300
301static void spufs_cntl_set(void *data, u64 val)
302{
303 struct spu_context *ctx = data;
304
305 spu_acquire(ctx);
306 ctx->ops->runcntl_write(ctx, val);
307 spu_release(ctx);
308}
309
Mark Nutter6df10a82006-03-23 00:00:12 +0100310static int spufs_cntl_open(struct inode *inode, struct file *file)
311{
312 struct spufs_inode_info *i = SPUFS_I(inode);
313 struct spu_context *ctx = i->i_ctx;
314
Christoph Hellwig47d3a5f2007-06-04 23:26:51 +1000315 mutex_lock(&ctx->mapping_lock);
Mark Nutter6df10a82006-03-23 00:00:12 +0100316 file->private_data = ctx;
Christoph Hellwig43c2bbd2007-04-23 21:08:07 +0200317 if (!i->i_openers++)
318 ctx->cntl = inode->i_mapping;
Christoph Hellwig47d3a5f2007-06-04 23:26:51 +1000319 mutex_unlock(&ctx->mapping_lock);
Arnd Bergmanne1dbff22006-10-04 17:26:19 +0200320 return simple_attr_open(inode, file, spufs_cntl_get,
321 spufs_cntl_set, "0x%08lx");
Mark Nutter6df10a82006-03-23 00:00:12 +0100322}
323
Christoph Hellwig43c2bbd2007-04-23 21:08:07 +0200324static int
325spufs_cntl_release(struct inode *inode, struct file *file)
326{
327 struct spufs_inode_info *i = SPUFS_I(inode);
328 struct spu_context *ctx = i->i_ctx;
329
330 simple_attr_close(inode, file);
331
Christoph Hellwig47d3a5f2007-06-04 23:26:51 +1000332 mutex_lock(&ctx->mapping_lock);
Christoph Hellwig43c2bbd2007-04-23 21:08:07 +0200333 if (!--i->i_openers)
334 ctx->cntl = NULL;
Christoph Hellwig47d3a5f2007-06-04 23:26:51 +1000335 mutex_unlock(&ctx->mapping_lock);
Christoph Hellwig43c2bbd2007-04-23 21:08:07 +0200336 return 0;
337}
338
Arjan van de Ven5dfe4c92007-02-12 00:55:31 -0800339static const struct file_operations spufs_cntl_fops = {
Mark Nutter6df10a82006-03-23 00:00:12 +0100340 .open = spufs_cntl_open,
Christoph Hellwig43c2bbd2007-04-23 21:08:07 +0200341 .release = spufs_cntl_release,
Arnd Bergmanne1dbff22006-10-04 17:26:19 +0200342 .read = simple_attr_read,
343 .write = simple_attr_write,
Mark Nutter6df10a82006-03-23 00:00:12 +0100344 .mmap = spufs_cntl_mmap,
Mark Nutter6df10a82006-03-23 00:00:12 +0100345};
346
Arnd Bergmann8b3d6662005-11-15 15:53:52 -0500347static int
348spufs_regs_open(struct inode *inode, struct file *file)
349{
350 struct spufs_inode_info *i = SPUFS_I(inode);
351 file->private_data = i->i_ctx;
352 return 0;
353}
354
355static ssize_t
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +0100356__spufs_regs_read(struct spu_context *ctx, char __user *buffer,
357 size_t size, loff_t *pos)
358{
359 struct spu_lscsa *lscsa = ctx->csa.lscsa;
360 return simple_read_from_buffer(buffer, size, pos,
361 lscsa->gprs, sizeof lscsa->gprs);
362}
363
364static ssize_t
Arnd Bergmann8b3d6662005-11-15 15:53:52 -0500365spufs_regs_read(struct file *file, char __user *buffer,
366 size_t size, loff_t *pos)
367{
Arnd Bergmann8b3d6662005-11-15 15:53:52 -0500368 int ret;
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +0100369 struct spu_context *ctx = file->private_data;
Arnd Bergmann8b3d6662005-11-15 15:53:52 -0500370
371 spu_acquire_saved(ctx);
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +0100372 ret = __spufs_regs_read(ctx, buffer, size, pos);
Arnd Bergmann8b3d6662005-11-15 15:53:52 -0500373 spu_release(ctx);
374 return ret;
375}
376
377static ssize_t
378spufs_regs_write(struct file *file, const char __user *buffer,
379 size_t size, loff_t *pos)
380{
381 struct spu_context *ctx = file->private_data;
382 struct spu_lscsa *lscsa = ctx->csa.lscsa;
383 int ret;
384
385 size = min_t(ssize_t, sizeof lscsa->gprs - *pos, size);
386 if (size <= 0)
387 return -EFBIG;
388 *pos += size;
389
390 spu_acquire_saved(ctx);
391
392 ret = copy_from_user(lscsa->gprs + *pos - size,
393 buffer, size) ? -EFAULT : size;
394
395 spu_release(ctx);
396 return ret;
397}
398
Arjan van de Ven5dfe4c92007-02-12 00:55:31 -0800399static const struct file_operations spufs_regs_fops = {
Arnd Bergmann8b3d6662005-11-15 15:53:52 -0500400 .open = spufs_regs_open,
401 .read = spufs_regs_read,
402 .write = spufs_regs_write,
403 .llseek = generic_file_llseek,
404};
405
406static ssize_t
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +0100407__spufs_fpcr_read(struct spu_context *ctx, char __user * buffer,
408 size_t size, loff_t * pos)
409{
410 struct spu_lscsa *lscsa = ctx->csa.lscsa;
411 return simple_read_from_buffer(buffer, size, pos,
412 &lscsa->fpcr, sizeof(lscsa->fpcr));
413}
414
415static ssize_t
Arnd Bergmann8b3d6662005-11-15 15:53:52 -0500416spufs_fpcr_read(struct file *file, char __user * buffer,
417 size_t size, loff_t * pos)
418{
Arnd Bergmann8b3d6662005-11-15 15:53:52 -0500419 int ret;
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +0100420 struct spu_context *ctx = file->private_data;
Arnd Bergmann8b3d6662005-11-15 15:53:52 -0500421
422 spu_acquire_saved(ctx);
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +0100423 ret = __spufs_fpcr_read(ctx, buffer, size, pos);
Arnd Bergmann8b3d6662005-11-15 15:53:52 -0500424 spu_release(ctx);
425 return ret;
426}
427
428static ssize_t
429spufs_fpcr_write(struct file *file, const char __user * buffer,
430 size_t size, loff_t * pos)
431{
432 struct spu_context *ctx = file->private_data;
433 struct spu_lscsa *lscsa = ctx->csa.lscsa;
434 int ret;
435
436 size = min_t(ssize_t, sizeof(lscsa->fpcr) - *pos, size);
437 if (size <= 0)
438 return -EFBIG;
439 *pos += size;
440
441 spu_acquire_saved(ctx);
442
443 ret = copy_from_user((char *)&lscsa->fpcr + *pos - size,
444 buffer, size) ? -EFAULT : size;
445
446 spu_release(ctx);
447 return ret;
448}
449
Arjan van de Ven5dfe4c92007-02-12 00:55:31 -0800450static const struct file_operations spufs_fpcr_fops = {
Arnd Bergmann8b3d6662005-11-15 15:53:52 -0500451 .open = spufs_regs_open,
452 .read = spufs_fpcr_read,
453 .write = spufs_fpcr_write,
454 .llseek = generic_file_llseek,
Arnd Bergmann67207b92005-11-15 15:53:48 -0500455};
456
457/* generic open function for all pipe-like files */
458static int spufs_pipe_open(struct inode *inode, struct file *file)
459{
460 struct spufs_inode_info *i = SPUFS_I(inode);
461 file->private_data = i->i_ctx;
462
463 return nonseekable_open(inode, file);
464}
465
Arnd Bergmanncdcc89b2006-10-04 17:26:17 +0200466/*
467 * Read as many bytes from the mailbox as possible, until
468 * one of the conditions becomes true:
469 *
470 * - no more data available in the mailbox
471 * - end of the user provided buffer
472 * - end of the mapped area
473 */
Arnd Bergmann67207b92005-11-15 15:53:48 -0500474static ssize_t spufs_mbox_read(struct file *file, char __user *buf,
475 size_t len, loff_t *pos)
476{
Arnd Bergmann8b3d6662005-11-15 15:53:52 -0500477 struct spu_context *ctx = file->private_data;
Arnd Bergmanncdcc89b2006-10-04 17:26:17 +0200478 u32 mbox_data, __user *udata;
479 ssize_t count;
Arnd Bergmann67207b92005-11-15 15:53:48 -0500480
481 if (len < 4)
482 return -EINVAL;
483
Arnd Bergmanncdcc89b2006-10-04 17:26:17 +0200484 if (!access_ok(VERIFY_WRITE, buf, len))
Arnd Bergmann67207b92005-11-15 15:53:48 -0500485 return -EFAULT;
486
Arnd Bergmanncdcc89b2006-10-04 17:26:17 +0200487 udata = (void __user *)buf;
488
489 spu_acquire(ctx);
Arnd Bergmann274cef52006-10-24 18:01:42 +0200490 for (count = 0; (count + 4) <= len; count += 4, udata++) {
Arnd Bergmanncdcc89b2006-10-04 17:26:17 +0200491 int ret;
492 ret = ctx->ops->mbox_read(ctx, &mbox_data);
493 if (ret == 0)
494 break;
495
496 /*
497 * at the end of the mapped area, we can fault
498 * but still need to return the data we have
499 * read successfully so far.
500 */
501 ret = __put_user(mbox_data, udata);
502 if (ret) {
503 if (!count)
504 count = -EFAULT;
505 break;
506 }
507 }
508 spu_release(ctx);
509
510 if (!count)
511 count = -EAGAIN;
512
513 return count;
Arnd Bergmann67207b92005-11-15 15:53:48 -0500514}
515
Arjan van de Ven5dfe4c92007-02-12 00:55:31 -0800516static const struct file_operations spufs_mbox_fops = {
Arnd Bergmann67207b92005-11-15 15:53:48 -0500517 .open = spufs_pipe_open,
518 .read = spufs_mbox_read,
519};
520
521static ssize_t spufs_mbox_stat_read(struct file *file, char __user *buf,
522 size_t len, loff_t *pos)
523{
Arnd Bergmann8b3d6662005-11-15 15:53:52 -0500524 struct spu_context *ctx = file->private_data;
Arnd Bergmann67207b92005-11-15 15:53:48 -0500525 u32 mbox_stat;
526
527 if (len < 4)
528 return -EINVAL;
529
Arnd Bergmann8b3d6662005-11-15 15:53:52 -0500530 spu_acquire(ctx);
531
532 mbox_stat = ctx->ops->mbox_stat_read(ctx) & 0xff;
533
534 spu_release(ctx);
Arnd Bergmann67207b92005-11-15 15:53:48 -0500535
536 if (copy_to_user(buf, &mbox_stat, sizeof mbox_stat))
537 return -EFAULT;
538
539 return 4;
540}
541
Arjan van de Ven5dfe4c92007-02-12 00:55:31 -0800542static const struct file_operations spufs_mbox_stat_fops = {
Arnd Bergmann67207b92005-11-15 15:53:48 -0500543 .open = spufs_pipe_open,
544 .read = spufs_mbox_stat_read,
545};
546
547/* low-level ibox access function */
Arnd Bergmann8b3d6662005-11-15 15:53:52 -0500548size_t spu_ibox_read(struct spu_context *ctx, u32 *data)
Arnd Bergmann67207b92005-11-15 15:53:48 -0500549{
Arnd Bergmann8b3d6662005-11-15 15:53:52 -0500550 return ctx->ops->ibox_read(ctx, data);
Arnd Bergmann67207b92005-11-15 15:53:48 -0500551}
Arnd Bergmann67207b92005-11-15 15:53:48 -0500552
553static int spufs_ibox_fasync(int fd, struct file *file, int on)
554{
Arnd Bergmann8b3d6662005-11-15 15:53:52 -0500555 struct spu_context *ctx = file->private_data;
556
557 return fasync_helper(fd, file, on, &ctx->ibox_fasync);
558}
559
560/* interrupt-level ibox callback function. */
561void spufs_ibox_callback(struct spu *spu)
562{
563 struct spu_context *ctx = spu->ctx;
564
565 wake_up_all(&ctx->ibox_wq);
566 kill_fasync(&ctx->ibox_fasync, SIGIO, POLLIN);
Arnd Bergmann67207b92005-11-15 15:53:48 -0500567}
568
Arnd Bergmanncdcc89b2006-10-04 17:26:17 +0200569/*
570 * Read as many bytes from the interrupt mailbox as possible, until
571 * one of the conditions becomes true:
572 *
573 * - no more data available in the mailbox
574 * - end of the user provided buffer
575 * - end of the mapped area
576 *
577 * If the file is opened without O_NONBLOCK, we wait here until
578 * any data is available, but return when we have been able to
579 * read something.
580 */
Arnd Bergmann67207b92005-11-15 15:53:48 -0500581static ssize_t spufs_ibox_read(struct file *file, char __user *buf,
582 size_t len, loff_t *pos)
583{
Arnd Bergmann8b3d6662005-11-15 15:53:52 -0500584 struct spu_context *ctx = file->private_data;
Arnd Bergmanncdcc89b2006-10-04 17:26:17 +0200585 u32 ibox_data, __user *udata;
586 ssize_t count;
Arnd Bergmann67207b92005-11-15 15:53:48 -0500587
588 if (len < 4)
589 return -EINVAL;
590
Arnd Bergmanncdcc89b2006-10-04 17:26:17 +0200591 if (!access_ok(VERIFY_WRITE, buf, len))
592 return -EFAULT;
593
594 udata = (void __user *)buf;
595
Arnd Bergmann8b3d6662005-11-15 15:53:52 -0500596 spu_acquire(ctx);
Arnd Bergmann67207b92005-11-15 15:53:48 -0500597
Arnd Bergmanncdcc89b2006-10-04 17:26:17 +0200598 /* wait only for the first element */
599 count = 0;
Arnd Bergmann67207b92005-11-15 15:53:48 -0500600 if (file->f_flags & O_NONBLOCK) {
Arnd Bergmann8b3d6662005-11-15 15:53:52 -0500601 if (!spu_ibox_read(ctx, &ibox_data))
Arnd Bergmanncdcc89b2006-10-04 17:26:17 +0200602 count = -EAGAIN;
Arnd Bergmann67207b92005-11-15 15:53:48 -0500603 } else {
Arnd Bergmanncdcc89b2006-10-04 17:26:17 +0200604 count = spufs_wait(ctx->ibox_wq, spu_ibox_read(ctx, &ibox_data));
605 }
606 if (count)
607 goto out;
608
609 /* if we can't write at all, return -EFAULT */
610 count = __put_user(ibox_data, udata);
611 if (count)
612 goto out;
613
614 for (count = 4, udata++; (count + 4) <= len; count += 4, udata++) {
615 int ret;
616 ret = ctx->ops->ibox_read(ctx, &ibox_data);
617 if (ret == 0)
618 break;
619 /*
620 * at the end of the mapped area, we can fault
621 * but still need to return the data we have
622 * read successfully so far.
623 */
624 ret = __put_user(ibox_data, udata);
625 if (ret)
626 break;
Arnd Bergmann67207b92005-11-15 15:53:48 -0500627 }
628
Arnd Bergmanncdcc89b2006-10-04 17:26:17 +0200629out:
Arnd Bergmann8b3d6662005-11-15 15:53:52 -0500630 spu_release(ctx);
631
Arnd Bergmanncdcc89b2006-10-04 17:26:17 +0200632 return count;
Arnd Bergmann67207b92005-11-15 15:53:48 -0500633}
634
635static unsigned int spufs_ibox_poll(struct file *file, poll_table *wait)
636{
Arnd Bergmann8b3d6662005-11-15 15:53:52 -0500637 struct spu_context *ctx = file->private_data;
Arnd Bergmann67207b92005-11-15 15:53:48 -0500638 unsigned int mask;
639
Arnd Bergmann8b3d6662005-11-15 15:53:52 -0500640 poll_wait(file, &ctx->ibox_wq, wait);
Arnd Bergmann67207b92005-11-15 15:53:48 -0500641
Arnd Bergmann3a843d72005-12-05 22:52:27 -0500642 spu_acquire(ctx);
643 mask = ctx->ops->mbox_stat_poll(ctx, POLLIN | POLLRDNORM);
644 spu_release(ctx);
Arnd Bergmann67207b92005-11-15 15:53:48 -0500645
646 return mask;
647}
648
Arjan van de Ven5dfe4c92007-02-12 00:55:31 -0800649static const struct file_operations spufs_ibox_fops = {
Arnd Bergmann67207b92005-11-15 15:53:48 -0500650 .open = spufs_pipe_open,
651 .read = spufs_ibox_read,
652 .poll = spufs_ibox_poll,
653 .fasync = spufs_ibox_fasync,
654};
655
656static ssize_t spufs_ibox_stat_read(struct file *file, char __user *buf,
657 size_t len, loff_t *pos)
658{
Arnd Bergmann8b3d6662005-11-15 15:53:52 -0500659 struct spu_context *ctx = file->private_data;
Arnd Bergmann67207b92005-11-15 15:53:48 -0500660 u32 ibox_stat;
661
662 if (len < 4)
663 return -EINVAL;
664
Arnd Bergmann8b3d6662005-11-15 15:53:52 -0500665 spu_acquire(ctx);
666 ibox_stat = (ctx->ops->mbox_stat_read(ctx) >> 16) & 0xff;
667 spu_release(ctx);
Arnd Bergmann67207b92005-11-15 15:53:48 -0500668
669 if (copy_to_user(buf, &ibox_stat, sizeof ibox_stat))
670 return -EFAULT;
671
672 return 4;
673}
674
Arjan van de Ven5dfe4c92007-02-12 00:55:31 -0800675static const struct file_operations spufs_ibox_stat_fops = {
Arnd Bergmann67207b92005-11-15 15:53:48 -0500676 .open = spufs_pipe_open,
677 .read = spufs_ibox_stat_read,
678};
679
680/* low-level mailbox write */
Arnd Bergmann8b3d6662005-11-15 15:53:52 -0500681size_t spu_wbox_write(struct spu_context *ctx, u32 data)
Arnd Bergmann67207b92005-11-15 15:53:48 -0500682{
Arnd Bergmann8b3d6662005-11-15 15:53:52 -0500683 return ctx->ops->wbox_write(ctx, data);
Arnd Bergmann67207b92005-11-15 15:53:48 -0500684}
Arnd Bergmann67207b92005-11-15 15:53:48 -0500685
686static int spufs_wbox_fasync(int fd, struct file *file, int on)
687{
Arnd Bergmann8b3d6662005-11-15 15:53:52 -0500688 struct spu_context *ctx = file->private_data;
689 int ret;
690
691 ret = fasync_helper(fd, file, on, &ctx->wbox_fasync);
692
693 return ret;
694}
695
696/* interrupt-level wbox callback function. */
697void spufs_wbox_callback(struct spu *spu)
698{
699 struct spu_context *ctx = spu->ctx;
700
701 wake_up_all(&ctx->wbox_wq);
702 kill_fasync(&ctx->wbox_fasync, SIGIO, POLLOUT);
Arnd Bergmann67207b92005-11-15 15:53:48 -0500703}
704
Arnd Bergmanncdcc89b2006-10-04 17:26:17 +0200705/*
706 * Write as many bytes to the interrupt mailbox as possible, until
707 * one of the conditions becomes true:
708 *
709 * - the mailbox is full
710 * - end of the user provided buffer
711 * - end of the mapped area
712 *
713 * If the file is opened without O_NONBLOCK, we wait here until
714 * space is availabyl, but return when we have been able to
715 * write something.
716 */
Arnd Bergmann67207b92005-11-15 15:53:48 -0500717static ssize_t spufs_wbox_write(struct file *file, const char __user *buf,
718 size_t len, loff_t *pos)
719{
Arnd Bergmann8b3d6662005-11-15 15:53:52 -0500720 struct spu_context *ctx = file->private_data;
Arnd Bergmanncdcc89b2006-10-04 17:26:17 +0200721 u32 wbox_data, __user *udata;
722 ssize_t count;
Arnd Bergmann67207b92005-11-15 15:53:48 -0500723
724 if (len < 4)
725 return -EINVAL;
726
Arnd Bergmanncdcc89b2006-10-04 17:26:17 +0200727 udata = (void __user *)buf;
728 if (!access_ok(VERIFY_READ, buf, len))
729 return -EFAULT;
730
731 if (__get_user(wbox_data, udata))
Arnd Bergmann67207b92005-11-15 15:53:48 -0500732 return -EFAULT;
733
Arnd Bergmann8b3d6662005-11-15 15:53:52 -0500734 spu_acquire(ctx);
735
Arnd Bergmanncdcc89b2006-10-04 17:26:17 +0200736 /*
737 * make sure we can at least write one element, by waiting
738 * in case of !O_NONBLOCK
739 */
740 count = 0;
Arnd Bergmann67207b92005-11-15 15:53:48 -0500741 if (file->f_flags & O_NONBLOCK) {
Arnd Bergmann8b3d6662005-11-15 15:53:52 -0500742 if (!spu_wbox_write(ctx, wbox_data))
Arnd Bergmanncdcc89b2006-10-04 17:26:17 +0200743 count = -EAGAIN;
Arnd Bergmann67207b92005-11-15 15:53:48 -0500744 } else {
Arnd Bergmanncdcc89b2006-10-04 17:26:17 +0200745 count = spufs_wait(ctx->wbox_wq, spu_wbox_write(ctx, wbox_data));
Arnd Bergmann67207b92005-11-15 15:53:48 -0500746 }
747
Arnd Bergmanncdcc89b2006-10-04 17:26:17 +0200748 if (count)
749 goto out;
Arnd Bergmann8b3d6662005-11-15 15:53:52 -0500750
Arnd Bergmanncdcc89b2006-10-04 17:26:17 +0200751 /* write aѕ much as possible */
752 for (count = 4, udata++; (count + 4) <= len; count += 4, udata++) {
753 int ret;
754 ret = __get_user(wbox_data, udata);
755 if (ret)
756 break;
757
758 ret = spu_wbox_write(ctx, wbox_data);
759 if (ret == 0)
760 break;
761 }
762
763out:
764 spu_release(ctx);
765 return count;
Arnd Bergmann67207b92005-11-15 15:53:48 -0500766}
767
768static unsigned int spufs_wbox_poll(struct file *file, poll_table *wait)
769{
Arnd Bergmann8b3d6662005-11-15 15:53:52 -0500770 struct spu_context *ctx = file->private_data;
Arnd Bergmann67207b92005-11-15 15:53:48 -0500771 unsigned int mask;
772
Arnd Bergmann8b3d6662005-11-15 15:53:52 -0500773 poll_wait(file, &ctx->wbox_wq, wait);
Arnd Bergmann67207b92005-11-15 15:53:48 -0500774
Arnd Bergmann3a843d72005-12-05 22:52:27 -0500775 spu_acquire(ctx);
776 mask = ctx->ops->mbox_stat_poll(ctx, POLLOUT | POLLWRNORM);
777 spu_release(ctx);
Arnd Bergmann67207b92005-11-15 15:53:48 -0500778
779 return mask;
780}
781
Arjan van de Ven5dfe4c92007-02-12 00:55:31 -0800782static const struct file_operations spufs_wbox_fops = {
Arnd Bergmann67207b92005-11-15 15:53:48 -0500783 .open = spufs_pipe_open,
784 .write = spufs_wbox_write,
785 .poll = spufs_wbox_poll,
786 .fasync = spufs_wbox_fasync,
787};
788
789static ssize_t spufs_wbox_stat_read(struct file *file, char __user *buf,
790 size_t len, loff_t *pos)
791{
Arnd Bergmann8b3d6662005-11-15 15:53:52 -0500792 struct spu_context *ctx = file->private_data;
Arnd Bergmann67207b92005-11-15 15:53:48 -0500793 u32 wbox_stat;
794
795 if (len < 4)
796 return -EINVAL;
797
Arnd Bergmann8b3d6662005-11-15 15:53:52 -0500798 spu_acquire(ctx);
799 wbox_stat = (ctx->ops->mbox_stat_read(ctx) >> 8) & 0xff;
800 spu_release(ctx);
Arnd Bergmann67207b92005-11-15 15:53:48 -0500801
802 if (copy_to_user(buf, &wbox_stat, sizeof wbox_stat))
803 return -EFAULT;
804
805 return 4;
806}
807
Arjan van de Ven5dfe4c92007-02-12 00:55:31 -0800808static const struct file_operations spufs_wbox_stat_fops = {
Arnd Bergmann67207b92005-11-15 15:53:48 -0500809 .open = spufs_pipe_open,
810 .read = spufs_wbox_stat_read,
811};
812
Mark Nutter6df10a82006-03-23 00:00:12 +0100813static int spufs_signal1_open(struct inode *inode, struct file *file)
814{
815 struct spufs_inode_info *i = SPUFS_I(inode);
816 struct spu_context *ctx = i->i_ctx;
Christoph Hellwig43c2bbd2007-04-23 21:08:07 +0200817
Christoph Hellwig47d3a5f2007-06-04 23:26:51 +1000818 mutex_lock(&ctx->mapping_lock);
Mark Nutter6df10a82006-03-23 00:00:12 +0100819 file->private_data = ctx;
Christoph Hellwig43c2bbd2007-04-23 21:08:07 +0200820 if (!i->i_openers++)
821 ctx->signal1 = inode->i_mapping;
Christoph Hellwig47d3a5f2007-06-04 23:26:51 +1000822 mutex_unlock(&ctx->mapping_lock);
Mark Nutter6df10a82006-03-23 00:00:12 +0100823 return nonseekable_open(inode, file);
824}
825
Christoph Hellwig43c2bbd2007-04-23 21:08:07 +0200826static int
827spufs_signal1_release(struct inode *inode, struct file *file)
828{
829 struct spufs_inode_info *i = SPUFS_I(inode);
830 struct spu_context *ctx = i->i_ctx;
831
Christoph Hellwig47d3a5f2007-06-04 23:26:51 +1000832 mutex_lock(&ctx->mapping_lock);
Christoph Hellwig43c2bbd2007-04-23 21:08:07 +0200833 if (!--i->i_openers)
834 ctx->signal1 = NULL;
Christoph Hellwig47d3a5f2007-06-04 23:26:51 +1000835 mutex_unlock(&ctx->mapping_lock);
Christoph Hellwig43c2bbd2007-04-23 21:08:07 +0200836 return 0;
837}
838
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +0100839static ssize_t __spufs_signal1_read(struct spu_context *ctx, char __user *buf,
Arnd Bergmann67207b92005-11-15 15:53:48 -0500840 size_t len, loff_t *pos)
841{
Dwayne Grant McConnell17f88ce2006-11-20 18:45:01 +0100842 int ret = 0;
Arnd Bergmann67207b92005-11-15 15:53:48 -0500843 u32 data;
844
Arnd Bergmann67207b92005-11-15 15:53:48 -0500845 if (len < 4)
846 return -EINVAL;
847
Dwayne Grant McConnell17f88ce2006-11-20 18:45:01 +0100848 if (ctx->csa.spu_chnlcnt_RW[3]) {
849 data = ctx->csa.spu_chnldata_RW[3];
850 ret = 4;
851 }
Arnd Bergmann8b3d6662005-11-15 15:53:52 -0500852
Dwayne Grant McConnell17f88ce2006-11-20 18:45:01 +0100853 if (!ret)
854 goto out;
855
Arnd Bergmann67207b92005-11-15 15:53:48 -0500856 if (copy_to_user(buf, &data, 4))
857 return -EFAULT;
858
Dwayne Grant McConnell17f88ce2006-11-20 18:45:01 +0100859out:
860 return ret;
Arnd Bergmann67207b92005-11-15 15:53:48 -0500861}
862
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +0100863static ssize_t spufs_signal1_read(struct file *file, char __user *buf,
864 size_t len, loff_t *pos)
865{
866 int ret;
867 struct spu_context *ctx = file->private_data;
868
869 spu_acquire_saved(ctx);
870 ret = __spufs_signal1_read(ctx, buf, len, pos);
871 spu_release(ctx);
872
873 return ret;
874}
875
Arnd Bergmann67207b92005-11-15 15:53:48 -0500876static ssize_t spufs_signal1_write(struct file *file, const char __user *buf,
877 size_t len, loff_t *pos)
878{
879 struct spu_context *ctx;
Arnd Bergmann67207b92005-11-15 15:53:48 -0500880 u32 data;
881
882 ctx = file->private_data;
Arnd Bergmann67207b92005-11-15 15:53:48 -0500883
884 if (len < 4)
885 return -EINVAL;
886
887 if (copy_from_user(&data, buf, 4))
888 return -EFAULT;
889
Arnd Bergmann8b3d6662005-11-15 15:53:52 -0500890 spu_acquire(ctx);
891 ctx->ops->signal1_write(ctx, data);
892 spu_release(ctx);
Arnd Bergmann67207b92005-11-15 15:53:48 -0500893
894 return 4;
895}
896
Benjamin Herrenschmidt78bde532007-02-13 11:46:06 +1100897static unsigned long spufs_signal1_mmap_nopfn(struct vm_area_struct *vma,
898 unsigned long address)
Mark Nutter6df10a82006-03-23 00:00:12 +0100899{
Benjamin Herrenschmidt27d5bf22006-10-04 17:26:11 +0200900#if PAGE_SIZE == 0x1000
Benjamin Herrenschmidt78bde532007-02-13 11:46:06 +1100901 return spufs_ps_nopfn(vma, address, 0x14000, 0x1000);
Benjamin Herrenschmidt27d5bf22006-10-04 17:26:11 +0200902#elif PAGE_SIZE == 0x10000
903 /* For 64k pages, both signal1 and signal2 can be used to mmap the whole
904 * signal 1 and 2 area
905 */
Benjamin Herrenschmidt78bde532007-02-13 11:46:06 +1100906 return spufs_ps_nopfn(vma, address, 0x10000, 0x10000);
Benjamin Herrenschmidt27d5bf22006-10-04 17:26:11 +0200907#else
908#error unsupported page size
909#endif
Mark Nutter6df10a82006-03-23 00:00:12 +0100910}
911
912static struct vm_operations_struct spufs_signal1_mmap_vmops = {
Benjamin Herrenschmidt78bde532007-02-13 11:46:06 +1100913 .nopfn = spufs_signal1_mmap_nopfn,
Mark Nutter6df10a82006-03-23 00:00:12 +0100914};
915
916static int spufs_signal1_mmap(struct file *file, struct vm_area_struct *vma)
917{
918 if (!(vma->vm_flags & VM_SHARED))
919 return -EINVAL;
920
Benjamin Herrenschmidt78bde532007-02-13 11:46:06 +1100921 vma->vm_flags |= VM_IO | VM_PFNMAP;
Mark Nutter6df10a82006-03-23 00:00:12 +0100922 vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot)
Benjamin Herrenschmidt23cc7702006-06-23 20:57:47 +0200923 | _PAGE_NO_CACHE | _PAGE_GUARDED);
Mark Nutter6df10a82006-03-23 00:00:12 +0100924
925 vma->vm_ops = &spufs_signal1_mmap_vmops;
926 return 0;
927}
Mark Nutter6df10a82006-03-23 00:00:12 +0100928
Arjan van de Ven5dfe4c92007-02-12 00:55:31 -0800929static const struct file_operations spufs_signal1_fops = {
Mark Nutter6df10a82006-03-23 00:00:12 +0100930 .open = spufs_signal1_open,
Christoph Hellwig43c2bbd2007-04-23 21:08:07 +0200931 .release = spufs_signal1_release,
Arnd Bergmann67207b92005-11-15 15:53:48 -0500932 .read = spufs_signal1_read,
933 .write = spufs_signal1_write,
Mark Nutter6df10a82006-03-23 00:00:12 +0100934 .mmap = spufs_signal1_mmap,
Arnd Bergmann67207b92005-11-15 15:53:48 -0500935};
936
Mark Nutter6df10a82006-03-23 00:00:12 +0100937static int spufs_signal2_open(struct inode *inode, struct file *file)
938{
939 struct spufs_inode_info *i = SPUFS_I(inode);
940 struct spu_context *ctx = i->i_ctx;
Christoph Hellwig43c2bbd2007-04-23 21:08:07 +0200941
Christoph Hellwig47d3a5f2007-06-04 23:26:51 +1000942 mutex_lock(&ctx->mapping_lock);
Mark Nutter6df10a82006-03-23 00:00:12 +0100943 file->private_data = ctx;
Christoph Hellwig43c2bbd2007-04-23 21:08:07 +0200944 if (!i->i_openers++)
945 ctx->signal2 = inode->i_mapping;
Christoph Hellwig47d3a5f2007-06-04 23:26:51 +1000946 mutex_unlock(&ctx->mapping_lock);
Mark Nutter6df10a82006-03-23 00:00:12 +0100947 return nonseekable_open(inode, file);
948}
949
Christoph Hellwig43c2bbd2007-04-23 21:08:07 +0200950static int
951spufs_signal2_release(struct inode *inode, struct file *file)
952{
953 struct spufs_inode_info *i = SPUFS_I(inode);
954 struct spu_context *ctx = i->i_ctx;
955
Christoph Hellwig47d3a5f2007-06-04 23:26:51 +1000956 mutex_lock(&ctx->mapping_lock);
Christoph Hellwig43c2bbd2007-04-23 21:08:07 +0200957 if (!--i->i_openers)
958 ctx->signal2 = NULL;
Christoph Hellwig47d3a5f2007-06-04 23:26:51 +1000959 mutex_unlock(&ctx->mapping_lock);
Christoph Hellwig43c2bbd2007-04-23 21:08:07 +0200960 return 0;
961}
962
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +0100963static ssize_t __spufs_signal2_read(struct spu_context *ctx, char __user *buf,
Arnd Bergmann67207b92005-11-15 15:53:48 -0500964 size_t len, loff_t *pos)
965{
Dwayne Grant McConnell17f88ce2006-11-20 18:45:01 +0100966 int ret = 0;
Arnd Bergmann67207b92005-11-15 15:53:48 -0500967 u32 data;
968
Arnd Bergmann67207b92005-11-15 15:53:48 -0500969 if (len < 4)
970 return -EINVAL;
971
Dwayne Grant McConnell17f88ce2006-11-20 18:45:01 +0100972 if (ctx->csa.spu_chnlcnt_RW[4]) {
973 data = ctx->csa.spu_chnldata_RW[4];
974 ret = 4;
975 }
Arnd Bergmann8b3d6662005-11-15 15:53:52 -0500976
Dwayne Grant McConnell17f88ce2006-11-20 18:45:01 +0100977 if (!ret)
978 goto out;
979
Arnd Bergmann67207b92005-11-15 15:53:48 -0500980 if (copy_to_user(buf, &data, 4))
981 return -EFAULT;
982
Dwayne Grant McConnell17f88ce2006-11-20 18:45:01 +0100983out:
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +0100984 return ret;
985}
986
987static ssize_t spufs_signal2_read(struct file *file, char __user *buf,
988 size_t len, loff_t *pos)
989{
990 struct spu_context *ctx = file->private_data;
991 int ret;
992
993 spu_acquire_saved(ctx);
994 ret = __spufs_signal2_read(ctx, buf, len, pos);
995 spu_release(ctx);
996
997 return ret;
Arnd Bergmann67207b92005-11-15 15:53:48 -0500998}
999
1000static ssize_t spufs_signal2_write(struct file *file, const char __user *buf,
1001 size_t len, loff_t *pos)
1002{
1003 struct spu_context *ctx;
Arnd Bergmann67207b92005-11-15 15:53:48 -05001004 u32 data;
1005
1006 ctx = file->private_data;
Arnd Bergmann67207b92005-11-15 15:53:48 -05001007
1008 if (len < 4)
1009 return -EINVAL;
1010
1011 if (copy_from_user(&data, buf, 4))
1012 return -EFAULT;
1013
Arnd Bergmann8b3d6662005-11-15 15:53:52 -05001014 spu_acquire(ctx);
1015 ctx->ops->signal2_write(ctx, data);
1016 spu_release(ctx);
Arnd Bergmann67207b92005-11-15 15:53:48 -05001017
1018 return 4;
1019}
1020
Benjamin Herrenschmidt27d5bf22006-10-04 17:26:11 +02001021#if SPUFS_MMAP_4K
Benjamin Herrenschmidt78bde532007-02-13 11:46:06 +11001022static unsigned long spufs_signal2_mmap_nopfn(struct vm_area_struct *vma,
1023 unsigned long address)
Mark Nutter6df10a82006-03-23 00:00:12 +01001024{
Benjamin Herrenschmidt27d5bf22006-10-04 17:26:11 +02001025#if PAGE_SIZE == 0x1000
Benjamin Herrenschmidt78bde532007-02-13 11:46:06 +11001026 return spufs_ps_nopfn(vma, address, 0x1c000, 0x1000);
Benjamin Herrenschmidt27d5bf22006-10-04 17:26:11 +02001027#elif PAGE_SIZE == 0x10000
1028 /* For 64k pages, both signal1 and signal2 can be used to mmap the whole
1029 * signal 1 and 2 area
1030 */
Benjamin Herrenschmidt78bde532007-02-13 11:46:06 +11001031 return spufs_ps_nopfn(vma, address, 0x10000, 0x10000);
Benjamin Herrenschmidt27d5bf22006-10-04 17:26:11 +02001032#else
1033#error unsupported page size
1034#endif
Mark Nutter6df10a82006-03-23 00:00:12 +01001035}
1036
1037static struct vm_operations_struct spufs_signal2_mmap_vmops = {
Benjamin Herrenschmidt78bde532007-02-13 11:46:06 +11001038 .nopfn = spufs_signal2_mmap_nopfn,
Mark Nutter6df10a82006-03-23 00:00:12 +01001039};
1040
1041static int spufs_signal2_mmap(struct file *file, struct vm_area_struct *vma)
1042{
1043 if (!(vma->vm_flags & VM_SHARED))
1044 return -EINVAL;
1045
Benjamin Herrenschmidt78bde532007-02-13 11:46:06 +11001046 vma->vm_flags |= VM_IO | VM_PFNMAP;
Mark Nutter6df10a82006-03-23 00:00:12 +01001047 vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot)
Benjamin Herrenschmidt23cc7702006-06-23 20:57:47 +02001048 | _PAGE_NO_CACHE | _PAGE_GUARDED);
Mark Nutter6df10a82006-03-23 00:00:12 +01001049
1050 vma->vm_ops = &spufs_signal2_mmap_vmops;
1051 return 0;
1052}
Benjamin Herrenschmidt27d5bf22006-10-04 17:26:11 +02001053#else /* SPUFS_MMAP_4K */
1054#define spufs_signal2_mmap NULL
1055#endif /* !SPUFS_MMAP_4K */
Mark Nutter6df10a82006-03-23 00:00:12 +01001056
Arjan van de Ven5dfe4c92007-02-12 00:55:31 -08001057static const struct file_operations spufs_signal2_fops = {
Mark Nutter6df10a82006-03-23 00:00:12 +01001058 .open = spufs_signal2_open,
Christoph Hellwig43c2bbd2007-04-23 21:08:07 +02001059 .release = spufs_signal2_release,
Arnd Bergmann67207b92005-11-15 15:53:48 -05001060 .read = spufs_signal2_read,
1061 .write = spufs_signal2_write,
Mark Nutter6df10a82006-03-23 00:00:12 +01001062 .mmap = spufs_signal2_mmap,
Arnd Bergmann67207b92005-11-15 15:53:48 -05001063};
1064
1065static void spufs_signal1_type_set(void *data, u64 val)
1066{
1067 struct spu_context *ctx = data;
Arnd Bergmann67207b92005-11-15 15:53:48 -05001068
Arnd Bergmann8b3d6662005-11-15 15:53:52 -05001069 spu_acquire(ctx);
1070 ctx->ops->signal1_type_set(ctx, val);
1071 spu_release(ctx);
Arnd Bergmann67207b92005-11-15 15:53:48 -05001072}
1073
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +01001074static u64 __spufs_signal1_type_get(void *data)
1075{
1076 struct spu_context *ctx = data;
1077 return ctx->ops->signal1_type_get(ctx);
1078}
1079
Arnd Bergmann67207b92005-11-15 15:53:48 -05001080static u64 spufs_signal1_type_get(void *data)
1081{
1082 struct spu_context *ctx = data;
Arnd Bergmann8b3d6662005-11-15 15:53:52 -05001083 u64 ret;
1084
1085 spu_acquire(ctx);
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +01001086 ret = __spufs_signal1_type_get(data);
Arnd Bergmann8b3d6662005-11-15 15:53:52 -05001087 spu_release(ctx);
1088
1089 return ret;
Arnd Bergmann67207b92005-11-15 15:53:48 -05001090}
1091DEFINE_SIMPLE_ATTRIBUTE(spufs_signal1_type, spufs_signal1_type_get,
1092 spufs_signal1_type_set, "%llu");
1093
1094static void spufs_signal2_type_set(void *data, u64 val)
1095{
1096 struct spu_context *ctx = data;
Arnd Bergmann67207b92005-11-15 15:53:48 -05001097
Arnd Bergmann8b3d6662005-11-15 15:53:52 -05001098 spu_acquire(ctx);
1099 ctx->ops->signal2_type_set(ctx, val);
1100 spu_release(ctx);
Arnd Bergmann67207b92005-11-15 15:53:48 -05001101}
1102
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +01001103static u64 __spufs_signal2_type_get(void *data)
1104{
1105 struct spu_context *ctx = data;
1106 return ctx->ops->signal2_type_get(ctx);
1107}
1108
Arnd Bergmann67207b92005-11-15 15:53:48 -05001109static u64 spufs_signal2_type_get(void *data)
1110{
1111 struct spu_context *ctx = data;
Arnd Bergmann8b3d6662005-11-15 15:53:52 -05001112 u64 ret;
1113
1114 spu_acquire(ctx);
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +01001115 ret = __spufs_signal2_type_get(data);
Arnd Bergmann8b3d6662005-11-15 15:53:52 -05001116 spu_release(ctx);
1117
1118 return ret;
Arnd Bergmann67207b92005-11-15 15:53:48 -05001119}
1120DEFINE_SIMPLE_ATTRIBUTE(spufs_signal2_type, spufs_signal2_type_get,
1121 spufs_signal2_type_set, "%llu");
1122
Benjamin Herrenschmidt27d5bf22006-10-04 17:26:11 +02001123#if SPUFS_MMAP_4K
Benjamin Herrenschmidt78bde532007-02-13 11:46:06 +11001124static unsigned long spufs_mss_mmap_nopfn(struct vm_area_struct *vma,
1125 unsigned long address)
arnd@arndb.ded9379c42006-06-19 20:33:21 +02001126{
Benjamin Herrenschmidt78bde532007-02-13 11:46:06 +11001127 return spufs_ps_nopfn(vma, address, 0x0000, 0x1000);
arnd@arndb.ded9379c42006-06-19 20:33:21 +02001128}
1129
1130static struct vm_operations_struct spufs_mss_mmap_vmops = {
Benjamin Herrenschmidt78bde532007-02-13 11:46:06 +11001131 .nopfn = spufs_mss_mmap_nopfn,
arnd@arndb.ded9379c42006-06-19 20:33:21 +02001132};
1133
1134/*
1135 * mmap support for problem state MFC DMA area [0x0000 - 0x0fff].
arnd@arndb.ded9379c42006-06-19 20:33:21 +02001136 */
1137static int spufs_mss_mmap(struct file *file, struct vm_area_struct *vma)
1138{
1139 if (!(vma->vm_flags & VM_SHARED))
1140 return -EINVAL;
1141
Benjamin Herrenschmidt78bde532007-02-13 11:46:06 +11001142 vma->vm_flags |= VM_IO | VM_PFNMAP;
arnd@arndb.ded9379c42006-06-19 20:33:21 +02001143 vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot)
Benjamin Herrenschmidt23cc7702006-06-23 20:57:47 +02001144 | _PAGE_NO_CACHE | _PAGE_GUARDED);
arnd@arndb.ded9379c42006-06-19 20:33:21 +02001145
1146 vma->vm_ops = &spufs_mss_mmap_vmops;
1147 return 0;
1148}
Benjamin Herrenschmidt27d5bf22006-10-04 17:26:11 +02001149#else /* SPUFS_MMAP_4K */
1150#define spufs_mss_mmap NULL
1151#endif /* !SPUFS_MMAP_4K */
arnd@arndb.ded9379c42006-06-19 20:33:21 +02001152
1153static int spufs_mss_open(struct inode *inode, struct file *file)
1154{
1155 struct spufs_inode_info *i = SPUFS_I(inode);
Benjamin Herrenschmidt17e0e272007-02-13 11:46:08 +11001156 struct spu_context *ctx = i->i_ctx;
arnd@arndb.ded9379c42006-06-19 20:33:21 +02001157
1158 file->private_data = i->i_ctx;
Christoph Hellwig43c2bbd2007-04-23 21:08:07 +02001159
Christoph Hellwig47d3a5f2007-06-04 23:26:51 +10001160 mutex_lock(&ctx->mapping_lock);
Christoph Hellwig43c2bbd2007-04-23 21:08:07 +02001161 if (!i->i_openers++)
1162 ctx->mss = inode->i_mapping;
Christoph Hellwig47d3a5f2007-06-04 23:26:51 +10001163 mutex_unlock(&ctx->mapping_lock);
arnd@arndb.ded9379c42006-06-19 20:33:21 +02001164 return nonseekable_open(inode, file);
1165}
1166
Christoph Hellwig43c2bbd2007-04-23 21:08:07 +02001167static int
1168spufs_mss_release(struct inode *inode, struct file *file)
1169{
1170 struct spufs_inode_info *i = SPUFS_I(inode);
1171 struct spu_context *ctx = i->i_ctx;
1172
Christoph Hellwig47d3a5f2007-06-04 23:26:51 +10001173 mutex_lock(&ctx->mapping_lock);
Christoph Hellwig43c2bbd2007-04-23 21:08:07 +02001174 if (!--i->i_openers)
1175 ctx->mss = NULL;
Christoph Hellwig47d3a5f2007-06-04 23:26:51 +10001176 mutex_unlock(&ctx->mapping_lock);
Christoph Hellwig43c2bbd2007-04-23 21:08:07 +02001177 return 0;
1178}
1179
Arjan van de Ven5dfe4c92007-02-12 00:55:31 -08001180static const struct file_operations spufs_mss_fops = {
arnd@arndb.ded9379c42006-06-19 20:33:21 +02001181 .open = spufs_mss_open,
Christoph Hellwig43c2bbd2007-04-23 21:08:07 +02001182 .release = spufs_mss_release,
arnd@arndb.ded9379c42006-06-19 20:33:21 +02001183 .mmap = spufs_mss_mmap,
Benjamin Herrenschmidt27d5bf22006-10-04 17:26:11 +02001184};
1185
Benjamin Herrenschmidt78bde532007-02-13 11:46:06 +11001186static unsigned long spufs_psmap_mmap_nopfn(struct vm_area_struct *vma,
1187 unsigned long address)
Benjamin Herrenschmidt27d5bf22006-10-04 17:26:11 +02001188{
Benjamin Herrenschmidt78bde532007-02-13 11:46:06 +11001189 return spufs_ps_nopfn(vma, address, 0x0000, 0x20000);
Benjamin Herrenschmidt27d5bf22006-10-04 17:26:11 +02001190}
1191
1192static struct vm_operations_struct spufs_psmap_mmap_vmops = {
Benjamin Herrenschmidt78bde532007-02-13 11:46:06 +11001193 .nopfn = spufs_psmap_mmap_nopfn,
Benjamin Herrenschmidt27d5bf22006-10-04 17:26:11 +02001194};
1195
1196/*
1197 * mmap support for full problem state area [0x00000 - 0x1ffff].
1198 */
1199static int spufs_psmap_mmap(struct file *file, struct vm_area_struct *vma)
1200{
1201 if (!(vma->vm_flags & VM_SHARED))
1202 return -EINVAL;
1203
Benjamin Herrenschmidt78bde532007-02-13 11:46:06 +11001204 vma->vm_flags |= VM_IO | VM_PFNMAP;
Benjamin Herrenschmidt27d5bf22006-10-04 17:26:11 +02001205 vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot)
1206 | _PAGE_NO_CACHE | _PAGE_GUARDED);
1207
1208 vma->vm_ops = &spufs_psmap_mmap_vmops;
1209 return 0;
1210}
1211
1212static int spufs_psmap_open(struct inode *inode, struct file *file)
1213{
1214 struct spufs_inode_info *i = SPUFS_I(inode);
Benjamin Herrenschmidt17e0e272007-02-13 11:46:08 +11001215 struct spu_context *ctx = i->i_ctx;
Benjamin Herrenschmidt27d5bf22006-10-04 17:26:11 +02001216
Christoph Hellwig47d3a5f2007-06-04 23:26:51 +10001217 mutex_lock(&ctx->mapping_lock);
Benjamin Herrenschmidt27d5bf22006-10-04 17:26:11 +02001218 file->private_data = i->i_ctx;
Christoph Hellwig43c2bbd2007-04-23 21:08:07 +02001219 if (!i->i_openers++)
1220 ctx->psmap = inode->i_mapping;
Christoph Hellwig47d3a5f2007-06-04 23:26:51 +10001221 mutex_unlock(&ctx->mapping_lock);
Benjamin Herrenschmidt27d5bf22006-10-04 17:26:11 +02001222 return nonseekable_open(inode, file);
1223}
1224
Christoph Hellwig43c2bbd2007-04-23 21:08:07 +02001225static int
1226spufs_psmap_release(struct inode *inode, struct file *file)
1227{
1228 struct spufs_inode_info *i = SPUFS_I(inode);
1229 struct spu_context *ctx = i->i_ctx;
1230
Christoph Hellwig47d3a5f2007-06-04 23:26:51 +10001231 mutex_lock(&ctx->mapping_lock);
Christoph Hellwig43c2bbd2007-04-23 21:08:07 +02001232 if (!--i->i_openers)
1233 ctx->psmap = NULL;
Christoph Hellwig47d3a5f2007-06-04 23:26:51 +10001234 mutex_unlock(&ctx->mapping_lock);
Christoph Hellwig43c2bbd2007-04-23 21:08:07 +02001235 return 0;
1236}
1237
Arjan van de Ven5dfe4c92007-02-12 00:55:31 -08001238static const struct file_operations spufs_psmap_fops = {
Benjamin Herrenschmidt27d5bf22006-10-04 17:26:11 +02001239 .open = spufs_psmap_open,
Christoph Hellwig43c2bbd2007-04-23 21:08:07 +02001240 .release = spufs_psmap_release,
Benjamin Herrenschmidt27d5bf22006-10-04 17:26:11 +02001241 .mmap = spufs_psmap_mmap,
arnd@arndb.ded9379c42006-06-19 20:33:21 +02001242};
1243
1244
Benjamin Herrenschmidt27d5bf22006-10-04 17:26:11 +02001245#if SPUFS_MMAP_4K
Benjamin Herrenschmidt78bde532007-02-13 11:46:06 +11001246static unsigned long spufs_mfc_mmap_nopfn(struct vm_area_struct *vma,
1247 unsigned long address)
Mark Nutter6df10a82006-03-23 00:00:12 +01001248{
Benjamin Herrenschmidt78bde532007-02-13 11:46:06 +11001249 return spufs_ps_nopfn(vma, address, 0x3000, 0x1000);
Mark Nutter6df10a82006-03-23 00:00:12 +01001250}
1251
1252static struct vm_operations_struct spufs_mfc_mmap_vmops = {
Benjamin Herrenschmidt78bde532007-02-13 11:46:06 +11001253 .nopfn = spufs_mfc_mmap_nopfn,
Mark Nutter6df10a82006-03-23 00:00:12 +01001254};
1255
1256/*
1257 * mmap support for problem state MFC DMA area [0x0000 - 0x0fff].
Mark Nutter6df10a82006-03-23 00:00:12 +01001258 */
1259static int spufs_mfc_mmap(struct file *file, struct vm_area_struct *vma)
1260{
1261 if (!(vma->vm_flags & VM_SHARED))
1262 return -EINVAL;
1263
Benjamin Herrenschmidt78bde532007-02-13 11:46:06 +11001264 vma->vm_flags |= VM_IO | VM_PFNMAP;
Mark Nutter6df10a82006-03-23 00:00:12 +01001265 vma->vm_page_prot = __pgprot(pgprot_val(vma->vm_page_prot)
Benjamin Herrenschmidt23cc7702006-06-23 20:57:47 +02001266 | _PAGE_NO_CACHE | _PAGE_GUARDED);
Mark Nutter6df10a82006-03-23 00:00:12 +01001267
1268 vma->vm_ops = &spufs_mfc_mmap_vmops;
1269 return 0;
1270}
Benjamin Herrenschmidt27d5bf22006-10-04 17:26:11 +02001271#else /* SPUFS_MMAP_4K */
1272#define spufs_mfc_mmap NULL
1273#endif /* !SPUFS_MMAP_4K */
Arnd Bergmanna33a7d72006-03-23 00:00:11 +01001274
1275static int spufs_mfc_open(struct inode *inode, struct file *file)
1276{
1277 struct spufs_inode_info *i = SPUFS_I(inode);
1278 struct spu_context *ctx = i->i_ctx;
1279
1280 /* we don't want to deal with DMA into other processes */
1281 if (ctx->owner != current->mm)
1282 return -EINVAL;
1283
1284 if (atomic_read(&inode->i_count) != 1)
1285 return -EBUSY;
1286
Christoph Hellwig47d3a5f2007-06-04 23:26:51 +10001287 mutex_lock(&ctx->mapping_lock);
Arnd Bergmanna33a7d72006-03-23 00:00:11 +01001288 file->private_data = ctx;
Christoph Hellwig43c2bbd2007-04-23 21:08:07 +02001289 if (!i->i_openers++)
1290 ctx->mfc = inode->i_mapping;
Christoph Hellwig47d3a5f2007-06-04 23:26:51 +10001291 mutex_unlock(&ctx->mapping_lock);
Arnd Bergmanna33a7d72006-03-23 00:00:11 +01001292 return nonseekable_open(inode, file);
1293}
1294
Christoph Hellwig43c2bbd2007-04-23 21:08:07 +02001295static int
1296spufs_mfc_release(struct inode *inode, struct file *file)
1297{
1298 struct spufs_inode_info *i = SPUFS_I(inode);
1299 struct spu_context *ctx = i->i_ctx;
1300
Christoph Hellwig47d3a5f2007-06-04 23:26:51 +10001301 mutex_lock(&ctx->mapping_lock);
Christoph Hellwig43c2bbd2007-04-23 21:08:07 +02001302 if (!--i->i_openers)
1303 ctx->mfc = NULL;
Christoph Hellwig47d3a5f2007-06-04 23:26:51 +10001304 mutex_unlock(&ctx->mapping_lock);
Christoph Hellwig43c2bbd2007-04-23 21:08:07 +02001305 return 0;
1306}
1307
Arnd Bergmanna33a7d72006-03-23 00:00:11 +01001308/* interrupt-level mfc callback function. */
1309void spufs_mfc_callback(struct spu *spu)
1310{
1311 struct spu_context *ctx = spu->ctx;
1312
1313 wake_up_all(&ctx->mfc_wq);
1314
1315 pr_debug("%s %s\n", __FUNCTION__, spu->name);
1316 if (ctx->mfc_fasync) {
1317 u32 free_elements, tagstatus;
1318 unsigned int mask;
1319
1320 /* no need for spu_acquire in interrupt context */
1321 free_elements = ctx->ops->get_mfc_free_elements(ctx);
1322 tagstatus = ctx->ops->read_mfc_tagstatus(ctx);
1323
1324 mask = 0;
1325 if (free_elements & 0xffff)
1326 mask |= POLLOUT;
1327 if (tagstatus & ctx->tagwait)
1328 mask |= POLLIN;
1329
1330 kill_fasync(&ctx->mfc_fasync, SIGIO, mask);
1331 }
1332}
1333
1334static int spufs_read_mfc_tagstatus(struct spu_context *ctx, u32 *status)
1335{
1336 /* See if there is one tag group is complete */
1337 /* FIXME we need locking around tagwait */
1338 *status = ctx->ops->read_mfc_tagstatus(ctx) & ctx->tagwait;
1339 ctx->tagwait &= ~*status;
1340 if (*status)
1341 return 1;
1342
1343 /* enable interrupt waiting for any tag group,
1344 may silently fail if interrupts are already enabled */
1345 ctx->ops->set_mfc_query(ctx, ctx->tagwait, 1);
1346 return 0;
1347}
1348
1349static ssize_t spufs_mfc_read(struct file *file, char __user *buffer,
1350 size_t size, loff_t *pos)
1351{
1352 struct spu_context *ctx = file->private_data;
1353 int ret = -EINVAL;
1354 u32 status;
1355
1356 if (size != 4)
1357 goto out;
1358
1359 spu_acquire(ctx);
1360 if (file->f_flags & O_NONBLOCK) {
1361 status = ctx->ops->read_mfc_tagstatus(ctx);
1362 if (!(status & ctx->tagwait))
1363 ret = -EAGAIN;
1364 else
1365 ctx->tagwait &= ~status;
1366 } else {
1367 ret = spufs_wait(ctx->mfc_wq,
1368 spufs_read_mfc_tagstatus(ctx, &status));
1369 }
1370 spu_release(ctx);
1371
1372 if (ret)
1373 goto out;
1374
1375 ret = 4;
1376 if (copy_to_user(buffer, &status, 4))
1377 ret = -EFAULT;
1378
1379out:
1380 return ret;
1381}
1382
1383static int spufs_check_valid_dma(struct mfc_dma_command *cmd)
1384{
1385 pr_debug("queueing DMA %x %lx %x %x %x\n", cmd->lsa,
1386 cmd->ea, cmd->size, cmd->tag, cmd->cmd);
1387
1388 switch (cmd->cmd) {
1389 case MFC_PUT_CMD:
1390 case MFC_PUTF_CMD:
1391 case MFC_PUTB_CMD:
1392 case MFC_GET_CMD:
1393 case MFC_GETF_CMD:
1394 case MFC_GETB_CMD:
1395 break;
1396 default:
1397 pr_debug("invalid DMA opcode %x\n", cmd->cmd);
1398 return -EIO;
1399 }
1400
1401 if ((cmd->lsa & 0xf) != (cmd->ea &0xf)) {
1402 pr_debug("invalid DMA alignment, ea %lx lsa %x\n",
1403 cmd->ea, cmd->lsa);
1404 return -EIO;
1405 }
1406
1407 switch (cmd->size & 0xf) {
1408 case 1:
1409 break;
1410 case 2:
1411 if (cmd->lsa & 1)
1412 goto error;
1413 break;
1414 case 4:
1415 if (cmd->lsa & 3)
1416 goto error;
1417 break;
1418 case 8:
1419 if (cmd->lsa & 7)
1420 goto error;
1421 break;
1422 case 0:
1423 if (cmd->lsa & 15)
1424 goto error;
1425 break;
1426 error:
1427 default:
1428 pr_debug("invalid DMA alignment %x for size %x\n",
1429 cmd->lsa & 0xf, cmd->size);
1430 return -EIO;
1431 }
1432
1433 if (cmd->size > 16 * 1024) {
1434 pr_debug("invalid DMA size %x\n", cmd->size);
1435 return -EIO;
1436 }
1437
1438 if (cmd->tag & 0xfff0) {
1439 /* we reserve the higher tag numbers for kernel use */
1440 pr_debug("invalid DMA tag\n");
1441 return -EIO;
1442 }
1443
1444 if (cmd->class) {
1445 /* not supported in this version */
1446 pr_debug("invalid DMA class\n");
1447 return -EIO;
1448 }
1449
1450 return 0;
1451}
1452
1453static int spu_send_mfc_command(struct spu_context *ctx,
1454 struct mfc_dma_command cmd,
1455 int *error)
1456{
1457 *error = ctx->ops->send_mfc_command(ctx, &cmd);
1458 if (*error == -EAGAIN) {
1459 /* wait for any tag group to complete
1460 so we have space for the new command */
1461 ctx->ops->set_mfc_query(ctx, ctx->tagwait, 1);
1462 /* try again, because the queue might be
1463 empty again */
1464 *error = ctx->ops->send_mfc_command(ctx, &cmd);
1465 if (*error == -EAGAIN)
1466 return 0;
1467 }
1468 return 1;
1469}
1470
1471static ssize_t spufs_mfc_write(struct file *file, const char __user *buffer,
1472 size_t size, loff_t *pos)
1473{
1474 struct spu_context *ctx = file->private_data;
1475 struct mfc_dma_command cmd;
1476 int ret = -EINVAL;
1477
1478 if (size != sizeof cmd)
1479 goto out;
1480
1481 ret = -EFAULT;
1482 if (copy_from_user(&cmd, buffer, sizeof cmd))
1483 goto out;
1484
1485 ret = spufs_check_valid_dma(&cmd);
1486 if (ret)
1487 goto out;
1488
Akinobu Mita577f8f12007-04-23 21:08:18 +02001489 ret = spu_acquire_runnable(ctx, 0);
1490 if (ret)
1491 goto out;
1492
Arnd Bergmanna33a7d72006-03-23 00:00:11 +01001493 if (file->f_flags & O_NONBLOCK) {
1494 ret = ctx->ops->send_mfc_command(ctx, &cmd);
1495 } else {
1496 int status;
1497 ret = spufs_wait(ctx->mfc_wq,
1498 spu_send_mfc_command(ctx, cmd, &status));
1499 if (status)
1500 ret = status;
1501 }
Arnd Bergmanna33a7d72006-03-23 00:00:11 +01001502
1503 if (ret)
Kazunori Asayama933b0e32007-06-29 10:58:08 +10001504 goto out_unlock;
Arnd Bergmanna33a7d72006-03-23 00:00:11 +01001505
1506 ctx->tagwait |= 1 << cmd.tag;
Masato Noguchi3692dc62006-11-20 18:45:07 +01001507 ret = size;
Arnd Bergmanna33a7d72006-03-23 00:00:11 +01001508
Kazunori Asayama933b0e32007-06-29 10:58:08 +10001509out_unlock:
1510 spu_release(ctx);
Arnd Bergmanna33a7d72006-03-23 00:00:11 +01001511out:
1512 return ret;
1513}
1514
1515static unsigned int spufs_mfc_poll(struct file *file,poll_table *wait)
1516{
1517 struct spu_context *ctx = file->private_data;
1518 u32 free_elements, tagstatus;
1519 unsigned int mask;
1520
Kazunori Asayama933b0e32007-06-29 10:58:08 +10001521 poll_wait(file, &ctx->mfc_wq, wait);
1522
Arnd Bergmanna33a7d72006-03-23 00:00:11 +01001523 spu_acquire(ctx);
1524 ctx->ops->set_mfc_query(ctx, ctx->tagwait, 2);
1525 free_elements = ctx->ops->get_mfc_free_elements(ctx);
1526 tagstatus = ctx->ops->read_mfc_tagstatus(ctx);
1527 spu_release(ctx);
1528
Arnd Bergmanna33a7d72006-03-23 00:00:11 +01001529 mask = 0;
1530 if (free_elements & 0xffff)
1531 mask |= POLLOUT | POLLWRNORM;
1532 if (tagstatus & ctx->tagwait)
1533 mask |= POLLIN | POLLRDNORM;
1534
1535 pr_debug("%s: free %d tagstatus %d tagwait %d\n", __FUNCTION__,
1536 free_elements, tagstatus, ctx->tagwait);
1537
1538 return mask;
1539}
1540
Al Viro73b6af82006-06-25 16:42:33 -07001541static int spufs_mfc_flush(struct file *file, fl_owner_t id)
Arnd Bergmanna33a7d72006-03-23 00:00:11 +01001542{
1543 struct spu_context *ctx = file->private_data;
1544 int ret;
1545
1546 spu_acquire(ctx);
1547#if 0
1548/* this currently hangs */
1549 ret = spufs_wait(ctx->mfc_wq,
1550 ctx->ops->set_mfc_query(ctx, ctx->tagwait, 2));
1551 if (ret)
1552 goto out;
1553 ret = spufs_wait(ctx->mfc_wq,
1554 ctx->ops->read_mfc_tagstatus(ctx) == ctx->tagwait);
1555out:
1556#else
1557 ret = 0;
1558#endif
1559 spu_release(ctx);
1560
1561 return ret;
1562}
1563
1564static int spufs_mfc_fsync(struct file *file, struct dentry *dentry,
1565 int datasync)
1566{
Al Viro73b6af82006-06-25 16:42:33 -07001567 return spufs_mfc_flush(file, NULL);
Arnd Bergmanna33a7d72006-03-23 00:00:11 +01001568}
1569
1570static int spufs_mfc_fasync(int fd, struct file *file, int on)
1571{
1572 struct spu_context *ctx = file->private_data;
1573
1574 return fasync_helper(fd, file, on, &ctx->mfc_fasync);
1575}
1576
Arjan van de Ven5dfe4c92007-02-12 00:55:31 -08001577static const struct file_operations spufs_mfc_fops = {
Arnd Bergmanna33a7d72006-03-23 00:00:11 +01001578 .open = spufs_mfc_open,
Christoph Hellwig43c2bbd2007-04-23 21:08:07 +02001579 .release = spufs_mfc_release,
Arnd Bergmanna33a7d72006-03-23 00:00:11 +01001580 .read = spufs_mfc_read,
1581 .write = spufs_mfc_write,
1582 .poll = spufs_mfc_poll,
1583 .flush = spufs_mfc_flush,
1584 .fsync = spufs_mfc_fsync,
1585 .fasync = spufs_mfc_fasync,
Mark Nutter6df10a82006-03-23 00:00:12 +01001586 .mmap = spufs_mfc_mmap,
Arnd Bergmanna33a7d72006-03-23 00:00:11 +01001587};
1588
Arnd Bergmann67207b92005-11-15 15:53:48 -05001589static void spufs_npc_set(void *data, u64 val)
1590{
1591 struct spu_context *ctx = data;
Arnd Bergmann8b3d6662005-11-15 15:53:52 -05001592 spu_acquire(ctx);
1593 ctx->ops->npc_write(ctx, val);
1594 spu_release(ctx);
Arnd Bergmann67207b92005-11-15 15:53:48 -05001595}
1596
1597static u64 spufs_npc_get(void *data)
1598{
1599 struct spu_context *ctx = data;
1600 u64 ret;
Arnd Bergmann8b3d6662005-11-15 15:53:52 -05001601 spu_acquire(ctx);
1602 ret = ctx->ops->npc_read(ctx);
1603 spu_release(ctx);
Arnd Bergmann67207b92005-11-15 15:53:48 -05001604 return ret;
1605}
Dwayne Grant McConnell9b5047e2006-11-20 18:44:57 +01001606DEFINE_SIMPLE_ATTRIBUTE(spufs_npc_ops, spufs_npc_get, spufs_npc_set,
1607 "0x%llx\n")
Arnd Bergmann67207b92005-11-15 15:53:48 -05001608
Arnd Bergmann8b3d6662005-11-15 15:53:52 -05001609static void spufs_decr_set(void *data, u64 val)
1610{
1611 struct spu_context *ctx = data;
1612 struct spu_lscsa *lscsa = ctx->csa.lscsa;
1613 spu_acquire_saved(ctx);
1614 lscsa->decr.slot[0] = (u32) val;
1615 spu_release(ctx);
1616}
1617
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +01001618static u64 __spufs_decr_get(void *data)
Arnd Bergmann8b3d6662005-11-15 15:53:52 -05001619{
1620 struct spu_context *ctx = data;
1621 struct spu_lscsa *lscsa = ctx->csa.lscsa;
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +01001622 return lscsa->decr.slot[0];
1623}
1624
1625static u64 spufs_decr_get(void *data)
1626{
1627 struct spu_context *ctx = data;
Arnd Bergmann8b3d6662005-11-15 15:53:52 -05001628 u64 ret;
1629 spu_acquire_saved(ctx);
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +01001630 ret = __spufs_decr_get(data);
Arnd Bergmann8b3d6662005-11-15 15:53:52 -05001631 spu_release(ctx);
1632 return ret;
1633}
1634DEFINE_SIMPLE_ATTRIBUTE(spufs_decr_ops, spufs_decr_get, spufs_decr_set,
Dwayne Grant McConnell9b5047e2006-11-20 18:44:57 +01001635 "0x%llx\n")
Arnd Bergmann8b3d6662005-11-15 15:53:52 -05001636
1637static void spufs_decr_status_set(void *data, u64 val)
1638{
1639 struct spu_context *ctx = data;
1640 struct spu_lscsa *lscsa = ctx->csa.lscsa;
1641 spu_acquire_saved(ctx);
1642 lscsa->decr_status.slot[0] = (u32) val;
1643 spu_release(ctx);
1644}
1645
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +01001646static u64 __spufs_decr_status_get(void *data)
Arnd Bergmann8b3d6662005-11-15 15:53:52 -05001647{
1648 struct spu_context *ctx = data;
1649 struct spu_lscsa *lscsa = ctx->csa.lscsa;
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +01001650 return lscsa->decr_status.slot[0];
1651}
1652
1653static u64 spufs_decr_status_get(void *data)
1654{
1655 struct spu_context *ctx = data;
Arnd Bergmann8b3d6662005-11-15 15:53:52 -05001656 u64 ret;
1657 spu_acquire_saved(ctx);
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +01001658 ret = __spufs_decr_status_get(data);
Arnd Bergmann8b3d6662005-11-15 15:53:52 -05001659 spu_release(ctx);
1660 return ret;
1661}
1662DEFINE_SIMPLE_ATTRIBUTE(spufs_decr_status_ops, spufs_decr_status_get,
Dwayne Grant McConnell9b5047e2006-11-20 18:44:57 +01001663 spufs_decr_status_set, "0x%llx\n")
Arnd Bergmann8b3d6662005-11-15 15:53:52 -05001664
Arnd Bergmann8b3d6662005-11-15 15:53:52 -05001665static void spufs_event_mask_set(void *data, u64 val)
1666{
1667 struct spu_context *ctx = data;
1668 struct spu_lscsa *lscsa = ctx->csa.lscsa;
1669 spu_acquire_saved(ctx);
1670 lscsa->event_mask.slot[0] = (u32) val;
1671 spu_release(ctx);
1672}
1673
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +01001674static u64 __spufs_event_mask_get(void *data)
Arnd Bergmann8b3d6662005-11-15 15:53:52 -05001675{
1676 struct spu_context *ctx = data;
1677 struct spu_lscsa *lscsa = ctx->csa.lscsa;
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +01001678 return lscsa->event_mask.slot[0];
1679}
1680
1681static u64 spufs_event_mask_get(void *data)
1682{
1683 struct spu_context *ctx = data;
Arnd Bergmann8b3d6662005-11-15 15:53:52 -05001684 u64 ret;
1685 spu_acquire_saved(ctx);
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +01001686 ret = __spufs_event_mask_get(data);
Arnd Bergmann8b3d6662005-11-15 15:53:52 -05001687 spu_release(ctx);
1688 return ret;
1689}
1690DEFINE_SIMPLE_ATTRIBUTE(spufs_event_mask_ops, spufs_event_mask_get,
Dwayne Grant McConnell9b5047e2006-11-20 18:44:57 +01001691 spufs_event_mask_set, "0x%llx\n")
Arnd Bergmann8b3d6662005-11-15 15:53:52 -05001692
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +01001693static u64 __spufs_event_status_get(void *data)
Dwayne Grant McConnellb9e3bd72006-11-20 18:44:58 +01001694{
1695 struct spu_context *ctx = data;
1696 struct spu_state *state = &ctx->csa;
Dwayne Grant McConnellb9e3bd72006-11-20 18:44:58 +01001697 u64 stat;
Dwayne Grant McConnellb9e3bd72006-11-20 18:44:58 +01001698 stat = state->spu_chnlcnt_RW[0];
1699 if (stat)
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +01001700 return state->spu_chnldata_RW[0];
1701 return 0;
1702}
1703
1704static u64 spufs_event_status_get(void *data)
1705{
1706 struct spu_context *ctx = data;
1707 u64 ret = 0;
1708
1709 spu_acquire_saved(ctx);
1710 ret = __spufs_event_status_get(data);
Dwayne Grant McConnellb9e3bd72006-11-20 18:44:58 +01001711 spu_release(ctx);
1712 return ret;
1713}
1714DEFINE_SIMPLE_ATTRIBUTE(spufs_event_status_ops, spufs_event_status_get,
1715 NULL, "0x%llx\n")
1716
Arnd Bergmann8b3d6662005-11-15 15:53:52 -05001717static void spufs_srr0_set(void *data, u64 val)
1718{
1719 struct spu_context *ctx = data;
1720 struct spu_lscsa *lscsa = ctx->csa.lscsa;
1721 spu_acquire_saved(ctx);
1722 lscsa->srr0.slot[0] = (u32) val;
1723 spu_release(ctx);
1724}
1725
1726static u64 spufs_srr0_get(void *data)
1727{
1728 struct spu_context *ctx = data;
1729 struct spu_lscsa *lscsa = ctx->csa.lscsa;
1730 u64 ret;
1731 spu_acquire_saved(ctx);
1732 ret = lscsa->srr0.slot[0];
1733 spu_release(ctx);
1734 return ret;
1735}
1736DEFINE_SIMPLE_ATTRIBUTE(spufs_srr0_ops, spufs_srr0_get, spufs_srr0_set,
Dwayne Grant McConnell9b5047e2006-11-20 18:44:57 +01001737 "0x%llx\n")
Arnd Bergmann8b3d6662005-11-15 15:53:52 -05001738
arnd@arndb.de7b1a7012006-06-19 20:33:24 +02001739static u64 spufs_id_get(void *data)
1740{
1741 struct spu_context *ctx = data;
1742 u64 num;
1743
1744 spu_acquire(ctx);
1745 if (ctx->state == SPU_STATE_RUNNABLE)
1746 num = ctx->spu->number;
1747 else
1748 num = (unsigned int)-1;
1749 spu_release(ctx);
1750
1751 return num;
1752}
Al Viroe45d6632006-09-23 01:37:41 +01001753DEFINE_SIMPLE_ATTRIBUTE(spufs_id_ops, spufs_id_get, NULL, "0x%llx\n")
arnd@arndb.de7b1a7012006-06-19 20:33:24 +02001754
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +01001755static u64 __spufs_object_id_get(void *data)
Arnd Bergmann86767272006-10-04 17:26:21 +02001756{
1757 struct spu_context *ctx = data;
1758 return ctx->object_id;
1759}
1760
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +01001761static u64 spufs_object_id_get(void *data)
1762{
1763 /* FIXME: Should there really be no locking here? */
1764 return __spufs_object_id_get(data);
1765}
1766
Arnd Bergmann86767272006-10-04 17:26:21 +02001767static void spufs_object_id_set(void *data, u64 id)
1768{
1769 struct spu_context *ctx = data;
1770 ctx->object_id = id;
1771}
1772
1773DEFINE_SIMPLE_ATTRIBUTE(spufs_object_id_ops, spufs_object_id_get,
1774 spufs_object_id_set, "0x%llx\n");
1775
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +01001776static u64 __spufs_lslr_get(void *data)
1777{
1778 struct spu_context *ctx = data;
1779 return ctx->csa.priv2.spu_lslr_RW;
1780}
1781
Dwayne Grant McConnellb9e3bd72006-11-20 18:44:58 +01001782static u64 spufs_lslr_get(void *data)
1783{
1784 struct spu_context *ctx = data;
1785 u64 ret;
1786
1787 spu_acquire_saved(ctx);
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +01001788 ret = __spufs_lslr_get(data);
Dwayne Grant McConnellb9e3bd72006-11-20 18:44:58 +01001789 spu_release(ctx);
1790
1791 return ret;
1792}
1793DEFINE_SIMPLE_ATTRIBUTE(spufs_lslr_ops, spufs_lslr_get, NULL, "0x%llx\n")
1794
1795static int spufs_info_open(struct inode *inode, struct file *file)
1796{
1797 struct spufs_inode_info *i = SPUFS_I(inode);
1798 struct spu_context *ctx = i->i_ctx;
1799 file->private_data = ctx;
1800 return 0;
1801}
1802
Benjamin Herrenschmidtcbe709c2007-06-04 15:15:38 +10001803static int spufs_caps_show(struct seq_file *s, void *private)
1804{
1805 struct spu_context *ctx = s->private;
1806
1807 if (!(ctx->flags & SPU_CREATE_NOSCHED))
1808 seq_puts(s, "sched\n");
1809 if (!(ctx->flags & SPU_CREATE_ISOLATE))
1810 seq_puts(s, "step\n");
1811 return 0;
1812}
1813
1814static int spufs_caps_open(struct inode *inode, struct file *file)
1815{
1816 return single_open(file, spufs_caps_show, SPUFS_I(inode)->i_ctx);
1817}
1818
1819static const struct file_operations spufs_caps_fops = {
1820 .open = spufs_caps_open,
1821 .read = seq_read,
1822 .llseek = seq_lseek,
1823 .release = single_release,
1824};
1825
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +01001826static ssize_t __spufs_mbox_info_read(struct spu_context *ctx,
1827 char __user *buf, size_t len, loff_t *pos)
1828{
1829 u32 mbox_stat;
1830 u32 data;
1831
1832 mbox_stat = ctx->csa.prob.mb_stat_R;
1833 if (mbox_stat & 0x0000ff) {
1834 data = ctx->csa.prob.pu_mb_R;
1835 }
1836
1837 return simple_read_from_buffer(buf, len, pos, &data, sizeof data);
1838}
1839
Dwayne Grant McConnell69a2f002006-11-20 18:45:00 +01001840static ssize_t spufs_mbox_info_read(struct file *file, char __user *buf,
1841 size_t len, loff_t *pos)
1842{
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +01001843 int ret;
Dwayne Grant McConnell69a2f002006-11-20 18:45:00 +01001844 struct spu_context *ctx = file->private_data;
Dwayne Grant McConnell69a2f002006-11-20 18:45:00 +01001845
1846 if (!access_ok(VERIFY_WRITE, buf, len))
1847 return -EFAULT;
1848
1849 spu_acquire_saved(ctx);
1850 spin_lock(&ctx->csa.register_lock);
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +01001851 ret = __spufs_mbox_info_read(ctx, buf, len, pos);
Dwayne Grant McConnell69a2f002006-11-20 18:45:00 +01001852 spin_unlock(&ctx->csa.register_lock);
1853 spu_release(ctx);
1854
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +01001855 return ret;
Dwayne Grant McConnell69a2f002006-11-20 18:45:00 +01001856}
1857
Arjan van de Ven5dfe4c92007-02-12 00:55:31 -08001858static const struct file_operations spufs_mbox_info_fops = {
Dwayne Grant McConnell69a2f002006-11-20 18:45:00 +01001859 .open = spufs_info_open,
1860 .read = spufs_mbox_info_read,
1861 .llseek = generic_file_llseek,
1862};
1863
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +01001864static ssize_t __spufs_ibox_info_read(struct spu_context *ctx,
1865 char __user *buf, size_t len, loff_t *pos)
1866{
1867 u32 ibox_stat;
1868 u32 data;
1869
1870 ibox_stat = ctx->csa.prob.mb_stat_R;
1871 if (ibox_stat & 0xff0000) {
1872 data = ctx->csa.priv2.puint_mb_R;
1873 }
1874
1875 return simple_read_from_buffer(buf, len, pos, &data, sizeof data);
1876}
1877
Dwayne Grant McConnell69a2f002006-11-20 18:45:00 +01001878static ssize_t spufs_ibox_info_read(struct file *file, char __user *buf,
1879 size_t len, loff_t *pos)
1880{
1881 struct spu_context *ctx = file->private_data;
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +01001882 int ret;
Dwayne Grant McConnell69a2f002006-11-20 18:45:00 +01001883
1884 if (!access_ok(VERIFY_WRITE, buf, len))
1885 return -EFAULT;
1886
1887 spu_acquire_saved(ctx);
1888 spin_lock(&ctx->csa.register_lock);
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +01001889 ret = __spufs_ibox_info_read(ctx, buf, len, pos);
Dwayne Grant McConnell69a2f002006-11-20 18:45:00 +01001890 spin_unlock(&ctx->csa.register_lock);
1891 spu_release(ctx);
1892
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +01001893 return ret;
Dwayne Grant McConnell69a2f002006-11-20 18:45:00 +01001894}
1895
Arjan van de Ven5dfe4c92007-02-12 00:55:31 -08001896static const struct file_operations spufs_ibox_info_fops = {
Dwayne Grant McConnell69a2f002006-11-20 18:45:00 +01001897 .open = spufs_info_open,
1898 .read = spufs_ibox_info_read,
1899 .llseek = generic_file_llseek,
1900};
1901
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +01001902static ssize_t __spufs_wbox_info_read(struct spu_context *ctx,
1903 char __user *buf, size_t len, loff_t *pos)
1904{
1905 int i, cnt;
1906 u32 data[4];
1907 u32 wbox_stat;
1908
1909 wbox_stat = ctx->csa.prob.mb_stat_R;
1910 cnt = 4 - ((wbox_stat & 0x00ff00) >> 8);
1911 for (i = 0; i < cnt; i++) {
1912 data[i] = ctx->csa.spu_mailbox_data[i];
1913 }
1914
1915 return simple_read_from_buffer(buf, len, pos, &data,
1916 cnt * sizeof(u32));
1917}
1918
Dwayne Grant McConnell69a2f002006-11-20 18:45:00 +01001919static ssize_t spufs_wbox_info_read(struct file *file, char __user *buf,
1920 size_t len, loff_t *pos)
1921{
1922 struct spu_context *ctx = file->private_data;
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +01001923 int ret;
Dwayne Grant McConnell69a2f002006-11-20 18:45:00 +01001924
1925 if (!access_ok(VERIFY_WRITE, buf, len))
1926 return -EFAULT;
1927
1928 spu_acquire_saved(ctx);
1929 spin_lock(&ctx->csa.register_lock);
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +01001930 ret = __spufs_wbox_info_read(ctx, buf, len, pos);
Dwayne Grant McConnell69a2f002006-11-20 18:45:00 +01001931 spin_unlock(&ctx->csa.register_lock);
1932 spu_release(ctx);
1933
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +01001934 return ret;
Dwayne Grant McConnell69a2f002006-11-20 18:45:00 +01001935}
1936
Arjan van de Ven5dfe4c92007-02-12 00:55:31 -08001937static const struct file_operations spufs_wbox_info_fops = {
Dwayne Grant McConnell69a2f002006-11-20 18:45:00 +01001938 .open = spufs_info_open,
1939 .read = spufs_wbox_info_read,
1940 .llseek = generic_file_llseek,
1941};
1942
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +01001943static ssize_t __spufs_dma_info_read(struct spu_context *ctx,
1944 char __user *buf, size_t len, loff_t *pos)
Dwayne Grant McConnellb9e3bd72006-11-20 18:44:58 +01001945{
Dwayne Grant McConnellb9e3bd72006-11-20 18:44:58 +01001946 struct spu_dma_info info;
1947 struct mfc_cq_sr *qp, *spuqp;
1948 int i;
1949
Dwayne Grant McConnellb9e3bd72006-11-20 18:44:58 +01001950 info.dma_info_type = ctx->csa.priv2.spu_tag_status_query_RW;
1951 info.dma_info_mask = ctx->csa.lscsa->tag_mask.slot[0];
1952 info.dma_info_status = ctx->csa.spu_chnldata_RW[24];
1953 info.dma_info_stall_and_notify = ctx->csa.spu_chnldata_RW[25];
1954 info.dma_info_atomic_command_status = ctx->csa.spu_chnldata_RW[27];
1955 for (i = 0; i < 16; i++) {
1956 qp = &info.dma_info_command_data[i];
1957 spuqp = &ctx->csa.priv2.spuq[i];
1958
1959 qp->mfc_cq_data0_RW = spuqp->mfc_cq_data0_RW;
1960 qp->mfc_cq_data1_RW = spuqp->mfc_cq_data1_RW;
1961 qp->mfc_cq_data2_RW = spuqp->mfc_cq_data2_RW;
1962 qp->mfc_cq_data3_RW = spuqp->mfc_cq_data3_RW;
1963 }
Dwayne Grant McConnellb9e3bd72006-11-20 18:44:58 +01001964
1965 return simple_read_from_buffer(buf, len, pos, &info,
1966 sizeof info);
1967}
1968
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +01001969static ssize_t spufs_dma_info_read(struct file *file, char __user *buf,
1970 size_t len, loff_t *pos)
1971{
1972 struct spu_context *ctx = file->private_data;
1973 int ret;
1974
1975 if (!access_ok(VERIFY_WRITE, buf, len))
1976 return -EFAULT;
1977
1978 spu_acquire_saved(ctx);
1979 spin_lock(&ctx->csa.register_lock);
1980 ret = __spufs_dma_info_read(ctx, buf, len, pos);
1981 spin_unlock(&ctx->csa.register_lock);
1982 spu_release(ctx);
1983
1984 return ret;
1985}
1986
Arjan van de Ven5dfe4c92007-02-12 00:55:31 -08001987static const struct file_operations spufs_dma_info_fops = {
Dwayne Grant McConnellb9e3bd72006-11-20 18:44:58 +01001988 .open = spufs_info_open,
1989 .read = spufs_dma_info_read,
1990};
1991
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +01001992static ssize_t __spufs_proxydma_info_read(struct spu_context *ctx,
1993 char __user *buf, size_t len, loff_t *pos)
Dwayne Grant McConnellb9e3bd72006-11-20 18:44:58 +01001994{
Dwayne Grant McConnellb9e3bd72006-11-20 18:44:58 +01001995 struct spu_proxydma_info info;
Dwayne Grant McConnellb9e3bd72006-11-20 18:44:58 +01001996 struct mfc_cq_sr *qp, *puqp;
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +01001997 int ret = sizeof info;
Dwayne Grant McConnellb9e3bd72006-11-20 18:44:58 +01001998 int i;
1999
2000 if (len < ret)
2001 return -EINVAL;
2002
2003 if (!access_ok(VERIFY_WRITE, buf, len))
2004 return -EFAULT;
2005
Dwayne Grant McConnellb9e3bd72006-11-20 18:44:58 +01002006 info.proxydma_info_type = ctx->csa.prob.dma_querytype_RW;
2007 info.proxydma_info_mask = ctx->csa.prob.dma_querymask_RW;
2008 info.proxydma_info_status = ctx->csa.prob.dma_tagstatus_R;
2009 for (i = 0; i < 8; i++) {
2010 qp = &info.proxydma_info_command_data[i];
2011 puqp = &ctx->csa.priv2.puq[i];
2012
2013 qp->mfc_cq_data0_RW = puqp->mfc_cq_data0_RW;
2014 qp->mfc_cq_data1_RW = puqp->mfc_cq_data1_RW;
2015 qp->mfc_cq_data2_RW = puqp->mfc_cq_data2_RW;
2016 qp->mfc_cq_data3_RW = puqp->mfc_cq_data3_RW;
2017 }
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +01002018
2019 return simple_read_from_buffer(buf, len, pos, &info,
2020 sizeof info);
2021}
2022
2023static ssize_t spufs_proxydma_info_read(struct file *file, char __user *buf,
2024 size_t len, loff_t *pos)
2025{
2026 struct spu_context *ctx = file->private_data;
2027 int ret;
2028
2029 spu_acquire_saved(ctx);
2030 spin_lock(&ctx->csa.register_lock);
2031 ret = __spufs_proxydma_info_read(ctx, buf, len, pos);
Dwayne Grant McConnellb9e3bd72006-11-20 18:44:58 +01002032 spin_unlock(&ctx->csa.register_lock);
2033 spu_release(ctx);
2034
Dwayne Grant McConnellb9e3bd72006-11-20 18:44:58 +01002035 return ret;
2036}
2037
Arjan van de Ven5dfe4c92007-02-12 00:55:31 -08002038static const struct file_operations spufs_proxydma_info_fops = {
Dwayne Grant McConnellb9e3bd72006-11-20 18:44:58 +01002039 .open = spufs_info_open,
2040 .read = spufs_proxydma_info_read,
2041};
2042
Christoph Hellwig476273a2007-06-29 10:58:01 +10002043static int spufs_show_tid(struct seq_file *s, void *private)
2044{
2045 struct spu_context *ctx = s->private;
2046
2047 seq_printf(s, "%d\n", ctx->tid);
2048 return 0;
2049}
2050
2051static int spufs_tid_open(struct inode *inode, struct file *file)
2052{
2053 return single_open(file, spufs_show_tid, SPUFS_I(inode)->i_ctx);
2054}
2055
2056static const struct file_operations spufs_tid_fops = {
2057 .open = spufs_tid_open,
2058 .read = seq_read,
2059 .llseek = seq_lseek,
2060 .release = single_release,
2061};
2062
Christoph Hellwige9f8a0b2007-06-29 10:58:03 +10002063static const char *ctx_state_names[] = {
2064 "user", "system", "iowait", "loaded"
2065};
2066
2067static unsigned long long spufs_acct_time(struct spu_context *ctx,
2068 enum spuctx_execution_state state)
2069{
2070 unsigned long time = ctx->stats.times[state];
2071
2072 if (ctx->stats.execution_state == state)
2073 time += jiffies - ctx->stats.tstamp;
2074
2075 return jiffies_to_msecs(time);
2076}
2077
2078static unsigned long long spufs_slb_flts(struct spu_context *ctx)
2079{
2080 unsigned long long slb_flts = ctx->stats.slb_flt;
2081
2082 if (ctx->state == SPU_STATE_RUNNABLE) {
2083 slb_flts += (ctx->spu->stats.slb_flt -
2084 ctx->stats.slb_flt_base);
2085 }
2086
2087 return slb_flts;
2088}
2089
2090static unsigned long long spufs_class2_intrs(struct spu_context *ctx)
2091{
2092 unsigned long long class2_intrs = ctx->stats.class2_intr;
2093
2094 if (ctx->state == SPU_STATE_RUNNABLE) {
2095 class2_intrs += (ctx->spu->stats.class2_intr -
2096 ctx->stats.class2_intr_base);
2097 }
2098
2099 return class2_intrs;
2100}
2101
2102
2103static int spufs_show_stat(struct seq_file *s, void *private)
2104{
2105 struct spu_context *ctx = s->private;
2106
2107 spu_acquire(ctx);
2108 seq_printf(s, "%s %llu %llu %llu %llu "
2109 "%llu %llu %llu %llu %llu %llu %llu %llu\n",
2110 ctx_state_names[ctx->stats.execution_state],
2111 spufs_acct_time(ctx, SPUCTX_UTIL_USER),
2112 spufs_acct_time(ctx, SPUCTX_UTIL_SYSTEM),
2113 spufs_acct_time(ctx, SPUCTX_UTIL_IOWAIT),
2114 spufs_acct_time(ctx, SPUCTX_UTIL_LOADED),
2115 ctx->stats.vol_ctx_switch,
2116 ctx->stats.invol_ctx_switch,
2117 spufs_slb_flts(ctx),
2118 ctx->stats.hash_flt,
2119 ctx->stats.min_flt,
2120 ctx->stats.maj_flt,
2121 spufs_class2_intrs(ctx),
2122 ctx->stats.libassist);
2123 spu_release(ctx);
2124 return 0;
2125}
2126
2127static int spufs_stat_open(struct inode *inode, struct file *file)
2128{
2129 return single_open(file, spufs_show_stat, SPUFS_I(inode)->i_ctx);
2130}
2131
2132static const struct file_operations spufs_stat_fops = {
2133 .open = spufs_stat_open,
2134 .read = seq_read,
2135 .llseek = seq_lseek,
2136 .release = single_release,
2137};
2138
2139
Arnd Bergmann67207b92005-11-15 15:53:48 -05002140struct tree_descr spufs_dir_contents[] = {
Benjamin Herrenschmidtcbe709c2007-06-04 15:15:38 +10002141 { "capabilities", &spufs_caps_fops, 0444, },
Arnd Bergmann67207b92005-11-15 15:53:48 -05002142 { "mem", &spufs_mem_fops, 0666, },
Arnd Bergmann8b3d6662005-11-15 15:53:52 -05002143 { "regs", &spufs_regs_fops, 0666, },
Arnd Bergmann67207b92005-11-15 15:53:48 -05002144 { "mbox", &spufs_mbox_fops, 0444, },
2145 { "ibox", &spufs_ibox_fops, 0444, },
2146 { "wbox", &spufs_wbox_fops, 0222, },
2147 { "mbox_stat", &spufs_mbox_stat_fops, 0444, },
2148 { "ibox_stat", &spufs_ibox_stat_fops, 0444, },
2149 { "wbox_stat", &spufs_wbox_stat_fops, 0444, },
2150 { "signal1", &spufs_signal1_fops, 0666, },
2151 { "signal2", &spufs_signal2_fops, 0666, },
2152 { "signal1_type", &spufs_signal1_type, 0666, },
2153 { "signal2_type", &spufs_signal2_type, 0666, },
Mark Nutter6df10a82006-03-23 00:00:12 +01002154 { "cntl", &spufs_cntl_fops, 0666, },
Arnd Bergmann8b3d6662005-11-15 15:53:52 -05002155 { "fpcr", &spufs_fpcr_fops, 0666, },
Dwayne Grant McConnellb9e3bd72006-11-20 18:44:58 +01002156 { "lslr", &spufs_lslr_ops, 0444, },
2157 { "mfc", &spufs_mfc_fops, 0666, },
2158 { "mss", &spufs_mss_fops, 0666, },
2159 { "npc", &spufs_npc_ops, 0666, },
2160 { "srr0", &spufs_srr0_ops, 0666, },
Arnd Bergmann8b3d6662005-11-15 15:53:52 -05002161 { "decr", &spufs_decr_ops, 0666, },
2162 { "decr_status", &spufs_decr_status_ops, 0666, },
Arnd Bergmann8b3d6662005-11-15 15:53:52 -05002163 { "event_mask", &spufs_event_mask_ops, 0666, },
Dwayne Grant McConnellb9e3bd72006-11-20 18:44:58 +01002164 { "event_status", &spufs_event_status_ops, 0444, },
Benjamin Herrenschmidt27d5bf22006-10-04 17:26:11 +02002165 { "psmap", &spufs_psmap_fops, 0666, },
Arnd Bergmann86767272006-10-04 17:26:21 +02002166 { "phys-id", &spufs_id_ops, 0666, },
2167 { "object-id", &spufs_object_id_ops, 0666, },
Dwayne Grant McConnell69a2f002006-11-20 18:45:00 +01002168 { "mbox_info", &spufs_mbox_info_fops, 0444, },
2169 { "ibox_info", &spufs_ibox_info_fops, 0444, },
2170 { "wbox_info", &spufs_wbox_info_fops, 0444, },
Dwayne Grant McConnellb9e3bd72006-11-20 18:44:58 +01002171 { "dma_info", &spufs_dma_info_fops, 0444, },
2172 { "proxydma_info", &spufs_proxydma_info_fops, 0444, },
Christoph Hellwig476273a2007-06-29 10:58:01 +10002173 { "tid", &spufs_tid_fops, 0444, },
Christoph Hellwige9f8a0b2007-06-29 10:58:03 +10002174 { "stat", &spufs_stat_fops, 0444, },
Arnd Bergmann67207b92005-11-15 15:53:48 -05002175 {},
2176};
Mark Nutter5737edd2006-10-24 18:31:16 +02002177
2178struct tree_descr spufs_dir_nosched_contents[] = {
Benjamin Herrenschmidtcbe709c2007-06-04 15:15:38 +10002179 { "capabilities", &spufs_caps_fops, 0444, },
Mark Nutter5737edd2006-10-24 18:31:16 +02002180 { "mem", &spufs_mem_fops, 0666, },
2181 { "mbox", &spufs_mbox_fops, 0444, },
2182 { "ibox", &spufs_ibox_fops, 0444, },
2183 { "wbox", &spufs_wbox_fops, 0222, },
2184 { "mbox_stat", &spufs_mbox_stat_fops, 0444, },
2185 { "ibox_stat", &spufs_ibox_stat_fops, 0444, },
2186 { "wbox_stat", &spufs_wbox_stat_fops, 0444, },
2187 { "signal1", &spufs_signal1_fops, 0666, },
2188 { "signal2", &spufs_signal2_fops, 0666, },
2189 { "signal1_type", &spufs_signal1_type, 0666, },
2190 { "signal2_type", &spufs_signal2_type, 0666, },
2191 { "mss", &spufs_mss_fops, 0666, },
2192 { "mfc", &spufs_mfc_fops, 0666, },
2193 { "cntl", &spufs_cntl_fops, 0666, },
2194 { "npc", &spufs_npc_ops, 0666, },
2195 { "psmap", &spufs_psmap_fops, 0666, },
2196 { "phys-id", &spufs_id_ops, 0666, },
2197 { "object-id", &spufs_object_id_ops, 0666, },
Christoph Hellwig476273a2007-06-29 10:58:01 +10002198 { "tid", &spufs_tid_fops, 0444, },
Christoph Hellwige9f8a0b2007-06-29 10:58:03 +10002199 { "stat", &spufs_stat_fops, 0444, },
Mark Nutter5737edd2006-10-24 18:31:16 +02002200 {},
2201};
Dwayne Grant McConnellbf1ab972006-11-23 00:46:37 +01002202
2203struct spufs_coredump_reader spufs_coredump_read[] = {
2204 { "regs", __spufs_regs_read, NULL, 128 * 16 },
2205 { "fpcr", __spufs_fpcr_read, NULL, 16 },
2206 { "lslr", NULL, __spufs_lslr_get, 11 },
2207 { "decr", NULL, __spufs_decr_get, 11 },
2208 { "decr_status", NULL, __spufs_decr_status_get, 11 },
2209 { "mem", __spufs_mem_read, NULL, 256 * 1024, },
2210 { "signal1", __spufs_signal1_read, NULL, 4 },
2211 { "signal1_type", NULL, __spufs_signal1_type_get, 2 },
2212 { "signal2", __spufs_signal2_read, NULL, 4 },
2213 { "signal2_type", NULL, __spufs_signal2_type_get, 2 },
2214 { "event_mask", NULL, __spufs_event_mask_get, 8 },
2215 { "event_status", NULL, __spufs_event_status_get, 8 },
2216 { "mbox_info", __spufs_mbox_info_read, NULL, 4 },
2217 { "ibox_info", __spufs_ibox_info_read, NULL, 4 },
2218 { "wbox_info", __spufs_wbox_info_read, NULL, 16 },
2219 { "dma_info", __spufs_dma_info_read, NULL, 69 * 8 },
2220 { "proxydma_info", __spufs_proxydma_info_read, NULL, 35 * 8 },
2221 { "object-id", NULL, __spufs_object_id_get, 19 },
2222 { },
2223};
2224int spufs_coredump_num_notes = ARRAY_SIZE(spufs_coredump_read) - 1;
2225