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);
136 spu_release_exclusive(ctx);
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;