2 * SPU file system -- file contents
4 * (C) Copyright IBM Deutschland Entwicklung GmbH 2005
6 * Author: Arnd Bergmann <arndb@de.ibm.com>
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)
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.
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.
26 #include <linux/ioctl.h>
27 #include <linux/module.h>
28 #include <linux/pagemap.h>
29 #include <linux/poll.h>
30 #include <linux/ptrace.h>
31 #include <linux/seq_file.h>
32 #include <linux/marker.h>
35 #include <asm/semaphore.h>
37 #include <asm/spu_info.h>
38 #include <asm/uaccess.h>
42 #define SPUFS_MMAP_4K (PAGE_SIZE == 0x1000)
44 /* Simple attribute files */
46 int (*get
)(void *, u64
*);
47 int (*set
)(void *, u64
);
48 char get_buf
[24]; /* enough to store a u64 and "\n\0" */
51 const char *fmt
; /* format for read operation */
52 struct mutex mutex
; /* protects access to these buffers */
55 static int spufs_attr_open(struct inode
*inode
, struct file
*file
,
56 int (*get
)(void *, u64
*), int (*set
)(void *, u64
),
59 struct spufs_attr
*attr
;
61 attr
= kmalloc(sizeof(*attr
), GFP_KERNEL
);
67 attr
->data
= inode
->i_private
;
69 mutex_init(&attr
->mutex
);
70 file
->private_data
= attr
;
72 return nonseekable_open(inode
, file
);
75 static int spufs_attr_release(struct inode
*inode
, struct file
*file
)
77 kfree(file
->private_data
);
81 static ssize_t
spufs_attr_read(struct file
*file
, char __user
*buf
,
82 size_t len
, loff_t
*ppos
)
84 struct spufs_attr
*attr
;
88 attr
= file
->private_data
;
92 ret
= mutex_lock_interruptible(&attr
->mutex
);
96 if (*ppos
) { /* continued read */
97 size
= strlen(attr
->get_buf
);
98 } else { /* first read */
100 ret
= attr
->get(attr
->data
, &val
);
104 size
= scnprintf(attr
->get_buf
, sizeof(attr
->get_buf
),
105 attr
->fmt
, (unsigned long long)val
);
108 ret
= simple_read_from_buffer(buf
, len
, ppos
, attr
->get_buf
, size
);
110 mutex_unlock(&attr
->mutex
);
114 static ssize_t
spufs_attr_write(struct file
*file
, const char __user
*buf
,
115 size_t len
, loff_t
*ppos
)
117 struct spufs_attr
*attr
;
122 attr
= file
->private_data
;
126 ret
= mutex_lock_interruptible(&attr
->mutex
);
131 size
= min(sizeof(attr
->set_buf
) - 1, len
);
132 if (copy_from_user(attr
->set_buf
, buf
, size
))
135 ret
= len
; /* claim we got the whole input */
136 attr
->set_buf
[size
] = '\0';
137 val
= simple_strtol(attr
->set_buf
, NULL
, 0);
138 attr
->set(attr
->data
, val
);
140 mutex_unlock(&attr
->mutex
);
144 #define DEFINE_SPUFS_SIMPLE_ATTRIBUTE(__fops, __get, __set, __fmt) \
145 static int __fops ## _open(struct inode *inode, struct file *file) \
147 __simple_attr_check_format(__fmt, 0ull); \
148 return spufs_attr_open(inode, file, __get, __set, __fmt); \
150 static struct file_operations __fops = { \
151 .owner = THIS_MODULE, \
152 .open = __fops ## _open, \
153 .release = spufs_attr_release, \
154 .read = spufs_attr_read, \
155 .write = spufs_attr_write, \
160 spufs_mem_open(struct inode
*inode
, struct file
*file
)
162 struct spufs_inode_info
*i
= SPUFS_I(inode
);
163 struct spu_context
*ctx
= i
->i_ctx
;
165 mutex_lock(&ctx
->mapping_lock
);
166 file
->private_data
= ctx
;
168 ctx
->local_store
= inode
->i_mapping
;
169 mutex_unlock(&ctx
->mapping_lock
);
174 spufs_mem_release(struct inode
*inode
, struct file
*file
)
176 struct spufs_inode_info
*i
= SPUFS_I(inode
);
177 struct spu_context
*ctx
= i
->i_ctx
;
179 mutex_lock(&ctx
->mapping_lock
);
181 ctx
->local_store
= NULL
;
182 mutex_unlock(&ctx
->mapping_lock
);
187 __spufs_mem_read(struct spu_context
*ctx
, char __user
*buffer
,
188 size_t size
, loff_t
*pos
)
190 char *local_store
= ctx
->ops
->get_ls(ctx
);
191 return simple_read_from_buffer(buffer
, size
, pos
, local_store
,
196 spufs_mem_read(struct file
*file
, char __user
*buffer
,
197 size_t size
, loff_t
*pos
)
199 struct spu_context
*ctx
= file
->private_data
;
202 ret
= spu_acquire(ctx
);
205 ret
= __spufs_mem_read(ctx
, buffer
, size
, pos
);
212 spufs_mem_write(struct file
*file
, const char __user
*buffer
,
213 size_t size
, loff_t
*ppos
)
215 struct spu_context
*ctx
= file
->private_data
;
224 if (size
> LS_SIZE
- pos
)
225 size
= LS_SIZE
- pos
;
227 ret
= spu_acquire(ctx
);
231 local_store
= ctx
->ops
->get_ls(ctx
);
232 ret
= copy_from_user(local_store
+ pos
, buffer
, size
);
241 static unsigned long spufs_mem_mmap_nopfn(struct vm_area_struct
*vma
,
242 unsigned long address
)
244 struct spu_context
*ctx
= vma
->vm_file
->private_data
;
245 unsigned long pfn
, offset
, addr0
= address
;
246 #ifdef CONFIG_SPU_FS_64K_LS
247 struct spu_state
*csa
= &ctx
->csa
;
250 /* Check what page size we are using */
251 psize
= get_slice_psize(vma
->vm_mm
, address
);
253 /* Some sanity checking */
254 BUG_ON(csa
->use_big_pages
!= (psize
== MMU_PAGE_64K
));
256 /* Wow, 64K, cool, we need to align the address though */
257 if (csa
->use_big_pages
) {
258 BUG_ON(vma
->vm_start
& 0xffff);
259 address
&= ~0xfffful
;
261 #endif /* CONFIG_SPU_FS_64K_LS */
263 offset
= (address
- vma
->vm_start
) + (vma
->vm_pgoff
<< PAGE_SHIFT
);
264 if (offset
>= LS_SIZE
)
267 pr_debug("spufs_mem_mmap_nopfn address=0x%lx -> 0x%lx, offset=0x%lx\n",
268 addr0
, address
, offset
);
270 if (spu_acquire(ctx
))
271 return NOPFN_REFAULT
;
273 if (ctx
->state
== SPU_STATE_SAVED
) {
274 vma
->vm_page_prot
= __pgprot(pgprot_val(vma
->vm_page_prot
)
276 pfn
= vmalloc_to_pfn(ctx
->csa
.lscsa
->ls
+ offset
);
278 vma
->vm_page_prot
= __pgprot(pgprot_val(vma
->vm_page_prot
)
280 pfn
= (ctx
->spu
->local_store_phys
+ offset
) >> PAGE_SHIFT
;
282 vm_insert_pfn(vma
, address
, pfn
);
286 return NOPFN_REFAULT
;
290 static struct vm_operations_struct spufs_mem_mmap_vmops
= {
291 .nopfn
= spufs_mem_mmap_nopfn
,
294 static int spufs_mem_mmap(struct file
*file
, struct vm_area_struct
*vma
)
296 #ifdef CONFIG_SPU_FS_64K_LS
297 struct spu_context
*ctx
= file
->private_data
;
298 struct spu_state
*csa
= &ctx
->csa
;
300 /* Sanity check VMA alignment */
301 if (csa
->use_big_pages
) {
302 pr_debug("spufs_mem_mmap 64K, start=0x%lx, end=0x%lx,"
303 " pgoff=0x%lx\n", vma
->vm_start
, vma
->vm_end
,
305 if (vma
->vm_start
& 0xffff)
307 if (vma
->vm_pgoff
& 0xf)
310 #endif /* CONFIG_SPU_FS_64K_LS */
312 if (!(vma
->vm_flags
& VM_SHARED
))
315 vma
->vm_flags
|= VM_IO
| VM_PFNMAP
;
316 vma
->vm_page_prot
= __pgprot(pgprot_val(vma
->vm_page_prot
)
319 vma
->vm_ops
= &spufs_mem_mmap_vmops
;
323 #ifdef CONFIG_SPU_FS_64K_LS
324 static unsigned long spufs_get_unmapped_area(struct file
*file
,
325 unsigned long addr
, unsigned long len
, unsigned long pgoff
,
328 struct spu_context
*ctx
= file
->private_data
;
329 struct spu_state
*csa
= &ctx
->csa
;
331 /* If not using big pages, fallback to normal MM g_u_a */
332 if (!csa
->use_big_pages
)
333 return current
->mm
->get_unmapped_area(file
, addr
, len
,
336 /* Else, try to obtain a 64K pages slice */
337 return slice_get_unmapped_area(addr
, len
, flags
,
340 #endif /* CONFIG_SPU_FS_64K_LS */
342 static const struct file_operations spufs_mem_fops
= {
343 .open
= spufs_mem_open
,
344 .release
= spufs_mem_release
,
345 .read
= spufs_mem_read
,
346 .write
= spufs_mem_write
,
347 .llseek
= generic_file_llseek
,
348 .mmap
= spufs_mem_mmap
,
349 #ifdef CONFIG_SPU_FS_64K_LS
350 .get_unmapped_area
= spufs_get_unmapped_area
,
354 static unsigned long spufs_ps_nopfn(struct vm_area_struct
*vma
,
355 unsigned long address
,
356 unsigned long ps_offs
,
357 unsigned long ps_size
)
359 struct spu_context
*ctx
= vma
->vm_file
->private_data
;
360 unsigned long area
, offset
= address
- vma
->vm_start
;
363 spu_context_nospu_trace(spufs_ps_nopfn__enter
, ctx
);
365 offset
+= vma
->vm_pgoff
<< PAGE_SHIFT
;
366 if (offset
>= ps_size
)
370 * Because we release the mmap_sem, the context may be destroyed while
371 * we're in spu_wait. Grab an extra reference so it isn't destroyed
374 get_spu_context(ctx
);
377 * We have to wait for context to be loaded before we have
378 * pages to hand out to the user, but we don't want to wait
379 * with the mmap_sem held.
380 * It is possible to drop the mmap_sem here, but then we need
381 * to return NOPFN_REFAULT because the mappings may have
384 if (spu_acquire(ctx
))
387 if (ctx
->state
== SPU_STATE_SAVED
) {
388 up_read(¤t
->mm
->mmap_sem
);
389 spu_context_nospu_trace(spufs_ps_nopfn__sleep
, ctx
);
390 ret
= spufs_wait(ctx
->run_wq
, ctx
->state
== SPU_STATE_RUNNABLE
);
391 spu_context_trace(spufs_ps_nopfn__wake
, ctx
, ctx
->spu
);
392 down_read(¤t
->mm
->mmap_sem
);
394 area
= ctx
->spu
->problem_phys
+ ps_offs
;
395 vm_insert_pfn(vma
, address
, (area
+ offset
) >> PAGE_SHIFT
);
396 spu_context_trace(spufs_ps_nopfn__insert
, ctx
, ctx
->spu
);
403 put_spu_context(ctx
);
404 return NOPFN_REFAULT
;
408 static unsigned long spufs_cntl_mmap_nopfn(struct vm_area_struct
*vma
,
409 unsigned long address
)
411 return spufs_ps_nopfn(vma
, address
, 0x4000, 0x1000);
414 static struct vm_operations_struct spufs_cntl_mmap_vmops
= {
415 .nopfn
= spufs_cntl_mmap_nopfn
,
419 * mmap support for problem state control area [0x4000 - 0x4fff].
421 static int spufs_cntl_mmap(struct file
*file
, struct vm_area_struct
*vma
)
423 if (!(vma
->vm_flags
& VM_SHARED
))
426 vma
->vm_flags
|= VM_IO
| VM_PFNMAP
;
427 vma
->vm_page_prot
= __pgprot(pgprot_val(vma
->vm_page_prot
)
428 | _PAGE_NO_CACHE
| _PAGE_GUARDED
);
430 vma
->vm_ops
= &spufs_cntl_mmap_vmops
;
433 #else /* SPUFS_MMAP_4K */
434 #define spufs_cntl_mmap NULL
435 #endif /* !SPUFS_MMAP_4K */
437 static int spufs_cntl_get(void *data
, u64
*val
)
439 struct spu_context
*ctx
= data
;
442 ret
= spu_acquire(ctx
);
445 *val
= ctx
->ops
->status_read(ctx
);
451 static int spufs_cntl_set(void *data
, u64 val
)
453 struct spu_context
*ctx
= data
;
456 ret
= spu_acquire(ctx
);
459 ctx
->ops
->runcntl_write(ctx
, val
);
465 static int spufs_cntl_open(struct inode
*inode
, struct file
*file
)
467 struct spufs_inode_info
*i
= SPUFS_I(inode
);
468 struct spu_context
*ctx
= i
->i_ctx
;
470 mutex_lock(&ctx
->mapping_lock
);
471 file
->private_data
= ctx
;
473 ctx
->cntl
= inode
->i_mapping
;
474 mutex_unlock(&ctx
->mapping_lock
);
475 return simple_attr_open(inode
, file
, spufs_cntl_get
,
476 spufs_cntl_set
, "0x%08lx");
480 spufs_cntl_release(struct inode
*inode
, struct file
*file
)
482 struct spufs_inode_info
*i
= SPUFS_I(inode
);
483 struct spu_context
*ctx
= i
->i_ctx
;
485 simple_attr_release(inode
, file
);
487 mutex_lock(&ctx
->mapping_lock
);
490 mutex_unlock(&ctx
->mapping_lock
);
494 static const struct file_operations spufs_cntl_fops
= {
495 .open
= spufs_cntl_open
,
496 .release
= spufs_cntl_release
,
497 .read
= simple_attr_read
,
498 .write
= simple_attr_write
,
499 .mmap
= spufs_cntl_mmap
,
503 spufs_regs_open(struct inode
*inode
, struct file
*file
)
505 struct spufs_inode_info
*i
= SPUFS_I(inode
);
506 file
->private_data
= i
->i_ctx
;
511 __spufs_regs_read(struct spu_context
*ctx
, char __user
*buffer
,
512 size_t size
, loff_t
*pos
)
514 struct spu_lscsa
*lscsa
= ctx
->csa
.lscsa
;
515 return simple_read_from_buffer(buffer
, size
, pos
,
516 lscsa
->gprs
, sizeof lscsa
->gprs
);
520 spufs_regs_read(struct file
*file
, char __user
*buffer
,
521 size_t size
, loff_t
*pos
)
524 struct spu_context
*ctx
= file
->private_data
;
526 ret
= spu_acquire_saved(ctx
);
529 ret
= __spufs_regs_read(ctx
, buffer
, size
, pos
);
530 spu_release_saved(ctx
);
535 spufs_regs_write(struct file
*file
, const char __user
*buffer
,
536 size_t size
, loff_t
*pos
)
538 struct spu_context
*ctx
= file
->private_data
;
539 struct spu_lscsa
*lscsa
= ctx
->csa
.lscsa
;
542 size
= min_t(ssize_t
, sizeof lscsa
->gprs
- *pos
, size
);
547 ret
= spu_acquire_saved(ctx
);
551 ret
= copy_from_user(lscsa
->gprs
+ *pos
- size
,
552 buffer
, size
) ? -EFAULT
: size
;
554 spu_release_saved(ctx
);
558 static const struct file_operations spufs_regs_fops
= {
559 .open
= spufs_regs_open
,
560 .read
= spufs_regs_read
,
561 .write
= spufs_regs_write
,
562 .llseek
= generic_file_llseek
,
566 __spufs_fpcr_read(struct spu_context
*ctx
, char __user
* buffer
,
567 size_t size
, loff_t
* pos
)
569 struct spu_lscsa
*lscsa
= ctx
->csa
.lscsa
;
570 return simple_read_from_buffer(buffer
, size
, pos
,
571 &lscsa
->fpcr
, sizeof(lscsa
->fpcr
));
575 spufs_fpcr_read(struct file
*file
, char __user
* buffer
,
576 size_t size
, loff_t
* pos
)
579 struct spu_context
*ctx
= file
->private_data
;
581 ret
= spu_acquire_saved(ctx
);
584 ret
= __spufs_fpcr_read(ctx
, buffer
, size
, pos
);
585 spu_release_saved(ctx
);
590 spufs_fpcr_write(struct file
*file
, const char __user
* buffer
,
591 size_t size
, loff_t
* pos
)
593 struct spu_context
*ctx
= file
->private_data
;
594 struct spu_lscsa
*lscsa
= ctx
->csa
.lscsa
;
597 size
= min_t(ssize_t
, sizeof(lscsa
->fpcr
) - *pos
, size
);
601 ret
= spu_acquire_saved(ctx
);
606 ret
= copy_from_user((char *)&lscsa
->fpcr
+ *pos
- size
,
607 buffer
, size
) ? -EFAULT
: size
;
609 spu_release_saved(ctx
);
613 static const struct file_operations spufs_fpcr_fops
= {
614 .open
= spufs_regs_open
,
615 .read
= spufs_fpcr_read
,
616 .write
= spufs_fpcr_write
,
617 .llseek
= generic_file_llseek
,
620 /* generic open function for all pipe-like files */
621 static int spufs_pipe_open(struct inode
*inode
, struct file
*file
)
623 struct spufs_inode_info
*i
= SPUFS_I(inode
);
624 file
->private_data
= i
->i_ctx
;
626 return nonseekable_open(inode
, file
);
630 * Read as many bytes from the mailbox as possible, until
631 * one of the conditions becomes true:
633 * - no more data available in the mailbox
634 * - end of the user provided buffer
635 * - end of the mapped area
637 static ssize_t
spufs_mbox_read(struct file
*file
, char __user
*buf
,
638 size_t len
, loff_t
*pos
)
640 struct spu_context
*ctx
= file
->private_data
;
641 u32 mbox_data
, __user
*udata
;
647 if (!access_ok(VERIFY_WRITE
, buf
, len
))
650 udata
= (void __user
*)buf
;
652 count
= spu_acquire(ctx
);
656 for (count
= 0; (count
+ 4) <= len
; count
+= 4, udata
++) {
658 ret
= ctx
->ops
->mbox_read(ctx
, &mbox_data
);
663 * at the end of the mapped area, we can fault
664 * but still need to return the data we have
665 * read successfully so far.
667 ret
= __put_user(mbox_data
, udata
);
682 static const struct file_operations spufs_mbox_fops
= {
683 .open
= spufs_pipe_open
,
684 .read
= spufs_mbox_read
,
687 static ssize_t
spufs_mbox_stat_read(struct file
*file
, char __user
*buf
,
688 size_t len
, loff_t
*pos
)
690 struct spu_context
*ctx
= file
->private_data
;
697 ret
= spu_acquire(ctx
);
701 mbox_stat
= ctx
->ops
->mbox_stat_read(ctx
) & 0xff;
705 if (copy_to_user(buf
, &mbox_stat
, sizeof mbox_stat
))
711 static const struct file_operations spufs_mbox_stat_fops
= {
712 .open
= spufs_pipe_open
,
713 .read
= spufs_mbox_stat_read
,
716 /* low-level ibox access function */
717 size_t spu_ibox_read(struct spu_context
*ctx
, u32
*data
)
719 return ctx
->ops
->ibox_read(ctx
, data
);
722 static int spufs_ibox_fasync(int fd
, struct file
*file
, int on
)
724 struct spu_context
*ctx
= file
->private_data
;
726 return fasync_helper(fd
, file
, on
, &ctx
->ibox_fasync
);
729 /* interrupt-level ibox callback function. */
730 void spufs_ibox_callback(struct spu
*spu
)
732 struct spu_context
*ctx
= spu
->ctx
;
737 wake_up_all(&ctx
->ibox_wq
);
738 kill_fasync(&ctx
->ibox_fasync
, SIGIO
, POLLIN
);
742 * Read as many bytes from the interrupt mailbox as possible, until
743 * one of the conditions becomes true:
745 * - no more data available in the mailbox
746 * - end of the user provided buffer
747 * - end of the mapped area
749 * If the file is opened without O_NONBLOCK, we wait here until
750 * any data is available, but return when we have been able to
753 static ssize_t
spufs_ibox_read(struct file
*file
, char __user
*buf
,
754 size_t len
, loff_t
*pos
)
756 struct spu_context
*ctx
= file
->private_data
;
757 u32 ibox_data
, __user
*udata
;
763 if (!access_ok(VERIFY_WRITE
, buf
, len
))
766 udata
= (void __user
*)buf
;
768 count
= spu_acquire(ctx
);
772 /* wait only for the first element */
774 if (file
->f_flags
& O_NONBLOCK
) {
775 if (!spu_ibox_read(ctx
, &ibox_data
)) {
780 count
= spufs_wait(ctx
->ibox_wq
, spu_ibox_read(ctx
, &ibox_data
));
785 /* if we can't write at all, return -EFAULT */
786 count
= __put_user(ibox_data
, udata
);
790 for (count
= 4, udata
++; (count
+ 4) <= len
; count
+= 4, udata
++) {
792 ret
= ctx
->ops
->ibox_read(ctx
, &ibox_data
);
796 * at the end of the mapped area, we can fault
797 * but still need to return the data we have
798 * read successfully so far.
800 ret
= __put_user(ibox_data
, udata
);
811 static unsigned int spufs_ibox_poll(struct file
*file
, poll_table
*wait
)
813 struct spu_context
*ctx
= file
->private_data
;
816 poll_wait(file
, &ctx
->ibox_wq
, wait
);
819 * For now keep this uninterruptible and also ignore the rule
820 * that poll should not sleep. Will be fixed later.
822 mutex_lock(&ctx
->state_mutex
);
823 mask
= ctx
->ops
->mbox_stat_poll(ctx
, POLLIN
| POLLRDNORM
);
829 static const struct file_operations spufs_ibox_fops
= {
830 .open
= spufs_pipe_open
,
831 .read
= spufs_ibox_read
,
832 .poll
= spufs_ibox_poll
,
833 .fasync
= spufs_ibox_fasync
,
836 static ssize_t
spufs_ibox_stat_read(struct file
*file
, char __user
*buf
,
837 size_t len
, loff_t
*pos
)
839 struct spu_context
*ctx
= file
->private_data
;
846 ret
= spu_acquire(ctx
);
849 ibox_stat
= (ctx
->ops
->mbox_stat_read(ctx
) >> 16) & 0xff;
852 if (copy_to_user(buf
, &ibox_stat
, sizeof ibox_stat
))
858 static const struct file_operations spufs_ibox_stat_fops
= {
859 .open
= spufs_pipe_open
,
860 .read
= spufs_ibox_stat_read
,
863 /* low-level mailbox write */
864 size_t spu_wbox_write(struct spu_context
*ctx
, u32 data
)
866 return ctx
->ops
->wbox_write(ctx
, data
);
869 static int spufs_wbox_fasync(int fd
, struct file
*file
, int on
)
871 struct spu_context
*ctx
= file
->private_data
;
874 ret
= fasync_helper(fd
, file
, on
, &ctx
->wbox_fasync
);
879 /* interrupt-level wbox callback function. */
880 void spufs_wbox_callback(struct spu
*spu
)
882 struct spu_context
*ctx
= spu
->ctx
;
887 wake_up_all(&ctx
->wbox_wq
);
888 kill_fasync(&ctx
->wbox_fasync
, SIGIO
, POLLOUT
);
892 * Write as many bytes to the interrupt mailbox as possible, until
893 * one of the conditions becomes true:
895 * - the mailbox is full
896 * - end of the user provided buffer
897 * - end of the mapped area
899 * If the file is opened without O_NONBLOCK, we wait here until
900 * space is availabyl, but return when we have been able to
903 static ssize_t
spufs_wbox_write(struct file
*file
, const char __user
*buf
,
904 size_t len
, loff_t
*pos
)
906 struct spu_context
*ctx
= file
->private_data
;
907 u32 wbox_data
, __user
*udata
;
913 udata
= (void __user
*)buf
;
914 if (!access_ok(VERIFY_READ
, buf
, len
))
917 if (__get_user(wbox_data
, udata
))
920 count
= spu_acquire(ctx
);
925 * make sure we can at least write one element, by waiting
926 * in case of !O_NONBLOCK
929 if (file
->f_flags
& O_NONBLOCK
) {
930 if (!spu_wbox_write(ctx
, wbox_data
)) {
935 count
= spufs_wait(ctx
->wbox_wq
, spu_wbox_write(ctx
, wbox_data
));
941 /* write as much as possible */
942 for (count
= 4, udata
++; (count
+ 4) <= len
; count
+= 4, udata
++) {
944 ret
= __get_user(wbox_data
, udata
);
948 ret
= spu_wbox_write(ctx
, wbox_data
);
959 static unsigned int spufs_wbox_poll(struct file
*file
, poll_table
*wait
)
961 struct spu_context
*ctx
= file
->private_data
;
964 poll_wait(file
, &ctx
->wbox_wq
, wait
);
967 * For now keep this uninterruptible and also ignore the rule
968 * that poll should not sleep. Will be fixed later.
970 mutex_lock(&ctx
->state_mutex
);
971 mask
= ctx
->ops
->mbox_stat_poll(ctx
, POLLOUT
| POLLWRNORM
);
977 static const struct file_operations spufs_wbox_fops
= {
978 .open
= spufs_pipe_open
,
979 .write
= spufs_wbox_write
,
980 .poll
= spufs_wbox_poll
,
981 .fasync
= spufs_wbox_fasync
,
984 static ssize_t
spufs_wbox_stat_read(struct file
*file
, char __user
*buf
,
985 size_t len
, loff_t
*pos
)
987 struct spu_context
*ctx
= file
->private_data
;
994 ret
= spu_acquire(ctx
);
997 wbox_stat
= (ctx
->ops
->mbox_stat_read(ctx
) >> 8) & 0xff;
1000 if (copy_to_user(buf
, &wbox_stat
, sizeof wbox_stat
))
1006 static const struct file_operations spufs_wbox_stat_fops
= {
1007 .open
= spufs_pipe_open
,
1008 .read
= spufs_wbox_stat_read
,
1011 static int spufs_signal1_open(struct inode
*inode
, struct file
*file
)
1013 struct spufs_inode_info
*i
= SPUFS_I(inode
);
1014 struct spu_context
*ctx
= i
->i_ctx
;
1016 mutex_lock(&ctx
->mapping_lock
);
1017 file
->private_data
= ctx
;
1018 if (!i
->i_openers
++)
1019 ctx
->signal1
= inode
->i_mapping
;
1020 mutex_unlock(&ctx
->mapping_lock
);
1021 return nonseekable_open(inode
, file
);
1025 spufs_signal1_release(struct inode
*inode
, struct file
*file
)
1027 struct spufs_inode_info
*i
= SPUFS_I(inode
);
1028 struct spu_context
*ctx
= i
->i_ctx
;
1030 mutex_lock(&ctx
->mapping_lock
);
1031 if (!--i
->i_openers
)
1032 ctx
->signal1
= NULL
;
1033 mutex_unlock(&ctx
->mapping_lock
);
1037 static ssize_t
__spufs_signal1_read(struct spu_context
*ctx
, char __user
*buf
,
1038 size_t len
, loff_t
*pos
)
1046 if (ctx
->csa
.spu_chnlcnt_RW
[3]) {
1047 data
= ctx
->csa
.spu_chnldata_RW
[3];
1054 if (copy_to_user(buf
, &data
, 4))
1061 static ssize_t
spufs_signal1_read(struct file
*file
, char __user
*buf
,
1062 size_t len
, loff_t
*pos
)
1065 struct spu_context
*ctx
= file
->private_data
;
1067 ret
= spu_acquire_saved(ctx
);
1070 ret
= __spufs_signal1_read(ctx
, buf
, len
, pos
);
1071 spu_release_saved(ctx
);
1076 static ssize_t
spufs_signal1_write(struct file
*file
, const char __user
*buf
,
1077 size_t len
, loff_t
*pos
)
1079 struct spu_context
*ctx
;
1083 ctx
= file
->private_data
;
1088 if (copy_from_user(&data
, buf
, 4))
1091 ret
= spu_acquire(ctx
);
1094 ctx
->ops
->signal1_write(ctx
, data
);
1100 static unsigned long spufs_signal1_mmap_nopfn(struct vm_area_struct
*vma
,
1101 unsigned long address
)
1103 #if PAGE_SIZE == 0x1000
1104 return spufs_ps_nopfn(vma
, address
, 0x14000, 0x1000);
1105 #elif PAGE_SIZE == 0x10000
1106 /* For 64k pages, both signal1 and signal2 can be used to mmap the whole
1107 * signal 1 and 2 area
1109 return spufs_ps_nopfn(vma
, address
, 0x10000, 0x10000);
1111 #error unsupported page size
1115 static struct vm_operations_struct spufs_signal1_mmap_vmops
= {
1116 .nopfn
= spufs_signal1_mmap_nopfn
,
1119 static int spufs_signal1_mmap(struct file
*file
, struct vm_area_struct
*vma
)
1121 if (!(vma
->vm_flags
& VM_SHARED
))
1124 vma
->vm_flags
|= VM_IO
| VM_PFNMAP
;
1125 vma
->vm_page_prot
= __pgprot(pgprot_val(vma
->vm_page_prot
)
1126 | _PAGE_NO_CACHE
| _PAGE_GUARDED
);
1128 vma
->vm_ops
= &spufs_signal1_mmap_vmops
;
1132 static const struct file_operations spufs_signal1_fops
= {
1133 .open
= spufs_signal1_open
,
1134 .release
= spufs_signal1_release
,
1135 .read
= spufs_signal1_read
,
1136 .write
= spufs_signal1_write
,
1137 .mmap
= spufs_signal1_mmap
,
1140 static const struct file_operations spufs_signal1_nosched_fops
= {
1141 .open
= spufs_signal1_open
,
1142 .release
= spufs_signal1_release
,
1143 .write
= spufs_signal1_write
,
1144 .mmap
= spufs_signal1_mmap
,
1147 static int spufs_signal2_open(struct inode
*inode
, struct file
*file
)
1149 struct spufs_inode_info
*i
= SPUFS_I(inode
);
1150 struct spu_context
*ctx
= i
->i_ctx
;
1152 mutex_lock(&ctx
->mapping_lock
);
1153 file
->private_data
= ctx
;
1154 if (!i
->i_openers
++)
1155 ctx
->signal2
= inode
->i_mapping
;
1156 mutex_unlock(&ctx
->mapping_lock
);
1157 return nonseekable_open(inode
, file
);
1161 spufs_signal2_release(struct inode
*inode
, struct file
*file
)
1163 struct spufs_inode_info
*i
= SPUFS_I(inode
);
1164 struct spu_context
*ctx
= i
->i_ctx
;
1166 mutex_lock(&ctx
->mapping_lock
);
1167 if (!--i
->i_openers
)
1168 ctx
->signal2
= NULL
;
1169 mutex_unlock(&ctx
->mapping_lock
);
1173 static ssize_t
__spufs_signal2_read(struct spu_context
*ctx
, char __user
*buf
,
1174 size_t len
, loff_t
*pos
)
1182 if (ctx
->csa
.spu_chnlcnt_RW
[4]) {
1183 data
= ctx
->csa
.spu_chnldata_RW
[4];
1190 if (copy_to_user(buf
, &data
, 4))
1197 static ssize_t
spufs_signal2_read(struct file
*file
, char __user
*buf
,
1198 size_t len
, loff_t
*pos
)
1200 struct spu_context
*ctx
= file
->private_data
;
1203 ret
= spu_acquire_saved(ctx
);
1206 ret
= __spufs_signal2_read(ctx
, buf
, len
, pos
);
1207 spu_release_saved(ctx
);
1212 static ssize_t
spufs_signal2_write(struct file
*file
, const char __user
*buf
,
1213 size_t len
, loff_t
*pos
)
1215 struct spu_context
*ctx
;
1219 ctx
= file
->private_data
;
1224 if (copy_from_user(&data
, buf
, 4))
1227 ret
= spu_acquire(ctx
);
1230 ctx
->ops
->signal2_write(ctx
, data
);
1237 static unsigned long spufs_signal2_mmap_nopfn(struct vm_area_struct
*vma
,
1238 unsigned long address
)
1240 #if PAGE_SIZE == 0x1000
1241 return spufs_ps_nopfn(vma
, address
, 0x1c000, 0x1000);
1242 #elif PAGE_SIZE == 0x10000
1243 /* For 64k pages, both signal1 and signal2 can be used to mmap the whole
1244 * signal 1 and 2 area
1246 return spufs_ps_nopfn(vma
, address
, 0x10000, 0x10000);
1248 #error unsupported page size
1252 static struct vm_operations_struct spufs_signal2_mmap_vmops
= {
1253 .nopfn
= spufs_signal2_mmap_nopfn
,
1256 static int spufs_signal2_mmap(struct file
*file
, struct vm_area_struct
*vma
)
1258 if (!(vma
->vm_flags
& VM_SHARED
))
1261 vma
->vm_flags
|= VM_IO
| VM_PFNMAP
;
1262 vma
->vm_page_prot
= __pgprot(pgprot_val(vma
->vm_page_prot
)
1263 | _PAGE_NO_CACHE
| _PAGE_GUARDED
);
1265 vma
->vm_ops
= &spufs_signal2_mmap_vmops
;
1268 #else /* SPUFS_MMAP_4K */
1269 #define spufs_signal2_mmap NULL
1270 #endif /* !SPUFS_MMAP_4K */
1272 static const struct file_operations spufs_signal2_fops
= {
1273 .open
= spufs_signal2_open
,
1274 .release
= spufs_signal2_release
,
1275 .read
= spufs_signal2_read
,
1276 .write
= spufs_signal2_write
,
1277 .mmap
= spufs_signal2_mmap
,
1280 static const struct file_operations spufs_signal2_nosched_fops
= {
1281 .open
= spufs_signal2_open
,
1282 .release
= spufs_signal2_release
,
1283 .write
= spufs_signal2_write
,
1284 .mmap
= spufs_signal2_mmap
,
1288 * This is a wrapper around DEFINE_SIMPLE_ATTRIBUTE which does the
1289 * work of acquiring (or not) the SPU context before calling through
1290 * to the actual get routine. The set routine is called directly.
1292 #define SPU_ATTR_NOACQUIRE 0
1293 #define SPU_ATTR_ACQUIRE 1
1294 #define SPU_ATTR_ACQUIRE_SAVED 2
1296 #define DEFINE_SPUFS_ATTRIBUTE(__name, __get, __set, __fmt, __acquire) \
1297 static int __##__get(void *data, u64 *val) \
1299 struct spu_context *ctx = data; \
1302 if (__acquire == SPU_ATTR_ACQUIRE) { \
1303 ret = spu_acquire(ctx); \
1306 *val = __get(ctx); \
1308 } else if (__acquire == SPU_ATTR_ACQUIRE_SAVED) { \
1309 ret = spu_acquire_saved(ctx); \
1312 *val = __get(ctx); \
1313 spu_release_saved(ctx); \
1315 *val = __get(ctx); \
1319 DEFINE_SPUFS_SIMPLE_ATTRIBUTE(__name, __##__get, __set, __fmt);
1321 static int spufs_signal1_type_set(void *data
, u64 val
)
1323 struct spu_context
*ctx
= data
;
1326 ret
= spu_acquire(ctx
);
1329 ctx
->ops
->signal1_type_set(ctx
, val
);
1335 static u64
spufs_signal1_type_get(struct spu_context
*ctx
)
1337 return ctx
->ops
->signal1_type_get(ctx
);
1339 DEFINE_SPUFS_ATTRIBUTE(spufs_signal1_type
, spufs_signal1_type_get
,
1340 spufs_signal1_type_set
, "%llu", SPU_ATTR_ACQUIRE
);
1343 static int spufs_signal2_type_set(void *data
, u64 val
)
1345 struct spu_context
*ctx
= data
;
1348 ret
= spu_acquire(ctx
);
1351 ctx
->ops
->signal2_type_set(ctx
, val
);
1357 static u64
spufs_signal2_type_get(struct spu_context
*ctx
)
1359 return ctx
->ops
->signal2_type_get(ctx
);
1361 DEFINE_SPUFS_ATTRIBUTE(spufs_signal2_type
, spufs_signal2_type_get
,
1362 spufs_signal2_type_set
, "%llu", SPU_ATTR_ACQUIRE
);
1365 static unsigned long spufs_mss_mmap_nopfn(struct vm_area_struct
*vma
,
1366 unsigned long address
)
1368 return spufs_ps_nopfn(vma
, address
, 0x0000, 0x1000);
1371 static struct vm_operations_struct spufs_mss_mmap_vmops
= {
1372 .nopfn
= spufs_mss_mmap_nopfn
,
1376 * mmap support for problem state MFC DMA area [0x0000 - 0x0fff].
1378 static int spufs_mss_mmap(struct file
*file
, struct vm_area_struct
*vma
)
1380 if (!(vma
->vm_flags
& VM_SHARED
))
1383 vma
->vm_flags
|= VM_IO
| VM_PFNMAP
;
1384 vma
->vm_page_prot
= __pgprot(pgprot_val(vma
->vm_page_prot
)
1385 | _PAGE_NO_CACHE
| _PAGE_GUARDED
);
1387 vma
->vm_ops
= &spufs_mss_mmap_vmops
;
1390 #else /* SPUFS_MMAP_4K */
1391 #define spufs_mss_mmap NULL
1392 #endif /* !SPUFS_MMAP_4K */
1394 static int spufs_mss_open(struct inode
*inode
, struct file
*file
)
1396 struct spufs_inode_info
*i
= SPUFS_I(inode
);
1397 struct spu_context
*ctx
= i
->i_ctx
;
1399 file
->private_data
= i
->i_ctx
;
1401 mutex_lock(&ctx
->mapping_lock
);
1402 if (!i
->i_openers
++)
1403 ctx
->mss
= inode
->i_mapping
;
1404 mutex_unlock(&ctx
->mapping_lock
);
1405 return nonseekable_open(inode
, file
);
1409 spufs_mss_release(struct inode
*inode
, struct file
*file
)
1411 struct spufs_inode_info
*i
= SPUFS_I(inode
);
1412 struct spu_context
*ctx
= i
->i_ctx
;
1414 mutex_lock(&ctx
->mapping_lock
);
1415 if (!--i
->i_openers
)
1417 mutex_unlock(&ctx
->mapping_lock
);
1421 static const struct file_operations spufs_mss_fops
= {
1422 .open
= spufs_mss_open
,
1423 .release
= spufs_mss_release
,
1424 .mmap
= spufs_mss_mmap
,
1427 static unsigned long spufs_psmap_mmap_nopfn(struct vm_area_struct
*vma
,
1428 unsigned long address
)
1430 return spufs_ps_nopfn(vma
, address
, 0x0000, 0x20000);
1433 static struct vm_operations_struct spufs_psmap_mmap_vmops
= {
1434 .nopfn
= spufs_psmap_mmap_nopfn
,
1438 * mmap support for full problem state area [0x00000 - 0x1ffff].
1440 static int spufs_psmap_mmap(struct file
*file
, struct vm_area_struct
*vma
)
1442 if (!(vma
->vm_flags
& VM_SHARED
))
1445 vma
->vm_flags
|= VM_IO
| VM_PFNMAP
;
1446 vma
->vm_page_prot
= __pgprot(pgprot_val(vma
->vm_page_prot
)
1447 | _PAGE_NO_CACHE
| _PAGE_GUARDED
);
1449 vma
->vm_ops
= &spufs_psmap_mmap_vmops
;
1453 static int spufs_psmap_open(struct inode
*inode
, struct file
*file
)
1455 struct spufs_inode_info
*i
= SPUFS_I(inode
);
1456 struct spu_context
*ctx
= i
->i_ctx
;
1458 mutex_lock(&ctx
->mapping_lock
);
1459 file
->private_data
= i
->i_ctx
;
1460 if (!i
->i_openers
++)
1461 ctx
->psmap
= inode
->i_mapping
;
1462 mutex_unlock(&ctx
->mapping_lock
);
1463 return nonseekable_open(inode
, file
);
1467 spufs_psmap_release(struct inode
*inode
, struct file
*file
)
1469 struct spufs_inode_info
*i
= SPUFS_I(inode
);
1470 struct spu_context
*ctx
= i
->i_ctx
;
1472 mutex_lock(&ctx
->mapping_lock
);
1473 if (!--i
->i_openers
)
1475 mutex_unlock(&ctx
->mapping_lock
);
1479 static const struct file_operations spufs_psmap_fops
= {
1480 .open
= spufs_psmap_open
,
1481 .release
= spufs_psmap_release
,
1482 .mmap
= spufs_psmap_mmap
,
1487 static unsigned long spufs_mfc_mmap_nopfn(struct vm_area_struct
*vma
,
1488 unsigned long address
)
1490 return spufs_ps_nopfn(vma
, address
, 0x3000, 0x1000);
1493 static struct vm_operations_struct spufs_mfc_mmap_vmops
= {
1494 .nopfn
= spufs_mfc_mmap_nopfn
,
1498 * mmap support for problem state MFC DMA area [0x0000 - 0x0fff].
1500 static int spufs_mfc_mmap(struct file
*file
, struct vm_area_struct
*vma
)
1502 if (!(vma
->vm_flags
& VM_SHARED
))
1505 vma
->vm_flags
|= VM_IO
| VM_PFNMAP
;
1506 vma
->vm_page_prot
= __pgprot(pgprot_val(vma
->vm_page_prot
)
1507 | _PAGE_NO_CACHE
| _PAGE_GUARDED
);
1509 vma
->vm_ops
= &spufs_mfc_mmap_vmops
;
1512 #else /* SPUFS_MMAP_4K */
1513 #define spufs_mfc_mmap NULL
1514 #endif /* !SPUFS_MMAP_4K */
1516 static int spufs_mfc_open(struct inode
*inode
, struct file
*file
)
1518 struct spufs_inode_info
*i
= SPUFS_I(inode
);
1519 struct spu_context
*ctx
= i
->i_ctx
;
1521 /* we don't want to deal with DMA into other processes */
1522 if (ctx
->owner
!= current
->mm
)
1525 if (atomic_read(&inode
->i_count
) != 1)
1528 mutex_lock(&ctx
->mapping_lock
);
1529 file
->private_data
= ctx
;
1530 if (!i
->i_openers
++)
1531 ctx
->mfc
= inode
->i_mapping
;
1532 mutex_unlock(&ctx
->mapping_lock
);
1533 return nonseekable_open(inode
, file
);
1537 spufs_mfc_release(struct inode
*inode
, struct file
*file
)
1539 struct spufs_inode_info
*i
= SPUFS_I(inode
);
1540 struct spu_context
*ctx
= i
->i_ctx
;
1542 mutex_lock(&ctx
->mapping_lock
);
1543 if (!--i
->i_openers
)
1545 mutex_unlock(&ctx
->mapping_lock
);
1549 /* interrupt-level mfc callback function. */
1550 void spufs_mfc_callback(struct spu
*spu
)
1552 struct spu_context
*ctx
= spu
->ctx
;
1557 wake_up_all(&ctx
->mfc_wq
);
1559 pr_debug("%s %s\n", __FUNCTION__
, spu
->name
);
1560 if (ctx
->mfc_fasync
) {
1561 u32 free_elements
, tagstatus
;
1564 /* no need for spu_acquire in interrupt context */
1565 free_elements
= ctx
->ops
->get_mfc_free_elements(ctx
);
1566 tagstatus
= ctx
->ops
->read_mfc_tagstatus(ctx
);
1569 if (free_elements
& 0xffff)
1571 if (tagstatus
& ctx
->tagwait
)
1574 kill_fasync(&ctx
->mfc_fasync
, SIGIO
, mask
);
1578 static int spufs_read_mfc_tagstatus(struct spu_context
*ctx
, u32
*status
)
1580 /* See if there is one tag group is complete */
1581 /* FIXME we need locking around tagwait */
1582 *status
= ctx
->ops
->read_mfc_tagstatus(ctx
) & ctx
->tagwait
;
1583 ctx
->tagwait
&= ~*status
;
1587 /* enable interrupt waiting for any tag group,
1588 may silently fail if interrupts are already enabled */
1589 ctx
->ops
->set_mfc_query(ctx
, ctx
->tagwait
, 1);
1593 static ssize_t
spufs_mfc_read(struct file
*file
, char __user
*buffer
,
1594 size_t size
, loff_t
*pos
)
1596 struct spu_context
*ctx
= file
->private_data
;
1603 ret
= spu_acquire(ctx
);
1608 if (file
->f_flags
& O_NONBLOCK
) {
1609 status
= ctx
->ops
->read_mfc_tagstatus(ctx
);
1610 if (!(status
& ctx
->tagwait
))
1613 /* XXX(hch): shouldn't we clear ret here? */
1614 ctx
->tagwait
&= ~status
;
1616 ret
= spufs_wait(ctx
->mfc_wq
,
1617 spufs_read_mfc_tagstatus(ctx
, &status
));
1624 if (copy_to_user(buffer
, &status
, 4))
1631 static int spufs_check_valid_dma(struct mfc_dma_command
*cmd
)
1633 pr_debug("queueing DMA %x %lx %x %x %x\n", cmd
->lsa
,
1634 cmd
->ea
, cmd
->size
, cmd
->tag
, cmd
->cmd
);
1645 pr_debug("invalid DMA opcode %x\n", cmd
->cmd
);
1649 if ((cmd
->lsa
& 0xf) != (cmd
->ea
&0xf)) {
1650 pr_debug("invalid DMA alignment, ea %lx lsa %x\n",
1655 switch (cmd
->size
& 0xf) {
1676 pr_debug("invalid DMA alignment %x for size %x\n",
1677 cmd
->lsa
& 0xf, cmd
->size
);
1681 if (cmd
->size
> 16 * 1024) {
1682 pr_debug("invalid DMA size %x\n", cmd
->size
);
1686 if (cmd
->tag
& 0xfff0) {
1687 /* we reserve the higher tag numbers for kernel use */
1688 pr_debug("invalid DMA tag\n");
1693 /* not supported in this version */
1694 pr_debug("invalid DMA class\n");
1701 static int spu_send_mfc_command(struct spu_context
*ctx
,
1702 struct mfc_dma_command cmd
,
1705 *error
= ctx
->ops
->send_mfc_command(ctx
, &cmd
);
1706 if (*error
== -EAGAIN
) {
1707 /* wait for any tag group to complete
1708 so we have space for the new command */
1709 ctx
->ops
->set_mfc_query(ctx
, ctx
->tagwait
, 1);
1710 /* try again, because the queue might be
1712 *error
= ctx
->ops
->send_mfc_command(ctx
, &cmd
);
1713 if (*error
== -EAGAIN
)
1719 static ssize_t
spufs_mfc_write(struct file
*file
, const char __user
*buffer
,
1720 size_t size
, loff_t
*pos
)
1722 struct spu_context
*ctx
= file
->private_data
;
1723 struct mfc_dma_command cmd
;
1726 if (size
!= sizeof cmd
)
1730 if (copy_from_user(&cmd
, buffer
, sizeof cmd
))
1733 ret
= spufs_check_valid_dma(&cmd
);
1737 ret
= spu_acquire(ctx
);
1741 ret
= spufs_wait(ctx
->run_wq
, ctx
->state
== SPU_STATE_RUNNABLE
);
1745 if (file
->f_flags
& O_NONBLOCK
) {
1746 ret
= ctx
->ops
->send_mfc_command(ctx
, &cmd
);
1749 ret
= spufs_wait(ctx
->mfc_wq
,
1750 spu_send_mfc_command(ctx
, cmd
, &status
));
1760 ctx
->tagwait
|= 1 << cmd
.tag
;
1769 static unsigned int spufs_mfc_poll(struct file
*file
,poll_table
*wait
)
1771 struct spu_context
*ctx
= file
->private_data
;
1772 u32 free_elements
, tagstatus
;
1775 poll_wait(file
, &ctx
->mfc_wq
, wait
);
1778 * For now keep this uninterruptible and also ignore the rule
1779 * that poll should not sleep. Will be fixed later.
1781 mutex_lock(&ctx
->state_mutex
);
1782 ctx
->ops
->set_mfc_query(ctx
, ctx
->tagwait
, 2);
1783 free_elements
= ctx
->ops
->get_mfc_free_elements(ctx
);
1784 tagstatus
= ctx
->ops
->read_mfc_tagstatus(ctx
);
1788 if (free_elements
& 0xffff)
1789 mask
|= POLLOUT
| POLLWRNORM
;
1790 if (tagstatus
& ctx
->tagwait
)
1791 mask
|= POLLIN
| POLLRDNORM
;
1793 pr_debug("%s: free %d tagstatus %d tagwait %d\n", __FUNCTION__
,
1794 free_elements
, tagstatus
, ctx
->tagwait
);
1799 static int spufs_mfc_flush(struct file
*file
, fl_owner_t id
)
1801 struct spu_context
*ctx
= file
->private_data
;
1804 ret
= spu_acquire(ctx
);
1808 /* this currently hangs */
1809 ret
= spufs_wait(ctx
->mfc_wq
,
1810 ctx
->ops
->set_mfc_query(ctx
, ctx
->tagwait
, 2));
1813 ret
= spufs_wait(ctx
->mfc_wq
,
1814 ctx
->ops
->read_mfc_tagstatus(ctx
) == ctx
->tagwait
);
1825 static int spufs_mfc_fsync(struct file
*file
, struct dentry
*dentry
,
1828 return spufs_mfc_flush(file
, NULL
);
1831 static int spufs_mfc_fasync(int fd
, struct file
*file
, int on
)
1833 struct spu_context
*ctx
= file
->private_data
;
1835 return fasync_helper(fd
, file
, on
, &ctx
->mfc_fasync
);
1838 static const struct file_operations spufs_mfc_fops
= {
1839 .open
= spufs_mfc_open
,
1840 .release
= spufs_mfc_release
,
1841 .read
= spufs_mfc_read
,
1842 .write
= spufs_mfc_write
,
1843 .poll
= spufs_mfc_poll
,
1844 .flush
= spufs_mfc_flush
,
1845 .fsync
= spufs_mfc_fsync
,
1846 .fasync
= spufs_mfc_fasync
,
1847 .mmap
= spufs_mfc_mmap
,
1850 static int spufs_npc_set(void *data
, u64 val
)
1852 struct spu_context
*ctx
= data
;
1855 ret
= spu_acquire(ctx
);
1858 ctx
->ops
->npc_write(ctx
, val
);
1864 static u64
spufs_npc_get(struct spu_context
*ctx
)
1866 return ctx
->ops
->npc_read(ctx
);
1868 DEFINE_SPUFS_ATTRIBUTE(spufs_npc_ops
, spufs_npc_get
, spufs_npc_set
,
1869 "0x%llx\n", SPU_ATTR_ACQUIRE
);
1871 static int spufs_decr_set(void *data
, u64 val
)
1873 struct spu_context
*ctx
= data
;
1874 struct spu_lscsa
*lscsa
= ctx
->csa
.lscsa
;
1877 ret
= spu_acquire_saved(ctx
);
1880 lscsa
->decr
.slot
[0] = (u32
) val
;
1881 spu_release_saved(ctx
);
1886 static u64
spufs_decr_get(struct spu_context
*ctx
)
1888 struct spu_lscsa
*lscsa
= ctx
->csa
.lscsa
;
1889 return lscsa
->decr
.slot
[0];
1891 DEFINE_SPUFS_ATTRIBUTE(spufs_decr_ops
, spufs_decr_get
, spufs_decr_set
,
1892 "0x%llx\n", SPU_ATTR_ACQUIRE_SAVED
);
1894 static int spufs_decr_status_set(void *data
, u64 val
)
1896 struct spu_context
*ctx
= data
;
1899 ret
= spu_acquire_saved(ctx
);
1903 ctx
->csa
.priv2
.mfc_control_RW
|= MFC_CNTL_DECREMENTER_RUNNING
;
1905 ctx
->csa
.priv2
.mfc_control_RW
&= ~MFC_CNTL_DECREMENTER_RUNNING
;
1906 spu_release_saved(ctx
);
1911 static u64
spufs_decr_status_get(struct spu_context
*ctx
)
1913 if (ctx
->csa
.priv2
.mfc_control_RW
& MFC_CNTL_DECREMENTER_RUNNING
)
1914 return SPU_DECR_STATUS_RUNNING
;
1918 DEFINE_SPUFS_ATTRIBUTE(spufs_decr_status_ops
, spufs_decr_status_get
,
1919 spufs_decr_status_set
, "0x%llx\n",
1920 SPU_ATTR_ACQUIRE_SAVED
);
1922 static int spufs_event_mask_set(void *data
, u64 val
)
1924 struct spu_context
*ctx
= data
;
1925 struct spu_lscsa
*lscsa
= ctx
->csa
.lscsa
;
1928 ret
= spu_acquire_saved(ctx
);
1931 lscsa
->event_mask
.slot
[0] = (u32
) val
;
1932 spu_release_saved(ctx
);
1937 static u64
spufs_event_mask_get(struct spu_context
*ctx
)
1939 struct spu_lscsa
*lscsa
= ctx
->csa
.lscsa
;
1940 return lscsa
->event_mask
.slot
[0];
1943 DEFINE_SPUFS_ATTRIBUTE(spufs_event_mask_ops
, spufs_event_mask_get
,
1944 spufs_event_mask_set
, "0x%llx\n",
1945 SPU_ATTR_ACQUIRE_SAVED
);
1947 static u64
spufs_event_status_get(struct spu_context
*ctx
)
1949 struct spu_state
*state
= &ctx
->csa
;
1951 stat
= state
->spu_chnlcnt_RW
[0];
1953 return state
->spu_chnldata_RW
[0];
1956 DEFINE_SPUFS_ATTRIBUTE(spufs_event_status_ops
, spufs_event_status_get
,
1957 NULL
, "0x%llx\n", SPU_ATTR_ACQUIRE_SAVED
)
1959 static int spufs_srr0_set(void *data
, u64 val
)
1961 struct spu_context
*ctx
= data
;
1962 struct spu_lscsa
*lscsa
= ctx
->csa
.lscsa
;
1965 ret
= spu_acquire_saved(ctx
);
1968 lscsa
->srr0
.slot
[0] = (u32
) val
;
1969 spu_release_saved(ctx
);
1974 static u64
spufs_srr0_get(struct spu_context
*ctx
)
1976 struct spu_lscsa
*lscsa
= ctx
->csa
.lscsa
;
1977 return lscsa
->srr0
.slot
[0];
1979 DEFINE_SPUFS_ATTRIBUTE(spufs_srr0_ops
, spufs_srr0_get
, spufs_srr0_set
,
1980 "0x%llx\n", SPU_ATTR_ACQUIRE_SAVED
)
1982 static u64
spufs_id_get(struct spu_context
*ctx
)
1986 if (ctx
->state
== SPU_STATE_RUNNABLE
)
1987 num
= ctx
->spu
->number
;
1989 num
= (unsigned int)-1;
1993 DEFINE_SPUFS_ATTRIBUTE(spufs_id_ops
, spufs_id_get
, NULL
, "0x%llx\n",
1996 static u64
spufs_object_id_get(struct spu_context
*ctx
)
1998 /* FIXME: Should there really be no locking here? */
1999 return ctx
->object_id
;
2002 static int spufs_object_id_set(void *data
, u64 id
)
2004 struct spu_context
*ctx
= data
;
2005 ctx
->object_id
= id
;
2010 DEFINE_SPUFS_ATTRIBUTE(spufs_object_id_ops
, spufs_object_id_get
,
2011 spufs_object_id_set
, "0x%llx\n", SPU_ATTR_NOACQUIRE
);
2013 static u64
spufs_lslr_get(struct spu_context
*ctx
)
2015 return ctx
->csa
.priv2
.spu_lslr_RW
;
2017 DEFINE_SPUFS_ATTRIBUTE(spufs_lslr_ops
, spufs_lslr_get
, NULL
, "0x%llx\n",
2018 SPU_ATTR_ACQUIRE_SAVED
);
2020 static int spufs_info_open(struct inode
*inode
, struct file
*file
)
2022 struct spufs_inode_info
*i
= SPUFS_I(inode
);
2023 struct spu_context
*ctx
= i
->i_ctx
;
2024 file
->private_data
= ctx
;
2028 static int spufs_caps_show(struct seq_file
*s
, void *private)
2030 struct spu_context
*ctx
= s
->private;
2032 if (!(ctx
->flags
& SPU_CREATE_NOSCHED
))
2033 seq_puts(s
, "sched\n");
2034 if (!(ctx
->flags
& SPU_CREATE_ISOLATE
))
2035 seq_puts(s
, "step\n");
2039 static int spufs_caps_open(struct inode
*inode
, struct file
*file
)
2041 return single_open(file
, spufs_caps_show
, SPUFS_I(inode
)->i_ctx
);
2044 static const struct file_operations spufs_caps_fops
= {
2045 .open
= spufs_caps_open
,
2047 .llseek
= seq_lseek
,
2048 .release
= single_release
,
2051 static ssize_t
__spufs_mbox_info_read(struct spu_context
*ctx
,
2052 char __user
*buf
, size_t len
, loff_t
*pos
)
2056 /* EOF if there's no entry in the mbox */
2057 if (!(ctx
->csa
.prob
.mb_stat_R
& 0x0000ff))
2060 data
= ctx
->csa
.prob
.pu_mb_R
;
2062 return simple_read_from_buffer(buf
, len
, pos
, &data
, sizeof data
);
2065 static ssize_t
spufs_mbox_info_read(struct file
*file
, char __user
*buf
,
2066 size_t len
, loff_t
*pos
)
2069 struct spu_context
*ctx
= file
->private_data
;
2071 if (!access_ok(VERIFY_WRITE
, buf
, len
))
2074 ret
= spu_acquire_saved(ctx
);
2077 spin_lock(&ctx
->csa
.register_lock
);
2078 ret
= __spufs_mbox_info_read(ctx
, buf
, len
, pos
);
2079 spin_unlock(&ctx
->csa
.register_lock
);
2080 spu_release_saved(ctx
);
2085 static const struct file_operations spufs_mbox_info_fops
= {
2086 .open
= spufs_info_open
,
2087 .read
= spufs_mbox_info_read
,
2088 .llseek
= generic_file_llseek
,
2091 static ssize_t
__spufs_ibox_info_read(struct spu_context
*ctx
,
2092 char __user
*buf
, size_t len
, loff_t
*pos
)
2096 /* EOF if there's no entry in the ibox */
2097 if (!(ctx
->csa
.prob
.mb_stat_R
& 0xff0000))
2100 data
= ctx
->csa
.priv2
.puint_mb_R
;
2102 return simple_read_from_buffer(buf
, len
, pos
, &data
, sizeof data
);
2105 static ssize_t
spufs_ibox_info_read(struct file
*file
, char __user
*buf
,
2106 size_t len
, loff_t
*pos
)
2108 struct spu_context
*ctx
= file
->private_data
;
2111 if (!access_ok(VERIFY_WRITE
, buf
, len
))
2114 ret
= spu_acquire_saved(ctx
);
2117 spin_lock(&ctx
->csa
.register_lock
);
2118 ret
= __spufs_ibox_info_read(ctx
, buf
, len
, pos
);
2119 spin_unlock(&ctx
->csa
.register_lock
);
2120 spu_release_saved(ctx
);
2125 static const struct file_operations spufs_ibox_info_fops
= {
2126 .open
= spufs_info_open
,
2127 .read
= spufs_ibox_info_read
,
2128 .llseek
= generic_file_llseek
,
2131 static ssize_t
__spufs_wbox_info_read(struct spu_context
*ctx
,
2132 char __user
*buf
, size_t len
, loff_t
*pos
)
2138 wbox_stat
= ctx
->csa
.prob
.mb_stat_R
;
2139 cnt
= 4 - ((wbox_stat
& 0x00ff00) >> 8);
2140 for (i
= 0; i
< cnt
; i
++) {
2141 data
[i
] = ctx
->csa
.spu_mailbox_data
[i
];
2144 return simple_read_from_buffer(buf
, len
, pos
, &data
,
2148 static ssize_t
spufs_wbox_info_read(struct file
*file
, char __user
*buf
,
2149 size_t len
, loff_t
*pos
)
2151 struct spu_context
*ctx
= file
->private_data
;
2154 if (!access_ok(VERIFY_WRITE
, buf
, len
))
2157 ret
= spu_acquire_saved(ctx
);
2160 spin_lock(&ctx
->csa
.register_lock
);
2161 ret
= __spufs_wbox_info_read(ctx
, buf
, len
, pos
);
2162 spin_unlock(&ctx
->csa
.register_lock
);
2163 spu_release_saved(ctx
);
2168 static const struct file_operations spufs_wbox_info_fops
= {
2169 .open
= spufs_info_open
,
2170 .read
= spufs_wbox_info_read
,
2171 .llseek
= generic_file_llseek
,
2174 static ssize_t
__spufs_dma_info_read(struct spu_context
*ctx
,
2175 char __user
*buf
, size_t len
, loff_t
*pos
)
2177 struct spu_dma_info info
;
2178 struct mfc_cq_sr
*qp
, *spuqp
;
2181 info
.dma_info_type
= ctx
->csa
.priv2
.spu_tag_status_query_RW
;
2182 info
.dma_info_mask
= ctx
->csa
.lscsa
->tag_mask
.slot
[0];
2183 info
.dma_info_status
= ctx
->csa
.spu_chnldata_RW
[24];
2184 info
.dma_info_stall_and_notify
= ctx
->csa
.spu_chnldata_RW
[25];
2185 info
.dma_info_atomic_command_status
= ctx
->csa
.spu_chnldata_RW
[27];
2186 for (i
= 0; i
< 16; i
++) {
2187 qp
= &info
.dma_info_command_data
[i
];
2188 spuqp
= &ctx
->csa
.priv2
.spuq
[i
];
2190 qp
->mfc_cq_data0_RW
= spuqp
->mfc_cq_data0_RW
;
2191 qp
->mfc_cq_data1_RW
= spuqp
->mfc_cq_data1_RW
;
2192 qp
->mfc_cq_data2_RW
= spuqp
->mfc_cq_data2_RW
;
2193 qp
->mfc_cq_data3_RW
= spuqp
->mfc_cq_data3_RW
;
2196 return simple_read_from_buffer(buf
, len
, pos
, &info
,
2200 static ssize_t
spufs_dma_info_read(struct file
*file
, char __user
*buf
,
2201 size_t len
, loff_t
*pos
)
2203 struct spu_context
*ctx
= file
->private_data
;
2206 if (!access_ok(VERIFY_WRITE
, buf
, len
))
2209 ret
= spu_acquire_saved(ctx
);
2212 spin_lock(&ctx
->csa
.register_lock
);
2213 ret
= __spufs_dma_info_read(ctx
, buf
, len
, pos
);
2214 spin_unlock(&ctx
->csa
.register_lock
);
2215 spu_release_saved(ctx
);
2220 static const struct file_operations spufs_dma_info_fops
= {
2221 .open
= spufs_info_open
,
2222 .read
= spufs_dma_info_read
,
2225 static ssize_t
__spufs_proxydma_info_read(struct spu_context
*ctx
,
2226 char __user
*buf
, size_t len
, loff_t
*pos
)
2228 struct spu_proxydma_info info
;
2229 struct mfc_cq_sr
*qp
, *puqp
;
2230 int ret
= sizeof info
;
2236 if (!access_ok(VERIFY_WRITE
, buf
, len
))
2239 info
.proxydma_info_type
= ctx
->csa
.prob
.dma_querytype_RW
;
2240 info
.proxydma_info_mask
= ctx
->csa
.prob
.dma_querymask_RW
;
2241 info
.proxydma_info_status
= ctx
->csa
.prob
.dma_tagstatus_R
;
2242 for (i
= 0; i
< 8; i
++) {
2243 qp
= &info
.proxydma_info_command_data
[i
];
2244 puqp
= &ctx
->csa
.priv2
.puq
[i
];
2246 qp
->mfc_cq_data0_RW
= puqp
->mfc_cq_data0_RW
;
2247 qp
->mfc_cq_data1_RW
= puqp
->mfc_cq_data1_RW
;
2248 qp
->mfc_cq_data2_RW
= puqp
->mfc_cq_data2_RW
;
2249 qp
->mfc_cq_data3_RW
= puqp
->mfc_cq_data3_RW
;
2252 return simple_read_from_buffer(buf
, len
, pos
, &info
,
2256 static ssize_t
spufs_proxydma_info_read(struct file
*file
, char __user
*buf
,
2257 size_t len
, loff_t
*pos
)
2259 struct spu_context
*ctx
= file
->private_data
;
2262 ret
= spu_acquire_saved(ctx
);
2265 spin_lock(&ctx
->csa
.register_lock
);
2266 ret
= __spufs_proxydma_info_read(ctx
, buf
, len
, pos
);
2267 spin_unlock(&ctx
->csa
.register_lock
);
2268 spu_release_saved(ctx
);
2273 static const struct file_operations spufs_proxydma_info_fops
= {
2274 .open
= spufs_info_open
,
2275 .read
= spufs_proxydma_info_read
,
2278 static int spufs_show_tid(struct seq_file
*s
, void *private)
2280 struct spu_context
*ctx
= s
->private;
2282 seq_printf(s
, "%d\n", ctx
->tid
);
2286 static int spufs_tid_open(struct inode
*inode
, struct file
*file
)
2288 return single_open(file
, spufs_show_tid
, SPUFS_I(inode
)->i_ctx
);
2291 static const struct file_operations spufs_tid_fops
= {
2292 .open
= spufs_tid_open
,
2294 .llseek
= seq_lseek
,
2295 .release
= single_release
,
2298 static const char *ctx_state_names
[] = {
2299 "user", "system", "iowait", "loaded"
2302 static unsigned long long spufs_acct_time(struct spu_context
*ctx
,
2303 enum spu_utilization_state state
)
2306 unsigned long long time
= ctx
->stats
.times
[state
];
2309 * In general, utilization statistics are updated by the controlling
2310 * thread as the spu context moves through various well defined
2311 * state transitions, but if the context is lazily loaded its
2312 * utilization statistics are not updated as the controlling thread
2313 * is not tightly coupled with the execution of the spu context. We
2314 * calculate and apply the time delta from the last recorded state
2315 * of the spu context.
2317 if (ctx
->spu
&& ctx
->stats
.util_state
== state
) {
2319 time
+= timespec_to_ns(&ts
) - ctx
->stats
.tstamp
;
2322 return time
/ NSEC_PER_MSEC
;
2325 static unsigned long long spufs_slb_flts(struct spu_context
*ctx
)
2327 unsigned long long slb_flts
= ctx
->stats
.slb_flt
;
2329 if (ctx
->state
== SPU_STATE_RUNNABLE
) {
2330 slb_flts
+= (ctx
->spu
->stats
.slb_flt
-
2331 ctx
->stats
.slb_flt_base
);
2337 static unsigned long long spufs_class2_intrs(struct spu_context
*ctx
)
2339 unsigned long long class2_intrs
= ctx
->stats
.class2_intr
;
2341 if (ctx
->state
== SPU_STATE_RUNNABLE
) {
2342 class2_intrs
+= (ctx
->spu
->stats
.class2_intr
-
2343 ctx
->stats
.class2_intr_base
);
2346 return class2_intrs
;
2350 static int spufs_show_stat(struct seq_file
*s
, void *private)
2352 struct spu_context
*ctx
= s
->private;
2355 ret
= spu_acquire(ctx
);
2359 seq_printf(s
, "%s %llu %llu %llu %llu "
2360 "%llu %llu %llu %llu %llu %llu %llu %llu\n",
2361 ctx_state_names
[ctx
->stats
.util_state
],
2362 spufs_acct_time(ctx
, SPU_UTIL_USER
),
2363 spufs_acct_time(ctx
, SPU_UTIL_SYSTEM
),
2364 spufs_acct_time(ctx
, SPU_UTIL_IOWAIT
),
2365 spufs_acct_time(ctx
, SPU_UTIL_IDLE_LOADED
),
2366 ctx
->stats
.vol_ctx_switch
,
2367 ctx
->stats
.invol_ctx_switch
,
2368 spufs_slb_flts(ctx
),
2369 ctx
->stats
.hash_flt
,
2372 spufs_class2_intrs(ctx
),
2373 ctx
->stats
.libassist
);
2378 static int spufs_stat_open(struct inode
*inode
, struct file
*file
)
2380 return single_open(file
, spufs_show_stat
, SPUFS_I(inode
)->i_ctx
);
2383 static const struct file_operations spufs_stat_fops
= {
2384 .open
= spufs_stat_open
,
2386 .llseek
= seq_lseek
,
2387 .release
= single_release
,
2391 struct tree_descr spufs_dir_contents
[] = {
2392 { "capabilities", &spufs_caps_fops
, 0444, },
2393 { "mem", &spufs_mem_fops
, 0666, },
2394 { "regs", &spufs_regs_fops
, 0666, },
2395 { "mbox", &spufs_mbox_fops
, 0444, },
2396 { "ibox", &spufs_ibox_fops
, 0444, },
2397 { "wbox", &spufs_wbox_fops
, 0222, },
2398 { "mbox_stat", &spufs_mbox_stat_fops
, 0444, },
2399 { "ibox_stat", &spufs_ibox_stat_fops
, 0444, },
2400 { "wbox_stat", &spufs_wbox_stat_fops
, 0444, },
2401 { "signal1", &spufs_signal1_fops
, 0666, },
2402 { "signal2", &spufs_signal2_fops
, 0666, },
2403 { "signal1_type", &spufs_signal1_type
, 0666, },
2404 { "signal2_type", &spufs_signal2_type
, 0666, },
2405 { "cntl", &spufs_cntl_fops
, 0666, },
2406 { "fpcr", &spufs_fpcr_fops
, 0666, },
2407 { "lslr", &spufs_lslr_ops
, 0444, },
2408 { "mfc", &spufs_mfc_fops
, 0666, },
2409 { "mss", &spufs_mss_fops
, 0666, },
2410 { "npc", &spufs_npc_ops
, 0666, },
2411 { "srr0", &spufs_srr0_ops
, 0666, },
2412 { "decr", &spufs_decr_ops
, 0666, },
2413 { "decr_status", &spufs_decr_status_ops
, 0666, },
2414 { "event_mask", &spufs_event_mask_ops
, 0666, },
2415 { "event_status", &spufs_event_status_ops
, 0444, },
2416 { "psmap", &spufs_psmap_fops
, 0666, },
2417 { "phys-id", &spufs_id_ops
, 0666, },
2418 { "object-id", &spufs_object_id_ops
, 0666, },
2419 { "mbox_info", &spufs_mbox_info_fops
, 0444, },
2420 { "ibox_info", &spufs_ibox_info_fops
, 0444, },
2421 { "wbox_info", &spufs_wbox_info_fops
, 0444, },
2422 { "dma_info", &spufs_dma_info_fops
, 0444, },
2423 { "proxydma_info", &spufs_proxydma_info_fops
, 0444, },
2424 { "tid", &spufs_tid_fops
, 0444, },
2425 { "stat", &spufs_stat_fops
, 0444, },
2429 struct tree_descr spufs_dir_nosched_contents
[] = {
2430 { "capabilities", &spufs_caps_fops
, 0444, },
2431 { "mem", &spufs_mem_fops
, 0666, },
2432 { "mbox", &spufs_mbox_fops
, 0444, },
2433 { "ibox", &spufs_ibox_fops
, 0444, },
2434 { "wbox", &spufs_wbox_fops
, 0222, },
2435 { "mbox_stat", &spufs_mbox_stat_fops
, 0444, },
2436 { "ibox_stat", &spufs_ibox_stat_fops
, 0444, },
2437 { "wbox_stat", &spufs_wbox_stat_fops
, 0444, },
2438 { "signal1", &spufs_signal1_nosched_fops
, 0222, },
2439 { "signal2", &spufs_signal2_nosched_fops
, 0222, },
2440 { "signal1_type", &spufs_signal1_type
, 0666, },
2441 { "signal2_type", &spufs_signal2_type
, 0666, },
2442 { "mss", &spufs_mss_fops
, 0666, },
2443 { "mfc", &spufs_mfc_fops
, 0666, },
2444 { "cntl", &spufs_cntl_fops
, 0666, },
2445 { "npc", &spufs_npc_ops
, 0666, },
2446 { "psmap", &spufs_psmap_fops
, 0666, },
2447 { "phys-id", &spufs_id_ops
, 0666, },
2448 { "object-id", &spufs_object_id_ops
, 0666, },
2449 { "tid", &spufs_tid_fops
, 0444, },
2450 { "stat", &spufs_stat_fops
, 0444, },
2454 struct spufs_coredump_reader spufs_coredump_read
[] = {
2455 { "regs", __spufs_regs_read
, NULL
, sizeof(struct spu_reg128
[128])},
2456 { "fpcr", __spufs_fpcr_read
, NULL
, sizeof(struct spu_reg128
) },
2457 { "lslr", NULL
, spufs_lslr_get
, 19 },
2458 { "decr", NULL
, spufs_decr_get
, 19 },
2459 { "decr_status", NULL
, spufs_decr_status_get
, 19 },
2460 { "mem", __spufs_mem_read
, NULL
, LS_SIZE
, },
2461 { "signal1", __spufs_signal1_read
, NULL
, sizeof(u32
) },
2462 { "signal1_type", NULL
, spufs_signal1_type_get
, 19 },
2463 { "signal2", __spufs_signal2_read
, NULL
, sizeof(u32
) },
2464 { "signal2_type", NULL
, spufs_signal2_type_get
, 19 },
2465 { "event_mask", NULL
, spufs_event_mask_get
, 19 },
2466 { "event_status", NULL
, spufs_event_status_get
, 19 },
2467 { "mbox_info", __spufs_mbox_info_read
, NULL
, sizeof(u32
) },
2468 { "ibox_info", __spufs_ibox_info_read
, NULL
, sizeof(u32
) },
2469 { "wbox_info", __spufs_wbox_info_read
, NULL
, 4 * sizeof(u32
)},
2470 { "dma_info", __spufs_dma_info_read
, NULL
, sizeof(struct spu_dma_info
)},
2471 { "proxydma_info", __spufs_proxydma_info_read
,
2472 NULL
, sizeof(struct spu_proxydma_info
)},
2473 { "object-id", NULL
, spufs_object_id_get
, 19 },
2474 { "npc", NULL
, spufs_npc_get
, 19 },