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); } }