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;
71 * We need to exclude userspace access to the context.
73 * To protect against memory access we invalidate all ptes
74 * and make sure the pagefault handlers block on the mutex.
76 spu_unmap_mappings(ctx);
78 mfc_cntl = &ctx->spu->priv2->mfc_control_RW;
80 /* purge the MFC DMA queue to ensure no spurious accesses before we
81 * enter kernel mode */
82 timeout = jiffies + HZ;
83 out_be64(mfc_cntl, MFC_CNTL_PURGE_DMA_REQUEST);
84 while ((in_be64(mfc_cntl) & MFC_CNTL_PURGE_DMA_STATUS_MASK)
85 != MFC_CNTL_PURGE_DMA_COMPLETE) {
86 if (time_after(jiffies, timeout)) {
87 printk(KERN_ERR "%s: timeout flushing MFC DMA queue\n",
95 /* put the SPE in kernel mode to allow access to the loader */
96 sr1 = spu_mfc_sr1_get(ctx->spu);
97 sr1 &= ~MFC_STATE1_PROBLEM_STATE_MASK;
98 spu_mfc_sr1_set(ctx->spu, sr1);
100 /* start the loader */
101 ctx->ops->signal1_write(ctx, (unsigned long)isolated_loader >> 32);
102 ctx->ops->signal2_write(ctx,
103 (unsigned long)isolated_loader & 0xffffffff);
105 ctx->ops->runcntl_write(ctx,
106 SPU_RUNCNTL_RUNNABLE | SPU_RUNCNTL_ISOLATE);
109 timeout = jiffies + HZ;
110 while (((status = ctx->ops->status_read(ctx)) & status_loading) ==
112 if (time_after(jiffies, timeout)) {
113 printk(KERN_ERR "%s: timeout waiting for loader\n",
121 if (!(status & SPU_STATUS_RUNNING)) {
122 /* If isolated LOAD has failed: run SPU, we will get a stop-and
124 pr_debug("%s: isolated LOAD failed\n", __FUNCTION__);
125 ctx->ops->runcntl_write(ctx, SPU_RUNCNTL_RUNNABLE);
130 if (!(status & SPU_STATUS_ISOLATED_STATE)) {
131 /* This isn't allowed by the CBEA, but check anyway */
132 pr_debug("%s: SPU fell out of isolated mode?\n", __FUNCTION__);
133 ctx->ops->runcntl_write(ctx, SPU_RUNCNTL_STOP);
139 /* Finished accessing the loader. Drop kernel mode */
140 sr1 |= MFC_STATE1_PROBLEM_STATE_MASK;
141 spu_mfc_sr1_set(ctx->spu, sr1);
147 static inline int spu_run_init(struct spu_context *ctx, u32 * npc)
150 unsigned long runcntl = SPU_RUNCNTL_RUNNABLE;
152 ret = spu_acquire_runnable(ctx, 0);
156 if (ctx->flags & SPU_CREATE_ISOLATE) {
157 if (!(ctx->ops->status_read(ctx) & SPU_STATUS_ISOLATED_STATE)) {
158 ret = spu_setup_isolated(ctx);
163 /* if userspace has set the runcntrl register (eg, to issue an
164 * isolated exit), we need to re-set it here */
165 runcntl = ctx->ops->runcntl_read(ctx) &
166 (SPU_RUNCNTL_RUNNABLE | SPU_RUNCNTL_ISOLATE);
168 runcntl = SPU_RUNCNTL_RUNNABLE;
171 ctx->ops->npc_write(ctx, *npc);
174 ctx->ops->runcntl_write(ctx, runcntl);
178 static inline int spu_run_fini(struct spu_context *ctx, u32 * npc,
184 *status = ctx->ops->status_read(ctx);
185 *npc = ctx->ops->npc_read(ctx);
188 if (signal_pending(current))
194 static inline int spu_reacquire_runnable(struct spu_context *ctx, u32 *npc,
199 if ((ret = spu_run_fini(ctx, npc, status)) != 0)
201 if (*status & (SPU_STATUS_STOPPED_BY_STOP |
202 SPU_STATUS_STOPPED_BY_HALT)) {
205 if ((ret = spu_run_init(ctx, npc)) != 0)
211 * SPU syscall restarting is tricky because we violate the basic
212 * assumption that the signal handler is running on the interrupted
213 * thread. Here instead, the handler runs on PowerPC user space code,
214 * while the syscall was called from the SPU.
215 * This means we can only do a very rough approximation of POSIX
218 int spu_handle_restartsys(struct spu_context *ctx, long *spu_ret,
225 case -ERESTARTNOINTR:
227 * Enter the regular syscall restarting for
228 * sys_spu_run, then restart the SPU syscall
234 case -ERESTARTNOHAND:
235 case -ERESTART_RESTARTBLOCK:
237 * Restart block is too hard for now, just return -EINTR
239 * ERESTARTNOHAND comes from sys_pause, we also return
241 * Assume that we need to be restarted ourselves though.
247 printk(KERN_WARNING "%s: unexpected return code %ld\n",
248 __FUNCTION__, *spu_ret);
254 int spu_process_callback(struct spu_context *ctx)
256 struct spu_syscall_block s;
262 /* get syscall block from local store */
263 npc = ctx->ops->npc_read(ctx);
264 ls = ctx->ops->get_ls(ctx);
265 ls_pointer = *(u32*)(ls + npc);
266 if (ls_pointer > (LS_SIZE - sizeof(s)))
268 memcpy(&s, ls + ls_pointer, sizeof (s));
270 /* do actual syscall without pinning the spu */
275 if (s.nr_ret < __NR_syscalls) {
277 /* do actual system call from here */
278 spu_ret = spu_sys_callback(&s);
279 if (spu_ret <= -ERESTARTSYS) {
280 ret = spu_handle_restartsys(ctx, &spu_ret, &npc);
283 if (ret == -ERESTARTSYS)
287 /* write result, jump over indirect pointer */
288 memcpy(ls + ls_pointer, &spu_ret, sizeof (spu_ret));
289 ctx->ops->npc_write(ctx, npc);
290 ctx->ops->runcntl_write(ctx, SPU_RUNCNTL_RUNNABLE);
294 static inline int spu_process_events(struct spu_context *ctx)
296 struct spu *spu = ctx->spu;
297 u64 pte_fault = MFC_DSISR_PTE_NOT_FOUND | MFC_DSISR_ACCESS_DENIED;
300 if (spu->dsisr & pte_fault)
301 ret = spu_irq_class_1_bottom(spu);
302 if (spu->class_0_pending)
303 ret = spu_irq_class_0_bottom(spu);
304 if (!ret && signal_pending(current))
309 long spufs_run_spu(struct file *file, struct spu_context *ctx,
310 u32 *npc, u32 *event)
315 if (down_interruptible(&ctx->run_sema))
318 ctx->ops->master_start(ctx);
319 ctx->event_return = 0;
320 ret = spu_run_init(ctx, npc);
325 ret = spufs_wait(ctx->stop_wq, spu_stopped(ctx, &status));
328 if ((status & SPU_STATUS_STOPPED_BY_STOP) &&
329 (status >> SPU_STOP_STATUS_SHIFT == 0x2104)) {
330 ret = spu_process_callback(ctx);
333 status &= ~SPU_STATUS_STOPPED_BY_STOP;
335 if (unlikely(ctx->state != SPU_STATE_RUNNABLE)) {
336 ret = spu_reacquire_runnable(ctx, npc, &status);
343 ret = spu_process_events(ctx);
345 } while (!ret && !(status & (SPU_STATUS_STOPPED_BY_STOP |
346 SPU_STATUS_STOPPED_BY_HALT)));
348 ctx->ops->master_stop(ctx);
349 ret = spu_run_fini(ctx, npc, &status);
354 ((ret == -ERESTARTSYS) &&
355 ((status & SPU_STATUS_STOPPED_BY_HALT) ||
356 ((status & SPU_STATUS_STOPPED_BY_STOP) &&
357 (status >> SPU_STOP_STATUS_SHIFT != 0x2104)))))
360 if ((status & SPU_STATUS_STOPPED_BY_STOP)
361 && (status >> SPU_STOP_STATUS_SHIFT) == 0x3fff) {
362 force_sig(SIGTRAP, current);
367 *event = ctx->event_return;