2 * Low-level SPU handling
4 * (C) Copyright IBM Deutschland Entwicklung GmbH 2005
6 * Author: Arnd Bergmann <arndb@de.ibm.com>
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2, or (at your option)
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
22 #include <linux/sched.h>
24 #include <linux/module.h>
27 #include <asm/spu_csa.h>
32 * This ought to be kept in sync with the powerpc specific do_page_fault
33 * function. Currently, there are a few corner cases that we haven't had
34 * to handle fortunately.
36 static int spu_handle_mm_fault(struct mm_struct
*mm
, unsigned long ea
,
37 unsigned long dsisr
, unsigned *flt
)
39 struct vm_area_struct
*vma
;
40 unsigned long is_write
;
44 if (!IS_VALID_EA(ea
)) {
51 if (mm
->pgd
== NULL
) {
55 down_read(&mm
->mmap_sem
);
56 vma
= find_vma(mm
, ea
);
59 if (vma
->vm_start
<= ea
)
61 if (!(vma
->vm_flags
& VM_GROWSDOWN
))
63 if (expand_stack(vma
, ea
))
66 is_write
= dsisr
& MFC_DSISR_ACCESS_PUT
;
68 if (!(vma
->vm_flags
& VM_WRITE
))
71 if (dsisr
& MFC_DSISR_ACCESS_DENIED
)
73 if (!(vma
->vm_flags
& (VM_READ
| VM_EXEC
)))
77 *flt
= handle_mm_fault(mm
, vma
, ea
, is_write
);
94 up_read(&mm
->mmap_sem
);
98 up_read(&mm
->mmap_sem
);
102 static void spufs_handle_dma_error(struct spu_context
*ctx
,
103 unsigned long ea
, int type
)
105 if (ctx
->flags
& SPU_CREATE_EVENTS_ENABLED
) {
106 ctx
->event_return
|= type
;
107 wake_up_all(&ctx
->stop_wq
);
110 memset(&info
, 0, sizeof(info
));
113 case SPE_EVENT_INVALID_DMA
:
114 info
.si_signo
= SIGBUS
;
115 info
.si_code
= BUS_OBJERR
;
117 case SPE_EVENT_SPE_DATA_STORAGE
:
118 info
.si_signo
= SIGBUS
;
119 info
.si_addr
= (void __user
*)ea
;
120 info
.si_code
= BUS_ADRERR
;
122 case SPE_EVENT_DMA_ALIGNMENT
:
123 info
.si_signo
= SIGBUS
;
124 /* DAR isn't set for an alignment fault :( */
125 info
.si_code
= BUS_ADRALN
;
127 case SPE_EVENT_SPE_ERROR
:
128 info
.si_signo
= SIGILL
;
129 info
.si_addr
= (void __user
*)(unsigned long)
130 ctx
->ops
->npc_read(ctx
) - 4;
131 info
.si_code
= ILL_ILLOPC
;
135 force_sig_info(info
.si_signo
, &info
, current
);
139 void spufs_dma_callback(struct spu
*spu
, int type
)
141 spufs_handle_dma_error(spu
->ctx
, spu
->dar
, type
);
143 EXPORT_SYMBOL_GPL(spufs_dma_callback
);
146 * bottom half handler for page faults, we can't do this from
147 * interrupt context, since we might need to sleep.
148 * we also need to give up the mutex so we can get scheduled
149 * out while waiting for the backing store.
151 * TODO: try calling hash_page from the interrupt handler first
152 * in order to speed up the easy case.
154 int spufs_handle_class1(struct spu_context
*ctx
)
156 u64 ea
, dsisr
, access
;
162 * dar and dsisr get passed from the registers
163 * to the spu_context, to this function, but not
164 * back to the spu if it gets scheduled again.
166 * if we don't handle the fault for a saved context
167 * in time, we can still expect to get the same fault
168 * the immediately after the context restore.
170 if (ctx
->state
== SPU_STATE_RUNNABLE
) {
172 dsisr
= ctx
->spu
->dsisr
;
173 ctx
->spu
->dar
= ctx
->spu
->dsisr
= 0;
175 ea
= ctx
->csa
.priv1
.mfc_dar_RW
;
176 dsisr
= ctx
->csa
.priv1
.mfc_dsisr_RW
;
177 ctx
->csa
.priv1
.mfc_dar_RW
= 0;
178 ctx
->csa
.priv1
.mfc_dsisr_RW
= 0;
181 if (!(dsisr
& (MFC_DSISR_PTE_NOT_FOUND
| MFC_DSISR_ACCESS_DENIED
)))
184 spuctx_switch_state(ctx
, SPUCTX_UTIL_IOWAIT
);
186 pr_debug("ctx %p: ea %016lx, dsisr %016lx state %d\n", ctx
, ea
,
189 ctx
->stats
.hash_flt
++;
190 if (ctx
->state
== SPU_STATE_RUNNABLE
) {
191 ctx
->spu
->stats
.hash_flt
++;
192 spu_switch_state(ctx
->spu
, SPU_UTIL_IOWAIT
);
195 /* we must not hold the lock when entering spu_handle_mm_fault */
198 access
= (_PAGE_PRESENT
| _PAGE_USER
);
199 access
|= (dsisr
& MFC_DSISR_ACCESS_PUT
) ? _PAGE_RW
: 0UL;
200 local_irq_save(flags
);
201 ret
= hash_page(ea
, access
, 0x300);
202 local_irq_restore(flags
);
204 /* hashing failed, so try the actual fault handler */
206 ret
= spu_handle_mm_fault(current
->mm
, ea
, dsisr
, &flt
);
210 * If we handled the fault successfully and are in runnable
211 * state, restart the DMA.
212 * In case of unhandled error report the problem to user space.
215 if (flt
== VM_FAULT_MINOR
)
216 ctx
->stats
.min_flt
++;
218 ctx
->stats
.maj_flt
++;
219 if (ctx
->state
== SPU_STATE_RUNNABLE
) {
220 if (flt
== VM_FAULT_MINOR
)
221 ctx
->spu
->stats
.min_flt
++;
223 ctx
->spu
->stats
.maj_flt
++;
227 ctx
->ops
->restart_dma(ctx
);
229 spufs_handle_dma_error(ctx
, ea
, SPE_EVENT_SPE_DATA_STORAGE
);
231 spuctx_switch_state(ctx
, SPUCTX_UTIL_SYSTEM
);
234 EXPORT_SYMBOL_GPL(spufs_handle_class1
);