]>
git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - arch/metag/kernel/process.c
2e611bd3751585f36dd8afe70a63d0f6d88af1d9
2 * Copyright (C) 2005,2006,2007,2008,2009,2010,2011 Imagination Technologies
4 * This file contains the architecture-dependent parts of process handling.
8 #include <linux/errno.h>
9 #include <linux/export.h>
10 #include <linux/sched.h>
11 #include <linux/sched/debug.h>
12 #include <linux/kernel.h>
14 #include <linux/unistd.h>
15 #include <linux/ptrace.h>
16 #include <linux/user.h>
17 #include <linux/reboot.h>
18 #include <linux/elfcore.h>
20 #include <linux/tick.h>
21 #include <linux/slab.h>
22 #include <linux/mman.h>
24 #include <linux/syscalls.h>
25 #include <linux/uaccess.h>
26 #include <linux/smp.h>
27 #include <asm/core_reg.h>
28 #include <asm/user_gateway.h>
30 #include <asm/traps.h>
31 #include <asm/switch_to.h>
34 * Wait for the next interrupt and enable local interrupts
36 void arch_cpu_idle(void)
41 * Quickly jump straight into the interrupt entry point without actually
42 * triggering an interrupt. When TXSTATI gets read the processor will
43 * block until an interrupt is triggered.
45 asm volatile (/* Switch into ISTAT mode */
47 /* Enable local interrupts */
50 * We can't directly "SWAP PC, PCX", so we swap via a
51 * temporary. Essentially we do:
52 * PCX_new = 1f (the place to continue execution)
55 "ADD %0, CPC0, #(1f-.)\n\t"
58 /* Continue execution here with interrupts enabled */
61 : "r" (get_trigger_mask()));
64 #ifdef CONFIG_HOTPLUG_CPU
65 void arch_cpu_idle_dead(void)
71 void (*pm_power_off
)(void);
72 EXPORT_SYMBOL(pm_power_off
);
74 void (*soc_restart
)(char *cmd
);
75 void (*soc_halt
)(void);
77 void machine_restart(char *cmd
)
81 hard_processor_halt(HALT_OK
);
84 void machine_halt(void)
89 hard_processor_halt(HALT_OK
);
92 void machine_power_off(void)
97 hard_processor_halt(HALT_OK
);
105 void show_regs(struct pt_regs
*regs
)
108 const char *AX0_names
[] = {"A0StP", "A0FrP"};
109 const char *AX1_names
[] = {"A1GbP", "A1LbP"};
111 const char *DX0_names
[] = {
122 const char *DX1_names
[] = {
133 show_regs_print_info(KERN_INFO
);
135 pr_info(" pt_regs @ %p\n", regs
);
136 pr_info(" SaveMask = 0x%04hx\n", regs
->ctx
.SaveMask
);
137 pr_info(" Flags = 0x%04hx (%c%c%c%c)\n", regs
->ctx
.Flags
,
138 regs
->ctx
.Flags
& FLAG_Z
? 'Z' : 'z',
139 regs
->ctx
.Flags
& FLAG_N
? 'N' : 'n',
140 regs
->ctx
.Flags
& FLAG_O
? 'O' : 'o',
141 regs
->ctx
.Flags
& FLAG_C
? 'C' : 'c');
142 pr_info(" TXRPT = 0x%08x\n", regs
->ctx
.CurrRPT
);
143 pr_info(" PC = 0x%08x\n", regs
->ctx
.CurrPC
);
146 for (i
= 0; i
< 2; i
++) {
147 pr_info(" %s = 0x%08x ",
150 printk(" %s = 0x%08x\n",
155 if (regs
->ctx
.SaveMask
& TBICTX_XEXT_BIT
)
156 pr_warn(" Extended state present - AX2.[01] will be WRONG\n");
158 /* Special place with AXx.2 */
159 pr_info(" A0.2 = 0x%08x ",
160 regs
->ctx
.Ext
.AX2
.U0
);
161 printk(" A1.2 = 0x%08x\n",
162 regs
->ctx
.Ext
.AX2
.U1
);
164 /* 'extended' AX regs (nominally, just AXx.3) */
165 for (i
= 0; i
< (TBICTX_AX_REGS
- 3); i
++) {
166 pr_info(" A0.%d = 0x%08x ", i
+ 3, regs
->ctx
.AX3
[i
].U0
);
167 printk(" A1.%d = 0x%08x\n", i
+ 3, regs
->ctx
.AX3
[i
].U1
);
170 for (i
= 0; i
< 8; i
++) {
171 pr_info(" %s = 0x%08x ", DX0_names
[i
], regs
->ctx
.DX
[i
].U0
);
172 printk(" %s = 0x%08x\n", DX1_names
[i
], regs
->ctx
.DX
[i
].U1
);
175 show_trace(NULL
, (unsigned long *)regs
->ctx
.AX
[0].U0
, regs
);
179 * Copy architecture-specific thread state
181 int copy_thread(unsigned long clone_flags
, unsigned long usp
,
182 unsigned long kthread_arg
, struct task_struct
*tsk
)
184 struct pt_regs
*childregs
= task_pt_regs(tsk
);
185 void *kernel_context
= ((void *) childregs
+
186 sizeof(struct pt_regs
));
187 unsigned long global_base
;
189 BUG_ON(((unsigned long)childregs
) & 0x7);
190 BUG_ON(((unsigned long)kernel_context
) & 0x7);
192 memset(&tsk
->thread
.kernel_context
, 0,
193 sizeof(tsk
->thread
.kernel_context
));
195 tsk
->thread
.kernel_context
= __TBISwitchInit(kernel_context
,
199 if (unlikely(tsk
->flags
& PF_KTHREAD
)) {
201 * Make sure we don't leak any kernel data to child's regs
202 * if kernel thread becomes a userspace thread in the future
204 memset(childregs
, 0 , sizeof(struct pt_regs
));
206 global_base
= __core_reg_get(A1GbP
);
207 childregs
->ctx
.AX
[0].U1
= (unsigned long) global_base
;
208 childregs
->ctx
.AX
[0].U0
= (unsigned long) kernel_context
;
209 /* Set D1Ar1=kthread_arg and D1RtP=usp (fn) */
210 childregs
->ctx
.DX
[4].U1
= usp
;
211 childregs
->ctx
.DX
[3].U1
= kthread_arg
;
212 tsk
->thread
.int_depth
= 2;
217 * Get a pointer to where the new child's register block should have
219 * The Meta's stack grows upwards, and the context is the the first
220 * thing to be pushed by TBX (phew)
222 *childregs
= *current_pt_regs();
223 /* Set the correct stack for the clone mode */
225 childregs
->ctx
.AX
[0].U0
= ALIGN(usp
, 8);
226 tsk
->thread
.int_depth
= 1;
228 /* set return value for child process */
229 childregs
->ctx
.DX
[0].U0
= 0;
231 /* The TLS pointer is passed as an argument to sys_clone. */
232 if (clone_flags
& CLONE_SETTLS
)
233 tsk
->thread
.tls_ptr
=
234 (__force
void __user
*)childregs
->ctx
.DX
[1].U1
;
236 #ifdef CONFIG_METAG_FPU
237 if (tsk
->thread
.fpu_context
) {
238 struct meta_fpu_context
*ctx
;
240 ctx
= kmemdup(tsk
->thread
.fpu_context
,
241 sizeof(struct meta_fpu_context
), GFP_ATOMIC
);
242 tsk
->thread
.fpu_context
= ctx
;
246 #ifdef CONFIG_METAG_DSP
247 if (tsk
->thread
.dsp_context
) {
248 struct meta_ext_context
*ctx
;
251 ctx
= kmemdup(tsk
->thread
.dsp_context
,
252 sizeof(struct meta_ext_context
), GFP_ATOMIC
);
253 for (i
= 0; i
< 2; i
++)
254 ctx
->ram
[i
] = kmemdup(ctx
->ram
[i
], ctx
->ram_sz
[i
],
256 tsk
->thread
.dsp_context
= ctx
;
263 #ifdef CONFIG_METAG_FPU
264 static void alloc_fpu_context(struct thread_struct
*thread
)
266 thread
->fpu_context
= kzalloc(sizeof(struct meta_fpu_context
),
270 static void clear_fpu(struct thread_struct
*thread
)
272 thread
->user_flags
&= ~TBICTX_FPAC_BIT
;
273 kfree(thread
->fpu_context
);
274 thread
->fpu_context
= NULL
;
277 static void clear_fpu(struct thread_struct
*thread
)
282 #ifdef CONFIG_METAG_DSP
283 static void clear_dsp(struct thread_struct
*thread
)
285 if (thread
->dsp_context
) {
286 kfree(thread
->dsp_context
->ram
[0]);
287 kfree(thread
->dsp_context
->ram
[1]);
289 kfree(thread
->dsp_context
);
291 thread
->dsp_context
= NULL
;
294 __core_reg_set(D0
.8
, 0);
297 static void clear_dsp(struct thread_struct
*thread
)
302 struct task_struct
*__sched
__switch_to(struct task_struct
*prev
,
303 struct task_struct
*next
)
307 to
.Switch
.pCtx
= next
->thread
.kernel_context
;
308 to
.Switch
.pPara
= prev
;
310 #ifdef CONFIG_METAG_FPU
311 if (prev
->thread
.user_flags
& TBICTX_FPAC_BIT
) {
312 struct pt_regs
*regs
= task_pt_regs(prev
);
315 state
.Sig
.SaveMask
= prev
->thread
.user_flags
;
316 state
.Sig
.pCtx
= ®s
->ctx
;
318 if (!prev
->thread
.fpu_context
)
319 alloc_fpu_context(&prev
->thread
);
320 if (prev
->thread
.fpu_context
)
321 __TBICtxFPUSave(state
, prev
->thread
.fpu_context
);
324 * Force a restore of the FPU context next time this process is
327 if (prev
->thread
.fpu_context
)
328 prev
->thread
.fpu_context
->needs_restore
= true;
332 from
= __TBISwitch(to
, &prev
->thread
.kernel_context
);
334 /* Restore TLS pointer for this process. */
335 set_gateway_tls(current
->thread
.tls_ptr
);
337 return (struct task_struct
*) from
.Switch
.pPara
;
340 void flush_thread(void)
342 clear_fpu(¤t
->thread
);
343 clear_dsp(¤t
->thread
);
347 * Free current thread data structures etc.
349 void exit_thread(struct task_struct
*tsk
)
351 clear_fpu(&tsk
->thread
);
352 clear_dsp(&tsk
->thread
);
355 /* TODO: figure out how to unwind the kernel stack here to figure out
356 * where we went to sleep. */
357 unsigned long get_wchan(struct task_struct
*p
)
362 int dump_fpu(struct pt_regs
*regs
, elf_fpregset_t
*fpu
)
364 /* Returning 0 indicates that the FPU state was not stored (as it was
369 #ifdef CONFIG_METAG_USER_TCM
371 #define ELF_MIN_ALIGN PAGE_SIZE
373 #define ELF_PAGESTART(_v) ((_v) & ~(unsigned long)(ELF_MIN_ALIGN-1))
374 #define ELF_PAGEOFFSET(_v) ((_v) & (ELF_MIN_ALIGN-1))
375 #define ELF_PAGEALIGN(_v) (((_v) + ELF_MIN_ALIGN - 1) & ~(ELF_MIN_ALIGN - 1))
377 #define BAD_ADDR(x) ((unsigned long)(x) >= TASK_SIZE)
379 unsigned long __metag_elf_map(struct file
*filep
, unsigned long addr
,
380 struct elf_phdr
*eppnt
, int prot
, int type
,
381 unsigned long total_size
)
383 unsigned long map_addr
, size
;
384 unsigned long page_off
= ELF_PAGEOFFSET(eppnt
->p_vaddr
);
385 unsigned long raw_size
= eppnt
->p_filesz
+ page_off
;
386 unsigned long off
= eppnt
->p_offset
- page_off
;
387 unsigned int tcm_tag
;
388 addr
= ELF_PAGESTART(addr
);
389 size
= ELF_PAGEALIGN(raw_size
);
391 /* mmap() will return -EINVAL if given a zero size, but a
392 * segment with zero filesize is perfectly valid */
396 tcm_tag
= tcm_lookup_tag(addr
);
398 if (tcm_tag
!= TCM_INVALID_TAG
)
402 * total_size is the size of the ELF (interpreter) image.
403 * The _first_ mmap needs to know the full size, otherwise
404 * randomization might put this image into an overlapping
405 * position with the ELF binary image. (since size < total_size)
406 * So we first map the 'big' image - and unmap the remainder at
407 * the end. (which unmap is needed for ELF images with holes.)
410 total_size
= ELF_PAGEALIGN(total_size
);
411 map_addr
= vm_mmap(filep
, addr
, total_size
, prot
, type
, off
);
412 if (!BAD_ADDR(map_addr
))
413 vm_munmap(map_addr
+size
, total_size
-size
);
415 map_addr
= vm_mmap(filep
, addr
, size
, prot
, type
, off
);
417 if (!BAD_ADDR(map_addr
) && tcm_tag
!= TCM_INVALID_TAG
) {
418 struct tcm_allocation
*tcm
;
419 unsigned long tcm_addr
;
421 tcm
= kmalloc(sizeof(*tcm
), GFP_KERNEL
);
425 tcm_addr
= tcm_alloc(tcm_tag
, raw_size
);
426 if (tcm_addr
!= addr
) {
432 tcm
->addr
= tcm_addr
;
433 tcm
->size
= raw_size
;
435 list_add(&tcm
->list
, ¤t
->mm
->context
.tcm
);
437 eppnt
->p_vaddr
= map_addr
;
438 if (copy_from_user((void *) addr
, (void __user
*) map_addr
,