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 static inline int spu_stopped(struct spu_context *ctx, u32 * stat)
26 *stat = ctx->ops->status_read(ctx);
27 if (ctx->state != SPU_STATE_RUNNABLE)
30 pte_fault = spu->dsisr &
31 (MFC_DSISR_PTE_NOT_FOUND | MFC_DSISR_ACCESS_DENIED);
32 return (!(*stat & 0x1) || pte_fault || spu->class_0_pending) ? 1 : 0;
35 static int spu_setup_isolated(struct spu_context *ctx)
38 u64 __iomem *mfc_cntl;
41 unsigned long timeout;
42 const u32 status_loading = SPU_STATUS_RUNNING
43 | SPU_STATUS_ISOLATED_STATE | SPU_STATUS_ISOLATED_LOAD_STATUS;
50 * We need to exclude userspace access to the context.
52 * To protect against memory access we invalidate all ptes
53 * and make sure the pagefault handlers block on the mutex.
55 spu_unmap_mappings(ctx);
57 mfc_cntl = &ctx->spu->priv2->mfc_control_RW;
59 /* purge the MFC DMA queue to ensure no spurious accesses before we
60 * enter kernel mode */
61 timeout = jiffies + HZ;
62 out_be64(mfc_cntl, MFC_CNTL_PURGE_DMA_REQUEST);
63 while ((in_be64(mfc_cntl) & MFC_CNTL_PURGE_DMA_STATUS_MASK)
64 != MFC_CNTL_PURGE_DMA_COMPLETE) {
65 if (time_after(jiffies, timeout)) {
66 printk(KERN_ERR "%s: timeout flushing MFC DMA queue\n",
74 /* put the SPE in kernel mode to allow access to the loader */
75 sr1 = spu_mfc_sr1_get(ctx->spu);
76 sr1 &= ~MFC_STATE1_PROBLEM_STATE_MASK;
77 spu_mfc_sr1_set(ctx->spu, sr1);
79 /* start the loader */
80 ctx->ops->signal1_write(ctx, (unsigned long)isolated_loader >> 32);
81 ctx->ops->signal2_write(ctx,
82 (unsigned long)isolated_loader & 0xffffffff);
84 ctx->ops->runcntl_write(ctx,
85 SPU_RUNCNTL_RUNNABLE | SPU_RUNCNTL_ISOLATE);
88 timeout = jiffies + HZ;
89 while (((status = ctx->ops->status_read(ctx)) & status_loading) ==
91 if (time_after(jiffies, timeout)) {
92 printk(KERN_ERR "%s: timeout waiting for loader\n",
100 if (!(status & SPU_STATUS_RUNNING)) {
101 /* If isolated LOAD has failed: run SPU, we will get a stop-and
103 pr_debug("%s: isolated LOAD failed\n", __FUNCTION__);
104 ctx->ops->runcntl_write(ctx, SPU_RUNCNTL_RUNNABLE);
109 if (!(status & SPU_STATUS_ISOLATED_STATE)) {
110 /* This isn't allowed by the CBEA, but check anyway */
111 pr_debug("%s: SPU fell out of isolated mode?\n", __FUNCTION__);
112 ctx->ops->runcntl_write(ctx, SPU_RUNCNTL_STOP);
118 /* Finished accessing the loader. Drop kernel mode */
119 sr1 |= MFC_STATE1_PROBLEM_STATE_MASK;
120 spu_mfc_sr1_set(ctx->spu, sr1);
126 static inline int spu_run_init(struct spu_context *ctx, u32 * npc)
129 unsigned long runcntl = SPU_RUNCNTL_RUNNABLE;
131 ret = spu_acquire_runnable(ctx, 0);
135 if (ctx->flags & SPU_CREATE_ISOLATE) {
136 if (!(ctx->ops->status_read(ctx) & SPU_STATUS_ISOLATED_STATE)) {
137 ret = spu_setup_isolated(ctx);
142 /* if userspace has set the runcntrl register (eg, to issue an
143 * isolated exit), we need to re-set it here */
144 runcntl = ctx->ops->runcntl_read(ctx) &
145 (SPU_RUNCNTL_RUNNABLE | SPU_RUNCNTL_ISOLATE);
147 runcntl = SPU_RUNCNTL_RUNNABLE;
150 ctx->ops->npc_write(ctx, *npc);
153 ctx->ops->runcntl_write(ctx, runcntl);
157 static inline int spu_run_fini(struct spu_context *ctx, u32 * npc,
163 *status = ctx->ops->status_read(ctx);
164 *npc = ctx->ops->npc_read(ctx);
167 if (signal_pending(current))
173 static inline int spu_reacquire_runnable(struct spu_context *ctx, u32 *npc,
178 if ((ret = spu_run_fini(ctx, npc, status)) != 0)
180 if (*status & (SPU_STATUS_STOPPED_BY_STOP |
181 SPU_STATUS_STOPPED_BY_HALT)) {
184 if ((ret = spu_run_init(ctx, npc)) != 0)
190 * SPU syscall restarting is tricky because we violate the basic
191 * assumption that the signal handler is running on the interrupted
192 * thread. Here instead, the handler runs on PowerPC user space code,
193 * while the syscall was called from the SPU.
194 * This means we can only do a very rough approximation of POSIX
197 int spu_handle_restartsys(struct spu_context *ctx, long *spu_ret,
204 case -ERESTARTNOINTR:
206 * Enter the regular syscall restarting for
207 * sys_spu_run, then restart the SPU syscall
213 case -ERESTARTNOHAND:
214 case -ERESTART_RESTARTBLOCK:
216 * Restart block is too hard for now, just return -EINTR
218 * ERESTARTNOHAND comes from sys_pause, we also return
220 * Assume that we need to be restarted ourselves though.
226 printk(KERN_WARNING "%s: unexpected return code %ld\n",
227 __FUNCTION__, *spu_ret);
233 int spu_process_callback(struct spu_context *ctx)
235 struct spu_syscall_block s;
241 /* get syscall block from local store */
242 npc = ctx->ops->npc_read(ctx) & ~3;
243 ls = (void __iomem *)ctx->ops->get_ls(ctx);
244 ls_pointer = in_be32(ls + npc);
245 if (ls_pointer > (LS_SIZE - sizeof(s)))
247 memcpy_fromio(&s, ls + ls_pointer, sizeof(s));
249 /* do actual syscall without pinning the spu */
254 if (s.nr_ret < __NR_syscalls) {
256 /* do actual system call from here */
257 spu_ret = spu_sys_callback(&s);
258 if (spu_ret <= -ERESTARTSYS) {
259 ret = spu_handle_restartsys(ctx, &spu_ret, &npc);
262 if (ret == -ERESTARTSYS)
266 /* write result, jump over indirect pointer */
267 memcpy_toio(ls + ls_pointer, &spu_ret, sizeof(spu_ret));
268 ctx->ops->npc_write(ctx, npc);
269 ctx->ops->runcntl_write(ctx, SPU_RUNCNTL_RUNNABLE);
273 static inline int spu_process_events(struct spu_context *ctx)
275 struct spu *spu = ctx->spu;
278 if (spu->class_0_pending)
279 ret = spu_irq_class_0_bottom(spu);
280 if (!ret && signal_pending(current))
285 long spufs_run_spu(struct file *file, struct spu_context *ctx,
286 u32 *npc, u32 *event)
291 if (mutex_lock_interruptible(&ctx->run_mutex))
294 ctx->ops->master_start(ctx);
295 ctx->event_return = 0;
296 ret = spu_run_init(ctx, npc);
301 ret = spufs_wait(ctx->stop_wq, spu_stopped(ctx, &status));
304 if ((status & SPU_STATUS_STOPPED_BY_STOP) &&
305 (status >> SPU_STOP_STATUS_SHIFT == 0x2104)) {
306 ret = spu_process_callback(ctx);
309 status &= ~SPU_STATUS_STOPPED_BY_STOP;
311 ret = spufs_handle_class1(ctx);
315 if (unlikely(ctx->state != SPU_STATE_RUNNABLE)) {
316 ret = spu_reacquire_runnable(ctx, npc, &status);
323 ret = spu_process_events(ctx);
325 } while (!ret && !(status & (SPU_STATUS_STOPPED_BY_STOP |
326 SPU_STATUS_STOPPED_BY_HALT)));
328 ctx->ops->master_stop(ctx);
329 ret = spu_run_fini(ctx, npc, &status);
334 ((ret == -ERESTARTSYS) &&
335 ((status & SPU_STATUS_STOPPED_BY_HALT) ||
336 ((status & SPU_STATUS_STOPPED_BY_STOP) &&
337 (status >> SPU_STOP_STATUS_SHIFT != 0x2104)))))
340 if ((status & SPU_STATUS_STOPPED_BY_STOP)
341 && (status >> SPU_STOP_STATUS_SHIFT) == 0x3fff) {
342 force_sig(SIGTRAP, current);
347 *event = ctx->event_return;
348 mutex_unlock(&ctx->run_mutex);