1b2441318SGreg Kroah-Hartman // SPDX-License-Identifier: GPL-2.0
20afacde3Sarnd@arndb.de #define DEBUG
30afacde3Sarnd@arndb.de
4ce8ab854SArnd Bergmann #include <linux/wait.h>
5ce8ab854SArnd Bergmann #include <linux/ptrace.h>
6ce8ab854SArnd Bergmann
7ce8ab854SArnd Bergmann #include <asm/spu.h>
8c6730ed4SJeremy Kerr #include <asm/spu_priv1.h>
9c6730ed4SJeremy Kerr #include <asm/io.h>
10cfff5b23SDave Jones #include <asm/unistd.h>
11ce8ab854SArnd Bergmann
12ce8ab854SArnd Bergmann #include "spufs.h"
13ce8ab854SArnd Bergmann
14ce8ab854SArnd Bergmann /* interrupt-level stop callback function. */
spufs_stop_callback(struct spu * spu,int irq)15f3d69e05SLuke Browning void spufs_stop_callback(struct spu *spu, int irq)
16ce8ab854SArnd Bergmann {
17ce8ab854SArnd Bergmann struct spu_context *ctx = spu->ctx;
18ce8ab854SArnd Bergmann
19d6ad39bcSJeremy Kerr /*
20d6ad39bcSJeremy Kerr * It should be impossible to preempt a context while an exception
21d6ad39bcSJeremy Kerr * is being processed, since the context switch code is specially
22d6ad39bcSJeremy Kerr * coded to deal with interrupts ... But, just in case, sanity check
23d6ad39bcSJeremy Kerr * the context pointer. It is OK to return doing nothing since
24d6ad39bcSJeremy Kerr * the exception will be regenerated when the context is resumed.
25d6ad39bcSJeremy Kerr */
26d6ad39bcSJeremy Kerr if (ctx) {
27d6ad39bcSJeremy Kerr /* Copy exception arguments into module specific structure */
28f3d69e05SLuke Browning switch(irq) {
29f3d69e05SLuke Browning case 0 :
30d6ad39bcSJeremy Kerr ctx->csa.class_0_pending = spu->class_0_pending;
31f3d69e05SLuke Browning ctx->csa.class_0_dar = spu->class_0_dar;
32f3d69e05SLuke Browning break;
33f3d69e05SLuke Browning case 1 :
34f3d69e05SLuke Browning ctx->csa.class_1_dsisr = spu->class_1_dsisr;
35f3d69e05SLuke Browning ctx->csa.class_1_dar = spu->class_1_dar;
36f3d69e05SLuke Browning break;
37f3d69e05SLuke Browning case 2 :
38f3d69e05SLuke Browning break;
39f3d69e05SLuke Browning }
40d6ad39bcSJeremy Kerr
41d6ad39bcSJeremy Kerr /* ensure that the exception status has hit memory before a
42d6ad39bcSJeremy Kerr * thread waiting on the context's stop queue is woken */
43d6ad39bcSJeremy Kerr smp_wmb();
44d6ad39bcSJeremy Kerr
45ce8ab854SArnd Bergmann wake_up_all(&ctx->stop_wq);
46ce8ab854SArnd Bergmann }
47d6ad39bcSJeremy Kerr }
48d6ad39bcSJeremy Kerr
spu_stopped(struct spu_context * ctx,u32 * stat)49e65c2f6fSLuke Browning int spu_stopped(struct spu_context *ctx, u32 *stat)
50ce8ab854SArnd Bergmann {
51e65c2f6fSLuke Browning u64 dsisr;
52e65c2f6fSLuke Browning u32 stopped;
53ce8ab854SArnd Bergmann
54e65c2f6fSLuke Browning stopped = SPU_STATUS_INVALID_INSTR | SPU_STATUS_SINGLE_STEP |
55e65c2f6fSLuke Browning SPU_STATUS_STOPPED_BY_HALT | SPU_STATUS_STOPPED_BY_STOP;
56d84050f4SLuke Browning
57d84050f4SLuke Browning top:
58d84050f4SLuke Browning *stat = ctx->ops->status_read(ctx);
59d84050f4SLuke Browning if (*stat & stopped) {
60d84050f4SLuke Browning /*
61d84050f4SLuke Browning * If the spu hasn't finished stopping, we need to
62d84050f4SLuke Browning * re-read the register to get the stopped value.
63d84050f4SLuke Browning */
64d84050f4SLuke Browning if (*stat & SPU_STATUS_RUNNING)
65d84050f4SLuke Browning goto top;
66d84050f4SLuke Browning return 1;
67d84050f4SLuke Browning }
68d84050f4SLuke Browning
69d84050f4SLuke Browning if (test_bit(SPU_SCHED_NOTIFY_ACTIVE, &ctx->sched_flags))
70e65c2f6fSLuke Browning return 1;
71e65c2f6fSLuke Browning
72f3d69e05SLuke Browning dsisr = ctx->csa.class_1_dsisr;
73e65c2f6fSLuke Browning if (dsisr & (MFC_DSISR_PTE_NOT_FOUND | MFC_DSISR_ACCESS_DENIED))
74e65c2f6fSLuke Browning return 1;
75e65c2f6fSLuke Browning
76e65c2f6fSLuke Browning if (ctx->csa.class_0_pending)
77e65c2f6fSLuke Browning return 1;
78e65c2f6fSLuke Browning
79e65c2f6fSLuke Browning return 0;
80ce8ab854SArnd Bergmann }
81ce8ab854SArnd Bergmann
spu_setup_isolated(struct spu_context * ctx)82c6730ed4SJeremy Kerr static int spu_setup_isolated(struct spu_context *ctx)
83c6730ed4SJeremy Kerr {
84c6730ed4SJeremy Kerr int ret;
85c6730ed4SJeremy Kerr u64 __iomem *mfc_cntl;
86c6730ed4SJeremy Kerr u64 sr1;
87c6730ed4SJeremy Kerr u32 status;
88c6730ed4SJeremy Kerr unsigned long timeout;
89c6730ed4SJeremy Kerr const u32 status_loading = SPU_STATUS_RUNNING
90c6730ed4SJeremy Kerr | SPU_STATUS_ISOLATED_STATE | SPU_STATUS_ISOLATED_LOAD_STATUS;
91c6730ed4SJeremy Kerr
927ec18ab9SChristoph Hellwig ret = -ENODEV;
93c6730ed4SJeremy Kerr if (!isolated_loader)
94c6730ed4SJeremy Kerr goto out;
95c6730ed4SJeremy Kerr
967ec18ab9SChristoph Hellwig /*
977ec18ab9SChristoph Hellwig * We need to exclude userspace access to the context.
987ec18ab9SChristoph Hellwig *
997ec18ab9SChristoph Hellwig * To protect against memory access we invalidate all ptes
1007ec18ab9SChristoph Hellwig * and make sure the pagefault handlers block on the mutex.
1017ec18ab9SChristoph Hellwig */
1027ec18ab9SChristoph Hellwig spu_unmap_mappings(ctx);
1037ec18ab9SChristoph Hellwig
104c6730ed4SJeremy Kerr mfc_cntl = &ctx->spu->priv2->mfc_control_RW;
105c6730ed4SJeremy Kerr
106c6730ed4SJeremy Kerr /* purge the MFC DMA queue to ensure no spurious accesses before we
107c6730ed4SJeremy Kerr * enter kernel mode */
108c6730ed4SJeremy Kerr timeout = jiffies + HZ;
109c6730ed4SJeremy Kerr out_be64(mfc_cntl, MFC_CNTL_PURGE_DMA_REQUEST);
110c6730ed4SJeremy Kerr while ((in_be64(mfc_cntl) & MFC_CNTL_PURGE_DMA_STATUS_MASK)
111c6730ed4SJeremy Kerr != MFC_CNTL_PURGE_DMA_COMPLETE) {
112c6730ed4SJeremy Kerr if (time_after(jiffies, timeout)) {
113c6730ed4SJeremy Kerr printk(KERN_ERR "%s: timeout flushing MFC DMA queue\n",
114e48b1b45SHarvey Harrison __func__);
115c6730ed4SJeremy Kerr ret = -EIO;
1167ec18ab9SChristoph Hellwig goto out;
117c6730ed4SJeremy Kerr }
118c6730ed4SJeremy Kerr cond_resched();
119c6730ed4SJeremy Kerr }
120c6730ed4SJeremy Kerr
1213688b46bSJeremy Kerr /* clear purge status */
1223688b46bSJeremy Kerr out_be64(mfc_cntl, 0);
1233688b46bSJeremy Kerr
124c6730ed4SJeremy Kerr /* put the SPE in kernel mode to allow access to the loader */
125c6730ed4SJeremy Kerr sr1 = spu_mfc_sr1_get(ctx->spu);
126c6730ed4SJeremy Kerr sr1 &= ~MFC_STATE1_PROBLEM_STATE_MASK;
127c6730ed4SJeremy Kerr spu_mfc_sr1_set(ctx->spu, sr1);
128c6730ed4SJeremy Kerr
129c6730ed4SJeremy Kerr /* start the loader */
130c6730ed4SJeremy Kerr ctx->ops->signal1_write(ctx, (unsigned long)isolated_loader >> 32);
131c6730ed4SJeremy Kerr ctx->ops->signal2_write(ctx,
132c6730ed4SJeremy Kerr (unsigned long)isolated_loader & 0xffffffff);
133c6730ed4SJeremy Kerr
134c6730ed4SJeremy Kerr ctx->ops->runcntl_write(ctx,
135c6730ed4SJeremy Kerr SPU_RUNCNTL_RUNNABLE | SPU_RUNCNTL_ISOLATE);
136c6730ed4SJeremy Kerr
137c6730ed4SJeremy Kerr ret = 0;
138c6730ed4SJeremy Kerr timeout = jiffies + HZ;
139c6730ed4SJeremy Kerr while (((status = ctx->ops->status_read(ctx)) & status_loading) ==
140c6730ed4SJeremy Kerr status_loading) {
141c6730ed4SJeremy Kerr if (time_after(jiffies, timeout)) {
142c6730ed4SJeremy Kerr printk(KERN_ERR "%s: timeout waiting for loader\n",
143e48b1b45SHarvey Harrison __func__);
144c6730ed4SJeremy Kerr ret = -EIO;
145c6730ed4SJeremy Kerr goto out_drop_priv;
146c6730ed4SJeremy Kerr }
147c6730ed4SJeremy Kerr cond_resched();
148c6730ed4SJeremy Kerr }
149c6730ed4SJeremy Kerr
150c6730ed4SJeremy Kerr if (!(status & SPU_STATUS_RUNNING)) {
151c6730ed4SJeremy Kerr /* If isolated LOAD has failed: run SPU, we will get a stop-and
152c6730ed4SJeremy Kerr * signal later. */
153e48b1b45SHarvey Harrison pr_debug("%s: isolated LOAD failed\n", __func__);
154c6730ed4SJeremy Kerr ctx->ops->runcntl_write(ctx, SPU_RUNCNTL_RUNNABLE);
155c6730ed4SJeremy Kerr ret = -EACCES;
1567ec18ab9SChristoph Hellwig goto out_drop_priv;
1577ec18ab9SChristoph Hellwig }
158c6730ed4SJeremy Kerr
1597ec18ab9SChristoph Hellwig if (!(status & SPU_STATUS_ISOLATED_STATE)) {
160c6730ed4SJeremy Kerr /* This isn't allowed by the CBEA, but check anyway */
161e48b1b45SHarvey Harrison pr_debug("%s: SPU fell out of isolated mode?\n", __func__);
162c6730ed4SJeremy Kerr ctx->ops->runcntl_write(ctx, SPU_RUNCNTL_STOP);
163c6730ed4SJeremy Kerr ret = -EINVAL;
1647ec18ab9SChristoph Hellwig goto out_drop_priv;
165c6730ed4SJeremy Kerr }
166c6730ed4SJeremy Kerr
167c6730ed4SJeremy Kerr out_drop_priv:
168c6730ed4SJeremy Kerr /* Finished accessing the loader. Drop kernel mode */
169c6730ed4SJeremy Kerr sr1 |= MFC_STATE1_PROBLEM_STATE_MASK;
170c6730ed4SJeremy Kerr spu_mfc_sr1_set(ctx->spu, sr1);
171c6730ed4SJeremy Kerr
172c6730ed4SJeremy Kerr out:
173c6730ed4SJeremy Kerr return ret;
174c6730ed4SJeremy Kerr }
175c6730ed4SJeremy Kerr
spu_run_init(struct spu_context * ctx,u32 * npc)176aa45e256SChristoph Hellwig static int spu_run_init(struct spu_context *ctx, u32 *npc)
177ce8ab854SArnd Bergmann {
178e65c2f6fSLuke Browning unsigned long runcntl = SPU_RUNCNTL_RUNNABLE;
17991569531SLuke Browning int ret;
180cc210b3eSLuke Browning
18127ec41d3SAndre Detsch spuctx_switch_state(ctx, SPU_UTIL_SYSTEM);
18227ec41d3SAndre Detsch
18391569531SLuke Browning /*
184e65c2f6fSLuke Browning * NOSCHED is synchronous scheduling with respect to the caller.
185e65c2f6fSLuke Browning * The caller waits for the context to be loaded.
18691569531SLuke Browning */
187e65c2f6fSLuke Browning if (ctx->flags & SPU_CREATE_NOSCHED) {
18891569531SLuke Browning if (ctx->state == SPU_STATE_SAVED) {
18991569531SLuke Browning ret = spu_activate(ctx, 0);
190c6730ed4SJeremy Kerr if (ret)
191ce8ab854SArnd Bergmann return ret;
1920afacde3Sarnd@arndb.de }
193e65c2f6fSLuke Browning }
194c6730ed4SJeremy Kerr
195e65c2f6fSLuke Browning /*
196e65c2f6fSLuke Browning * Apply special setup as required.
197e65c2f6fSLuke Browning */
198e65c2f6fSLuke Browning if (ctx->flags & SPU_CREATE_ISOLATE) {
19991569531SLuke Browning if (!(ctx->ops->status_read(ctx) & SPU_STATUS_ISOLATED_STATE)) {
20091569531SLuke Browning ret = spu_setup_isolated(ctx);
20191569531SLuke Browning if (ret)
20291569531SLuke Browning return ret;
20391569531SLuke Browning }
20491569531SLuke Browning
20591569531SLuke Browning /*
20691569531SLuke Browning * If userspace has set the runcntrl register (eg, to
20791569531SLuke Browning * issue an isolated exit), we need to re-set it here
20891569531SLuke Browning */
209c6730ed4SJeremy Kerr runcntl = ctx->ops->runcntl_read(ctx) &
210c6730ed4SJeremy Kerr (SPU_RUNCNTL_RUNNABLE | SPU_RUNCNTL_ISOLATE);
211c6730ed4SJeremy Kerr if (runcntl == 0)
212c6730ed4SJeremy Kerr runcntl = SPU_RUNCNTL_RUNNABLE;
2132eb1b120SChristoph Hellwig } else {
214cc210b3eSLuke Browning unsigned long privcntl;
215cc210b3eSLuke Browning
21605169237SBenjamin Herrenschmidt if (test_thread_flag(TIF_SINGLESTEP))
217cc210b3eSLuke Browning privcntl = SPU_PRIVCNTL_MODE_SINGLE_STEP;
218cc210b3eSLuke Browning else
219cc210b3eSLuke Browning privcntl = SPU_PRIVCNTL_MODE_NORMAL;
220cc210b3eSLuke Browning
221cc210b3eSLuke Browning ctx->ops->privcntl_write(ctx, privcntl);
222d9dd421fSJeremy Kerr ctx->ops->npc_write(ctx, *npc);
223d9dd421fSJeremy Kerr }
224d9dd421fSJeremy Kerr
225e65c2f6fSLuke Browning ctx->ops->runcntl_write(ctx, runcntl);
22691569531SLuke Browning
227d9dd421fSJeremy Kerr if (ctx->flags & SPU_CREATE_NOSCHED) {
228d9dd421fSJeremy Kerr spuctx_switch_state(ctx, SPU_UTIL_USER);
229d9dd421fSJeremy Kerr } else {
230d9dd421fSJeremy Kerr
23191569531SLuke Browning if (ctx->state == SPU_STATE_SAVED) {
23291569531SLuke Browning ret = spu_activate(ctx, 0);
23391569531SLuke Browning if (ret)
23491569531SLuke Browning return ret;
235e65c2f6fSLuke Browning } else {
23627ec41d3SAndre Detsch spuctx_switch_state(ctx, SPU_UTIL_USER);
237e65c2f6fSLuke Browning }
23891569531SLuke Browning }
23927ec41d3SAndre Detsch
240ce7c191bSJeremy Kerr set_bit(SPU_SCHED_SPU_RUN, &ctx->sched_flags);
241aa45e256SChristoph Hellwig return 0;
242ce8ab854SArnd Bergmann }
243ce8ab854SArnd Bergmann
spu_run_fini(struct spu_context * ctx,u32 * npc,u32 * status)244aa45e256SChristoph Hellwig static int spu_run_fini(struct spu_context *ctx, u32 *npc,
245ce8ab854SArnd Bergmann u32 *status)
246ce8ab854SArnd Bergmann {
247ce8ab854SArnd Bergmann int ret = 0;
248ce8ab854SArnd Bergmann
249e65c2f6fSLuke Browning spu_del_from_rq(ctx);
250e65c2f6fSLuke Browning
251ce8ab854SArnd Bergmann *status = ctx->ops->status_read(ctx);
252ce8ab854SArnd Bergmann *npc = ctx->ops->npc_read(ctx);
25327ec41d3SAndre Detsch
25427ec41d3SAndre Detsch spuctx_switch_state(ctx, SPU_UTIL_IDLE_LOADED);
255ce7c191bSJeremy Kerr clear_bit(SPU_SCHED_SPU_RUN, &ctx->sched_flags);
256f5ed0eb6SJeremy Kerr spu_switch_log_notify(NULL, ctx, SWITCH_LOG_EXIT, *status);
257ce8ab854SArnd Bergmann spu_release(ctx);
258ce8ab854SArnd Bergmann
259ce8ab854SArnd Bergmann if (signal_pending(current))
260ce8ab854SArnd Bergmann ret = -ERESTARTSYS;
2612ebb2477SMasato Noguchi
262ce8ab854SArnd Bergmann return ret;
263ce8ab854SArnd Bergmann }
264ce8ab854SArnd Bergmann
2652dd14934SArnd Bergmann /*
2662dd14934SArnd Bergmann * SPU syscall restarting is tricky because we violate the basic
2672dd14934SArnd Bergmann * assumption that the signal handler is running on the interrupted
2682dd14934SArnd Bergmann * thread. Here instead, the handler runs on PowerPC user space code,
2692dd14934SArnd Bergmann * while the syscall was called from the SPU.
2702dd14934SArnd Bergmann * This means we can only do a very rough approximation of POSIX
2712dd14934SArnd Bergmann * signal semantics.
2722dd14934SArnd Bergmann */
spu_handle_restartsys(struct spu_context * ctx,long * spu_ret,unsigned int * npc)2731238819aSSebastian Siewior static int spu_handle_restartsys(struct spu_context *ctx, long *spu_ret,
2742dd14934SArnd Bergmann unsigned int *npc)
2752dd14934SArnd Bergmann {
2762dd14934SArnd Bergmann int ret;
2772dd14934SArnd Bergmann
2782dd14934SArnd Bergmann switch (*spu_ret) {
2792dd14934SArnd Bergmann case -ERESTARTSYS:
2802dd14934SArnd Bergmann case -ERESTARTNOINTR:
2812dd14934SArnd Bergmann /*
2822dd14934SArnd Bergmann * Enter the regular syscall restarting for
2832dd14934SArnd Bergmann * sys_spu_run, then restart the SPU syscall
2842dd14934SArnd Bergmann * callback.
2852dd14934SArnd Bergmann */
2862dd14934SArnd Bergmann *npc -= 8;
2872dd14934SArnd Bergmann ret = -ERESTARTSYS;
2882dd14934SArnd Bergmann break;
2892dd14934SArnd Bergmann case -ERESTARTNOHAND:
2902dd14934SArnd Bergmann case -ERESTART_RESTARTBLOCK:
2912dd14934SArnd Bergmann /*
2922dd14934SArnd Bergmann * Restart block is too hard for now, just return -EINTR
2932dd14934SArnd Bergmann * to the SPU.
2942dd14934SArnd Bergmann * ERESTARTNOHAND comes from sys_pause, we also return
2952dd14934SArnd Bergmann * -EINTR from there.
2962dd14934SArnd Bergmann * Assume that we need to be restarted ourselves though.
2972dd14934SArnd Bergmann */
2982dd14934SArnd Bergmann *spu_ret = -EINTR;
2992dd14934SArnd Bergmann ret = -ERESTARTSYS;
3002dd14934SArnd Bergmann break;
3012dd14934SArnd Bergmann default:
3022dd14934SArnd Bergmann printk(KERN_WARNING "%s: unexpected return code %ld\n",
303e48b1b45SHarvey Harrison __func__, *spu_ret);
3042dd14934SArnd Bergmann ret = 0;
3052dd14934SArnd Bergmann }
3062dd14934SArnd Bergmann return ret;
3072dd14934SArnd Bergmann }
3082dd14934SArnd Bergmann
spu_process_callback(struct spu_context * ctx)3091238819aSSebastian Siewior static int spu_process_callback(struct spu_context *ctx)
3102dd14934SArnd Bergmann {
3112dd14934SArnd Bergmann struct spu_syscall_block s;
3122dd14934SArnd Bergmann u32 ls_pointer, npc;
3139e2fe2ceSAkinobu Mita void __iomem *ls;
3142dd14934SArnd Bergmann long spu_ret;
315d29694f0SJeremy Kerr int ret;
3162dd14934SArnd Bergmann
3172dd14934SArnd Bergmann /* get syscall block from local store */
3189e2fe2ceSAkinobu Mita npc = ctx->ops->npc_read(ctx) & ~3;
3199e2fe2ceSAkinobu Mita ls = (void __iomem *)ctx->ops->get_ls(ctx);
3209e2fe2ceSAkinobu Mita ls_pointer = in_be32(ls + npc);
3212dd14934SArnd Bergmann if (ls_pointer > (LS_SIZE - sizeof(s)))
3222dd14934SArnd Bergmann return -EFAULT;
3239e2fe2ceSAkinobu Mita memcpy_fromio(&s, ls + ls_pointer, sizeof(s));
3242dd14934SArnd Bergmann
3252dd14934SArnd Bergmann /* do actual syscall without pinning the spu */
3262dd14934SArnd Bergmann ret = 0;
3272dd14934SArnd Bergmann spu_ret = -ENOSYS;
3282dd14934SArnd Bergmann npc += 4;
3292dd14934SArnd Bergmann
330f43194e4SRashmica Gupta if (s.nr_ret < NR_syscalls) {
3312dd14934SArnd Bergmann spu_release(ctx);
3322dd14934SArnd Bergmann /* do actual system call from here */
3332dd14934SArnd Bergmann spu_ret = spu_sys_callback(&s);
3342dd14934SArnd Bergmann if (spu_ret <= -ERESTARTSYS) {
3352dd14934SArnd Bergmann ret = spu_handle_restartsys(ctx, &spu_ret, &npc);
3362dd14934SArnd Bergmann }
337d29694f0SJeremy Kerr mutex_lock(&ctx->state_mutex);
3382dd14934SArnd Bergmann if (ret == -ERESTARTSYS)
3392dd14934SArnd Bergmann return ret;
3402dd14934SArnd Bergmann }
3412dd14934SArnd Bergmann
3424eb5aef5SJeremy Kerr /* need to re-get the ls, as it may have changed when we released the
3434eb5aef5SJeremy Kerr * spu */
3444eb5aef5SJeremy Kerr ls = (void __iomem *)ctx->ops->get_ls(ctx);
3454eb5aef5SJeremy Kerr
3462dd14934SArnd Bergmann /* write result, jump over indirect pointer */
3479e2fe2ceSAkinobu Mita memcpy_toio(ls + ls_pointer, &spu_ret, sizeof(spu_ret));
3482dd14934SArnd Bergmann ctx->ops->npc_write(ctx, npc);
3492dd14934SArnd Bergmann ctx->ops->runcntl_write(ctx, SPU_RUNCNTL_RUNNABLE);
3502dd14934SArnd Bergmann return ret;
3512dd14934SArnd Bergmann }
3522dd14934SArnd Bergmann
spufs_run_spu(struct spu_context * ctx,u32 * npc,u32 * event)35350af32a9SJeremy Kerr long spufs_run_spu(struct spu_context *ctx, u32 *npc, u32 *event)
354ce8ab854SArnd Bergmann {
355ce8ab854SArnd Bergmann int ret;
3569add11daSArnd Bergmann u32 status;
357ce8ab854SArnd Bergmann
358e45d48a3SChristoph Hellwig if (mutex_lock_interruptible(&ctx->run_mutex))
359ce8ab854SArnd Bergmann return -ERESTARTSYS;
360ce8ab854SArnd Bergmann
3619add11daSArnd Bergmann ctx->event_return = 0;
362aa45e256SChristoph Hellwig
363c9101bdbSChristoph Hellwig ret = spu_acquire(ctx);
364c9101bdbSChristoph Hellwig if (ret)
365c9101bdbSChristoph Hellwig goto out_unlock;
3662cf2b3b4SChristoph Hellwig
367c0bace5cSJeremy Kerr spu_enable_spu(ctx);
368c0bace5cSJeremy Kerr
3692cf2b3b4SChristoph Hellwig spu_update_sched_info(ctx);
370aa45e256SChristoph Hellwig
371aa45e256SChristoph Hellwig ret = spu_run_init(ctx, npc);
372aa45e256SChristoph Hellwig if (ret) {
373aa45e256SChristoph Hellwig spu_release(ctx);
374ce8ab854SArnd Bergmann goto out;
375aa45e256SChristoph Hellwig }
376ce8ab854SArnd Bergmann
377ce8ab854SArnd Bergmann do {
3789add11daSArnd Bergmann ret = spufs_wait(ctx->stop_wq, spu_stopped(ctx, &status));
379eebead5bSChristoph Hellwig if (unlikely(ret)) {
380eebead5bSChristoph Hellwig /*
381eebead5bSChristoph Hellwig * This is nasty: we need the state_mutex for all the
382eebead5bSChristoph Hellwig * bookkeeping even if the syscall was interrupted by
383eebead5bSChristoph Hellwig * a signal. ewww.
384eebead5bSChristoph Hellwig */
385eebead5bSChristoph Hellwig mutex_lock(&ctx->state_mutex);
386ce8ab854SArnd Bergmann break;
387eebead5bSChristoph Hellwig }
38836aaccc1SBob Nelson if (unlikely(test_and_clear_bit(SPU_SCHED_NOTIFY_ACTIVE,
38936aaccc1SBob Nelson &ctx->sched_flags))) {
390*7a3c90dfSViresh Kumar if (!(status & SPU_STATUS_STOPPED_BY_STOP))
39136aaccc1SBob Nelson continue;
39236aaccc1SBob Nelson }
39327ec41d3SAndre Detsch
39427ec41d3SAndre Detsch spuctx_switch_state(ctx, SPU_UTIL_SYSTEM);
39527ec41d3SAndre Detsch
3969add11daSArnd Bergmann if ((status & SPU_STATUS_STOPPED_BY_STOP) &&
3979add11daSArnd Bergmann (status >> SPU_STOP_STATUS_SHIFT == 0x2104)) {
3982dd14934SArnd Bergmann ret = spu_process_callback(ctx);
3992dd14934SArnd Bergmann if (ret)
4002dd14934SArnd Bergmann break;
4019add11daSArnd Bergmann status &= ~SPU_STATUS_STOPPED_BY_STOP;
4022dd14934SArnd Bergmann }
40357dace23SArnd Bergmann ret = spufs_handle_class1(ctx);
40457dace23SArnd Bergmann if (ret)
40557dace23SArnd Bergmann break;
40657dace23SArnd Bergmann
407d6ad39bcSJeremy Kerr ret = spufs_handle_class0(ctx);
408d6ad39bcSJeremy Kerr if (ret)
409d6ad39bcSJeremy Kerr break;
410d6ad39bcSJeremy Kerr
411d6ad39bcSJeremy Kerr if (signal_pending(current))
412d6ad39bcSJeremy Kerr ret = -ERESTARTSYS;
4139add11daSArnd Bergmann } while (!ret && !(status & (SPU_STATUS_STOPPED_BY_STOP |
41405169237SBenjamin Herrenschmidt SPU_STATUS_STOPPED_BY_HALT |
41505169237SBenjamin Herrenschmidt SPU_STATUS_SINGLE_STEP)));
416ce8ab854SArnd Bergmann
417c25620d7SMasato Noguchi spu_disable_spu(ctx);
4189add11daSArnd Bergmann ret = spu_run_fini(ctx, npc, &status);
419ce8ab854SArnd Bergmann spu_yield(ctx);
420ce8ab854SArnd Bergmann
421e66686b4SLuke Browning if ((status & SPU_STATUS_STOPPED_BY_STOP) &&
422e66686b4SLuke Browning (((status >> SPU_STOP_STATUS_SHIFT) & 0x3f00) == 0x2100))
423e66686b4SLuke Browning ctx->stats.libassist++;
424e66686b4SLuke Browning
4252ebb2477SMasato Noguchi if ((ret == 0) ||
4262ebb2477SMasato Noguchi ((ret == -ERESTARTSYS) &&
4272ebb2477SMasato Noguchi ((status & SPU_STATUS_STOPPED_BY_HALT) ||
42805169237SBenjamin Herrenschmidt (status & SPU_STATUS_SINGLE_STEP) ||
4292ebb2477SMasato Noguchi ((status & SPU_STATUS_STOPPED_BY_STOP) &&
4302ebb2477SMasato Noguchi (status >> SPU_STOP_STATUS_SHIFT != 0x2104)))))
4312ebb2477SMasato Noguchi ret = status;
4322ebb2477SMasato Noguchi
43305169237SBenjamin Herrenschmidt /* Note: we don't need to force_sig SIGTRAP on single-step
43405169237SBenjamin Herrenschmidt * since we have TIF_SINGLESTEP set, thus the kernel will do
435027dfac6SMichael Ellerman * it upon return from the syscall anyway.
43605169237SBenjamin Herrenschmidt */
43760cf54dbSJeremy Kerr if (unlikely(status & SPU_STATUS_SINGLE_STEP))
43860cf54dbSJeremy Kerr ret = -ERESTARTSYS;
43960cf54dbSJeremy Kerr
44060cf54dbSJeremy Kerr else if (unlikely((status & SPU_STATUS_STOPPED_BY_STOP)
44160cf54dbSJeremy Kerr && (status >> SPU_STOP_STATUS_SHIFT) == 0x3fff)) {
4423cf5d076SEric W. Biederman force_sig(SIGTRAP);
4432ebb2477SMasato Noguchi ret = -ERESTARTSYS;
4442ebb2477SMasato Noguchi }
4452ebb2477SMasato Noguchi
446ce8ab854SArnd Bergmann out:
4479add11daSArnd Bergmann *event = ctx->event_return;
448c9101bdbSChristoph Hellwig out_unlock:
449e45d48a3SChristoph Hellwig mutex_unlock(&ctx->run_mutex);
450ce8ab854SArnd Bergmann return ret;
451ce8ab854SArnd Bergmann }
452