static void hangcheck_fire(unsigned long data)
{
unsigned long long cur_tsc, tsc_diff;
cur_tsc = monotonic_clock();
if (cur_tsc > hangcheck_tsc)
tsc_diff = cur_tsc - hangcheck_tsc;
else
tsc_diff = (cur_tsc + (~0ULL - hangcheck_tsc)); /* or something */
if (tsc_diff > hangcheck_tsc_margin) {
if (hangcheck_dump_tasks) {
printk(KERN_CRIT "Hangcheck: Task state:\n");
#ifdef CONFIG_MAGIC_SYSRQ
handle_sysrq('t', NULL, NULL);
#endif /* CONFIG_MAGIC_SYSRQ */
}
if (hangcheck_reboot) {
printk(KERN_CRIT "Hangcheck: hangcheck is restarting the machine.\n");
machine_restart(NULL);
} else {
printk(KERN_CRIT "Hangcheck: hangcheck value past margin!\n");
}
}
mod_timer(&hangcheck_ticktock, jiffies + (hangcheck_tick*HZ));
hangcheck_tsc = monotonic_clock();
}
void dom0_shutdown(u8 reason)
{
switch ( reason )
{
case SHUTDOWN_poweroff:
{
printk("Domain 0 halted: halting machine.\n");
machine_halt();
break; /* not reached */
}
case SHUTDOWN_crash:
{
debugger_trap_immediate();
printk("Domain 0 crashed: ");
maybe_reboot();
break; /* not reached */
}
case SHUTDOWN_reboot:
{
printk("Domain 0 shutdown: rebooting machine.\n");
machine_restart(0);
break; /* not reached */
}
default:
{
printk("Domain 0 shutdown (unknown reason %u): ", reason);
maybe_reboot();
break; /* not reached */
}
}
}
static irqreturn_t wdtpci_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
/*
* Read the status register see what is up and
* then printk it.
*/
unsigned char status=inb_p(WDT_SR);
status|=FEATUREMAP1;
status&=~FEATUREMAP2;
printk(KERN_CRIT "WDT status %d\n", status);
if(!(status&WDC_SR_TGOOD))
printk(KERN_CRIT "Overheat alarm.(%d)\n",inb_p(WDT_RT));
if(!(status&WDC_SR_PSUOVER))
printk(KERN_CRIT "PSU over voltage.\n");
if(!(status&WDC_SR_PSUUNDR))
printk(KERN_CRIT "PSU under voltage.\n");
if(!(status&WDC_SR_FANGOOD))
printk(KERN_CRIT "Possible fan fault.\n");
if(!(status&WDC_SR_WCCR))
#ifdef SOFTWARE_REBOOT
#ifdef ONLY_TESTING
printk(KERN_CRIT "Would Reboot.\n");
#else
printk(KERN_CRIT "Initiating system reboot.\n");
machine_restart(NULL);
#endif
#else
printk(KERN_CRIT "Reset in 5ms.\n");
#endif
return IRQ_HANDLED;
}
static void mips_machine_power_off(void)
{
mips_pm_suspend(PIIX4_FUNC3IO_PMCNTRL_SUS_TYP_SOFF);
pr_info("Failed to power down, resetting\n");
machine_restart(NULL);
}
static void power_down(suspend_disk_method_t mode)
{
unsigned long flags;
int error = 0;
local_irq_save(flags);
switch(mode) {
case PM_DISK_PLATFORM:
device_power_down(PM_SUSPEND_DISK);
error = pm_ops->enter(PM_SUSPEND_DISK);
break;
case PM_DISK_SHUTDOWN:
printk("Powering off system\n");
device_shutdown();
machine_power_off();
break;
case PM_DISK_REBOOT:
device_shutdown();
machine_restart(NULL);
break;
}
machine_halt();
/* Valid image is on the disk, if we continue we risk serious data corruption
after resume. */
printk(KERN_CRIT "Please power me down manually\n");
while(1);
}
int
kdb_reboot(int argc, const char **argv, const char **envp, struct pt_regs *regs)
{
machine_restart(0);
/* NOTREACHED */
return 0;
}
static void zeus_poweroff(void)
{
/* int n_usbic_state; */
printk("\nZEUS BOARD GOING TO SHUTDOWN!!!\n");
#if defined(CONFIG_USB_ANDROID)
android_usb_set_connected(0);
#endif
tl2796_lcd_poweroff();
/* get_real_usbic_state(); */
//gpio_direction_output(GPIO_MSM_RST,0);
//gpio_direction_output(GPIO_FONE_ACTIVE, 0);
// if (GPIO_TA_CONNECTED_N is LOW)
//#if (CONFIG_ARCHER_REV < ARCHER_REV13)
// if ( get_real_usbic_state() )
if ( sec_switch_get_cable_status() != CABLE_TYPE_NONE ) //me add
//#else
// if ( !gpio_get_value( OMAP_GPIO_TA_NCONNECTED ) || gpio_get_value( OMAP_GPIO_IF_CON_SENSE ) )
//#endif
{
printk("Warmreset by TA or USB or Jtag\n\n");
preempt_disable();
local_irq_disable();
local_fiq_disable();
#ifdef CONFIG_ARCHER_KOR_DEBUG
omap_writel(0x54455352, OMAP343X_CTRL_BASE + 0x9C4); // set to normal reset
#endif
#if 1
/* using watchdog reset */
omap_watchdog_reset();
/* machine_restart("ta_inserted"); */
#else
/* using core_dpll_warmreset with global reset */
//omap3_configure_core_dpll_warmreset();
machine_restart("ta_inserted");
#endif
while(1);
}
else
{
printk("Power Off !\n\n");
while(1)
{
gpio_direction_output(GPIO_PS_HOLD, 0);
if (0 /*is_powerbutton_pressed*/)
printk("Power button is pressed\n\n");
else
twl4030_poweroff();
}
}
return;
}
static void do_restart(void)
{
#if defined(CONFIG_POWER_KEY_CLR_RESET)
clear_hw_reset();
#endif
sys_sync();
machine_restart("power-key-force-hard");
}
/******************************************************************************
* *
* BOOL cmdHboot(char *args, int subClass) *
* *
*******************************************************************************
*
* Total computer reset
*
******************************************************************************/
BOOL cmdHboot(char *args, int subClass)
{
// Linux: process.c
machine_restart(NULL);
return( TRUE );
}
NORET_TYPE void panic(const char * fmt, ...)
{
static char buf[1024];
va_list args;
#if defined(CONFIG_ARCH_S390)
unsigned long caller = (unsigned long) __builtin_return_address(0);
#endif
bust_spinlocks(1);
va_start(args, fmt);
vsprintf(buf, fmt, args);
va_end(args);
printk(KERN_EMERG "Kernel panic: %s\n",buf);
if (in_interrupt())
printk(KERN_EMERG "In interrupt handler - not syncing\n");
else if (!current->pid)
printk(KERN_EMERG "In idle task - not syncing\n");
else
sys_sync();
bust_spinlocks(0);
#ifdef CONFIG_SMP
smp_send_stop();
#endif
notifier_call_chain(&panic_notifier_list, 0, NULL);
if (panic_timeout > 0)
{
/*
* Delay timeout seconds before rebooting the machine.
* We can't use the "normal" timers since we just panicked..
*/
printk(KERN_EMERG "Rebooting in %d seconds..",panic_timeout);
mdelay(panic_timeout*1000);
/*
* Should we run the reboot notifier. For the moment Im
* choosing not too. It might crash, be corrupt or do
* more harm than good for other reasons.
*/
machine_restart(NULL);
}
#ifdef __sparc__
{
extern int stop_a_enabled;
/* Make sure the user can actually press L1-A */
stop_a_enabled = 1;
printk("Press L1-A to return to the boot prom\n");
}
#endif
#if defined(CONFIG_ARCH_S390)
disabled_wait(caller);
#endif
sti();
for(;;) {
CHECK_EMERGENCY_SYNC
}
}
void axp81x_power_off(int power_start)
{
uint8_t val;
struct axp_dev *axp;
axp = axp_dev_lookup(AXP81X);
if (NULL == axp) {
printk("%s: axp data is null\n", __func__);
return;
}
if(axp81x_config.pmu_pwroff_vol >= 2600 && axp81x_config.pmu_pwroff_vol <= 3300){
if (axp81x_config.pmu_pwroff_vol > 3200){
val = 0x7;
}else if (axp81x_config.pmu_pwroff_vol > 3100){
val = 0x6;
}else if (axp81x_config.pmu_pwroff_vol > 3000){
val = 0x5;
}else if (axp81x_config.pmu_pwroff_vol > 2900){
val = 0x4;
}else if (axp81x_config.pmu_pwroff_vol > 2800){
val = 0x3;
}else if (axp81x_config.pmu_pwroff_vol > 2700){
val = 0x2;
}else if (axp81x_config.pmu_pwroff_vol > 2600){
val = 0x1;
}else
val = 0x0;
axp_update(axp->dev, AXP81X_VOFF_SET, val, 0x7);
}
val = 0xff;
printk("[axp] send power-off command!\n");
mdelay(20);
if(axp81x_config.power_start != 1){
axp_read(axp->dev, AXP81X_STATUS, &val);
if(val & 0xF0){
axp_read(axp->dev, AXP81X_MODE_CHGSTATUS, &val);
if(val & 0x20) {
printk("[axp] set flag!\n");
axp_read(axp->dev, AXP81X_BUFFERC, &val);
if (0x0d != val)
axp_write(axp->dev, AXP81X_BUFFERC, 0x0f);
mdelay(20);
printk("[axp] reboot!\n");
machine_restart(NULL);
printk("[axp] warning!!! arch can't ,reboot, maybe some error happend!\n");
}
}
}
axp_read(axp->dev, AXP81X_BUFFERC, &val);
if (0x0d != val)
axp_write(axp->dev, AXP81X_BUFFERC, 0x00);
mdelay(20);
axp_set_bits(axp->dev, AXP81X_OFF_CTL, 0x80);
mdelay(20);
printk("[axp] warning!!! axp can't power-off, maybe some error happend!\n");
}
static void hisi_pmic_panic_handler(void)
{
#ifdef CONFIG_HISI_BB
rdr_syserr_process_for_ap(MODID_AP_S_PMU, 0, 0);
#else
machine_restart("AP_S_PMU");
#endif
return;
}
static irqreturn_t fsg_reset_handler(int irq, void *dev_id)
{
/* This is the paper-clip reset which does an emergency reboot. */
printk(KERN_INFO "Restarting system.\n");
machine_restart(NULL);
/* This should never be reached. */
return IRQ_HANDLED;
}
/**
* kernel_restart - reboot the system
* @cmd: pointer to buffer containing command to execute for restart
* or %NULL
*
* Shutdown everything and perform a clean reboot.
* This is not safe to call in interrupt context.
*/
void kernel_restart(char *cmd)
{
kernel_restart_prepare(cmd);
if (!cmd)
printk(KERN_EMERG "Restarting system.\n");
else
printk(KERN_EMERG "Restarting system with command '%s'.\n", cmd);
machine_restart(cmd);
}
void
abort(void)
{
#ifdef CONFIG_XMON
extern void xmon(void *);
xmon(0);
#endif
machine_restart(NULL);
}
/******************************************************************************
* *
* BOOL cmdHalt(char *args, int subClass) *
* *
*******************************************************************************
*
* Powers computer off
*
******************************************************************************/
BOOL cmdHalt(char *args, int subClass)
{
// Use APM power off:
machine_power_off();
// If that fails, we hboot-it
machine_restart(NULL);
return( TRUE );
}
static void do_restart(struct work_struct *unused)
{
#if defined(CONFIG_POWER_KEY_CLR_RESET)
clear_hw_reset();
#endif
sys_sync();
KEY_LOGI("[PWR] Show Blocked State -- long press power key\n");
show_state_filter(TASK_UNINTERRUPTIBLE);
machine_restart("power-key-force-hard");
}
static void gcn_rsw_emergency_reset(void)
{
#ifdef CONFIG_KEXEC
struct kimage *image;
image = xchg(&kexec_image, 0);
if (image) {
machine_kexec(image);
}
#endif
machine_restart(NULL);
}
void eurwdt_interrupt(int irq, void *dev_id, struct pt_regs *regs)
{
printk(KERN_CRIT "timeout WDT timeout\n");
#ifdef ONLY_TESTING
printk(KERN_CRIT "Would Reboot.\n");
#else
printk(KERN_CRIT "Initiating system reboot.\n");
machine_restart(NULL);
#endif
}
static void omap_fidji_power_off(void)
{
if(board_rev < 8 && board_rev != 0) // board_rev != 0 if print_board_rev is not called
gpio_set_value(GPIO_RESET_PHY_0, 0);
else
gpio_set_value(GPIO_RESET_PHY_1, 0);
/* reboot if we are still alive after 1 s */
local_irq_disable();
mdelay(1000);
machine_restart(NULL);
}
void hwdom_shutdown(u8 reason)
{
switch ( reason )
{
case SHUTDOWN_poweroff:
printk("Hardware Dom%u halted: halting machine\n",
hardware_domain->domain_id);
machine_halt();
break; /* not reached */
case SHUTDOWN_crash:
debugger_trap_immediate();
printk("Hardware Dom%u crashed: ", hardware_domain->domain_id);
#ifdef CONFIG_KEXEC
kexec_crash();
#endif
maybe_reboot();
break; /* not reached */
case SHUTDOWN_reboot:
printk("Hardware Dom%u shutdown: rebooting machine\n",
hardware_domain->domain_id);
machine_restart(0);
break; /* not reached */
case SHUTDOWN_watchdog:
printk("Hardware Dom%u shutdown: watchdog rebooting machine\n",
hardware_domain->domain_id);
#ifdef CONFIG_KEXEC
kexec_crash();
#endif
machine_restart(0);
break; /* not reached */
default:
printk("Hardware Dom%u shutdown (unknown reason %u): ",
hardware_domain->domain_id, reason);
maybe_reboot();
break; /* not reached */
}
}
/**
* kernel_restart - reboot the system
* @cmd: pointer to buffer containing command to execute for restart
* or %NULL
*
* Shutdown everything and perform a clean reboot.
* This is not safe to call in interrupt context.
*/
void kernel_restart(char *cmd)
{
kernel_restart_prepare(cmd);
migrate_to_reboot_cpu();
syscore_shutdown();
if (!cmd)
pr_emerg("Restarting system\n");
else
pr_emerg("Restarting system with command '%s'\n", cmd);
kmsg_dump(KMSG_DUMP_RESTART);
machine_restart(cmd);
}
void
ppc4xx_wdt_heartbeat(void)
{
if (wdt_default ){
/* default used until wdt inits */
heartbeat_count(0) = wdt_period * HZ;
wdt_default = 0;
}
if (wdt_enable)
machine_restart("Watchdog Timer Timed out, system reset!");
heartbeat_reset(0) = 1;
}
/*
* Do not allocate memory (or fail in any way) in machine_kexec().
* We are past the point of no return, committed to rebooting now.
*/
NORET_TYPE void machine_kexec(struct kimage *image)
{
if (ppc_md.machine_kexec)
ppc_md.machine_kexec(image);
else {
/*
* Fall back to normal restart if platform doesn't provide
* its own kexec function, and user insist to kexec...
*/
machine_restart(NULL);
}
for(;;);
}
void domain_shutdown(struct domain *d, u8 reason)
{
struct vcpu *v;
if ( d->domain_id == 0 )
{
extern void machine_restart(char *);
extern void machine_halt(void);
debugger_trap_immediate();
if ( reason == SHUTDOWN_poweroff )
{
printk("Domain 0 halted: halting machine.\n");
machine_halt();
}
else if ( reason == SHUTDOWN_crash )
{
printk("Domain 0 crashed: rebooting machine in 5 seconds.\n");
watchdog_disable();
//mdelay(5000);
machine_restart(0);
}
else
{
printk("Domain 0 shutdown: rebooting machine.\n");
machine_restart(0);
}
}
/* Mark the domain as shutting down. */
d->shutdown_code = reason;
/* Put every vcpu to sleep, but don't wait (avoids inter-vcpu deadlock). */
for_each_vcpu ( d, v )
{
atomic_inc(&v->pausecnt);
vcpu_sleep_nosync(v);
}
static irqreturn_t ar5312_ahb_err_handler(int cpl, void *dev_id)
{
u32 proc1 = ar5312_rst_reg_read(AR5312_PROC1);
u32 proc_addr = ar5312_rst_reg_read(AR5312_PROCADDR); /* clears error */
u32 dma1 = ar5312_rst_reg_read(AR5312_DMA1);
u32 dma_addr = ar5312_rst_reg_read(AR5312_DMAADDR); /* clears error */
pr_emerg("AHB interrupt: PROCADDR=0x%8.8x PROC1=0x%8.8x DMAADDR=0x%8.8x DMA1=0x%8.8x\n",
proc_addr, proc1, dma_addr, dma1);
machine_restart("AHB error"); /* Catastrophic failure */
return IRQ_HANDLED;
}
void modem_power_on_do_work(struct work_struct *work)
{
reset_print_debug("\n");
if (1 == g_modem_reset_ctrl.in_suspend_state)
{
if (!wait_for_completion_timeout(&(g_modem_reset_ctrl.suspend_completion), HZ*10))
{
machine_restart("system halt");
return;
}
}
reset_prepare(MODEM_POWER_ON);
}
void modem_reset_do_work(struct work_struct *work)
{
reset_print_debug("\n");
g_modem_reset_ctrl.exec_time = bsp_get_slice_value();
if (1 == g_modem_reset_ctrl.in_suspend_state)
{
if (!wait_for_completion_timeout(&(g_modem_reset_ctrl.suspend_completion), HZ*10))
{
machine_restart("system halt"); /* 调systemError */
return;
}
}
reset_prepare(MODEM_RESET);
}
static void maybe_reboot(void)
{
if ( opt_noreboot )
{
printk("'noreboot' set - not rebooting.\n");
machine_halt();
}
else
{
printk("rebooting machine in 5 seconds.\n");
watchdog_disable();
machine_restart(5000);
}
}
static void mapphone_shutdown_timeout_handler(unsigned long data)
{
struct shutdown_timer_arg *arg = (struct shutdown_timer_arg *)data;
printk(KERN_ERR"mapphone shutdown/reboot timeout!\n");
if (!arg || SYS_RESTART != arg->event) {
printk(KERN_ERR"%s: Force to power down\n", __func__);
mapphone_pm_power_off();
} else {
printk(KERN_ERR"%s: Force to cold reset\n", __func__);
set_cold_reset(NULL, arg->event, (void *)arg->command);
machine_restart(arg->command);
}
}
