projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
powerpc/spufs: Use llseek in all file operations
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / arch / powerpc / platforms / cell / spufs / file.c
1 /*
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
23 #undef DEBUG
24
25 #include <linux/fs.h>
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/slab.h>
33
34 #include <asm/io.h>
35 #include <asm/time.h>
36 #include <asm/spu.h>
37 #include <asm/spu_info.h>
38 #include <asm/uaccess.h>
39
40 #include "spufs.h"
41 #include "sputrace.h"
42
43 #define SPUFS_MMAP_4K (PAGE_SIZE == 0x1000)
44
45 /* Simple attribute files */
46 struct spufs_attr {
47 int (*get)(void *, u64 *);
48 int (*set)(void *, u64);
49 char get_buf[24]; /* enough to store a u64 and "\n\0" */
50 char set_buf[24];
51 void *data;
52 const char *fmt; /* format for read operation */
53 struct mutex mutex; /* protects access to these buffers */
54 };
55
56 static int spufs_attr_open(struct inode *inode, struct file *file,
57 int (*get)(void *, u64 *), int (*set)(void *, u64),
58 const char *fmt)
59 {
60 struct spufs_attr *attr;
61
62 attr = kmalloc(sizeof(*attr), GFP_KERNEL);
63 if (!attr)
64 return -ENOMEM;
65
66 attr->get = get;
67 attr->set = set;
68 attr->data = inode->i_private;
69 attr->fmt = fmt;
70 mutex_init(&attr->mutex);
71 file->private_data = attr;
72
73 return nonseekable_open(inode, file);
74 }
75
76 static int spufs_attr_release(struct inode *inode, struct file *file)
77 {
78 kfree(file->private_data);
79 return 0;
80 }
81
82 static ssize_t spufs_attr_read(struct file *file, char __user *buf,
83 size_t len, loff_t *ppos)
84 {
85 struct spufs_attr *attr;
86 size_t size;
87 ssize_t ret;
88
89 attr = file->private_data;
90 if (!attr->get)
91 return -EACCES;
92
93 ret = mutex_lock_interruptible(&attr->mutex);
94 if (ret)
95 return ret;
96
97 if (*ppos) { /* continued read */
98 size = strlen(attr->get_buf);
99 } else { /* first read */
100 u64 val;
101 ret = attr->get(attr->data, &val);
102 if (ret)
103 goto out;
104
105 size = scnprintf(attr->get_buf, sizeof(attr->get_buf),
106 attr->fmt, (unsigned long long)val);
107 }
108
109 ret = simple_read_from_buffer(buf, len, ppos, attr->get_buf, size);
110 out:
111 mutex_unlock(&attr->mutex);
112 return ret;
113 }
114
115 static ssize_t spufs_attr_write(struct file *file, const char __user *buf,
116 size_t len, loff_t *ppos)
117 {
118 struct spufs_attr *attr;
119 u64 val;
120 size_t size;
121 ssize_t ret;
122
123 attr = file->private_data;
124 if (!attr->set)
125 return -EACCES;
126
127 ret = mutex_lock_interruptible(&attr->mutex);
128 if (ret)
129 return ret;
130
131 ret = -EFAULT;
132 size = min(sizeof(attr->set_buf) - 1, len);
133 if (copy_from_user(attr->set_buf, buf, size))
134 goto out;
135
136 ret = len; /* claim we got the whole input */
137 attr->set_buf[size] = '\0';
138 val = simple_strtol(attr->set_buf, NULL, 0);
139 attr->set(attr->data, val);
140 out:
141 mutex_unlock(&attr->mutex);
142 return ret;
143 }
144
145 #define DEFINE_SPUFS_SIMPLE_ATTRIBUTE(__fops, __get, __set, __fmt) \
146 static int __fops ## _open(struct inode *inode, struct file *file) \
147 { \
148 __simple_attr_check_format(__fmt, 0ull); \
149 return spufs_attr_open(inode, file, __get, __set, __fmt); \
150 } \
151 static const struct file_operations __fops = { \
152 .owner = THIS_MODULE, \
153 .open = __fops ## _open, \
154 .release = spufs_attr_release, \
155 .read = spufs_attr_read, \
156 .write = spufs_attr_write, \
157 .llseek = generic_file_llseek, \
158 };
159
160
161 static int
162 spufs_mem_open(struct inode *inode, struct file *file)
163 {
164 struct spufs_inode_info *i = SPUFS_I(inode);
165 struct spu_context *ctx = i->i_ctx;
166
167 mutex_lock(&ctx->mapping_lock);
168 file->private_data = ctx;
169 if (!i->i_openers++)
170 ctx->local_store = inode->i_mapping;
171 mutex_unlock(&ctx->mapping_lock);
172 return 0;
173 }
174
175 static int
176 spufs_mem_release(struct inode *inode, struct file *file)
177 {
178 struct spufs_inode_info *i = SPUFS_I(inode);
179 struct spu_context *ctx = i->i_ctx;
180
181 mutex_lock(&ctx->mapping_lock);
182 if (!--i->i_openers)
183 ctx->local_store = NULL;
184 mutex_unlock(&ctx->mapping_lock);
185 return 0;
186 }
187
188 static ssize_t
189 __spufs_mem_read(struct spu_context *ctx, char __user *buffer,
190 size_t size, loff_t *pos)
191 {
192 char *local_store = ctx->ops->get_ls(ctx);
193 return simple_read_from_buffer(buffer, size, pos, local_store,
194 LS_SIZE);
195 }
196
197 static ssize_t
198 spufs_mem_read(struct file *file, char __user *buffer,
199 size_t size, loff_t *pos)
200 {
201 struct spu_context *ctx = file->private_data;
202 ssize_t ret;
203
204 ret = spu_acquire(ctx);
205 if (ret)
206 return ret;
207 ret = __spufs_mem_read(ctx, buffer, size, pos);
208 spu_release(ctx);
209
210 return ret;
211 }
212
213 static ssize_t
214 spufs_mem_write(struct file *file, const char __user *buffer,
215 size_t size, loff_t *ppos)
216 {
217 struct spu_context *ctx = file->private_data;
218 char *local_store;
219 loff_t pos = *ppos;
220 int ret;
221
222 if (pos < 0)
223 return -EINVAL;
224 if (pos > LS_SIZE)
225 return -EFBIG;
226 if (size > LS_SIZE - pos)
227 size = LS_SIZE - pos;
228
229 ret = spu_acquire(ctx);
230 if (ret)
231 return ret;
232
233 local_store = ctx->ops->get_ls(ctx);
234 ret = copy_from_user(local_store + pos, buffer, size);
235 spu_release(ctx);
236
237 if (ret)
238 return -EFAULT;
239 *ppos = pos + size;
240 return size;
241 }
242
243 static int
244 spufs_mem_mmap_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
245 {
246 struct spu_context *ctx = vma->vm_file->private_data;
247 unsigned long address = (unsigned long)vmf->virtual_address;
248 unsigned long pfn, offset;
249
250 #ifdef CONFIG_SPU_FS_64K_LS
251 struct spu_state *csa = &ctx->csa;
252 int psize;
253
254 /* Check what page size we are using */
255 psize = get_slice_psize(vma->vm_mm, address);
256
257 /* Some sanity checking */
258 BUG_ON(csa->use_big_pages != (psize == MMU_PAGE_64K));
259
260 /* Wow, 64K, cool, we need to align the address though */
261 if (csa->use_big_pages) {
262 BUG_ON(vma->vm_start & 0xffff);
263 address &= ~0xfffful;
264 }
265 #endif /* CONFIG_SPU_FS_64K_LS */
266
267 offset = vmf->pgoff << PAGE_SHIFT;
268 if (offset >= LS_SIZE)
269 return VM_FAULT_SIGBUS;
270
271 pr_debug("spufs_mem_mmap_fault address=0x%lx, offset=0x%lx\n",
272 address, offset);
273
274 if (spu_acquire(ctx))
275 return VM_FAULT_NOPAGE;
276
277 if (ctx->state == SPU_STATE_SAVED) {
278 vma->vm_page_prot = pgprot_cached(vma->vm_page_prot);
279 pfn = vmalloc_to_pfn(ctx->csa.lscsa->ls + offset);
280 } else {
281 vma->vm_page_prot = pgprot_noncached_wc(vma->vm_page_prot);
282 pfn = (ctx->spu->local_store_phys + offset) >> PAGE_SHIFT;
283 }
284 vm_insert_pfn(vma, address, pfn);
285
286 spu_release(ctx);
287
288 return VM_FAULT_NOPAGE;
289 }
290
291 static int spufs_mem_mmap_access(struct vm_area_struct *vma,
292 unsigned long address,
293 void *buf, int len, int write)
294 {
295 struct spu_context *ctx = vma->vm_file->private_data;
296 unsigned long offset = address - vma->vm_start;
297 char *local_store;
298
299 if (write && !(vma->vm_flags & VM_WRITE))
300 return -EACCES;
301 if (spu_acquire(ctx))
302 return -EINTR;
303 if ((offset + len) > vma->vm_end)
304 len = vma->vm_end - offset;
305 local_store = ctx->ops->get_ls(ctx);
306 if (write)
307 memcpy_toio(local_store + offset, buf, len);
308 else
309 memcpy_fromio(buf, local_store + offset, len);
310 spu_release(ctx);
311 return len;
312 }
313
314 static const struct vm_operations_struct spufs_mem_mmap_vmops = {
315 .fault = spufs_mem_mmap_fault,
316 .access = spufs_mem_mmap_access,
317 };
318
319 static int spufs_mem_mmap(struct file *file, struct vm_area_struct *vma)
320 {
321 #ifdef CONFIG_SPU_FS_64K_LS
322 struct spu_context *ctx = file->private_data;
323 struct spu_state *csa = &ctx->csa;
324
325 /* Sanity check VMA alignment */
326 if (csa->use_big_pages) {
327 pr_debug("spufs_mem_mmap 64K, start=0x%lx, end=0x%lx,"
328 " pgoff=0x%lx\n", vma->vm_start, vma->vm_end,
329 vma->vm_pgoff);
330 if (vma->vm_start & 0xffff)
331 return -EINVAL;
332 if (vma->vm_pgoff & 0xf)
333 return -EINVAL;
334 }
335 #endif /* CONFIG_SPU_FS_64K_LS */
336
337 if (!(vma->vm_flags & VM_SHARED))
338 return -EINVAL;
339
340 vma->vm_flags |= VM_IO | VM_PFNMAP;
341 vma->vm_page_prot = pgprot_noncached_wc(vma->vm_page_prot);
342
343 vma->vm_ops = &spufs_mem_mmap_vmops;
344 return 0;
345 }
346
347 #ifdef CONFIG_SPU_FS_64K_LS
348 static unsigned long spufs_get_unmapped_area(struct file *file,
349 unsigned long addr, unsigned long len, unsigned long pgoff,
350 unsigned long flags)
351 {
352 struct spu_context *ctx = file->private_data;
353 struct spu_state *csa = &ctx->csa;
354
355 /* If not using big pages, fallback to normal MM g_u_a */
356 if (!csa->use_big_pages)
357 return current->mm->get_unmapped_area(file, addr, len,
358 pgoff, flags);
359
360 /* Else, try to obtain a 64K pages slice */
361 return slice_get_unmapped_area(addr, len, flags,
362 MMU_PAGE_64K, 1, 0);
363 }
364 #endif /* CONFIG_SPU_FS_64K_LS */
365
366 static const struct file_operations spufs_mem_fops = {
367 .open = spufs_mem_open,
368 .release = spufs_mem_release,
369 .read = spufs_mem_read,
370 .write = spufs_mem_write,
371 .llseek = generic_file_llseek,
372 .mmap = spufs_mem_mmap,
373 #ifdef CONFIG_SPU_FS_64K_LS
374 .get_unmapped_area = spufs_get_unmapped_area,
375 #endif
376 };
377
378 static int spufs_ps_fault(struct vm_area_struct *vma,
379 struct vm_fault *vmf,
380 unsigned long ps_offs,
381 unsigned long ps_size)
382 {
383 struct spu_context *ctx = vma->vm_file->private_data;
384 unsigned long area, offset = vmf->pgoff << PAGE_SHIFT;
385 int ret = 0;
386
387 spu_context_nospu_trace(spufs_ps_fault__enter, ctx);
388
389 if (offset >= ps_size)
390 return VM_FAULT_SIGBUS;
391
392 if (fatal_signal_pending(current))
393 return VM_FAULT_SIGBUS;
394
395 /*
396 * Because we release the mmap_sem, the context may be destroyed while
397 * we're in spu_wait. Grab an extra reference so it isn't destroyed
398 * in the meantime.
399 */
400 get_spu_context(ctx);
401
402 /*
403 * We have to wait for context to be loaded before we have
404 * pages to hand out to the user, but we don't want to wait
405 * with the mmap_sem held.
406 * It is possible to drop the mmap_sem here, but then we need
407 * to return VM_FAULT_NOPAGE because the mappings may have
408 * hanged.
409 */
410 if (spu_acquire(ctx))
411 goto refault;
412
413 if (ctx->state == SPU_STATE_SAVED) {
414 up_read(&current->mm->mmap_sem);
415 spu_context_nospu_trace(spufs_ps_fault__sleep, ctx);
416 ret = spufs_wait(ctx->run_wq, ctx->state == SPU_STATE_RUNNABLE);
417 spu_context_trace(spufs_ps_fault__wake, ctx, ctx->spu);
418 down_read(&current->mm->mmap_sem);
419 } else {
420 area = ctx->spu->problem_phys + ps_offs;
421 vm_insert_pfn(vma, (unsigned long)vmf->virtual_address,
422 (area + offset) >> PAGE_SHIFT);
423 spu_context_trace(spufs_ps_fault__insert, ctx, ctx->spu);
424 }
425
426 if (!ret)
427 spu_release(ctx);
428
429 refault:
430 put_spu_context(ctx);
431 return VM_FAULT_NOPAGE;
432 }
433
434 #if SPUFS_MMAP_4K
435 static int spufs_cntl_mmap_fault(struct vm_area_struct *vma,
436 struct vm_fault *vmf)
437 {
438 return spufs_ps_fault(vma, vmf, 0x4000, SPUFS_CNTL_MAP_SIZE);
439 }
440
441 static const struct vm_operations_struct spufs_cntl_mmap_vmops = {
442 .fault = spufs_cntl_mmap_fault,
443 };
444
445 /*
446 * mmap support for problem state control area [0x4000 - 0x4fff].
447 */
448 static int spufs_cntl_mmap(struct file *file, struct vm_area_struct *vma)
449 {
450 if (!(vma->vm_flags & VM_SHARED))
451 return -EINVAL;
452
453 vma->vm_flags |= VM_IO | VM_PFNMAP;
454 vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
455
456 vma->vm_ops = &spufs_cntl_mmap_vmops;
457 return 0;
458 }
459 #else /* SPUFS_MMAP_4K */
460 #define spufs_cntl_mmap NULL
461 #endif /* !SPUFS_MMAP_4K */
462
463 static int spufs_cntl_get(void *data, u64 *val)
464 {
465 struct spu_context *ctx = data;
466 int ret;
467
468 ret = spu_acquire(ctx);
469 if (ret)
470 return ret;
471 *val = ctx->ops->status_read(ctx);
472 spu_release(ctx);
473
474 return 0;
475 }
476
477 static int spufs_cntl_set(void *data, u64 val)
478 {
479 struct spu_context *ctx = data;
480 int ret;
481
482 ret = spu_acquire(ctx);
483 if (ret)
484 return ret;
485 ctx->ops->runcntl_write(ctx, val);
486 spu_release(ctx);
487
488 return 0;
489 }
490
491 static int spufs_cntl_open(struct inode *inode, struct file *file)
492 {
493 struct spufs_inode_info *i = SPUFS_I(inode);
494 struct spu_context *ctx = i->i_ctx;
495
496 mutex_lock(&ctx->mapping_lock);
497 file->private_data = ctx;
498 if (!i->i_openers++)
499 ctx->cntl = inode->i_mapping;
500 mutex_unlock(&ctx->mapping_lock);
501 return simple_attr_open(inode, file, spufs_cntl_get,
502 spufs_cntl_set, "0x%08lx");
503 }
504
505 static int
506 spufs_cntl_release(struct inode *inode, struct file *file)
507 {
508 struct spufs_inode_info *i = SPUFS_I(inode);
509 struct spu_context *ctx = i->i_ctx;
510
511 simple_attr_release(inode, file);
512
513 mutex_lock(&ctx->mapping_lock);
514 if (!--i->i_openers)
515 ctx->cntl = NULL;
516 mutex_unlock(&ctx->mapping_lock);
517 return 0;
518 }
519
520 static const struct file_operations spufs_cntl_fops = {
521 .open = spufs_cntl_open,
522 .release = spufs_cntl_release,
523 .read = simple_attr_read,
524 .write = simple_attr_write,
525 .llseek = generic_file_llseek,
526 .mmap = spufs_cntl_mmap,
527 };
528
529 static int
530 spufs_regs_open(struct inode *inode, struct file *file)
531 {
532 struct spufs_inode_info *i = SPUFS_I(inode);
533 file->private_data = i->i_ctx;
534 return 0;
535 }
536
537 static ssize_t
538 __spufs_regs_read(struct spu_context *ctx, char __user *buffer,
539 size_t size, loff_t *pos)
540 {
541 struct spu_lscsa *lscsa = ctx->csa.lscsa;
542 return simple_read_from_buffer(buffer, size, pos,
543 lscsa->gprs, sizeof lscsa->gprs);
544 }
545
546 static ssize_t
547 spufs_regs_read(struct file *file, char __user *buffer,
548 size_t size, loff_t *pos)
549 {
550 int ret;
551 struct spu_context *ctx = file->private_data;
552
553 /* pre-check for file position: if we'd return EOF, there's no point
554 * causing a deschedule */
555 if (*pos >= sizeof(ctx->csa.lscsa->gprs))
556 return 0;
557
558 ret = spu_acquire_saved(ctx);
559 if (ret)
560 return ret;
561 ret = __spufs_regs_read(ctx, buffer, size, pos);
562 spu_release_saved(ctx);
563 return ret;
564 }
565
566 static ssize_t
567 spufs_regs_write(struct file *file, const char __user *buffer,
568 size_t size, loff_t *pos)
569 {
570 struct spu_context *ctx = file->private_data;
571 struct spu_lscsa *lscsa = ctx->csa.lscsa;
572 int ret;
573
574 if (*pos >= sizeof(lscsa->gprs))
575 return -EFBIG;
576
577 size = min_t(ssize_t, sizeof(lscsa->gprs) - *pos, size);
578 *pos += size;
579
580 ret = spu_acquire_saved(ctx);
581 if (ret)
582 return ret;
583
584 ret = copy_from_user((char *)lscsa->gprs + *pos - size,
585 buffer, size) ? -EFAULT : size;
586
587 spu_release_saved(ctx);
588 return ret;
589 }
590
591 static const struct file_operations spufs_regs_fops = {
592 .open = spufs_regs_open,
593 .read = spufs_regs_read,
594 .write = spufs_regs_write,
595 .llseek = generic_file_llseek,
596 };
597
598 static ssize_t
599 __spufs_fpcr_read(struct spu_context *ctx, char __user * buffer,
600 size_t size, loff_t * pos)
601 {
602 struct spu_lscsa *lscsa = ctx->csa.lscsa;
603 return simple_read_from_buffer(buffer, size, pos,
604 &lscsa->fpcr, sizeof(lscsa->fpcr));
605 }
606
607 static ssize_t
608 spufs_fpcr_read(struct file *file, char __user * buffer,
609 size_t size, loff_t * pos)
610 {
611 int ret;
612 struct spu_context *ctx = file->private_data;
613
614 ret = spu_acquire_saved(ctx);
615 if (ret)
616 return ret;
617 ret = __spufs_fpcr_read(ctx, buffer, size, pos);
618 spu_release_saved(ctx);
619 return ret;
620 }
621
622 static ssize_t
623 spufs_fpcr_write(struct file *file, const char __user * buffer,
624 size_t size, loff_t * pos)
625 {
626 struct spu_context *ctx = file->private_data;
627 struct spu_lscsa *lscsa = ctx->csa.lscsa;
628 int ret;
629
630 if (*pos >= sizeof(lscsa->fpcr))
631 return -EFBIG;
632
633 size = min_t(ssize_t, sizeof(lscsa->fpcr) - *pos, size);
634
635 ret = spu_acquire_saved(ctx);
636 if (ret)
637 return ret;
638
639 *pos += size;
640 ret = copy_from_user((char *)&lscsa->fpcr + *pos - size,
641 buffer, size) ? -EFAULT : size;
642
643 spu_release_saved(ctx);
644 return ret;
645 }
646
647 static const struct file_operations spufs_fpcr_fops = {
648 .open = spufs_regs_open,
649 .read = spufs_fpcr_read,
650 .write = spufs_fpcr_write,
651 .llseek = generic_file_llseek,
652 };
653
654 /* generic open function for all pipe-like files */
655 static int spufs_pipe_open(struct inode *inode, struct file *file)
656 {
657 struct spufs_inode_info *i = SPUFS_I(inode);
658 file->private_data = i->i_ctx;
659
660 return nonseekable_open(inode, file);
661 }
662
663 /*
664 * Read as many bytes from the mailbox as possible, until
665 * one of the conditions becomes true:
666 *
667 * - no more data available in the mailbox
668 * - end of the user provided buffer
669 * - end of the mapped area
670 */
671 static ssize_t spufs_mbox_read(struct file *file, char __user *buf,
672 size_t len, loff_t *pos)
673 {
674 struct spu_context *ctx = file->private_data;
675 u32 mbox_data, __user *udata;
676 ssize_t count;
677
678 if (len < 4)
679 return -EINVAL;
680
681 if (!access_ok(VERIFY_WRITE, buf, len))
682 return -EFAULT;
683
684 udata = (void __user *)buf;
685
686 count = spu_acquire(ctx);
687 if (count)
688 return count;
689
690 for (count = 0; (count + 4) <= len; count += 4, udata++) {
691 int ret;
692 ret = ctx->ops->mbox_read(ctx, &mbox_data);
693 if (ret == 0)
694 break;
695
696 /*
697 * at the end of the mapped area, we can fault
698 * but still need to return the data we have
699 * read successfully so far.
700 */
701 ret = __put_user(mbox_data, udata);
702 if (ret) {
703 if (!count)
704 count = -EFAULT;
705 break;
706 }
707 }
708 spu_release(ctx);
709
710 if (!count)
711 count = -EAGAIN;
712
713 return count;
714 }
715
716 static const struct file_operations spufs_mbox_fops = {
717 .open = spufs_pipe_open,
718 .read = spufs_mbox_read,
719 .llseek = no_llseek,
720 };
721
722 static ssize_t spufs_mbox_stat_read(struct file *file, char __user *buf,
723 size_t len, loff_t *pos)
724 {
725 struct spu_context *ctx = file->private_data;
726 ssize_t ret;
727 u32 mbox_stat;
728
729 if (len < 4)
730 return -EINVAL;
731
732 ret = spu_acquire(ctx);
733 if (ret)
734 return ret;
735
736 mbox_stat = ctx->ops->mbox_stat_read(ctx) & 0xff;
737
738 spu_release(ctx);
739
740 if (copy_to_user(buf, &mbox_stat, sizeof mbox_stat))
741 return -EFAULT;
742
743 return 4;
744 }
745
746 static const struct file_operations spufs_mbox_stat_fops = {
747 .open = spufs_pipe_open,
748 .read = spufs_mbox_stat_read,
749 .llseek = no_llseek,
750 };
751
752 /* low-level ibox access function */
753 size_t spu_ibox_read(struct spu_context *ctx, u32 *data)
754 {
755 return ctx->ops->ibox_read(ctx, data);
756 }
757
758 static int spufs_ibox_fasync(int fd, struct file *file, int on)
759 {
760 struct spu_context *ctx = file->private_data;
761
762 return fasync_helper(fd, file, on, &ctx->ibox_fasync);
763 }
764
765 /* interrupt-level ibox callback function. */
766 void spufs_ibox_callback(struct spu *spu)
767 {
768 struct spu_context *ctx = spu->ctx;
769
770 if (!ctx)
771 return;
772
773 wake_up_all(&ctx->ibox_wq);
774 kill_fasync(&ctx->ibox_fasync, SIGIO, POLLIN);
775 }
776
777 /*
778 * Read as many bytes from the interrupt mailbox as possible, until
779 * one of the conditions becomes true:
780 *
781 * - no more data available in the mailbox
782 * - end of the user provided buffer
783 * - end of the mapped area
784 *
785 * If the file is opened without O_NONBLOCK, we wait here until
786 * any data is available, but return when we have been able to
787 * read something.
788 */
789 static ssize_t spufs_ibox_read(struct file *file, char __user *buf,
790 size_t len, loff_t *pos)
791 {
792 struct spu_context *ctx = file->private_data;
793 u32 ibox_data, __user *udata;
794 ssize_t count;
795
796 if (len < 4)
797 return -EINVAL;
798
799 if (!access_ok(VERIFY_WRITE, buf, len))
800 return -EFAULT;
801
802 udata = (void __user *)buf;
803
804 count = spu_acquire(ctx);
805 if (count)
806 goto out;
807
808 /* wait only for the first element */
809 count = 0;
810 if (file->f_flags & O_NONBLOCK) {
811 if (!spu_ibox_read(ctx, &ibox_data)) {
812 count = -EAGAIN;
813 goto out_unlock;
814 }
815 } else {
816 count = spufs_wait(ctx->ibox_wq, spu_ibox_read(ctx, &ibox_data));
817 if (count)
818 goto out;
819 }
820
821 /* if we can't write at all, return -EFAULT */
822 count = __put_user(ibox_data, udata);
823 if (count)
824 goto out_unlock;
825
826 for (count = 4, udata++; (count + 4) <= len; count += 4, udata++) {
827 int ret;
828 ret = ctx->ops->ibox_read(ctx, &ibox_data);
829 if (ret == 0)
830 break;
831 /*
832 * at the end of the mapped area, we can fault
833 * but still need to return the data we have
834 * read successfully so far.
835 */
836 ret = __put_user(ibox_data, udata);
837 if (ret)
838 break;
839 }
840
841 out_unlock:
842 spu_release(ctx);
843 out:
844 return count;
845 }
846
847 static unsigned int spufs_ibox_poll(struct file *file, poll_table *wait)
848 {
849 struct spu_context *ctx = file->private_data;
850 unsigned int mask;
851
852 poll_wait(file, &ctx->ibox_wq, wait);
853
854 /*
855 * For now keep this uninterruptible and also ignore the rule
856 * that poll should not sleep. Will be fixed later.
857 */
858 mutex_lock(&ctx->state_mutex);
859 mask = ctx->ops->mbox_stat_poll(ctx, POLLIN | POLLRDNORM);
860 spu_release(ctx);
861
862 return mask;
863 }
864
865 static const struct file_operations spufs_ibox_fops = {
866 .open = spufs_pipe_open,
867 .read = spufs_ibox_read,
868 .poll = spufs_ibox_poll,
869 .fasync = spufs_ibox_fasync,
870 .llseek = no_llseek,
871 };
872
873 static ssize_t spufs_ibox_stat_read(struct file *file, char __user *buf,
874 size_t len, loff_t *pos)
875 {
876 struct spu_context *ctx = file->private_data;
877 ssize_t ret;
878 u32 ibox_stat;
879
880 if (len < 4)
881 return -EINVAL;
882
883 ret = spu_acquire(ctx);
884 if (ret)
885 return ret;
886 ibox_stat = (ctx->ops->mbox_stat_read(ctx) >> 16) & 0xff;
887 spu_release(ctx);
888
889 if (copy_to_user(buf, &ibox_stat, sizeof ibox_stat))
890 return -EFAULT;
891
892 return 4;
893 }
894
895 static const struct file_operations spufs_ibox_stat_fops = {
896 .open = spufs_pipe_open,
897 .read = spufs_ibox_stat_read,
898 .llseek = no_llseek,
899 };
900
901 /* low-level mailbox write */
902 size_t spu_wbox_write(struct spu_context *ctx, u32 data)
903 {
904 return ctx->ops->wbox_write(ctx, data);
905 }
906
907 static int spufs_wbox_fasync(int fd, struct file *file, int on)
908 {
909 struct spu_context *ctx = file->private_data;
910 int ret;
911
912 ret = fasync_helper(fd, file, on, &ctx->wbox_fasync);
913
914 return ret;
915 }
916
917 /* interrupt-level wbox callback function. */
918 void spufs_wbox_callback(struct spu *spu)
919 {
920 struct spu_context *ctx = spu->ctx;
921
922 if (!ctx)
923 return;
924
925 wake_up_all(&ctx->wbox_wq);
926 kill_fasync(&ctx->wbox_fasync, SIGIO, POLLOUT);
927 }
928
929 /*
930 * Write as many bytes to the interrupt mailbox as possible, until
931 * one of the conditions becomes true:
932 *
933 * - the mailbox is full
934 * - end of the user provided buffer
935 * - end of the mapped area
936 *
937 * If the file is opened without O_NONBLOCK, we wait here until
938 * space is availabyl, but return when we have been able to
939 * write something.
940 */
941 static ssize_t spufs_wbox_write(struct file *file, const char __user *buf,
942 size_t len, loff_t *pos)
943 {
944 struct spu_context *ctx = file->private_data;
945 u32 wbox_data, __user *udata;
946 ssize_t count;
947
948 if (len < 4)
949 return -EINVAL;
950
951 udata = (void __user *)buf;
952 if (!access_ok(VERIFY_READ, buf, len))
953 return -EFAULT;
954
955 if (__get_user(wbox_data, udata))
956 return -EFAULT;
957
958 count = spu_acquire(ctx);
959 if (count)
960 goto out;
961
962 /*
963 * make sure we can at least write one element, by waiting
964 * in case of !O_NONBLOCK
965 */
966 count = 0;
967 if (file->f_flags & O_NONBLOCK) {
968 if (!spu_wbox_write(ctx, wbox_data)) {
969 count = -EAGAIN;
970 goto out_unlock;
971 }
972 } else {
973 count = spufs_wait(ctx->wbox_wq, spu_wbox_write(ctx, wbox_data));
974 if (count)
975 goto out;
976 }
977
978
979 /* write as much as possible */
980 for (count = 4, udata++; (count + 4) <= len; count += 4, udata++) {
981 int ret;
982 ret = __get_user(wbox_data, udata);
983 if (ret)
984 break;
985
986 ret = spu_wbox_write(ctx, wbox_data);
987 if (ret == 0)
988 break;
989 }
990
991 out_unlock:
992 spu_release(ctx);
993 out:
994 return count;
995 }
996
997 static unsigned int spufs_wbox_poll(struct file *file, poll_table *wait)
998 {
999 struct spu_context *ctx = file->private_data;
1000 unsigned int mask;
1001
1002 poll_wait(file, &ctx->wbox_wq, wait);
1003
1004 /*
1005 * For now keep this uninterruptible and also ignore the rule
1006 * that poll should not sleep. Will be fixed later.
1007 */
1008 mutex_lock(&ctx->state_mutex);
1009 mask = ctx->ops->mbox_stat_poll(ctx, POLLOUT | POLLWRNORM);
1010 spu_release(ctx);
1011
1012 return mask;
1013 }
1014
1015 static const struct file_operations spufs_wbox_fops = {
1016 .open = spufs_pipe_open,
1017 .write = spufs_wbox_write,
1018 .poll = spufs_wbox_poll,
1019 .fasync = spufs_wbox_fasync,
1020 .llseek = no_llseek,
1021 };
1022
1023 static ssize_t spufs_wbox_stat_read(struct file *file, char __user *buf,
1024 size_t len, loff_t *pos)
1025 {
1026 struct spu_context *ctx = file->private_data;
1027 ssize_t ret;
1028 u32 wbox_stat;
1029
1030 if (len < 4)
1031 return -EINVAL;
1032
1033 ret = spu_acquire(ctx);
1034 if (ret)
1035 return ret;
1036 wbox_stat = (ctx->ops->mbox_stat_read(ctx) >> 8) & 0xff;
1037 spu_release(ctx);
1038
1039 if (copy_to_user(buf, &wbox_stat, sizeof wbox_stat))
1040 return -EFAULT;
1041
1042 return 4;
1043 }
1044
1045 static const struct file_operations spufs_wbox_stat_fops = {
1046 .open = spufs_pipe_open,
1047 .read = spufs_wbox_stat_read,
1048 .llseek = no_llseek,
1049 };
1050
1051 static int spufs_signal1_open(struct inode *inode, struct file *file)
1052 {
1053 struct spufs_inode_info *i = SPUFS_I(inode);
1054 struct spu_context *ctx = i->i_ctx;
1055
1056 mutex_lock(&ctx->mapping_lock);
1057 file->private_data = ctx;
1058 if (!i->i_openers++)
1059 ctx->signal1 = inode->i_mapping;
1060 mutex_unlock(&ctx->mapping_lock);
1061 return nonseekable_open(inode, file);
1062 }
1063
1064 static int
1065 spufs_signal1_release(struct inode *inode, struct file *file)
1066 {
1067 struct spufs_inode_info *i = SPUFS_I(inode);
1068 struct spu_context *ctx = i->i_ctx;
1069
1070 mutex_lock(&ctx->mapping_lock);
1071 if (!--i->i_openers)
1072 ctx->signal1 = NULL;
1073 mutex_unlock(&ctx->mapping_lock);
1074 return 0;
1075 }
1076
1077 static ssize_t __spufs_signal1_read(struct spu_context *ctx, char __user *buf,
1078 size_t len, loff_t *pos)
1079 {
1080 int ret = 0;
1081 u32 data;
1082
1083 if (len < 4)
1084 return -EINVAL;
1085
1086 if (ctx->csa.spu_chnlcnt_RW[3]) {
1087 data = ctx->csa.spu_chnldata_RW[3];
1088 ret = 4;
1089 }
1090
1091 if (!ret)
1092 goto out;
1093
1094 if (copy_to_user(buf, &data, 4))
1095 return -EFAULT;
1096
1097 out:
1098 return ret;
1099 }
1100
1101 static ssize_t spufs_signal1_read(struct file *file, char __user *buf,
1102 size_t len, loff_t *pos)
1103 {
1104 int ret;
1105 struct spu_context *ctx = file->private_data;
1106
1107 ret = spu_acquire_saved(ctx);
1108 if (ret)
1109 return ret;
1110 ret = __spufs_signal1_read(ctx, buf, len, pos);
1111 spu_release_saved(ctx);
1112
1113 return ret;
1114 }
1115
1116 static ssize_t spufs_signal1_write(struct file *file, const char __user *buf,
1117 size_t len, loff_t *pos)
1118 {
1119 struct spu_context *ctx;
1120 ssize_t ret;
1121 u32 data;
1122
1123 ctx = file->private_data;
1124
1125 if (len < 4)
1126 return -EINVAL;
1127
1128 if (copy_from_user(&data, buf, 4))
1129 return -EFAULT;
1130
1131 ret = spu_acquire(ctx);
1132 if (ret)
1133 return ret;
1134 ctx->ops->signal1_write(ctx, data);
1135 spu_release(ctx);
1136
1137 return 4;
1138 }
1139
1140 static int
1141 spufs_signal1_mmap_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
1142 {
1143 #if SPUFS_SIGNAL_MAP_SIZE == 0x1000
1144 return spufs_ps_fault(vma, vmf, 0x14000, SPUFS_SIGNAL_MAP_SIZE);
1145 #elif SPUFS_SIGNAL_MAP_SIZE == 0x10000
1146 /* For 64k pages, both signal1 and signal2 can be used to mmap the whole
1147 * signal 1 and 2 area
1148 */
1149 return spufs_ps_fault(vma, vmf, 0x10000, SPUFS_SIGNAL_MAP_SIZE);
1150 #else
1151 #error unsupported page size
1152 #endif
1153 }
1154
1155 static const struct vm_operations_struct spufs_signal1_mmap_vmops = {
1156 .fault = spufs_signal1_mmap_fault,
1157 };
1158
1159 static int spufs_signal1_mmap(struct file *file, struct vm_area_struct *vma)
1160 {
1161 if (!(vma->vm_flags & VM_SHARED))
1162 return -EINVAL;
1163
1164 vma->vm_flags |= VM_IO | VM_PFNMAP;
1165 vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
1166
1167 vma->vm_ops = &spufs_signal1_mmap_vmops;
1168 return 0;
1169 }
1170
1171 static const struct file_operations spufs_signal1_fops = {
1172 .open = spufs_signal1_open,
1173 .release = spufs_signal1_release,
1174 .read = spufs_signal1_read,
1175 .write = spufs_signal1_write,
1176 .mmap = spufs_signal1_mmap,
1177 .llseek = no_llseek,
1178 };
1179
1180 static const struct file_operations spufs_signal1_nosched_fops = {
1181 .open = spufs_signal1_open,
1182 .release = spufs_signal1_release,
1183 .write = spufs_signal1_write,
1184 .mmap = spufs_signal1_mmap,
1185 .llseek = no_llseek,
1186 };
1187
1188 static int spufs_signal2_open(struct inode *inode, struct file *file)
1189 {
1190 struct spufs_inode_info *i = SPUFS_I(inode);
1191 struct spu_context *ctx = i->i_ctx;
1192
1193 mutex_lock(&ctx->mapping_lock);
1194 file->private_data = ctx;
1195 if (!i->i_openers++)
1196 ctx->signal2 = inode->i_mapping;
1197 mutex_unlock(&ctx->mapping_lock);
1198 return nonseekable_open(inode, file);
1199 }
1200
1201 static int
1202 spufs_signal2_release(struct inode *inode, struct file *file)
1203 {
1204 struct spufs_inode_info *i = SPUFS_I(inode);
1205 struct spu_context *ctx = i->i_ctx;
1206
1207 mutex_lock(&ctx->mapping_lock);
1208 if (!--i->i_openers)
1209 ctx->signal2 = NULL;
1210 mutex_unlock(&ctx->mapping_lock);
1211 return 0;
1212 }
1213
1214 static ssize_t __spufs_signal2_read(struct spu_context *ctx, char __user *buf,
1215 size_t len, loff_t *pos)
1216 {
1217 int ret = 0;
1218 u32 data;
1219
1220 if (len < 4)
1221 return -EINVAL;
1222
1223 if (ctx->csa.spu_chnlcnt_RW[4]) {
1224 data = ctx->csa.spu_chnldata_RW[4];
1225 ret = 4;
1226 }
1227
1228 if (!ret)
1229 goto out;
1230
1231 if (copy_to_user(buf, &data, 4))
1232 return -EFAULT;
1233
1234 out:
1235 return ret;
1236 }
1237
1238 static ssize_t spufs_signal2_read(struct file *file, char __user *buf,
1239 size_t len, loff_t *pos)
1240 {
1241 struct spu_context *ctx = file->private_data;
1242 int ret;
1243
1244 ret = spu_acquire_saved(ctx);
1245 if (ret)
1246 return ret;
1247 ret = __spufs_signal2_read(ctx, buf, len, pos);
1248 spu_release_saved(ctx);
1249
1250 return ret;
1251 }
1252
1253 static ssize_t spufs_signal2_write(struct file *file, const char __user *buf,
1254 size_t len, loff_t *pos)
1255 {
1256 struct spu_context *ctx;
1257 ssize_t ret;
1258 u32 data;
1259
1260 ctx = file->private_data;
1261
1262 if (len < 4)
1263 return -EINVAL;
1264
1265 if (copy_from_user(&data, buf, 4))
1266 return -EFAULT;
1267
1268 ret = spu_acquire(ctx);
1269 if (ret)
1270 return ret;
1271 ctx->ops->signal2_write(ctx, data);
1272 spu_release(ctx);
1273
1274 return 4;
1275 }
1276
1277 #if SPUFS_MMAP_4K
1278 static int
1279 spufs_signal2_mmap_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
1280 {
1281 #if SPUFS_SIGNAL_MAP_SIZE == 0x1000
1282 return spufs_ps_fault(vma, vmf, 0x1c000, SPUFS_SIGNAL_MAP_SIZE);
1283 #elif SPUFS_SIGNAL_MAP_SIZE == 0x10000
1284 /* For 64k pages, both signal1 and signal2 can be used to mmap the whole
1285 * signal 1 and 2 area
1286 */
1287 return spufs_ps_fault(vma, vmf, 0x10000, SPUFS_SIGNAL_MAP_SIZE);
1288 #else
1289 #error unsupported page size
1290 #endif
1291 }
1292
1293 static const struct vm_operations_struct spufs_signal2_mmap_vmops = {
1294 .fault = spufs_signal2_mmap_fault,
1295 };
1296
1297 static int spufs_signal2_mmap(struct file *file, struct vm_area_struct *vma)
1298 {
1299 if (!(vma->vm_flags & VM_SHARED))
1300 return -EINVAL;
1301
1302 vma->vm_flags |= VM_IO | VM_PFNMAP;
1303 vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
1304
1305 vma->vm_ops = &spufs_signal2_mmap_vmops;
1306 return 0;
1307 }
1308 #else /* SPUFS_MMAP_4K */
1309 #define spufs_signal2_mmap NULL
1310 #endif /* !SPUFS_MMAP_4K */
1311
1312 static const struct file_operations spufs_signal2_fops = {
1313 .open = spufs_signal2_open,
1314 .release = spufs_signal2_release,
1315 .read = spufs_signal2_read,
1316 .write = spufs_signal2_write,
1317 .mmap = spufs_signal2_mmap,
1318 .llseek = no_llseek,
1319 };
1320
1321 static const struct file_operations spufs_signal2_nosched_fops = {
1322 .open = spufs_signal2_open,
1323 .release = spufs_signal2_release,
1324 .write = spufs_signal2_write,
1325 .mmap = spufs_signal2_mmap,
1326 .llseek = no_llseek,
1327 };
1328
1329 /*
1330 * This is a wrapper around DEFINE_SIMPLE_ATTRIBUTE which does the
1331 * work of acquiring (or not) the SPU context before calling through
1332 * to the actual get routine. The set routine is called directly.
1333 */
1334 #define SPU_ATTR_NOACQUIRE 0
1335 #define SPU_ATTR_ACQUIRE 1
1336 #define SPU_ATTR_ACQUIRE_SAVED 2
1337
1338 #define DEFINE_SPUFS_ATTRIBUTE(__name, __get, __set, __fmt, __acquire) \
1339 static int __##__get(void *data, u64 *val) \
1340 { \
1341 struct spu_context *ctx = data; \
1342 int ret = 0; \
1343 \
1344 if (__acquire == SPU_ATTR_ACQUIRE) { \
1345 ret = spu_acquire(ctx); \
1346 if (ret) \
1347 return ret; \
1348 *val = __get(ctx); \
1349 spu_release(ctx); \
1350 } else if (__acquire == SPU_ATTR_ACQUIRE_SAVED) { \
1351 ret = spu_acquire_saved(ctx); \
1352 if (ret) \
1353 return ret; \
1354 *val = __get(ctx); \
1355 spu_release_saved(ctx); \
1356 } else \
1357 *val = __get(ctx); \
1358 \
1359 return 0; \
1360 } \
1361 DEFINE_SPUFS_SIMPLE_ATTRIBUTE(__name, __##__get, __set, __fmt);
1362
1363 static int spufs_signal1_type_set(void *data, u64 val)
1364 {
1365 struct spu_context *ctx = data;
1366 int ret;
1367
1368 ret = spu_acquire(ctx);
1369 if (ret)
1370 return ret;
1371 ctx->ops->signal1_type_set(ctx, val);
1372 spu_release(ctx);
1373
1374 return 0;
1375 }
1376
1377 static u64 spufs_signal1_type_get(struct spu_context *ctx)
1378 {
1379 return ctx->ops->signal1_type_get(ctx);
1380 }
1381 DEFINE_SPUFS_ATTRIBUTE(spufs_signal1_type, spufs_signal1_type_get,
1382 spufs_signal1_type_set, "%llu\n", SPU_ATTR_ACQUIRE);
1383
1384
1385 static int spufs_signal2_type_set(void *data, u64 val)
1386 {
1387 struct spu_context *ctx = data;
1388 int ret;
1389
1390 ret = spu_acquire(ctx);
1391 if (ret)
1392 return ret;
1393 ctx->ops->signal2_type_set(ctx, val);
1394 spu_release(ctx);
1395
1396 return 0;
1397 }
1398
1399 static u64 spufs_signal2_type_get(struct spu_context *ctx)
1400 {
1401 return ctx->ops->signal2_type_get(ctx);
1402 }
1403 DEFINE_SPUFS_ATTRIBUTE(spufs_signal2_type, spufs_signal2_type_get,
1404 spufs_signal2_type_set, "%llu\n", SPU_ATTR_ACQUIRE);
1405
1406 #if SPUFS_MMAP_4K
1407 static int
1408 spufs_mss_mmap_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
1409 {
1410 return spufs_ps_fault(vma, vmf, 0x0000, SPUFS_MSS_MAP_SIZE);
1411 }
1412
1413 static const struct vm_operations_struct spufs_mss_mmap_vmops = {
1414 .fault = spufs_mss_mmap_fault,
1415 };
1416
1417 /*
1418 * mmap support for problem state MFC DMA area [0x0000 - 0x0fff].
1419 */
1420 static int spufs_mss_mmap(struct file *file, struct vm_area_struct *vma)
1421 {
1422 if (!(vma->vm_flags & VM_SHARED))
1423 return -EINVAL;
1424
1425 vma->vm_flags |= VM_IO | VM_PFNMAP;
1426 vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
1427
1428 vma->vm_ops = &spufs_mss_mmap_vmops;
1429 return 0;
1430 }
1431 #else /* SPUFS_MMAP_4K */
1432 #define spufs_mss_mmap NULL
1433 #endif /* !SPUFS_MMAP_4K */
1434
1435 static int spufs_mss_open(struct inode *inode, struct file *file)
1436 {
1437 struct spufs_inode_info *i = SPUFS_I(inode);
1438 struct spu_context *ctx = i->i_ctx;
1439
1440 file->private_data = i->i_ctx;
1441
1442 mutex_lock(&ctx->mapping_lock);
1443 if (!i->i_openers++)
1444 ctx->mss = inode->i_mapping;
1445 mutex_unlock(&ctx->mapping_lock);
1446 return nonseekable_open(inode, file);
1447 }
1448
1449 static int
1450 spufs_mss_release(struct inode *inode, struct file *file)
1451 {
1452 struct spufs_inode_info *i = SPUFS_I(inode);
1453 struct spu_context *ctx = i->i_ctx;
1454
1455 mutex_lock(&ctx->mapping_lock);
1456 if (!--i->i_openers)
1457 ctx->mss = NULL;
1458 mutex_unlock(&ctx->mapping_lock);
1459 return 0;
1460 }
1461
1462 static const struct file_operations spufs_mss_fops = {
1463 .open = spufs_mss_open,
1464 .release = spufs_mss_release,
1465 .mmap = spufs_mss_mmap,
1466 .llseek = no_llseek,
1467 };
1468
1469 static int
1470 spufs_psmap_mmap_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
1471 {
1472 return spufs_ps_fault(vma, vmf, 0x0000, SPUFS_PS_MAP_SIZE);
1473 }
1474
1475 static const struct vm_operations_struct spufs_psmap_mmap_vmops = {
1476 .fault = spufs_psmap_mmap_fault,
1477 };
1478
1479 /*
1480 * mmap support for full problem state area [0x00000 - 0x1ffff].
1481 */
1482 static int spufs_psmap_mmap(struct file *file, struct vm_area_struct *vma)
1483 {
1484 if (!(vma->vm_flags & VM_SHARED))
1485 return -EINVAL;
1486
1487 vma->vm_flags |= VM_IO | VM_PFNMAP;
1488 vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
1489
1490 vma->vm_ops = &spufs_psmap_mmap_vmops;
1491 return 0;
1492 }
1493
1494 static int spufs_psmap_open(struct inode *inode, struct file *file)
1495 {
1496 struct spufs_inode_info *i = SPUFS_I(inode);
1497 struct spu_context *ctx = i->i_ctx;
1498
1499 mutex_lock(&ctx->mapping_lock);
1500 file->private_data = i->i_ctx;
1501 if (!i->i_openers++)
1502 ctx->psmap = inode->i_mapping;
1503 mutex_unlock(&ctx->mapping_lock);
1504 return nonseekable_open(inode, file);
1505 }
1506
1507 static int
1508 spufs_psmap_release(struct inode *inode, struct file *file)
1509 {
1510 struct spufs_inode_info *i = SPUFS_I(inode);
1511 struct spu_context *ctx = i->i_ctx;
1512
1513 mutex_lock(&ctx->mapping_lock);
1514 if (!--i->i_openers)
1515 ctx->psmap = NULL;
1516 mutex_unlock(&ctx->mapping_lock);
1517 return 0;
1518 }
1519
1520 static const struct file_operations spufs_psmap_fops = {
1521 .open = spufs_psmap_open,
1522 .release = spufs_psmap_release,
1523 .mmap = spufs_psmap_mmap,
1524 .llseek = no_llseek,
1525 };
1526
1527
1528 #if SPUFS_MMAP_4K
1529 static int
1530 spufs_mfc_mmap_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
1531 {
1532 return spufs_ps_fault(vma, vmf, 0x3000, SPUFS_MFC_MAP_SIZE);
1533 }
1534
1535 static const struct vm_operations_struct spufs_mfc_mmap_vmops = {
1536 .fault = spufs_mfc_mmap_fault,
1537 };
1538
1539 /*
1540 * mmap support for problem state MFC DMA area [0x0000 - 0x0fff].
1541 */
1542 static int spufs_mfc_mmap(struct file *file, struct vm_area_struct *vma)
1543 {
1544 if (!(vma->vm_flags & VM_SHARED))
1545 return -EINVAL;
1546
1547 vma->vm_flags |= VM_IO | VM_PFNMAP;
1548 vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
1549
1550 vma->vm_ops = &spufs_mfc_mmap_vmops;
1551 return 0;
1552 }
1553 #else /* SPUFS_MMAP_4K */
1554 #define spufs_mfc_mmap NULL
1555 #endif /* !SPUFS_MMAP_4K */
1556
1557 static int spufs_mfc_open(struct inode *inode, struct file *file)
1558 {
1559 struct spufs_inode_info *i = SPUFS_I(inode);
1560 struct spu_context *ctx = i->i_ctx;
1561
1562 /* we don't want to deal with DMA into other processes */
1563 if (ctx->owner != current->mm)
1564 return -EINVAL;
1565
1566 if (atomic_read(&inode->i_count) != 1)
1567 return -EBUSY;
1568
1569 mutex_lock(&ctx->mapping_lock);
1570 file->private_data = ctx;
1571 if (!i->i_openers++)
1572 ctx->mfc = inode->i_mapping;
1573 mutex_unlock(&ctx->mapping_lock);
1574 return nonseekable_open(inode, file);
1575 }
1576
1577 static int
1578 spufs_mfc_release(struct inode *inode, struct file *file)
1579 {
1580 struct spufs_inode_info *i = SPUFS_I(inode);
1581 struct spu_context *ctx = i->i_ctx;
1582
1583 mutex_lock(&ctx->mapping_lock);
1584 if (!--i->i_openers)
1585 ctx->mfc = NULL;
1586 mutex_unlock(&ctx->mapping_lock);
1587 return 0;
1588 }
1589
1590 /* interrupt-level mfc callback function. */
1591 void spufs_mfc_callback(struct spu *spu)
1592 {
1593 struct spu_context *ctx = spu->ctx;
1594
1595 if (!ctx)
1596 return;
1597
1598 wake_up_all(&ctx->mfc_wq);
1599
1600 pr_debug("%s %s\n", __func__, spu->name);
1601 if (ctx->mfc_fasync) {
1602 u32 free_elements, tagstatus;
1603 unsigned int mask;
1604
1605 /* no need for spu_acquire in interrupt context */
1606 free_elements = ctx->ops->get_mfc_free_elements(ctx);
1607 tagstatus = ctx->ops->read_mfc_tagstatus(ctx);
1608
1609 mask = 0;
1610 if (free_elements & 0xffff)
1611 mask |= POLLOUT;
1612 if (tagstatus & ctx->tagwait)
1613 mask |= POLLIN;
1614
1615 kill_fasync(&ctx->mfc_fasync, SIGIO, mask);
1616 }
1617 }
1618
1619 static int spufs_read_mfc_tagstatus(struct spu_context *ctx, u32 *status)
1620 {
1621 /* See if there is one tag group is complete */
1622 /* FIXME we need locking around tagwait */
1623 *status = ctx->ops->read_mfc_tagstatus(ctx) & ctx->tagwait;
1624 ctx->tagwait &= ~*status;
1625 if (*status)
1626 return 1;
1627
1628 /* enable interrupt waiting for any tag group,
1629 may silently fail if interrupts are already enabled */
1630 ctx->ops->set_mfc_query(ctx, ctx->tagwait, 1);
1631 return 0;
1632 }
1633
1634 static ssize_t spufs_mfc_read(struct file *file, char __user *buffer,
1635 size_t size, loff_t *pos)
1636 {
1637 struct spu_context *ctx = file->private_data;
1638 int ret = -EINVAL;
1639 u32 status;
1640
1641 if (size != 4)
1642 goto out;
1643
1644 ret = spu_acquire(ctx);
1645 if (ret)
1646 return ret;
1647
1648 ret = -EINVAL;
1649 if (file->f_flags & O_NONBLOCK) {
1650 status = ctx->ops->read_mfc_tagstatus(ctx);
1651 if (!(status & ctx->tagwait))
1652 ret = -EAGAIN;
1653 else
1654 /* XXX(hch): shouldn't we clear ret here? */
1655 ctx->tagwait &= ~status;
1656 } else {
1657 ret = spufs_wait(ctx->mfc_wq,
1658 spufs_read_mfc_tagstatus(ctx, &status));
1659 if (ret)
1660 goto out;
1661 }
1662 spu_release(ctx);
1663
1664 ret = 4;
1665 if (copy_to_user(buffer, &status, 4))
1666 ret = -EFAULT;
1667
1668 out:
1669 return ret;
1670 }
1671
1672 static int spufs_check_valid_dma(struct mfc_dma_command *cmd)
1673 {
1674 pr_debug("queueing DMA %x %llx %x %x %x\n", cmd->lsa,
1675 cmd->ea, cmd->size, cmd->tag, cmd->cmd);
1676
1677 switch (cmd->cmd) {
1678 case MFC_PUT_CMD:
1679 case MFC_PUTF_CMD:
1680 case MFC_PUTB_CMD:
1681 case MFC_GET_CMD:
1682 case MFC_GETF_CMD:
1683 case MFC_GETB_CMD:
1684 break;
1685 default:
1686 pr_debug("invalid DMA opcode %x\n", cmd->cmd);
1687 return -EIO;
1688 }
1689
1690 if ((cmd->lsa & 0xf) != (cmd->ea &0xf)) {
1691 pr_debug("invalid DMA alignment, ea %llx lsa %x\n",
1692 cmd->ea, cmd->lsa);
1693 return -EIO;
1694 }
1695
1696 switch (cmd->size & 0xf) {
1697 case 1:
1698 break;
1699 case 2:
1700 if (cmd->lsa & 1)
1701 goto error;
1702 break;
1703 case 4:
1704 if (cmd->lsa & 3)
1705 goto error;
1706 break;
1707 case 8:
1708 if (cmd->lsa & 7)
1709 goto error;
1710 break;
1711 case 0:
1712 if (cmd->lsa & 15)
1713 goto error;
1714 break;
1715 error:
1716 default:
1717 pr_debug("invalid DMA alignment %x for size %x\n",
1718 cmd->lsa & 0xf, cmd->size);
1719 return -EIO;
1720 }
1721
1722 if (cmd->size > 16 * 1024) {
1723 pr_debug("invalid DMA size %x\n", cmd->size);
1724 return -EIO;
1725 }
1726
1727 if (cmd->tag & 0xfff0) {
1728 /* we reserve the higher tag numbers for kernel use */
1729 pr_debug("invalid DMA tag\n");
1730 return -EIO;
1731 }
1732
1733 if (cmd->class) {
1734 /* not supported in this version */
1735 pr_debug("invalid DMA class\n");
1736 return -EIO;
1737 }
1738
1739 return 0;
1740 }
1741
1742 static int spu_send_mfc_command(struct spu_context *ctx,
1743 struct mfc_dma_command cmd,
1744 int *error)
1745 {
1746 *error = ctx->ops->send_mfc_command(ctx, &cmd);
1747 if (*error == -EAGAIN) {
1748 /* wait for any tag group to complete
1749 so we have space for the new command */
1750 ctx->ops->set_mfc_query(ctx, ctx->tagwait, 1);
1751 /* try again, because the queue might be
1752 empty again */
1753 *error = ctx->ops->send_mfc_command(ctx, &cmd);
1754 if (*error == -EAGAIN)
1755 return 0;
1756 }
1757 return 1;
1758 }
1759
1760 static ssize_t spufs_mfc_write(struct file *file, const char __user *buffer,
1761 size_t size, loff_t *pos)
1762 {
1763 struct spu_context *ctx = file->private_data;
1764 struct mfc_dma_command cmd;
1765 int ret = -EINVAL;
1766
1767 if (size != sizeof cmd)
1768 goto out;
1769
1770 ret = -EFAULT;
1771 if (copy_from_user(&cmd, buffer, sizeof cmd))
1772 goto out;
1773
1774 ret = spufs_check_valid_dma(&cmd);
1775 if (ret)
1776 goto out;
1777
1778 ret = spu_acquire(ctx);
1779 if (ret)
1780 goto out;
1781
1782 ret = spufs_wait(ctx->run_wq, ctx->state == SPU_STATE_RUNNABLE);
1783 if (ret)
1784 goto out;
1785
1786 if (file->f_flags & O_NONBLOCK) {
1787 ret = ctx->ops->send_mfc_command(ctx, &cmd);
1788 } else {
1789 int status;
1790 ret = spufs_wait(ctx->mfc_wq,
1791 spu_send_mfc_command(ctx, cmd, &status));
1792 if (ret)
1793 goto out;
1794 if (status)
1795 ret = status;
1796 }
1797
1798 if (ret)
1799 goto out_unlock;
1800
1801 ctx->tagwait |= 1 << cmd.tag;
1802 ret = size;
1803
1804 out_unlock:
1805 spu_release(ctx);
1806 out:
1807 return ret;
1808 }
1809
1810 static unsigned int spufs_mfc_poll(struct file *file,poll_table *wait)
1811 {
1812 struct spu_context *ctx = file->private_data;
1813 u32 free_elements, tagstatus;
1814 unsigned int mask;
1815
1816 poll_wait(file, &ctx->mfc_wq, wait);
1817
1818 /*
1819 * For now keep this uninterruptible and also ignore the rule
1820 * that poll should not sleep. Will be fixed later.
1821 */
1822 mutex_lock(&ctx->state_mutex);
1823 ctx->ops->set_mfc_query(ctx, ctx->tagwait, 2);
1824 free_elements = ctx->ops->get_mfc_free_elements(ctx);
1825 tagstatus = ctx->ops->read_mfc_tagstatus(ctx);
1826 spu_release(ctx);
1827
1828 mask = 0;
1829 if (free_elements & 0xffff)
1830 mask |= POLLOUT | POLLWRNORM;
1831 if (tagstatus & ctx->tagwait)
1832 mask |= POLLIN | POLLRDNORM;
1833
1834 pr_debug("%s: free %d tagstatus %d tagwait %d\n", __func__,
1835 free_elements, tagstatus, ctx->tagwait);
1836
1837 return mask;
1838 }
1839
1840 static int spufs_mfc_flush(struct file *file, fl_owner_t id)
1841 {
1842 struct spu_context *ctx = file->private_data;
1843 int ret;
1844
1845 ret = spu_acquire(ctx);
1846 if (ret)
1847 goto out;
1848 #if 0
1849 /* this currently hangs */
1850 ret = spufs_wait(ctx->mfc_wq,
1851 ctx->ops->set_mfc_query(ctx, ctx->tagwait, 2));
1852 if (ret)
1853 goto out;
1854 ret = spufs_wait(ctx->mfc_wq,
1855 ctx->ops->read_mfc_tagstatus(ctx) == ctx->tagwait);
1856 if (ret)
1857 goto out;
1858 #else
1859 ret = 0;
1860 #endif
1861 spu_release(ctx);
1862 out:
1863 return ret;
1864 }
1865
1866 static int spufs_mfc_fsync(struct file *file, int datasync)
1867 {
1868 return spufs_mfc_flush(file, NULL);
1869 }
1870
1871 static int spufs_mfc_fasync(int fd, struct file *file, int on)
1872 {
1873 struct spu_context *ctx = file->private_data;
1874
1875 return fasync_helper(fd, file, on, &ctx->mfc_fasync);
1876 }
1877
1878 static const struct file_operations spufs_mfc_fops = {
1879 .open = spufs_mfc_open,
1880 .release = spufs_mfc_release,
1881 .read = spufs_mfc_read,
1882 .write = spufs_mfc_write,
1883 .poll = spufs_mfc_poll,
1884 .flush = spufs_mfc_flush,
1885 .fsync = spufs_mfc_fsync,
1886 .fasync = spufs_mfc_fasync,
1887 .mmap = spufs_mfc_mmap,
1888 .llseek = no_llseek,
1889 };
1890
1891 static int spufs_npc_set(void *data, u64 val)
1892 {
1893 struct spu_context *ctx = data;
1894 int ret;
1895
1896 ret = spu_acquire(ctx);
1897 if (ret)
1898 return ret;
1899 ctx->ops->npc_write(ctx, val);
1900 spu_release(ctx);
1901
1902 return 0;
1903 }
1904
1905 static u64 spufs_npc_get(struct spu_context *ctx)
1906 {
1907 return ctx->ops->npc_read(ctx);
1908 }
1909 DEFINE_SPUFS_ATTRIBUTE(spufs_npc_ops, spufs_npc_get, spufs_npc_set,
1910 "0x%llx\n", SPU_ATTR_ACQUIRE);
1911
1912 static int spufs_decr_set(void *data, u64 val)
1913 {
1914 struct spu_context *ctx = data;
1915 struct spu_lscsa *lscsa = ctx->csa.lscsa;
1916 int ret;
1917
1918 ret = spu_acquire_saved(ctx);
1919 if (ret)
1920 return ret;
1921 lscsa->decr.slot[0] = (u32) val;
1922 spu_release_saved(ctx);
1923
1924 return 0;
1925 }
1926
1927 static u64 spufs_decr_get(struct spu_context *ctx)
1928 {
1929 struct spu_lscsa *lscsa = ctx->csa.lscsa;
1930 return lscsa->decr.slot[0];
1931 }
1932 DEFINE_SPUFS_ATTRIBUTE(spufs_decr_ops, spufs_decr_get, spufs_decr_set,
1933 "0x%llx\n", SPU_ATTR_ACQUIRE_SAVED);
1934
1935 static int spufs_decr_status_set(void *data, u64 val)
1936 {
1937 struct spu_context *ctx = data;
1938 int ret;
1939
1940 ret = spu_acquire_saved(ctx);
1941 if (ret)
1942 return ret;
1943 if (val)
1944 ctx->csa.priv2.mfc_control_RW |= MFC_CNTL_DECREMENTER_RUNNING;
1945 else
1946 ctx->csa.priv2.mfc_control_RW &= ~MFC_CNTL_DECREMENTER_RUNNING;
1947 spu_release_saved(ctx);
1948
1949 return 0;
1950 }
1951
1952 static u64 spufs_decr_status_get(struct spu_context *ctx)
1953 {
1954 if (ctx->csa.priv2.mfc_control_RW & MFC_CNTL_DECREMENTER_RUNNING)
1955 return SPU_DECR_STATUS_RUNNING;
1956 else
1957 return 0;
1958 }
1959 DEFINE_SPUFS_ATTRIBUTE(spufs_decr_status_ops, spufs_decr_status_get,
1960 spufs_decr_status_set, "0x%llx\n",
1961 SPU_ATTR_ACQUIRE_SAVED);
1962
1963 static int spufs_event_mask_set(void *data, u64 val)
1964 {
1965 struct spu_context *ctx = data;
1966 struct spu_lscsa *lscsa = ctx->csa.lscsa;
1967 int ret;
1968
1969 ret = spu_acquire_saved(ctx);
1970 if (ret)
1971 return ret;
1972 lscsa->event_mask.slot[0] = (u32) val;
1973 spu_release_saved(ctx);
1974
1975 return 0;
1976 }
1977
1978 static u64 spufs_event_mask_get(struct spu_context *ctx)
1979 {
1980 struct spu_lscsa *lscsa = ctx->csa.lscsa;
1981 return lscsa->event_mask.slot[0];
1982 }
1983
1984 DEFINE_SPUFS_ATTRIBUTE(spufs_event_mask_ops, spufs_event_mask_get,
1985 spufs_event_mask_set, "0x%llx\n",
1986 SPU_ATTR_ACQUIRE_SAVED);
1987
1988 static u64 spufs_event_status_get(struct spu_context *ctx)
1989 {
1990 struct spu_state *state = &ctx->csa;
1991 u64 stat;
1992 stat = state->spu_chnlcnt_RW[0];
1993 if (stat)
1994 return state->spu_chnldata_RW[0];
1995 return 0;
1996 }
1997 DEFINE_SPUFS_ATTRIBUTE(spufs_event_status_ops, spufs_event_status_get,
1998 NULL, "0x%llx\n", SPU_ATTR_ACQUIRE_SAVED)
1999
2000 static int spufs_srr0_set(void *data, u64 val)
2001 {
2002 struct spu_context *ctx = data;
2003 struct spu_lscsa *lscsa = ctx->csa.lscsa;
2004 int ret;
2005
2006 ret = spu_acquire_saved(ctx);
2007 if (ret)
2008 return ret;
2009 lscsa->srr0.slot[0] = (u32) val;
2010 spu_release_saved(ctx);
2011
2012 return 0;
2013 }
2014
2015 static u64 spufs_srr0_get(struct spu_context *ctx)
2016 {
2017 struct spu_lscsa *lscsa = ctx->csa.lscsa;
2018 return lscsa->srr0.slot[0];
2019 }
2020 DEFINE_SPUFS_ATTRIBUTE(spufs_srr0_ops, spufs_srr0_get, spufs_srr0_set,
2021 "0x%llx\n", SPU_ATTR_ACQUIRE_SAVED)
2022
2023 static u64 spufs_id_get(struct spu_context *ctx)
2024 {
2025 u64 num;
2026
2027 if (ctx->state == SPU_STATE_RUNNABLE)
2028 num = ctx->spu->number;
2029 else
2030 num = (unsigned int)-1;
2031
2032 return num;
2033 }
2034 DEFINE_SPUFS_ATTRIBUTE(spufs_id_ops, spufs_id_get, NULL, "0x%llx\n",
2035 SPU_ATTR_ACQUIRE)
2036
2037 static u64 spufs_object_id_get(struct spu_context *ctx)
2038 {
2039 /* FIXME: Should there really be no locking here? */
2040 return ctx->object_id;
2041 }
2042
2043 static int spufs_object_id_set(void *data, u64 id)
2044 {
2045 struct spu_context *ctx = data;
2046 ctx->object_id = id;
2047
2048 return 0;
2049 }
2050
2051 DEFINE_SPUFS_ATTRIBUTE(spufs_object_id_ops, spufs_object_id_get,
2052 spufs_object_id_set, "0x%llx\n", SPU_ATTR_NOACQUIRE);
2053
2054 static u64 spufs_lslr_get(struct spu_context *ctx)
2055 {
2056 return ctx->csa.priv2.spu_lslr_RW;
2057 }
2058 DEFINE_SPUFS_ATTRIBUTE(spufs_lslr_ops, spufs_lslr_get, NULL, "0x%llx\n",
2059 SPU_ATTR_ACQUIRE_SAVED);
2060
2061 static int spufs_info_open(struct inode *inode, struct file *file)
2062 {
2063 struct spufs_inode_info *i = SPUFS_I(inode);
2064 struct spu_context *ctx = i->i_ctx;
2065 file->private_data = ctx;
2066 return 0;
2067 }
2068
2069 static int spufs_caps_show(struct seq_file *s, void *private)
2070 {
2071 struct spu_context *ctx = s->private;
2072
2073 if (!(ctx->flags & SPU_CREATE_NOSCHED))
2074 seq_puts(s, "sched\n");
2075 if (!(ctx->flags & SPU_CREATE_ISOLATE))
2076 seq_puts(s, "step\n");
2077 return 0;
2078 }
2079
2080 static int spufs_caps_open(struct inode *inode, struct file *file)
2081 {
2082 return single_open(file, spufs_caps_show, SPUFS_I(inode)->i_ctx);
2083 }
2084
2085 static const struct file_operations spufs_caps_fops = {
2086 .open = spufs_caps_open,
2087 .read = seq_read,
2088 .llseek = seq_lseek,
2089 .release = single_release,
2090 };
2091
2092 static ssize_t __spufs_mbox_info_read(struct spu_context *ctx,
2093 char __user *buf, size_t len, loff_t *pos)
2094 {
2095 u32 data;
2096
2097 /* EOF if there's no entry in the mbox */
2098 if (!(ctx->csa.prob.mb_stat_R & 0x0000ff))
2099 return 0;
2100
2101 data = ctx->csa.prob.pu_mb_R;
2102
2103 return simple_read_from_buffer(buf, len, pos, &data, sizeof data);
2104 }
2105
2106 static ssize_t spufs_mbox_info_read(struct file *file, char __user *buf,
2107 size_t len, loff_t *pos)
2108 {
2109 int ret;
2110 struct spu_context *ctx = file->private_data;
2111
2112 if (!access_ok(VERIFY_WRITE, buf, len))
2113 return -EFAULT;
2114
2115 ret = spu_acquire_saved(ctx);
2116 if (ret)
2117 return ret;
2118 spin_lock(&ctx->csa.register_lock);
2119 ret = __spufs_mbox_info_read(ctx, buf, len, pos);
2120 spin_unlock(&ctx->csa.register_lock);
2121 spu_release_saved(ctx);
2122
2123 return ret;
2124 }
2125
2126 static const struct file_operations spufs_mbox_info_fops = {
2127 .open = spufs_info_open,
2128 .read = spufs_mbox_info_read,
2129 .llseek = generic_file_llseek,
2130 };
2131
2132 static ssize_t __spufs_ibox_info_read(struct spu_context *ctx,
2133 char __user *buf, size_t len, loff_t *pos)
2134 {
2135 u32 data;
2136
2137 /* EOF if there's no entry in the ibox */
2138 if (!(ctx->csa.prob.mb_stat_R & 0xff0000))
2139 return 0;
2140
2141 data = ctx->csa.priv2.puint_mb_R;
2142
2143 return simple_read_from_buffer(buf, len, pos, &data, sizeof data);
2144 }
2145
2146 static ssize_t spufs_ibox_info_read(struct file *file, char __user *buf,
2147 size_t len, loff_t *pos)
2148 {
2149 struct spu_context *ctx = file->private_data;
2150 int ret;
2151
2152 if (!access_ok(VERIFY_WRITE, buf, len))
2153 return -EFAULT;
2154
2155 ret = spu_acquire_saved(ctx);
2156 if (ret)
2157 return ret;
2158 spin_lock(&ctx->csa.register_lock);
2159 ret = __spufs_ibox_info_read(ctx, buf, len, pos);
2160 spin_unlock(&ctx->csa.register_lock);
2161 spu_release_saved(ctx);
2162
2163 return ret;
2164 }
2165
2166 static const struct file_operations spufs_ibox_info_fops = {
2167 .open = spufs_info_open,
2168 .read = spufs_ibox_info_read,
2169 .llseek = generic_file_llseek,
2170 };
2171
2172 static ssize_t __spufs_wbox_info_read(struct spu_context *ctx,
2173 char __user *buf, size_t len, loff_t *pos)
2174 {
2175 int i, cnt;
2176 u32 data[4];
2177 u32 wbox_stat;
2178
2179 wbox_stat = ctx->csa.prob.mb_stat_R;
2180 cnt = 4 - ((wbox_stat & 0x00ff00) >> 8);
2181 for (i = 0; i < cnt; i++) {
2182 data[i] = ctx->csa.spu_mailbox_data[i];
2183 }
2184
2185 return simple_read_from_buffer(buf, len, pos, &data,
2186 cnt * sizeof(u32));
2187 }
2188
2189 static ssize_t spufs_wbox_info_read(struct file *file, char __user *buf,
2190 size_t len, loff_t *pos)
2191 {
2192 struct spu_context *ctx = file->private_data;
2193 int ret;
2194
2195 if (!access_ok(VERIFY_WRITE, buf, len))
2196 return -EFAULT;
2197
2198 ret = spu_acquire_saved(ctx);
2199 if (ret)
2200 return ret;
2201 spin_lock(&ctx->csa.register_lock);
2202 ret = __spufs_wbox_info_read(ctx, buf, len, pos);
2203 spin_unlock(&ctx->csa.register_lock);
2204 spu_release_saved(ctx);
2205
2206 return ret;
2207 }
2208
2209 static const struct file_operations spufs_wbox_info_fops = {
2210 .open = spufs_info_open,
2211 .read = spufs_wbox_info_read,
2212 .llseek = generic_file_llseek,
2213 };
2214
2215 static ssize_t __spufs_dma_info_read(struct spu_context *ctx,
2216 char __user *buf, size_t len, loff_t *pos)
2217 {
2218 struct spu_dma_info info;
2219 struct mfc_cq_sr *qp, *spuqp;
2220 int i;
2221
2222 info.dma_info_type = ctx->csa.priv2.spu_tag_status_query_RW;
2223 info.dma_info_mask = ctx->csa.lscsa->tag_mask.slot[0];
2224 info.dma_info_status = ctx->csa.spu_chnldata_RW[24];
2225 info.dma_info_stall_and_notify = ctx->csa.spu_chnldata_RW[25];
2226 info.dma_info_atomic_command_status = ctx->csa.spu_chnldata_RW[27];
2227 for (i = 0; i < 16; i++) {
2228 qp = &info.dma_info_command_data[i];
2229 spuqp = &ctx->csa.priv2.spuq[i];
2230
2231 qp->mfc_cq_data0_RW = spuqp->mfc_cq_data0_RW;
2232 qp->mfc_cq_data1_RW = spuqp->mfc_cq_data1_RW;
2233 qp->mfc_cq_data2_RW = spuqp->mfc_cq_data2_RW;
2234 qp->mfc_cq_data3_RW = spuqp->mfc_cq_data3_RW;
2235 }
2236
2237 return simple_read_from_buffer(buf, len, pos, &info,
2238 sizeof info);
2239 }
2240
2241 static ssize_t spufs_dma_info_read(struct file *file, char __user *buf,
2242 size_t len, loff_t *pos)
2243 {
2244 struct spu_context *ctx = file->private_data;
2245 int ret;
2246
2247 if (!access_ok(VERIFY_WRITE, buf, len))
2248 return -EFAULT;
2249
2250 ret = spu_acquire_saved(ctx);
2251 if (ret)
2252 return ret;
2253 spin_lock(&ctx->csa.register_lock);
2254 ret = __spufs_dma_info_read(ctx, buf, len, pos);
2255 spin_unlock(&ctx->csa.register_lock);
2256 spu_release_saved(ctx);
2257
2258 return ret;
2259 }
2260
2261 static const struct file_operations spufs_dma_info_fops = {
2262 .open = spufs_info_open,
2263 .read = spufs_dma_info_read,
2264 .llseek = no_llseek,
2265 };
2266
2267 static ssize_t __spufs_proxydma_info_read(struct spu_context *ctx,
2268 char __user *buf, size_t len, loff_t *pos)
2269 {
2270 struct spu_proxydma_info info;
2271 struct mfc_cq_sr *qp, *puqp;
2272 int ret = sizeof info;
2273 int i;
2274
2275 if (len < ret)
2276 return -EINVAL;
2277
2278 if (!access_ok(VERIFY_WRITE, buf, len))
2279 return -EFAULT;
2280
2281 info.proxydma_info_type = ctx->csa.prob.dma_querytype_RW;
2282 info.proxydma_info_mask = ctx->csa.prob.dma_querymask_RW;
2283 info.proxydma_info_status = ctx->csa.prob.dma_tagstatus_R;
2284 for (i = 0; i < 8; i++) {
2285 qp = &info.proxydma_info_command_data[i];
2286 puqp = &ctx->csa.priv2.puq[i];
2287
2288 qp->mfc_cq_data0_RW = puqp->mfc_cq_data0_RW;
2289 qp->mfc_cq_data1_RW = puqp->mfc_cq_data1_RW;
2290 qp->mfc_cq_data2_RW = puqp->mfc_cq_data2_RW;
2291 qp->mfc_cq_data3_RW = puqp->mfc_cq_data3_RW;
2292 }
2293
2294 return simple_read_from_buffer(buf, len, pos, &info,
2295 sizeof info);
2296 }
2297
2298 static ssize_t spufs_proxydma_info_read(struct file *file, char __user *buf,
2299 size_t len, loff_t *pos)
2300 {
2301 struct spu_context *ctx = file->private_data;
2302 int ret;
2303
2304 ret = spu_acquire_saved(ctx);
2305 if (ret)
2306 return ret;
2307 spin_lock(&ctx->csa.register_lock);
2308 ret = __spufs_proxydma_info_read(ctx, buf, len, pos);
2309 spin_unlock(&ctx->csa.register_lock);
2310 spu_release_saved(ctx);
2311
2312 return ret;
2313 }
2314
2315 static const struct file_operations spufs_proxydma_info_fops = {
2316 .open = spufs_info_open,
2317 .read = spufs_proxydma_info_read,
2318 .llseek = no_llseek,
2319 };
2320
2321 static int spufs_show_tid(struct seq_file *s, void *private)
2322 {
2323 struct spu_context *ctx = s->private;
2324
2325 seq_printf(s, "%d\n", ctx->tid);
2326 return 0;
2327 }
2328
2329 static int spufs_tid_open(struct inode *inode, struct file *file)
2330 {
2331 return single_open(file, spufs_show_tid, SPUFS_I(inode)->i_ctx);
2332 }
2333
2334 static const struct file_operations spufs_tid_fops = {
2335 .open = spufs_tid_open,
2336 .read = seq_read,
2337 .llseek = seq_lseek,
2338 .release = single_release,
2339 };
2340
2341 static const char *ctx_state_names[] = {
2342 "user", "system", "iowait", "loaded"
2343 };
2344
2345 static unsigned long long spufs_acct_time(struct spu_context *ctx,
2346 enum spu_utilization_state state)
2347 {
2348 struct timespec ts;
2349 unsigned long long time = ctx->stats.times[state];
2350
2351 /*
2352 * In general, utilization statistics are updated by the controlling
2353 * thread as the spu context moves through various well defined
2354 * state transitions, but if the context is lazily loaded its
2355 * utilization statistics are not updated as the controlling thread
2356 * is not tightly coupled with the execution of the spu context. We
2357 * calculate and apply the time delta from the last recorded state
2358 * of the spu context.
2359 */
2360 if (ctx->spu && ctx->stats.util_state == state) {
2361 ktime_get_ts(&ts);
2362 time += timespec_to_ns(&ts) - ctx->stats.tstamp;
2363 }
2364
2365 return time / NSEC_PER_MSEC;
2366 }
2367
2368 static unsigned long long spufs_slb_flts(struct spu_context *ctx)
2369 {
2370 unsigned long long slb_flts = ctx->stats.slb_flt;
2371
2372 if (ctx->state == SPU_STATE_RUNNABLE) {
2373 slb_flts += (ctx->spu->stats.slb_flt -
2374 ctx->stats.slb_flt_base);
2375 }
2376
2377 return slb_flts;
2378 }
2379
2380 static unsigned long long spufs_class2_intrs(struct spu_context *ctx)
2381 {
2382 unsigned long long class2_intrs = ctx->stats.class2_intr;
2383
2384 if (ctx->state == SPU_STATE_RUNNABLE) {
2385 class2_intrs += (ctx->spu->stats.class2_intr -
2386 ctx->stats.class2_intr_base);
2387 }
2388
2389 return class2_intrs;
2390 }
2391
2392
2393 static int spufs_show_stat(struct seq_file *s, void *private)
2394 {
2395 struct spu_context *ctx = s->private;
2396 int ret;
2397
2398 ret = spu_acquire(ctx);
2399 if (ret)
2400 return ret;
2401
2402 seq_printf(s, "%s %llu %llu %llu %llu "
2403 "%llu %llu %llu %llu %llu %llu %llu %llu\n",
2404 ctx_state_names[ctx->stats.util_state],
2405 spufs_acct_time(ctx, SPU_UTIL_USER),
2406 spufs_acct_time(ctx, SPU_UTIL_SYSTEM),
2407 spufs_acct_time(ctx, SPU_UTIL_IOWAIT),
2408 spufs_acct_time(ctx, SPU_UTIL_IDLE_LOADED),
2409 ctx->stats.vol_ctx_switch,
2410 ctx->stats.invol_ctx_switch,
2411 spufs_slb_flts(ctx),
2412 ctx->stats.hash_flt,
2413 ctx->stats.min_flt,
2414 ctx->stats.maj_flt,
2415 spufs_class2_intrs(ctx),
2416 ctx->stats.libassist);
2417 spu_release(ctx);
2418 return 0;
2419 }
2420
2421 static int spufs_stat_open(struct inode *inode, struct file *file)
2422 {
2423 return single_open(file, spufs_show_stat, SPUFS_I(inode)->i_ctx);
2424 }
2425
2426 static const struct file_operations spufs_stat_fops = {
2427 .open = spufs_stat_open,
2428 .read = seq_read,
2429 .llseek = seq_lseek,
2430 .release = single_release,
2431 };
2432
2433 static inline int spufs_switch_log_used(struct spu_context *ctx)
2434 {
2435 return (ctx->switch_log->head - ctx->switch_log->tail) %
2436 SWITCH_LOG_BUFSIZE;
2437 }
2438
2439 static inline int spufs_switch_log_avail(struct spu_context *ctx)
2440 {
2441 return SWITCH_LOG_BUFSIZE - spufs_switch_log_used(ctx);
2442 }
2443
2444 static int spufs_switch_log_open(struct inode *inode, struct file *file)
2445 {
2446 struct spu_context *ctx = SPUFS_I(inode)->i_ctx;
2447 int rc;
2448
2449 rc = spu_acquire(ctx);
2450 if (rc)
2451 return rc;
2452
2453 if (ctx->switch_log) {
2454 rc = -EBUSY;
2455 goto out;
2456 }
2457
2458 ctx->switch_log = kmalloc(sizeof(struct switch_log) +
2459 SWITCH_LOG_BUFSIZE * sizeof(struct switch_log_entry),
2460 GFP_KERNEL);
2461
2462 if (!ctx->switch_log) {
2463 rc = -ENOMEM;
2464 goto out;
2465 }
2466
2467 ctx->switch_log->head = ctx->switch_log->tail = 0;
2468 init_waitqueue_head(&ctx->switch_log->wait);
2469 rc = 0;
2470
2471 out:
2472 spu_release(ctx);
2473 return rc;
2474 }
2475
2476 static int spufs_switch_log_release(struct inode *inode, struct file *file)
2477 {
2478 struct spu_context *ctx = SPUFS_I(inode)->i_ctx;
2479 int rc;
2480
2481 rc = spu_acquire(ctx);
2482 if (rc)
2483 return rc;
2484
2485 kfree(ctx->switch_log);
2486 ctx->switch_log = NULL;
2487 spu_release(ctx);
2488
2489 return 0;
2490 }
2491
2492 static int switch_log_sprint(struct spu_context *ctx, char *tbuf, int n)
2493 {
2494 struct switch_log_entry *p;
2495
2496 p = ctx->switch_log->log + ctx->switch_log->tail % SWITCH_LOG_BUFSIZE;
2497
2498 return snprintf(tbuf, n, "%u.%09u %d %u %u %llu\n",
2499 (unsigned int) p->tstamp.tv_sec,
2500 (unsigned int) p->tstamp.tv_nsec,
2501 p->spu_id,
2502 (unsigned int) p->type,
2503 (unsigned int) p->val,
2504 (unsigned long long) p->timebase);
2505 }
2506
2507 static ssize_t spufs_switch_log_read(struct file *file, char __user *buf,
2508 size_t len, loff_t *ppos)
2509 {
2510 struct inode *inode = file->f_path.dentry->d_inode;
2511 struct spu_context *ctx = SPUFS_I(inode)->i_ctx;
2512 int error = 0, cnt = 0;
2513
2514 if (!buf)
2515 return -EINVAL;
2516
2517 error = spu_acquire(ctx);
2518 if (error)
2519 return error;
2520
2521 while (cnt < len) {
2522 char tbuf[128];
2523 int width;
2524
2525 if (spufs_switch_log_used(ctx) == 0) {
2526 if (cnt > 0) {
2527 /* If there's data ready to go, we can
2528 * just return straight away */
2529 break;
2530
2531 } else if (file->f_flags & O_NONBLOCK) {
2532 error = -EAGAIN;
2533 break;
2534
2535 } else {
2536 /* spufs_wait will drop the mutex and
2537 * re-acquire, but since we're in read(), the
2538 * file cannot be _released (and so
2539 * ctx->switch_log is stable).
2540 */
2541 error = spufs_wait(ctx->switch_log->wait,
2542 spufs_switch_log_used(ctx) > 0);
2543
2544 /* On error, spufs_wait returns without the
2545 * state mutex held */
2546 if (error)
2547 return error;
2548
2549 /* We may have had entries read from underneath
2550 * us while we dropped the mutex in spufs_wait,
2551 * so re-check */
2552 if (spufs_switch_log_used(ctx) == 0)
2553 continue;
2554 }
2555 }
2556
2557 width = switch_log_sprint(ctx, tbuf, sizeof(tbuf));
2558 if (width < len)
2559 ctx->switch_log->tail =
2560 (ctx->switch_log->tail + 1) %
2561 SWITCH_LOG_BUFSIZE;
2562 else
2563 /* If the record is greater than space available return
2564 * partial buffer (so far) */
2565 break;
2566
2567 error = copy_to_user(buf + cnt, tbuf, width);
2568 if (error)
2569 break;
2570 cnt += width;
2571 }
2572
2573 spu_release(ctx);
2574
2575 return cnt == 0 ? error : cnt;
2576 }
2577
2578 static unsigned int spufs_switch_log_poll(struct file *file, poll_table *wait)
2579 {
2580 struct inode *inode = file->f_path.dentry->d_inode;
2581 struct spu_context *ctx = SPUFS_I(inode)->i_ctx;
2582 unsigned int mask = 0;
2583 int rc;
2584
2585 poll_wait(file, &ctx->switch_log->wait, wait);
2586
2587 rc = spu_acquire(ctx);
2588 if (rc)
2589 return rc;
2590
2591 if (spufs_switch_log_used(ctx) > 0)
2592 mask |= POLLIN;
2593
2594 spu_release(ctx);
2595
2596 return mask;
2597 }
2598
2599 static const struct file_operations spufs_switch_log_fops = {
2600 .owner = THIS_MODULE,
2601 .open = spufs_switch_log_open,
2602 .read = spufs_switch_log_read,
2603 .poll = spufs_switch_log_poll,
2604 .release = spufs_switch_log_release,
2605 .llseek = no_llseek,
2606 };
2607
2608 /**
2609 * Log a context switch event to a switch log reader.
2610 *
2611 * Must be called with ctx->state_mutex held.
2612 */
2613 void spu_switch_log_notify(struct spu *spu, struct spu_context *ctx,
2614 u32 type, u32 val)
2615 {
2616 if (!ctx->switch_log)
2617 return;
2618
2619 if (spufs_switch_log_avail(ctx) > 1) {
2620 struct switch_log_entry *p;
2621
2622 p = ctx->switch_log->log + ctx->switch_log->head;
2623 ktime_get_ts(&p->tstamp);
2624 p->timebase = get_tb();
2625 p->spu_id = spu ? spu->number : -1;
2626 p->type = type;
2627 p->val = val;
2628
2629 ctx->switch_log->head =
2630 (ctx->switch_log->head + 1) % SWITCH_LOG_BUFSIZE;
2631 }
2632
2633 wake_up(&ctx->switch_log->wait);
2634 }
2635
2636 static int spufs_show_ctx(struct seq_file *s, void *private)
2637 {
2638 struct spu_context *ctx = s->private;
2639 u64 mfc_control_RW;
2640
2641 mutex_lock(&ctx->state_mutex);
2642 if (ctx->spu) {
2643 struct spu *spu = ctx->spu;
2644 struct spu_priv2 __iomem *priv2 = spu->priv2;
2645
2646 spin_lock_irq(&spu->register_lock);
2647 mfc_control_RW = in_be64(&priv2->mfc_control_RW);
2648 spin_unlock_irq(&spu->register_lock);
2649 } else {
2650 struct spu_state *csa = &ctx->csa;
2651
2652 mfc_control_RW = csa->priv2.mfc_control_RW;
2653 }
2654
2655 seq_printf(s, "%c flgs(%lx) sflgs(%lx) pri(%d) ts(%d) spu(%02d)"
2656 " %c %llx %llx %llx %llx %x %x\n",
2657 ctx->state == SPU_STATE_SAVED ? 'S' : 'R',
2658 ctx->flags,
2659 ctx->sched_flags,
2660 ctx->prio,
2661 ctx->time_slice,
2662 ctx->spu ? ctx->spu->number : -1,
2663 !list_empty(&ctx->rq) ? 'q' : ' ',
2664 ctx->csa.class_0_pending,
2665 ctx->csa.class_0_dar,
2666 ctx->csa.class_1_dsisr,
2667 mfc_control_RW,
2668 ctx->ops->runcntl_read(ctx),
2669 ctx->ops->status_read(ctx));
2670
2671 mutex_unlock(&ctx->state_mutex);
2672
2673 return 0;
2674 }
2675
2676 static int spufs_ctx_open(struct inode *inode, struct file *file)
2677 {
2678 return single_open(file, spufs_show_ctx, SPUFS_I(inode)->i_ctx);
2679 }
2680
2681 static const struct file_operations spufs_ctx_fops = {
2682 .open = spufs_ctx_open,
2683 .read = seq_read,
2684 .llseek = seq_lseek,
2685 .release = single_release,
2686 };
2687
2688 const struct spufs_tree_descr spufs_dir_contents[] = {
2689 { "capabilities", &spufs_caps_fops, 0444, },
2690 { "mem", &spufs_mem_fops, 0666, LS_SIZE, },
2691 { "regs", &spufs_regs_fops, 0666, sizeof(struct spu_reg128[128]), },
2692 { "mbox", &spufs_mbox_fops, 0444, },
2693 { "ibox", &spufs_ibox_fops, 0444, },
2694 { "wbox", &spufs_wbox_fops, 0222, },
2695 { "mbox_stat", &spufs_mbox_stat_fops, 0444, sizeof(u32), },
2696 { "ibox_stat", &spufs_ibox_stat_fops, 0444, sizeof(u32), },
2697 { "wbox_stat", &spufs_wbox_stat_fops, 0444, sizeof(u32), },
2698 { "signal1", &spufs_signal1_fops, 0666, },
2699 { "signal2", &spufs_signal2_fops, 0666, },
2700 { "signal1_type", &spufs_signal1_type, 0666, },
2701 { "signal2_type", &spufs_signal2_type, 0666, },
2702 { "cntl", &spufs_cntl_fops, 0666, },
2703 { "fpcr", &spufs_fpcr_fops, 0666, sizeof(struct spu_reg128), },
2704 { "lslr", &spufs_lslr_ops, 0444, },
2705 { "mfc", &spufs_mfc_fops, 0666, },
2706 { "mss", &spufs_mss_fops, 0666, },
2707 { "npc", &spufs_npc_ops, 0666, },
2708 { "srr0", &spufs_srr0_ops, 0666, },
2709 { "decr", &spufs_decr_ops, 0666, },
2710 { "decr_status", &spufs_decr_status_ops, 0666, },
2711 { "event_mask", &spufs_event_mask_ops, 0666, },
2712 { "event_status", &spufs_event_status_ops, 0444, },
2713 { "psmap", &spufs_psmap_fops, 0666, SPUFS_PS_MAP_SIZE, },
2714 { "phys-id", &spufs_id_ops, 0666, },
2715 { "object-id", &spufs_object_id_ops, 0666, },
2716 { "mbox_info", &spufs_mbox_info_fops, 0444, sizeof(u32), },
2717 { "ibox_info", &spufs_ibox_info_fops, 0444, sizeof(u32), },
2718 { "wbox_info", &spufs_wbox_info_fops, 0444, sizeof(u32), },
2719 { "dma_info", &spufs_dma_info_fops, 0444,
2720 sizeof(struct spu_dma_info), },
2721 { "proxydma_info", &spufs_proxydma_info_fops, 0444,
2722 sizeof(struct spu_proxydma_info)},
2723 { "tid", &spufs_tid_fops, 0444, },
2724 { "stat", &spufs_stat_fops, 0444, },
2725 { "switch_log", &spufs_switch_log_fops, 0444 },
2726 {},
2727 };
2728
2729 const struct spufs_tree_descr spufs_dir_nosched_contents[] = {
2730 { "capabilities", &spufs_caps_fops, 0444, },
2731 { "mem", &spufs_mem_fops, 0666, LS_SIZE, },
2732 { "mbox", &spufs_mbox_fops, 0444, },
2733 { "ibox", &spufs_ibox_fops, 0444, },
2734 { "wbox", &spufs_wbox_fops, 0222, },
2735 { "mbox_stat", &spufs_mbox_stat_fops, 0444, sizeof(u32), },
2736 { "ibox_stat", &spufs_ibox_stat_fops, 0444, sizeof(u32), },
2737 { "wbox_stat", &spufs_wbox_stat_fops, 0444, sizeof(u32), },
2738 { "signal1", &spufs_signal1_nosched_fops, 0222, },
2739 { "signal2", &spufs_signal2_nosched_fops, 0222, },
2740 { "signal1_type", &spufs_signal1_type, 0666, },
2741 { "signal2_type", &spufs_signal2_type, 0666, },
2742 { "mss", &spufs_mss_fops, 0666, },
2743 { "mfc", &spufs_mfc_fops, 0666, },
2744 { "cntl", &spufs_cntl_fops, 0666, },
2745 { "npc", &spufs_npc_ops, 0666, },
2746 { "psmap", &spufs_psmap_fops, 0666, SPUFS_PS_MAP_SIZE, },
2747 { "phys-id", &spufs_id_ops, 0666, },
2748 { "object-id", &spufs_object_id_ops, 0666, },
2749 { "tid", &spufs_tid_fops, 0444, },
2750 { "stat", &spufs_stat_fops, 0444, },
2751 {},
2752 };
2753
2754 const struct spufs_tree_descr spufs_dir_debug_contents[] = {
2755 { ".ctx", &spufs_ctx_fops, 0444, },
2756 {},
2757 };
2758
2759 const struct spufs_coredump_reader spufs_coredump_read[] = {
2760 { "regs", __spufs_regs_read, NULL, sizeof(struct spu_reg128[128])},
2761 { "fpcr", __spufs_fpcr_read, NULL, sizeof(struct spu_reg128) },
2762 { "lslr", NULL, spufs_lslr_get, 19 },
2763 { "decr", NULL, spufs_decr_get, 19 },
2764 { "decr_status", NULL, spufs_decr_status_get, 19 },
2765 { "mem", __spufs_mem_read, NULL, LS_SIZE, },
2766 { "signal1", __spufs_signal1_read, NULL, sizeof(u32) },
2767 { "signal1_type", NULL, spufs_signal1_type_get, 19 },
2768 { "signal2", __spufs_signal2_read, NULL, sizeof(u32) },
2769 { "signal2_type", NULL, spufs_signal2_type_get, 19 },
2770 { "event_mask", NULL, spufs_event_mask_get, 19 },
2771 { "event_status", NULL, spufs_event_status_get, 19 },
2772 { "mbox_info", __spufs_mbox_info_read, NULL, sizeof(u32) },
2773 { "ibox_info", __spufs_ibox_info_read, NULL, sizeof(u32) },
2774 { "wbox_info", __spufs_wbox_info_read, NULL, 4 * sizeof(u32)},
2775 { "dma_info", __spufs_dma_info_read, NULL, sizeof(struct spu_dma_info)},
2776 { "proxydma_info", __spufs_proxydma_info_read,
2777 NULL, sizeof(struct spu_proxydma_info)},
2778 { "object-id", NULL, spufs_object_id_get, 19 },
2779 { "npc", NULL, spufs_npc_get, 19 },
2780 { NULL },
2781 };
kernel source for telekom puls (alcatel/mediatek)