3 #include <linux/wait.h>
4 #include <linux/ptrace.h>
7 #include <asm/spu_priv1.h>
9 #include <asm/unistd.h>
13 /* interrupt-level stop callback function. */
14 void spufs_stop_callback(struct spu
*spu
)
16 struct spu_context
*ctx
= spu
->ctx
;
18 wake_up_all(&ctx
->stop_wq
);
21 void spufs_dma_callback(struct spu
*spu
, int type
)
23 struct spu_context
*ctx
= spu
->ctx
;
25 if (ctx
->flags
& SPU_CREATE_EVENTS_ENABLED
) {
26 ctx
->event_return
|= type
;
27 wake_up_all(&ctx
->stop_wq
);
30 case SPE_EVENT_DMA_ALIGNMENT
:
31 case SPE_EVENT_SPE_DATA_STORAGE
:
32 case SPE_EVENT_INVALID_DMA
:
33 force_sig(SIGBUS
, /* info, */ current
);
35 case SPE_EVENT_SPE_ERROR
:
36 force_sig(SIGILL
, /* info */ current
);
42 static inline int spu_stopped(struct spu_context
*ctx
, u32
* stat
)
47 *stat
= ctx
->ops
->status_read(ctx
);
48 if (ctx
->state
!= SPU_STATE_RUNNABLE
)
51 pte_fault
= spu
->dsisr
&
52 (MFC_DSISR_PTE_NOT_FOUND
| MFC_DSISR_ACCESS_DENIED
);
53 return (!(*stat
& 0x1) || pte_fault
|| spu
->class_0_pending
) ? 1 : 0;
56 static int spu_setup_isolated(struct spu_context
*ctx
)
59 u64 __iomem
*mfc_cntl
;
62 unsigned long timeout
;
63 const u32 status_loading
= SPU_STATUS_RUNNING
64 | SPU_STATUS_ISOLATED_STATE
| SPU_STATUS_ISOLATED_LOAD_STATUS
;
69 ret
= spu_acquire_exclusive(ctx
);
73 mfc_cntl
= &ctx
->spu
->priv2
->mfc_control_RW
;
75 /* purge the MFC DMA queue to ensure no spurious accesses before we
76 * enter kernel mode */
77 timeout
= jiffies
+ HZ
;
78 out_be64(mfc_cntl
, MFC_CNTL_PURGE_DMA_REQUEST
);
79 while ((in_be64(mfc_cntl
) & MFC_CNTL_PURGE_DMA_STATUS_MASK
)
80 != MFC_CNTL_PURGE_DMA_COMPLETE
) {
81 if (time_after(jiffies
, timeout
)) {
82 printk(KERN_ERR
"%s: timeout flushing MFC DMA queue\n",
90 /* put the SPE in kernel mode to allow access to the loader */
91 sr1
= spu_mfc_sr1_get(ctx
->spu
);
92 sr1
&= ~MFC_STATE1_PROBLEM_STATE_MASK
;
93 spu_mfc_sr1_set(ctx
->spu
, sr1
);
95 /* start the loader */
96 ctx
->ops
->signal1_write(ctx
, (unsigned long)isolated_loader
>> 32);
97 ctx
->ops
->signal2_write(ctx
,
98 (unsigned long)isolated_loader
& 0xffffffff);
100 ctx
->ops
->runcntl_write(ctx
,
101 SPU_RUNCNTL_RUNNABLE
| SPU_RUNCNTL_ISOLATE
);
104 timeout
= jiffies
+ HZ
;
105 while (((status
= ctx
->ops
->status_read(ctx
)) & status_loading
) ==
107 if (time_after(jiffies
, timeout
)) {
108 printk(KERN_ERR
"%s: timeout waiting for loader\n",
116 if (!(status
& SPU_STATUS_RUNNING
)) {
117 /* If isolated LOAD has failed: run SPU, we will get a stop-and
119 pr_debug("%s: isolated LOAD failed\n", __FUNCTION__
);
120 ctx
->ops
->runcntl_write(ctx
, SPU_RUNCNTL_RUNNABLE
);
123 } else if (!(status
& SPU_STATUS_ISOLATED_STATE
)) {
124 /* This isn't allowed by the CBEA, but check anyway */
125 pr_debug("%s: SPU fell out of isolated mode?\n", __FUNCTION__
);
126 ctx
->ops
->runcntl_write(ctx
, SPU_RUNCNTL_STOP
);
131 /* Finished accessing the loader. Drop kernel mode */
132 sr1
|= MFC_STATE1_PROBLEM_STATE_MASK
;
133 spu_mfc_sr1_set(ctx
->spu
, sr1
);
141 static inline int spu_run_init(struct spu_context
*ctx
, u32
* npc
)
144 unsigned long runcntl
= SPU_RUNCNTL_RUNNABLE
;
146 ret
= spu_acquire_runnable(ctx
);
150 if (ctx
->flags
& SPU_CREATE_ISOLATE
) {
151 if (!(ctx
->ops
->status_read(ctx
) & SPU_STATUS_ISOLATED_STATE
)) {
152 /* Need to release ctx, because spu_setup_isolated will
153 * acquire it exclusively.
156 ret
= spu_setup_isolated(ctx
);
158 ret
= spu_acquire_runnable(ctx
);
161 /* if userspace has set the runcntrl register (eg, to issue an
162 * isolated exit), we need to re-set it here */
163 runcntl
= ctx
->ops
->runcntl_read(ctx
) &
164 (SPU_RUNCNTL_RUNNABLE
| SPU_RUNCNTL_ISOLATE
);
166 runcntl
= SPU_RUNCNTL_RUNNABLE
;
168 ctx
->ops
->npc_write(ctx
, *npc
);
170 ctx
->ops
->runcntl_write(ctx
, runcntl
);
174 static inline int spu_run_fini(struct spu_context
*ctx
, u32
* npc
,
179 *status
= ctx
->ops
->status_read(ctx
);
180 *npc
= ctx
->ops
->npc_read(ctx
);
183 if (signal_pending(current
))
189 static inline int spu_reacquire_runnable(struct spu_context
*ctx
, u32
*npc
,
194 if ((ret
= spu_run_fini(ctx
, npc
, status
)) != 0)
196 if (*status
& (SPU_STATUS_STOPPED_BY_STOP
|
197 SPU_STATUS_STOPPED_BY_HALT
)) {
200 if ((ret
= spu_run_init(ctx
, npc
)) != 0)
206 * SPU syscall restarting is tricky because we violate the basic
207 * assumption that the signal handler is running on the interrupted
208 * thread. Here instead, the handler runs on PowerPC user space code,
209 * while the syscall was called from the SPU.
210 * This means we can only do a very rough approximation of POSIX
213 int spu_handle_restartsys(struct spu_context
*ctx
, long *spu_ret
,
220 case -ERESTARTNOINTR
:
222 * Enter the regular syscall restarting for
223 * sys_spu_run, then restart the SPU syscall
229 case -ERESTARTNOHAND
:
230 case -ERESTART_RESTARTBLOCK
:
232 * Restart block is too hard for now, just return -EINTR
234 * ERESTARTNOHAND comes from sys_pause, we also return
236 * Assume that we need to be restarted ourselves though.
242 printk(KERN_WARNING
"%s: unexpected return code %ld\n",
243 __FUNCTION__
, *spu_ret
);
249 int spu_process_callback(struct spu_context
*ctx
)
251 struct spu_syscall_block s
;
257 /* get syscall block from local store */
258 npc
= ctx
->ops
->npc_read(ctx
);
259 ls
= ctx
->ops
->get_ls(ctx
);
260 ls_pointer
= *(u32
*)(ls
+ npc
);
261 if (ls_pointer
> (LS_SIZE
- sizeof(s
)))
263 memcpy(&s
, ls
+ ls_pointer
, sizeof (s
));
265 /* do actual syscall without pinning the spu */
270 if (s
.nr_ret
< __NR_syscalls
) {
272 /* do actual system call from here */
273 spu_ret
= spu_sys_callback(&s
);
274 if (spu_ret
<= -ERESTARTSYS
) {
275 ret
= spu_handle_restartsys(ctx
, &spu_ret
, &npc
);
278 if (ret
== -ERESTARTSYS
)
282 /* write result, jump over indirect pointer */
283 memcpy(ls
+ ls_pointer
, &spu_ret
, sizeof (spu_ret
));
284 ctx
->ops
->npc_write(ctx
, npc
);
285 ctx
->ops
->runcntl_write(ctx
, SPU_RUNCNTL_RUNNABLE
);
289 static inline int spu_process_events(struct spu_context
*ctx
)
291 struct spu
*spu
= ctx
->spu
;
292 u64 pte_fault
= MFC_DSISR_PTE_NOT_FOUND
| MFC_DSISR_ACCESS_DENIED
;
295 if (spu
->dsisr
& pte_fault
)
296 ret
= spu_irq_class_1_bottom(spu
);
297 if (spu
->class_0_pending
)
298 ret
= spu_irq_class_0_bottom(spu
);
299 if (!ret
&& signal_pending(current
))
304 long spufs_run_spu(struct file
*file
, struct spu_context
*ctx
,
305 u32
*npc
, u32
*event
)
310 if (down_interruptible(&ctx
->run_sema
))
313 ctx
->ops
->master_start(ctx
);
314 ctx
->event_return
= 0;
315 ret
= spu_run_init(ctx
, npc
);
320 ret
= spufs_wait(ctx
->stop_wq
, spu_stopped(ctx
, &status
));
323 if ((status
& SPU_STATUS_STOPPED_BY_STOP
) &&
324 (status
>> SPU_STOP_STATUS_SHIFT
== 0x2104)) {
325 ret
= spu_process_callback(ctx
);
328 status
&= ~SPU_STATUS_STOPPED_BY_STOP
;
330 if (unlikely(ctx
->state
!= SPU_STATE_RUNNABLE
)) {
331 ret
= spu_reacquire_runnable(ctx
, npc
, &status
);
336 ret
= spu_process_events(ctx
);
338 } while (!ret
&& !(status
& (SPU_STATUS_STOPPED_BY_STOP
|
339 SPU_STATUS_STOPPED_BY_HALT
)));
341 ctx
->ops
->master_stop(ctx
);
342 ret
= spu_run_fini(ctx
, npc
, &status
);
347 ((ret
== -ERESTARTSYS
) &&
348 ((status
& SPU_STATUS_STOPPED_BY_HALT
) ||
349 ((status
& SPU_STATUS_STOPPED_BY_STOP
) &&
350 (status
>> SPU_STOP_STATUS_SHIFT
!= 0x2104)))))
353 if ((status
& SPU_STATUS_STOPPED_BY_STOP
)
354 && (status
>> SPU_STOP_STATUS_SHIFT
) == 0x3fff) {
355 force_sig(SIGTRAP
, current
);
360 *event
= ctx
->event_return
;