1// SPDX-License-Identifier: GPL-2.0
  2// Copyright (C) 2005-2017 Andes Technology Corporation
  3
  4#include <linux/sched.h>
  5#include <linux/sched/debug.h>
  6#include <linux/sched/task_stack.h>
  7#include <linux/delay.h>
  8#include <linux/kallsyms.h>
  9#include <linux/uaccess.h>
 10#include <asm/elf.h>
 11#include <asm/proc-fns.h>
 12#include <linux/ptrace.h>
 13#include <linux/reboot.h>
 14
 15extern void setup_mm_for_reboot(char mode);
 16#ifdef CONFIG_PROC_FS
 17struct proc_dir_entry *proc_dir_cpu;
 18EXPORT_SYMBOL(proc_dir_cpu);
 19#endif
 20
 21extern inline void arch_reset(char mode)
 22{
 23	if (mode == 's') {
 24		/* Use cpu handler, jump to 0 */
 25		cpu_reset(0);
 26	}
 27}
 28
 29void (*pm_power_off) (void);
 30EXPORT_SYMBOL(pm_power_off);
 31
 32static char reboot_mode_nds32 = 'h';
 33
 34int __init reboot_setup(char *str)
 35{
 36	reboot_mode_nds32 = str[0];
 37	return 1;
 38}
 39
 40static int cpub_pwroff(void)
 41{
 42	return 0;
 43}
 44
 45__setup("reboot=", reboot_setup);
 46
 47void machine_halt(void)
 48{
 49	cpub_pwroff();
 50}
 51
 52EXPORT_SYMBOL(machine_halt);
 53
 54void machine_power_off(void)
 55{
 56	if (pm_power_off)
 57		pm_power_off();
 58}
 59
 60EXPORT_SYMBOL(machine_power_off);
 61
 62void machine_restart(char *cmd)
 63{
 64	/*
 65	 * Clean and disable cache, and turn off interrupts
 66	 */
 67	cpu_proc_fin();
 68
 69	/*
 70	 * Tell the mm system that we are going to reboot -
 71	 * we may need it to insert some 1:1 mappings so that
 72	 * soft boot works.
 73	 */
 74	setup_mm_for_reboot(reboot_mode_nds32);
 75
 76	/* Execute kernel restart handler call chain */
 77	do_kernel_restart(cmd);
 78
 79	/*
 80	 * Now call the architecture specific reboot code.
 81	 */
 82	arch_reset(reboot_mode_nds32);
 83
 84	/*
 85	 * Whoops - the architecture was unable to reboot.
 86	 * Tell the user!
 87	 */
 88	mdelay(1000);
 89	pr_info("Reboot failed -- System halted\n");
 90	while (1) ;
 91}
 92
 93EXPORT_SYMBOL(machine_restart);
 94
 95void show_regs(struct pt_regs *regs)
 96{
 97	printk("PC is at %pS\n", (void *)instruction_pointer(regs));
 98	printk("LP is at %pS\n", (void *)regs->lp);
 99	pr_info("pc : [<%08lx>]    lp : [<%08lx>]    %s\n"
100		"sp : %08lx  fp : %08lx  gp : %08lx\n",
101		instruction_pointer(regs),
102		regs->lp, print_tainted(), regs->sp, regs->fp, regs->gp);
103	pr_info("r25: %08lx  r24: %08lx\n", regs->uregs[25], regs->uregs[24]);
104
105	pr_info("r23: %08lx  r22: %08lx  r21: %08lx  r20: %08lx\n",
106		regs->uregs[23], regs->uregs[22],
107		regs->uregs[21], regs->uregs[20]);
108	pr_info("r19: %08lx  r18: %08lx  r17: %08lx  r16: %08lx\n",
109		regs->uregs[19], regs->uregs[18],
110		regs->uregs[17], regs->uregs[16]);
111	pr_info("r15: %08lx  r14: %08lx  r13: %08lx  r12: %08lx\n",
112		regs->uregs[15], regs->uregs[14],
113		regs->uregs[13], regs->uregs[12]);
114	pr_info("r11: %08lx  r10: %08lx  r9 : %08lx  r8 : %08lx\n",
115		regs->uregs[11], regs->uregs[10],
116		regs->uregs[9], regs->uregs[8]);
117	pr_info("r7 : %08lx  r6 : %08lx  r5 : %08lx  r4 : %08lx\n",
118		regs->uregs[7], regs->uregs[6], regs->uregs[5], regs->uregs[4]);
119	pr_info("r3 : %08lx  r2 : %08lx  r1 : %08lx  r0 : %08lx\n",
120		regs->uregs[3], regs->uregs[2], regs->uregs[1], regs->uregs[0]);
121	pr_info("  IRQs o%s  Segment %s\n",
122		interrupts_enabled(regs) ? "n" : "ff",
123		segment_eq(get_fs(), get_ds())? "kernel" : "user");
124}
125
126EXPORT_SYMBOL(show_regs);
127
128void flush_thread(void)
129{
130}
131
132DEFINE_PER_CPU(struct task_struct *, __entry_task);
133
134asmlinkage void ret_from_fork(void) __asm__("ret_from_fork");
135int copy_thread(unsigned long clone_flags, unsigned long stack_start,
136	    unsigned long stk_sz, struct task_struct *p)
137{
138	struct pt_regs *childregs = task_pt_regs(p);
139
140	memset(&p->thread.cpu_context, 0, sizeof(struct cpu_context));
141
142	if (unlikely(p->flags & PF_KTHREAD)) {
143		memset(childregs, 0, sizeof(struct pt_regs));
144		/* kernel thread fn */
145		p->thread.cpu_context.r6 = stack_start;
146		/* kernel thread argument */
147		p->thread.cpu_context.r7 = stk_sz;
148	} else {
149		*childregs = *current_pt_regs();
150		if (stack_start)
151			childregs->sp = stack_start;
152		/* child get zero as ret. */
153		childregs->uregs[0] = 0;
154		childregs->osp = 0;
155		if (clone_flags & CLONE_SETTLS)
156			childregs->uregs[25] = childregs->uregs[3];
157	}
158	/* cpu context switching  */
159	p->thread.cpu_context.pc = (unsigned long)ret_from_fork;
160	p->thread.cpu_context.sp = (unsigned long)childregs;
161
162#ifdef CONFIG_HWZOL
163	childregs->lb = 0;
164	childregs->le = 0;
165	childregs->lc = 0;
166#endif
167
168	return 0;
169}
170
171/*
172 * fill in the fpe structure for a core dump...
173 */
174int dump_fpu(struct pt_regs *regs, elf_fpregset_t * fpu)
175{
176	int fpvalid = 0;
177	return fpvalid;
178}
179
180EXPORT_SYMBOL(dump_fpu);
181
182unsigned long get_wchan(struct task_struct *p)
183{
184	unsigned long fp, lr;
185	unsigned long stack_start, stack_end;
186	int count = 0;
187
188	if (!p || p == current || p->state == TASK_RUNNING)
189		return 0;
190
191	if (IS_ENABLED(CONFIG_FRAME_POINTER)) {
192		stack_start = (unsigned long)end_of_stack(p);
193		stack_end = (unsigned long)task_stack_page(p) + THREAD_SIZE;
194
195		fp = thread_saved_fp(p);
196		do {
197			if (fp < stack_start || fp > stack_end)
198				return 0;
199			lr = ((unsigned long *)fp)[0];
200			if (!in_sched_functions(lr))
201				return lr;
202			fp = *(unsigned long *)(fp + 4);
203		} while (count++ < 16);
204	}
205	return 0;
206}
207
208EXPORT_SYMBOL(get_wchan);