void
cpu_reboot(int howto, char *bootstr)
{
static int waittime = -1;
/* Take a snapshot before clobbering any registers. */
if (curproc)
savectx((struct user *)curpcb);
if (cold) {
howto |= RB_HALT;
goto haltsys;
}
/* If "always halt" was specified as a boot flag, obey. */
if (boothowto & RB_HALT) {
howto |= RB_HALT;
}
#ifdef KLOADER_KERNEL_PATH
if ((howto & RB_HALT) == 0)
kloader_reboot_setup(KLOADER_KERNEL_PATH);
#endif
boothowto = howto;
if ((howto & RB_NOSYNC) == 0 && (waittime < 0)) {
waittime = 0;
vfs_shutdown();
/*
* If we've been adjusting the clock, the todr
* will be out of synch; adjust it now.
*/
resettodr();
}
splhigh();
if (howto & RB_DUMP)
dumpsys();
haltsys:
doshutdownhooks();
if ((howto & RB_POWERDOWN) == RB_POWERDOWN)
sifbios_halt(0); /* power down */
else if (howto & RB_HALT)
sifbios_halt(1); /* halt */
else {
#ifdef KLOADER_KERNEL_PATH
kloader_reboot();
/* NOTREACHED */
#endif
sifbios_halt(2); /* reset */
}
while (1)
;
/* NOTREACHED */
}
int
doadump(boolean_t textdump)
{
boolean_t coredump;
int error;
error = 0;
if (dumping)
return (EBUSY);
if (dumper.dumper == NULL)
return (ENXIO);
savectx(&dumppcb);
dumptid = curthread->td_tid;
dumping++;
coredump = TRUE;
#ifdef DDB
if (textdump && textdump_pending) {
coredump = FALSE;
textdump_dumpsys(&dumper);
}
#endif
if (coredump)
error = dumpsys(&dumper);
dumping--;
return (error);
}
void
cpu_reboot(int howto, char *bootstr)
{
#ifdef DIAGNOSTIC
/* info */
printf("boot: howto=%08x curproc=%p\n", howto, curproc);
#endif
/*
* If we are still cold then hit the air brakes
* and crash to earth fast
*/
if (cold) {
doshutdownhooks();
pmf_system_shutdown(boothowto);
printf("The operating system has halted.\n");
printf("Please press any key to reboot.\n\n");
cngetc();
printf("rebooting...\n");
cpu_reset();
/*NOTREACHED*/
}
/*
* If RB_NOSYNC was not specified sync the discs.
* Note: Unless cold is set to 1 here, syslogd will die during the
* unmount. It looks like syslogd is getting woken up only to find
* that it cannot page part of the binary in as the filesystem has
* been unmounted.
*/
if (!(howto & RB_NOSYNC))
bootsync();
/* Say NO to interrupts */
splhigh();
/* Do a dump if requested. */
if ((howto & (RB_DUMP | RB_HALT)) == RB_DUMP)
dumpsys();
/* Run any shutdown hooks */
doshutdownhooks();
pmf_system_shutdown(boothowto);
/* Make sure IRQ's are disabled */
IRQdisable;
if (howto & RB_HALT) {
printf("The operating system has halted.\n");
printf("Please press any key to reboot.\n\n");
cngetc();
}
printf("rebooting...\n");
cpu_reset();
/*NOTREACHED*/
}
void
boot(int howto)
{
if (cold) {
if ((howto & RB_USERREQ) == 0)
howto |= RB_HALT;
goto haltsys;
}
boothowto = howto;
if ((howto & RB_NOSYNC) == 0) {
vfs_shutdown();
/*
* If we've been adjusting the clock, the todr
* will be out of synch; adjust it now.
*/
if ((howto & RB_TIMEBAD) == 0)
resettodr();
else
printf("WARNING: not updating battery clock\n");
}
uvm_shutdown();
splhigh(); /* Disable interrupts. */
/* Do a dump if requested. */
if (howto & RB_DUMP)
dumpsys();
haltsys:
doshutdownhooks();
if ((howto & RB_POWERDOWN) == RB_POWERDOWN) {
_reg_write_1(LANDISK_PWRMNG, PWRMNG_POWEROFF);
delay(1 * 1000 * 1000);
printf("POWEROFF FAILED!\n");
howto |= RB_HALT;
}
if (howto & RB_HALT) {
printf("\n");
printf("The operating system has halted.\n");
printf("Please press any key to reboot.\n\n");
cnpollc(1);
cngetc();
cnpollc(0);
}
printf("rebooting...\n");
machine_reset();
/*NOTREACHED*/
for (;;) {
continue;
}
}
void
cpu_reboot(int howto, char *bootstr)
{
/* Take a snapshot before clobbering any registers. */
savectx(curpcb);
if (cold) {
howto |= RB_HALT;
goto haltsys;
}
/* If "always halt" was specified as a boot flag, obey. */
if (boothowto & RB_HALT)
howto |= RB_HALT;
boothowto = howto;
if ((howto & RB_NOSYNC) == 0 && (waittime < 0)) {
waittime = 0;
vfs_shutdown();
/*
* If we've been adjusting the clock, the todr
* will be out of synch; adjust it now.
*/
resettodr();
}
splhigh();
if (howto & RB_DUMP)
dumpsys();
haltsys:
doshutdownhooks();
pmf_system_shutdown(boothowto);
if (howto & RB_HALT) {
printf("\n");
printf("The operating system has halted.\n");
printf("Please press any key to reboot.\n\n");
cnpollc(1); /* For proper keyboard command handling */
cngetc();
cnpollc(0);
}
printf("rebooting...\n\n");
delay(500000);
*(volatile char *)MIPS_PHYS_TO_KSEG1(LED_ADDR) = LED_RESET;
printf("WARNING: reboot failed!\n");
for (;;)
;
}
__dead void
boot(int howto)
{
if (cold) {
if ((howto & RB_USERREQ) == 0)
howto |= RB_HALT;
goto haltsys;
}
/*
* If RB_NOSYNC was not specified sync the discs.
* Note: Unless cold is set to 1 here, syslogd will die during the
* unmount. It looks like syslogd is getting woken up only to find
* that it cannot page part of the binary in as the filesystem has
* been unmounted.
*/
if ((howto & RB_NOSYNC) == 0)
bootsync(howto);
if_downall();
uvm_shutdown();
splhigh();
cold = 1;
if ((howto & (RB_DUMP | RB_HALT)) == RB_DUMP)
dumpsys();
haltsys:
config_suspend_all(DVACT_POWERDOWN);
/* Make sure IRQ's are disabled */
IRQdisable;
if ((howto & RB_HALT) != 0) {
if ((howto & RB_POWERDOWN) != 0) {
board_powerdown();
printf("WARNING: powerdown failed!\n");
}
printf("The operating system has halted.\n");
printf("Please press any key to reboot.\n\n");
cnpollc(1);
cngetc();
cnpollc(0);
}
printf("rebooting...\n");
board_reset();
cpu_reset();
printf("reboot failed; spinning\n");
for (;;) ;
/* NOTREACHED */
}
/*
* void cpu_reboot(int howto, char *bootstr)
*
* Reboots the system
*
* Deal with any syncing, unmounting, dumping and shutdown hooks,
* then reset the CPU.
*/
void
cpu_reboot(int howto, char *bootstr)
{
/*
* If we are still cold then hit the air brakes
* and crash to earth fast
*/
if (cold) {
doshutdownhooks();
printf("The operating system has halted.\n");
printf("Please press any key to reboot.\n\n");
cngetc();
printf("rebooting...\n");
goto reset;
}
/* Disable console buffering */
/*
* If RB_NOSYNC was not specified sync the discs.
* Note: Unless cold is set to 1 here, syslogd will die during the
* unmount. It looks like syslogd is getting woken up only to find
* that it cannot page part of the binary in as the filesystem has
* been unmounted.
*/
if (!(howto & RB_NOSYNC))
bootsync();
/* Say NO to interrupts */
splhigh();
/* Do a dump if requested. */
if ((howto & (RB_DUMP | RB_HALT)) == RB_DUMP)
dumpsys();
/* Run any shutdown hooks */
doshutdownhooks();
/* Make sure IRQ's are disabled */
IRQdisable;
if (howto & RB_HALT) {
brh_7seg('8');
printf("The operating system has halted.\n");
printf("Please press any key to reboot.\n\n");
cngetc();
}
printf("rebooting...\n\r");
reset:
cpu_reset();
}
__dead void
boot(int howto)
{
if (curproc && curproc->p_addr)
savectx(curpcb);
if (cold) {
if ((howto & RB_USERREQ) == 0)
howto |= RB_HALT;
goto haltsys;
}
boothowto = howto;
if ((howto & RB_NOSYNC) == 0) {
vfs_shutdown();
if ((howto & RB_TIMEBAD) == 0) {
resettodr();
} else {
printf("WARNING: not updating battery clock\n");
}
}
if_downall();
uvm_shutdown();
splhigh();
cold = 1;
if ((howto & RB_DUMP) != 0)
dumpsys();
haltsys:
config_suspend_all(DVACT_POWERDOWN);
if ((howto & RB_HALT) != 0) {
printf("System halted.\n\n");
bootstack();
cmmu_shutdown();
scm_halt();
}
doboot();
for (;;) ;
/* NOTREACHED */
}
void
cpu_reboot(int howto, char *bootstr)
{
static int waittime = -1;
if (cold) {
howto |= RB_HALT;
goto haltsys;
}
boothowto = howto;
if ((howto & RB_NOSYNC) == 0 && waittime < 0) {
waittime = 0;
vfs_shutdown();
/*
* If we've been adjusting the clock, the todr
* will be out of synch; adjust it now.
*/
/* resettodr(); */
}
/* Disable interrupts. */
splhigh();
/* Do a dump if requested. */
if ((howto & (RB_DUMP | RB_HALT)) == RB_DUMP)
dumpsys();
haltsys:
doshutdownhooks();
if (howto & RB_HALT) {
printf("\n");
printf("The operating system has halted.\n");
printf("Please press any key to reboot.\n\n");
cngetc();
}
printf("rebooting...\n");
cpu_reset();
for(;;)
;
/*NOTREACHED*/
}
/*
* void cpu_reboot(int howto, char *bootstr)
*
* Reboots the system
*
* Deal with any syncing, unmounting, dumping and shutdown hooks,
* then reset the CPU.
*/
void
cpu_reboot(int howto, char *bootstr)
{
/*
* If we are still cold then hit the air brakes
* and crash to earth fast
*/
if (cold) {
doshutdownhooks();
pmf_system_shutdown(boothowto);
printf("\r\n");
printf("The operating system has halted.\r\n");
printf("Please press any key to reboot.\r\n");
cngetc();
printf("\r\nrebooting...\r\n");
goto reset;
}
/* Disable console buffering */
/*
* If RB_NOSYNC was not specified sync the discs.
* Note: Unless cold is set to 1 here, syslogd will die during the
* unmount. It looks like syslogd is getting woken up only to find
* that it cannot page part of the binary in as the filesystem has
* been unmounted.
*/
if (!(howto & RB_NOSYNC))
bootsync();
/* Say NO to interrupts */
splhigh();
/* Do a dump if requested. */
if ((howto & (RB_DUMP | RB_HALT)) == RB_DUMP)
dumpsys();
/* Run any shutdown hooks */
doshutdownhooks();
pmf_system_shutdown(boothowto);
/* Make sure IRQ's are disabled */
IRQdisable;
if (howto & RB_HALT) {
printf("\r\n");
printf("The operating system has halted.\r\n");
printf("Please press any key to reboot.\r\n");
cngetc();
}
printf("\r\nrebooting...\r\n");
reset:
/*
* Make really really sure that all interrupts are disabled,
* and poke the Internal Bus and Peripheral Bus reset lines.
*/
(void) disable_interrupts(I32_bit|F32_bit);
#if NEPWDOG > 0
epwdog_reset();
#else
{
uint32_t ctrl = EP93XX_APB_VBASE + EP93XX_APB_WDOG + EP93XX_WDOG_Ctrl;
uint32_t val = EP93XX_WDOG_ENABLE;
__asm volatile (
"str %1, [%0]\n"
:
: "r" (ctrl), "r" (val)
);
}
#endif
for (;;);
}
void
cpu_reboot(int howto, char *bootstr)
{
/* Take a snapshot before clobbering any registers. */
if (curlwp)
savectx((struct user *)curpcb);
if (cold) {
howto |= RB_HALT;
goto haltsys;
}
/* If "always halt" was specified as a boot flag, obey. */
if (boothowto & RB_HALT)
howto |= RB_HALT;
boothowto = howto;
if ((howto & RB_NOSYNC) == 0 && (waittime < 0)) {
waittime = 0;
vfs_shutdown();
/*
* If we've been adjusting the clock, the todr
* will be out of synch; adjust it now.
*/
resettodr();
}
splhigh();
if (howto & RB_DUMP)
dumpsys();
haltsys:
doshutdownhooks();
if (howto & RB_HALT) {
printf("\n");
printf("The operating system has halted.\n");
printf("Please press any key to reboot.\n\n");
cnpollc(1); /* For proper keyboard command handling */
cngetc();
cnpollc(0);
}
printf("rebooting...\n\n");
if (cfe_present) {
/*
* XXX
* For some reason we can't return to CFE with
* and do a warm start. Need to look into this...
*/
cfe_exit(0, (howto & RB_DUMP) ? 1 : 0);
printf("cfe_exit didn't!\n");
}
printf("WARNING: reboot failed!\n");
for (;;);
}
/*
* void cpu_reboot(int howto, char *bootstr)
*
* Reboots the system
*
* Deal with any syncing, unmounting, dumping and shutdown hooks,
* then reset the CPU.
*/
void
cpu_reboot(int howto, char *bootstr)
{
u_int32_t reg;
#ifdef DIAGNOSTIC
/* info */
printf("boot: howto=%08x curproc=%p\n", howto, curproc);
#endif
/*
* If we are still cold then hit the air brakes
* and crash to earth fast
*/
if (cold) {
doshutdownhooks();
printf("The operating system has halted.\n");
printf("Please press any key to reboot.\n\n");
cngetc();
printf("rebooting...\n");
goto reset;
}
/* Disable console buffering */
/*
* If RB_NOSYNC was not specified sync the discs.
* Note: Unless cold is set to 1 here, syslogd will die during the
* unmount. It looks like syslogd is getting woken up only to find
* that it cannot page part of the binary in as the filesystem has
* been unmounted.
*/
if (!(howto & RB_NOSYNC))
bootsync();
/* Say NO to interrupts */
splhigh();
/* Do a dump if requested. */
if ((howto & (RB_DUMP | RB_HALT)) == RB_DUMP)
dumpsys();
/* Run any shutdown hooks */
doshutdownhooks();
/* Make sure IRQ's are disabled */
IRQdisable;
if (howto & RB_HALT) {
printf("The operating system has halted.\n");
printf("Please press any key to reboot.\n\n");
cngetc();
}
printf("rebooting...\n\r");
reset:
/*
* Make really really sure that all interrupts are disabled,
*/
(void) disable_interrupts(I32_bit|F32_bit);
IXPREG(IXP425_INT_ENABLE) = 0;
/*
* Map the boot Flash device down at physical address 0.
* This is safe since NetBSD runs out of an alias of
* SDRAM at 0x10000000.
*/
reg = EXP_CSR_READ_4(ixpsip_softc, EXP_CNFG0_OFFSET);
reg |= EXP_CNFG0_MEM_MAP;
EXP_CSR_WRITE_4(ixpsip_softc, EXP_CNFG0_OFFSET, reg);
/*
* Jump into the bootcode's reset vector
*
* XXX:
* Redboot doesn't like the state in which we leave the PCI
* ethernet card, and so fails to detect it on reboot. This
* pretty much necessitates a hard reset/power cycle to be
* able to download a new kernel image over ethernet.
*
* I suspect this is due to a bug in Redboot's i82557 driver.
*/
cpu_reset();
/* ...and if that didn't work, just croak. */
printf("RESET FAILED!\n");
for (;;);
}
void
cpu_reboot(volatile int howto, char *bootstr)
{
/* take a snap shot before clobbering any registers */
savectx(curpcb);
#ifdef DEBUG
if (panicstr)
stacktrace();
#endif
/* If system is cold, just halt. */
if (cold) {
howto |= RB_HALT;
goto haltsys;
}
/* If "always halt" was specified as a boot flag, obey. */
if ((boothowto & RB_HALT) != 0)
howto |= RB_HALT;
boothowto = howto;
if ((howto & RB_NOSYNC) == 0 && waittime < 0) {
/*
* Synchronize the disks....
*/
waittime = 0;
vfs_shutdown();
/*
* If we've been adjusting the clock, the todr
* will be out of synch; adjust it now.
*/
resettodr();
}
/* Disable interrupts. */
disable_intr();
splhigh();
/* If rebooting and a dump is requested do it. */
#if 0
if ((howto & (RB_DUMP | RB_HALT)) == RB_DUMP)
#else
if (howto & RB_DUMP)
#endif
dumpsys();
haltsys:
/* run any shutdown hooks */
doshutdownhooks();
pmf_system_shutdown(boothowto);
if ((howto & RB_POWERDOWN) == RB_POWERDOWN)
prom_halt(0x80); /* rom monitor RB_PWOFF */
/* Finally, halt/reboot the system. */
printf("%s\n\n", howto & RB_HALT ? "halted." : "rebooting...");
prom_halt(howto & RB_HALT);
/*NOTREACHED*/
}
/*
* void cpu_reboot(int howto, char *bootstr)
*
* Reboots the system
*
* Deal with any syncing, unmounting, dumping and shutdown hooks,
* then reset the CPU.
*/
void
cpu_reboot(int howto, char *bootstr)
{
/*
* If we are still cold then hit the air brakes
* and crash to earth fast
*/
if (cold) {
*(volatile uint8_t *)HDLG_LEDCTRL |= LEDCTRL_STAT_RED;
howto |= RB_HALT;
goto haltsys;
}
/* Disable console buffering */
/*
* If RB_NOSYNC was not specified sync the discs.
* Note: Unless cold is set to 1 here, syslogd will die during the
* unmount. It looks like syslogd is getting woken up only to find
* that it cannot page part of the binary in as the filesystem has
* been unmounted.
*/
if ((howto & RB_NOSYNC) == 0) {
bootsync();
/*resettodr();*/
}
/* wait 1s */
delay(1 * 1000 * 1000);
/* Say NO to interrupts */
splhigh();
/* Do a dump if requested. */
if ((howto & (RB_DUMP | RB_HALT)) == RB_DUMP) {
dumpsys();
}
haltsys:
/* Run any shutdown hooks */
doshutdownhooks();
/* Make sure IRQ's are disabled */
IRQdisable;
if (howto & RB_HALT) {
*(volatile uint8_t *)HDLG_PWRMNG = PWRMNG_POWOFF;
delay(3 * 1000 * 1000); /* wait 3s */
printf("SHUTDOWN FAILED!\n");
printf("The operating system has halted.\n");
printf("Please press any key to reboot.\n\n");
cngetc();
}
printf("rebooting...\n\r");
(void)disable_interrupts(I32_bit|F32_bit);
cpu_idcache_wbinv_all();
cpu_drain_writebuf();
*(volatile uint8_t *)HDLG_PWRMNG = PWRMNG_RESET;
delay(1 * 1000 * 1000); /* wait 1s */
/* ...and if that didn't work, just croak. */
printf("RESET FAILED!\n");
for (;;) {
continue;
}
}
/*ARGSUSED*/
int
dump_ioctl(dev_t dev, int cmd, intptr_t arg, int mode, cred_t *cred, int *rvalp)
{
uint64_t size;
uint64_t dumpsize_in_pages;
int error = 0;
char *pathbuf = kmem_zalloc(MAXPATHLEN, KM_SLEEP);
char uuidbuf[36 + 1];
size_t len;
vnode_t *vp;
switch (cmd) {
case DIOCGETDUMPSIZE:
if (dump_conflags & DUMP_ALL)
size = ptob((uint64_t)physmem) / DUMP_COMPRESS_RATIO;
else {
/*
* We can't give a good answer for the DUMP_CURPROC
* because we won't know which process to use until it
* causes a panic. We'll therefore punt and give the
* caller the size for the kernel.
*
* This kernel size equation takes care of the
* boot time kernel footprint and also accounts
* for availrmem changes due to user explicit locking.
* Refer to common/vm/vm_page.c for an explanation
* of these counters.
*/
dumpsize_in_pages = (physinstalled - obp_pages -
availrmem -
anon_segkp_pages_locked -
k_anoninfo.ani_mem_resv -
pages_locked -
pages_claimed -
pages_useclaim);
/*
* Protect against vm vagaries.
*/
if (dumpsize_in_pages > (uint64_t)physmem)
dumpsize_in_pages = (uint64_t)physmem;
size = ptob(dumpsize_in_pages) / DUMP_COMPRESS_RATIO;
}
if (copyout(&size, (void *)arg, sizeof (size)) < 0)
error = EFAULT;
break;
case DIOCGETCONF:
mutex_enter(&dump_lock);
*rvalp = dump_conflags;
if (dumpvp && !(dumpvp->v_flag & VISSWAP))
*rvalp |= DUMP_EXCL;
mutex_exit(&dump_lock);
break;
case DIOCSETCONF:
mutex_enter(&dump_lock);
if (arg == DUMP_KERNEL || arg == DUMP_ALL ||
arg == DUMP_CURPROC)
dump_conflags = arg;
else
error = EINVAL;
mutex_exit(&dump_lock);
break;
case DIOCGETDEV:
mutex_enter(&dump_lock);
if (dumppath == NULL) {
mutex_exit(&dump_lock);
error = ENODEV;
break;
}
(void) strcpy(pathbuf, dumppath);
mutex_exit(&dump_lock);
error = copyoutstr(pathbuf, (void *)arg, MAXPATHLEN, NULL);
break;
case DIOCSETDEV:
case DIOCTRYDEV:
if ((error = copyinstr((char *)arg, pathbuf, MAXPATHLEN,
NULL)) != 0 || (error = lookupname(pathbuf, UIO_SYSSPACE,
FOLLOW, NULLVPP, &vp)) != 0)
break;
mutex_enter(&dump_lock);
if (vp->v_type == VBLK)
error = dumpinit(vp, pathbuf, cmd == DIOCTRYDEV);
else
error = ENOTBLK;
mutex_exit(&dump_lock);
VN_RELE(vp);
break;
case DIOCDUMP:
mutex_enter(&dump_lock);
if (dumpvp == NULL)
error = ENODEV;
else if (dumpvp->v_flag & VISSWAP)
error = EBUSY;
else
dumpsys();
mutex_exit(&dump_lock);
break;
case DIOCSETUUID:
if ((error = copyinstr((char *)arg, uuidbuf, sizeof (uuidbuf),
&len)) != 0)
break;
if (len != 37) {
error = EINVAL;
break;
}
error = dump_set_uuid(uuidbuf);
break;
case DIOCGETUUID:
error = copyoutstr(dump_get_uuid(), (void *)arg, 37, NULL);
break;
default:
error = ENXIO;
}
kmem_free(pathbuf, MAXPATHLEN);
return (error);
}
int
cpu_sysctl(int *name, u_int namelen, void *oldp, size_t *oldlenp,
void *newp, size_t newlen, struct proc *p)
{
/* all sysctl names at this level are terminal */
if (namelen != 1)
return (ENOTDIR); /* overloaded */
switch (name[0]) {
case CPU_CONSDEV:
return (sysctl_rdstruct(oldp, oldlenp, newp, &cn_tab->cn_dev,
sizeof cn_tab->cn_dev));
default:
}
return (EOPNOTSUPP);
}
void
cpu_reboot(int howto, char *bootstr)
{
/* take a snap shot before clobbering any registers */
if (curproc)
savectx(curpcb);
/* If system is cold, just halt. */
if (cold) {
howto |= RB_HALT;
goto haltsys;
}
/* If "always halt" was specified as a boot flag, obey. */
if ((boothowto & RB_HALT) != 0) {
howto |= RB_HALT;
}
#ifdef KLOADER_KERNEL_PATH
if ((howto & RB_HALT) == 0)
kloader_reboot_setup(KLOADER_KERNEL_PATH);
#endif
boothowto = howto;
if ((howto & RB_NOSYNC) == 0) {
/*
* Synchronize the disks....
*/
vfs_shutdown();
/*
* If we've been adjusting the clock, the todr
* will be out of synch; adjust it now.
*/
resettodr();
}
/* Disable interrupts. */
splhigh();
/* If rebooting and a dump is requested do it. */
#if notyet
if (howto & RB_DUMP)
dumpsys();
#endif
haltsys:
/* run any shutdown hooks */
doshutdownhooks();
/* Finally, halt/reboot the system. */
if (howto & RB_HALT) {
printf("halted.\n");
} else {
#ifdef KLOADER_KERNEL_PATH
kloader_reboot();
/* NOTREACHED */
#endif
}
#if NHD64465IF > 0
hd64465_shutdown();
#endif
cpu_reset();
/*NOTREACHED*/
while(1)
;
}
/* return # of physical pages. */
int
mem_cluster_init(paddr_t addr)
{
phys_ram_seg_t *seg;
int npages, i;
/* cluster 0 is always kernel myself. */
mem_clusters[0].start = SH_CS3_START;
mem_clusters[0].size = addr - SH_CS3_START;
mem_cluster_cnt = 1;
/* search CS3 */
#ifdef SH3
/* SH7709A's CS3 is splited to 2 banks. */
if (CPU_IS_SH3) {
__find_dram_shadow(addr, SH7709_CS3_BANK0_END);
__find_dram_shadow(SH7709_CS3_BANK1_START,
SH7709_CS3_BANK1_END);
}
#endif
#ifdef SH4
/* contig CS3 */
if (CPU_IS_SH4) {
__find_dram_shadow(addr, SH_CS3_END);
}
#endif
_DPRINTF("mem_cluster_cnt = %d\n", mem_cluster_cnt);
npages = 0;
for (i = 0, seg = mem_clusters; i < mem_cluster_cnt; i++, seg++) {
_DPRINTF("mem_clusters[%d] = {0x%lx+0x%lx <0x%lx}", i,
(paddr_t)seg->start, (paddr_t)seg->size,
(paddr_t)seg->start + (paddr_t)seg->size);
npages += sh3_btop(seg->size);
#ifdef NARLY_MEMORY_PROBE
if (i == 0) {
_DPRINTF(" don't check.\n");
continue;
}
if (__check_dram((paddr_t)seg->start, (paddr_t)seg->start +
(paddr_t)seg->size) != 0)
panic("D-RAM check failed.");
#else
_DPRINTF("\n");
#endif /* NARLY_MEMORY_PROBE */
}
return (npages);
}
void
boot(int howto)
{
struct device *mainbus;
if (cold) {
/*
* If the system is cold, just halt, unless the user
* explicitely asked for reboot.
*/
if ((howto & RB_USERREQ) == 0)
howto |= RB_HALT;
goto haltsys;
}
/*
* If RB_NOSYNC was not specified sync the discs.
* Note: Unless cold is set to 1 here, syslogd will die during the
* unmount. It looks like syslogd is getting woken up only to find
* that it cannot page part of the binary in as the filesystem has
* been unmounted.
*/
if (!(howto & RB_NOSYNC))
bootsync(howto);
if_downall();
uvm_shutdown();
/* Say NO to interrupts */
splhigh();
/* Do a dump if requested. */
if ((howto & (RB_DUMP | RB_HALT)) == RB_DUMP)
dumpsys();
haltsys:
doshutdownhooks();
mainbus = device_mainbus();
if (mainbus != NULL)
config_suspend(mainbus, DVACT_POWERDOWN);
/* Make sure IRQ's are disabled */
IRQdisable;
if (howto & RB_HALT) {
if (howto & RB_POWERDOWN) {
board_powerdown();
printf("WARNING: powerdown failed!\n");
}
printf("The operating system has halted.\n");
printf("Please press any key to reboot.\n\n");
cnpollc(1);
cngetc();
cnpollc(0);
}
printf("rebooting...\n");
board_reset();
cpu_reset();
printf("reboot failed; spinning\n");
while(1);
/*NOTREACHED*/
}
void
cpu_reboot(int howto, char *bootstr)
{
static int waittime = -1;
/* Take a snapshot before clobbering any registers. */
savectx(curpcb);
/* If "always halt" was specified as a boot flag, obey. */
if (boothowto & RB_HALT)
howto |= RB_HALT;
boothowto = howto;
/* If system is cold, just halt. */
if (cold) {
boothowto |= RB_HALT;
goto haltsys;
}
if ((boothowto & RB_NOSYNC) == 0 && waittime < 0) {
waittime = 0;
/*
* Synchronize the disks....
*/
vfs_shutdown();
/*
* If we've been adjusting the clock, the todr
* will be out of synch; adjust it now.
*/
resettodr();
}
/* Disable interrupts. */
splhigh();
if (boothowto & RB_DUMP)
dumpsys();
haltsys:
/* Run any shutdown hooks. */
doshutdownhooks();
pmf_system_shutdown(boothowto);
#if 0
if ((boothowto & RB_POWERDOWN) == RB_POWERDOWN)
if (board && board->ab_poweroff)
board->ab_poweroff();
#endif
/*
* Firmware may autoboot (depending on settings), and we cannot pass
* flags to it (at least I haven't figured out how to yet), so
* we "pseudo-halt" now.
*/
if (boothowto & RB_HALT) {
printf("\n");
printf("The operating system has halted.\n");
printf("Please press any key to reboot.\n\n");
cnpollc(1); /* For proper keyboard command handling */
cngetc();
cnpollc(0);
}
printf("reseting board...\n\n");
mips_icache_sync_all();
mips_dcache_wbinv_all();
atheros_reset();
__asm volatile("jr %0" :: "r"(MIPS_RESET_EXC_VEC));
printf("Oops, back from reset\n\nSpinning...");
for (;;)
/* spin forever */ ; /* XXX */
/*NOTREACHED*/
}
/*
* void cpu_reboot(int howto, char *bootstr)
*
* Reboots the system
*
* Deal with any syncing, unmounting, dumping and shutdown hooks,
* then reset the CPU.
*/
void
cpu_reboot(int howto, char *bootstr)
{
/*
* If we are still cold then hit the air brakes
* and crash to earth fast
*/
if (cold) {
doshutdownhooks();
printf("\r\n");
printf("The operating system has halted.\r\n");
printf("Please press any key to reboot.\r\n");
cngetc();
printf("\r\nrebooting...\r\n");
goto reset;
}
/* Disable console buffering */
/*
* If RB_NOSYNC was not specified sync the discs.
* Note: Unless cold is set to 1 here, syslogd will die during the
* unmount. It looks like syslogd is getting woken up only to find
* that it cannot page part of the binary in as the filesystem has
* been unmounted.
*/
if (!(howto & RB_NOSYNC))
bootsync();
/* Say NO to interrupts */
splhigh();
/* Do a dump if requested. */
if ((howto & (RB_DUMP | RB_HALT)) == RB_DUMP)
dumpsys();
/* Run any shutdown hooks */
doshutdownhooks();
/* Make sure IRQ's are disabled */
IRQdisable;
if (howto & RB_HALT) {
printf("\r\n");
printf("The operating system has halted.\r\n");
printf("Please press any key to reboot.\r\n");
cngetc();
}
printf("\r\nrebooting...\r\n");
reset:
/*
* Make really really sure that all interrupts are disabled,
* and poke the Internal Bus and Peripheral Bus reset lines.
*/
(void) disable_interrupts(I32_bit|F32_bit);
{
u_int32_t feed, ctrl;
feed = TS7XXX_IO16_VBASE + TS7XXX_WDOGFEED;
ctrl = TS7XXX_IO16_VBASE + TS7XXX_WDOGCTRL;
__asm volatile (
"mov r0, #0x5\n"
"mov r1, #0x1\n"
"strh r0, [%0]\n"
"strh r1, [%1]\n"
:
: "r" (feed), "r" (ctrl)
: "r0", "r1"
);
}
for (;;);
}
/*
* void cpu_reboot(int howto, char *bootstr)
*
* Reboots the system
*
* Deal with any syncing, unmounting, dumping and shutdown hooks,
* then reset the CPU.
*/
void
cpu_reboot(int howto, char *bootstr)
{
/*
* If we are still cold then hit the air brakes
* and crash to earth fast
*/
if (cold) {
doshutdownhooks();
printf("The operating system has halted.\n");
printf("Please press any key to reboot.\n\n");
cngetc();
printf("rebooting...\n");
goto reset;
}
/* Disable console buffering */
/*
* If RB_NOSYNC was not specified sync the discs.
* Note: Unless cold is set to 1 here, syslogd will die during the
* unmount. It looks like syslogd is getting woken up only to find
* that it cannot page part of the binary in as the filesystem has
* been unmounted.
*/
if (!(howto & RB_NOSYNC))
bootsync();
/* Say NO to interrupts */
splhigh();
/* Do a dump if requested. */
if ((howto & (RB_DUMP | RB_HALT)) == RB_DUMP)
dumpsys();
/* Run any shutdown hooks */
doshutdownhooks();
/* Make sure IRQ's are disabled */
IRQdisable;
if (howto & RB_HALT) {
iq80321_7seg('.', '.');
printf("The operating system has halted.\n");
printf("Please press any key to reboot.\n\n");
cngetc();
}
printf("rebooting...\n\r");
reset:
/*
* Make really really sure that all interrupts are disabled,
* and poke the Internal Bus and Peripheral Bus reset lines.
*/
(void) disable_interrupts(I32_bit|F32_bit);
*(volatile uint32_t *)(IQ80321_80321_VBASE + VERDE_ATU_BASE +
ATU_PCSR) = PCSR_RIB | PCSR_RPB;
/* ...and if that didn't work, just croak. */
printf("RESET FAILED!\n");
for (;;);
}
void
cpu_reboot(int howto, char *bootstr)
{
/*
* If we are still cold then hit the air brakes
* and crash to earth fast
*/
if (cold) {
doshutdownhooks();
pmf_system_shutdown(boothowto);
printf("Halted while still in the ICE age.\n");
printf("The operating system has halted.\n");
printf("Please press any key to reboot.\n\n");
cngetc();
printf("rebooting...\n");
ixp12x0_reset();
}
/* Disable console buffering */
cnpollc(1);
/*
* If RB_NOSYNC was not specified sync the discs.
* Note: Unless cold is set to 1 here, syslogd will die during the unmount.
* It looks like syslogd is getting woken up only to find that it cannot
* page part of the binary in as the filesystem has been unmounted.
*/
if (!(howto & RB_NOSYNC))
bootsync();
/* Say NO to interrupts */
splhigh();
/* Do a dump if requested. */
if ((howto & (RB_DUMP | RB_HALT)) == RB_DUMP)
dumpsys();
/* Run any shutdown hooks */
doshutdownhooks();
pmf_system_shutdown(boothowto);
/* Make sure IRQ's are disabled */
IRQdisable;
if (howto & RB_HALT) {
printf("The operating system has halted.\n");
printf("Please press any key to reboot.\n\n");
cngetc();
}
printf("rebooting...\n");
/* all interrupts are disabled */
disable_interrupts(I32_bit);
ixp12x0_reset();
/* ...and if that didn't work, just croak. */
printf("RESET FAILED!\n");
for (;;);
}
void
panicsys(const char *format, va_list alist, struct regs *rp, int on_panic_stack)
{
int s = spl8();
kthread_t *t = curthread;
cpu_t *cp = CPU;
caddr_t intr_stack = NULL;
uint_t intr_actv;
ushort_t schedflag = t->t_schedflag;
cpu_t *bound_cpu = t->t_bound_cpu;
char preempt = t->t_preempt;
(void) setjmp(&t->t_pcb);
t->t_flag |= T_PANIC;
t->t_schedflag |= TS_DONT_SWAP;
t->t_bound_cpu = cp;
t->t_preempt++;
/*
* Switch lbolt to event driven mode.
*/
lbolt_hybrid = lbolt_event_driven;
panic_enter_hw(s);
/*
* If we're on the interrupt stack and an interrupt thread is available
* in this CPU's pool, preserve the interrupt stack by detaching an
* interrupt thread and making its stack the intr_stack.
*/
if (CPU_ON_INTR(cp) && cp->cpu_intr_thread != NULL) {
kthread_t *it = cp->cpu_intr_thread;
intr_stack = cp->cpu_intr_stack;
intr_actv = cp->cpu_intr_actv;
cp->cpu_intr_stack = thread_stk_init(it->t_stk);
cp->cpu_intr_thread = it->t_link;
/*
* Clear only the high level bits of cpu_intr_actv.
* We want to indicate that high-level interrupts are
* not active without destroying the low-level interrupt
* information stored there.
*/
cp->cpu_intr_actv &= ((1 << (LOCK_LEVEL + 1)) - 1);
}
/*
* Record one-time panic information and quiesce the other CPUs.
* Then print out the panic message and stack trace.
*/
if (on_panic_stack) {
panic_data_t *pdp = (panic_data_t *)panicbuf;
pdp->pd_version = PANICBUFVERS;
pdp->pd_msgoff = sizeof (panic_data_t) - sizeof (panic_nv_t);
if (t->t_panic_trap != NULL)
panic_savetrap(pdp, t->t_panic_trap);
else
panic_saveregs(pdp, rp);
(void) vsnprintf(&panicbuf[pdp->pd_msgoff],
PANICBUFSIZE - pdp->pd_msgoff, format, alist);
/*
* Call into the platform code to stop the other CPUs.
* We currently have all interrupts blocked, and expect that
* the platform code will lower ipl only as far as needed to
* perform cross-calls, and will acquire as *few* locks as is
* possible -- panicstr is not set so we can still deadlock.
*/
panic_stopcpus(cp, t, s);
panicstr = (char *)format;
va_copy(panicargs, alist);
panic_lbolt = LBOLT_NO_ACCOUNT;
panic_lbolt64 = LBOLT_NO_ACCOUNT64;
panic_hrestime = hrestime;
panic_hrtime = gethrtime_waitfree();
panic_thread = t;
panic_regs = t->t_pcb;
panic_reg = rp;
panic_cpu = *cp;
panic_ipl = spltoipl(s);
panic_schedflag = schedflag;
panic_bound_cpu = bound_cpu;
panic_preempt = preempt;
if (intr_stack != NULL) {
panic_cpu.cpu_intr_stack = intr_stack;
panic_cpu.cpu_intr_actv = intr_actv;
}
/*
* Lower ipl to 10 to keep clock() from running, but allow
* keyboard interrupts to enter the debugger. These callbacks
* are executed with panicstr set so they can bypass locks.
*/
splx(ipltospl(CLOCK_LEVEL));
panic_quiesce_hw(pdp);
(void) FTRACE_STOP();
(void) callb_execute_class(CB_CL_PANIC, NULL);
if (log_intrq != NULL)
log_flushq(log_intrq);
/*
* If log_consq has been initialized and syslogd has started,
* print any messages in log_consq that haven't been consumed.
*/
if (log_consq != NULL && log_consq != log_backlogq)
log_printq(log_consq);
fm_banner();
#if defined(__x86)
/*
* A hypervisor panic originates outside of Solaris, so we
* don't want to prepend the panic message with misleading
* pointers from within Solaris.
*/
if (!IN_XPV_PANIC())
#endif
printf("\n\rpanic[cpu%d]/thread=%p: ", cp->cpu_id,
(void *)t);
vprintf(format, alist);
printf("\n\n");
if (t->t_panic_trap != NULL) {
panic_showtrap(t->t_panic_trap);
printf("\n");
}
traceregs(rp);
printf("\n");
if (((boothowto & RB_DEBUG) || obpdebug) &&
!nopanicdebug && !panic_forced) {
if (dumpvp != NULL) {
debug_enter("panic: entering debugger "
"(continue to save dump)");
} else {
debug_enter("panic: entering debugger "
"(no dump device, continue to reboot)");
}
}
} else if (panic_dump != 0 || panic_sync != 0 || panicstr != NULL) {
printf("\n\rpanic[cpu%d]/thread=%p: ", cp->cpu_id, (void *)t);
vprintf(format, alist);
printf("\n");
} else
goto spin;
/*
* Prior to performing sync or dump, we make sure that do_polled_io is
* set, but we'll leave ipl at 10; deadman(), a CY_HIGH_LEVEL cyclic,
* will re-enter panic if we are not making progress with sync or dump.
*/
/*
* Sync the filesystems. Reset t_cred if not set because much of
* the filesystem code depends on CRED() being valid.
*/
if (!in_sync && panic_trigger(&panic_sync)) {
if (t->t_cred == NULL)
t->t_cred = kcred;
splx(ipltospl(CLOCK_LEVEL));
do_polled_io = 1;
vfs_syncall();
}
/*
* Take the crash dump. If the dump trigger is already set, try to
* enter the debugger again before rebooting the system.
*/
if (panic_trigger(&panic_dump)) {
panic_dump_hw(s);
splx(ipltospl(CLOCK_LEVEL));
errorq_panic();
do_polled_io = 1;
dumpsys();
} else if (((boothowto & RB_DEBUG) || obpdebug) && !nopanicdebug) {
debug_enter("panic: entering debugger (continue to reboot)");
} else
printf("dump aborted: please record the above information!\n");
if (halt_on_panic)
mdboot(A_REBOOT, AD_HALT, NULL, B_FALSE);
else
mdboot(A_REBOOT, panic_bootfcn, panic_bootstr, B_FALSE);
spin:
/*
* Restore ipl to at most CLOCK_LEVEL so we don't end up spinning
* and unable to jump into the debugger.
*/
splx(MIN(s, ipltospl(CLOCK_LEVEL)));
for (;;)
;
}
/*
* void cpu_reboot(int howto, char *bootstr)
*
* Reboots the system
*
* Deal with any syncing, unmounting, dumping and shutdown hooks,
* then reset the CPU.
*/
void
cpu_reboot(int howto, char *bootstr)
{
#ifdef DIAGNOSTIC
/* info */
printf("boot: howto=%08x curproc=%p\n", howto, curproc);
#endif
/*
* If we are still cold then hit the air brakes
* and crash to earth fast
*/
if (cold) {
doshutdownhooks();
pmf_system_shutdown(boothowto);
printf("The operating system has halted.\n");
printf("Please press any key to reboot.\n\n");
cngetc();
goto reset;
}
/* Disable console buffering */
/*
* If RB_NOSYNC was not specified sync the discs.
* Note: Unless cold is set to 1 here, syslogd will die during the
* unmount. It looks like syslogd is getting woken up only to find
* that it cannot page part of the binary in as the filesystem has
* been unmounted.
*/
if (!(howto & RB_NOSYNC))
bootsync();
/* Say NO to interrupts */
splhigh();
/* Do a dump if requested. */
if ((howto & (RB_DUMP | RB_HALT)) == RB_DUMP)
dumpsys();
/* Run any shutdown hooks */
doshutdownhooks();
pmf_system_shutdown(boothowto);
/* Make sure IRQ's are disabled */
IRQdisable;
if ((howto & (RB_HALT | RB_POWERDOWN)) == RB_HALT) {
printf("The operating system has halted.\n");
printf("Please press any key to reboot.\n\n");
cngetc();
}
reset:
/*
* Make really really sure that all interrupts are disabled,
*/
(void) disable_interrupts(I32_bit | F32_bit);
if (howto & RB_POWERDOWN) {
uint32_t reg;
printf("powering down...\n\r");
/* Delay to allow the UART's Tx FIFO to drain */
delay(50000);
#define GPRD(r) *((volatile uint32_t *)(IXP425_GPIO_VBASE+(r)))
#define GPWR(r,v) *((volatile uint32_t *)(IXP425_GPIO_VBASE+(r))) = (v)
/*
* Power-down pin requires a short pulse
*/
reg = GPRD(IXP425_GPIO_GPOUTR);
reg |= 1u << GPIO_POWER_OFF;
GPWR(IXP425_GPIO_GPOUTR, reg);
delay(1000);
reg = GPRD(IXP425_GPIO_GPOUTR);
reg &= ~(1u << GPIO_POWER_OFF);
GPWR(IXP425_GPIO_GPOUTR, reg);
delay(500000);
printf("POWER OFF FAILED! TRYING TO REBOOT INSTEAD\n\r");
}
printf("rebooting...\n\r");
#define WDWR(r,v) *((volatile uint32_t *)(IXP425_OST_WDOG_VBASE+(r))) = (v)
/* Force a watchdog reset */
WDWR(IXP425_OST_WDOG_KEY, OST_WDOG_KEY_MAJICK);
WDWR(IXP425_OST_WDOG_ENAB, OST_WDOG_ENAB_RST_ENA);
WDWR(IXP425_OST_WDOG, 0x1000);
WDWR(IXP425_OST_WDOG_ENAB,
OST_WDOG_ENAB_RST_ENA | OST_WDOG_ENAB_CNT_ENA);
delay(500000);
/* ...and if that didn't work, just croak. */
printf("RESET FAILED!\n");
for (;;);
}
/*
* Halt or reboot the machine after syncing/dumping according to howto.
*/
void
cpu_reboot(int howto, char *what)
{
static int syncing;
static char str[256];
char *ap = str, *ap1 = ap;
boothowto = howto;
if (!cold && !(howto & RB_NOSYNC) && !syncing) {
syncing = 1;
vfs_shutdown(); /* sync */
resettodr(); /* set wall clock */
}
splhigh();
if (!cold && (howto & RB_DUMP))
dumpsys();
doshutdownhooks();
pmf_system_shutdown(boothowto);
if ((howto & RB_POWERDOWN) == RB_POWERDOWN) {
/* Power off here if we know how...*/
}
if (howto & RB_HALT) {
printf("halted\n\n");
goto reboot; /* XXX for now... */
#ifdef DDB
printf("dropping to debugger\n");
while(1)
Debugger();
#endif
#ifdef KGDB
printf("dropping to kgdb\n");
while(1)
kgdb_connect(1);
#endif
}
printf("rebooting\n\n");
if (what && *what) {
if (strlen(what) > sizeof str - 5)
printf("boot string too large, ignored\n");
else {
strcpy(str, what);
ap1 = ap = str + strlen(str);
*ap++ = ' ';
}
}
*ap++ = '-';
if (howto & RB_SINGLE)
*ap++ = 's';
if (howto & RB_KDB)
*ap++ = 'd';
*ap++ = 0;
if (ap[-2] == '-')
*ap1 = 0;
/* flush cache for msgbuf */
__syncicache((void *)msgbuf_paddr, round_page(MSGBUFSIZE));
reboot:
ppc4xx_reset();
printf("ppc4xx_reset() failed!\n");
#ifdef DDB
while(1)
Debugger();
#endif
#ifdef KGDB
while(1)
kgdb_connect(1);
#else
while (1)
/* nothing */;
#endif
}
void
boot(int howto)
{
if (cold) {
/*
* If the system is cold, just halt, unless the user
* explicitly asked for reboot.
*/
if ((howto & RB_USERREQ) == 0)
howto |= RB_HALT;
goto haltsys;
}
boothowto = howto;
if ((howto & RB_NOSYNC) == 0 && waittime < 0) {
waittime = 0;
if (curproc == NULL)
curproc = &proc0; /* XXX */
vfs_shutdown();
/*
* If we've been adjusting the clock, the todr
* will be out of synch; adjust it now.
*/
if ((howto & RB_TIMEBAD) == 0) {
resettodr();
} else {
printf("WARNING: not updating battery clock\n");
}
}
/* Disable interrupts. */
splhigh();
/* Do a dump if requested. */
if (howto & RB_DUMP)
dumpsys();
haltsys:
doshutdownhooks();
#ifdef MULTIPROCESSOR
x86_broadcast_ipi(X86_IPI_HALT);
#endif
if (howto & RB_HALT) {
#if NACPI > 0 && !defined(SMALL_KERNEL)
extern int acpi_s5, acpi_enabled;
if (acpi_enabled) {
delay(500000);
if (howto & RB_POWERDOWN || acpi_s5)
acpi_powerdown();
}
#endif
printf("\n");
printf("The operating system has halted.\n");
printf("Please press any key to reboot.\n\n");
cnpollc(1); /* for proper keyboard command handling */
cngetc();
cnpollc(0);
}
printf("rebooting...\n");
if (cpureset_delay > 0)
delay(cpureset_delay * 1000);
cpu_reset();
for(;;) ;
/*NOTREACHED*/
}
void
cpu_reboot(int howto, char *bootstr)
{
static int waittime = -1;
const struct alchemy_board *board;
/* Take a snapshot before clobbering any registers. */
if (curproc)
savectx((struct user *)curpcb);
board = board_info();
KASSERT(board != NULL);
/* If "always halt" was specified as a boot flag, obey. */
if (boothowto & RB_HALT)
howto |= RB_HALT;
boothowto = howto;
/* If system is cold, just halt. */
if (cold) {
boothowto |= RB_HALT;
goto haltsys;
}
if ((boothowto & RB_NOSYNC) == 0 && waittime < 0) {
waittime = 0;
/*
* Synchronize the disks....
*/
vfs_shutdown();
/*
* If we've been adjusting the clock, the todr
* will be out of synch; adjust it now.
*/
resettodr();
}
/* Disable interrupts. */
splhigh();
if (boothowto & RB_DUMP)
dumpsys();
haltsys:
/* Run any shutdown hooks. */
doshutdownhooks();
if ((boothowto & RB_POWERDOWN) == RB_POWERDOWN)
if (board && board->ab_poweroff)
board->ab_poweroff();
/*
* YAMON may autoboot (depending on settings), and we cannot pass
* flags to it (at least I haven't figured out how to yet), so
* we "pseudo-halt" now.
*/
if (boothowto & RB_HALT) {
printf("\n");
printf("The operating system has halted.\n");
printf("Please press any key to reboot.\n\n");
cnpollc(1); /* For proper keyboard command handling */
cngetc();
cnpollc(0);
}
printf("reseting board...\n\n");
/*
* Try to use board-specific reset logic, which might involve a better
* hardware reset.
*/
if (board->ab_reboot)
board->ab_reboot();
#if 1
/* XXX
* For some reason we are leaving the ethernet MAC in a state where
* YAMON isn't happy with it. So just call the reset vector (grr,
* Alchemy YAMON doesn't have a "reset" command).
*/
mips_icache_sync_all();
mips_dcache_wbinv_all();
__asm volatile("jr %0" :: "r"(MIPS_RESET_EXC_VEC));
#else
printf("%s\n\n", ((howto & RB_HALT) != 0) ? "halted." : "rebooting...");
yamon_exit(boothowto);
printf("Oops, back from yamon_exit()\n\nSpinning...");
#endif
for (;;)
/* spin forever */ ; /* XXX */
/*NOTREACHED*/
}
/*
* Go through the rigmarole of shutting down..
* this used to be in machdep.c but I'll be dammned if I could see
* anything machine dependant in it.
*/
static void
boot(int howto)
{
/*
* Get rid of any user scheduler baggage and then give
* us a high priority.
*/
if (curthread->td_release)
curthread->td_release(curthread);
lwkt_setpri_self(TDPRI_MAX);
/* collect extra flags that shutdown_nice might have set */
howto |= shutdown_howto;
#ifdef SMP
/*
* We really want to shutdown on the BSP. Subsystems such as ACPI
* can't power-down the box otherwise.
*/
if (smp_active_mask > 1) {
kprintf("boot() called on cpu#%d\n", mycpu->gd_cpuid);
}
if (panicstr == NULL && mycpu->gd_cpuid != 0) {
kprintf("Switching to cpu #0 for shutdown\n");
lwkt_setcpu_self(globaldata_find(0));
}
#endif
/*
* Do any callouts that should be done BEFORE syncing the filesystems.
*/
EVENTHANDLER_INVOKE(shutdown_pre_sync, howto);
/*
* Try to get rid of any remaining FS references. The calling
* process, proc0, and init may still hold references. The
* VFS cache subsystem may still hold a root reference to root.
*
* XXX this needs work. We really need to SIGSTOP all remaining
* processes in order to avoid blowups due to proc0's filesystem
* references going away. For now just make sure that the init
* process is stopped.
*/
if (panicstr == NULL) {
shutdown_cleanup_proc(curproc);
shutdown_cleanup_proc(&proc0);
if (initproc) {
if (initproc != curproc) {
ksignal(initproc, SIGSTOP);
tsleep(boot, 0, "shutdn", hz / 20);
}
shutdown_cleanup_proc(initproc);
}
vfs_cache_setroot(NULL, NULL);
}
/*
* Now sync filesystems
*/
if (!cold && (howto & RB_NOSYNC) == 0 && waittime < 0) {
int iter, nbusy, pbusy;
waittime = 0;
kprintf("\nsyncing disks... ");
sys_sync(NULL); /* YYY was sync(&proc0, NULL). why proc0 ? */
/*
* With soft updates, some buffers that are
* written will be remarked as dirty until other
* buffers are written.
*/
for (iter = pbusy = 0; iter < 20; iter++) {
nbusy = scan_all_buffers(shutdown_busycount1, NULL);
if (nbusy == 0)
break;
kprintf("%d ", nbusy);
if (nbusy < pbusy)
iter = 0;
pbusy = nbusy;
/*
* XXX:
* Process soft update work queue if buffers don't sync
* after 6 iterations by permitting the syncer to run.
*/
if (iter > 5)
bio_ops_sync(NULL);
sys_sync(NULL); /* YYY was sync(&proc0, NULL). why proc0 ? */
tsleep(boot, 0, "shutdn", hz * iter / 20 + 1);
}
kprintf("\n");
/*
* Count only busy local buffers to prevent forcing
* a fsck if we're just a client of a wedged NFS server
*/
nbusy = scan_all_buffers(shutdown_busycount2, NULL);
if (nbusy) {
/*
* Failed to sync all blocks. Indicate this and don't
* unmount filesystems (thus forcing an fsck on reboot).
*/
kprintf("giving up on %d buffers\n", nbusy);
#ifdef DDB
if (debugger_on_panic)
Debugger("busy buffer problem");
#endif /* DDB */
tsleep(boot, 0, "shutdn", hz * 5 + 1);
} else {
kprintf("done\n");
/*
* Unmount filesystems
*/
if (panicstr == NULL)
vfs_unmountall();
}
tsleep(boot, 0, "shutdn", hz / 10 + 1);
}
print_uptime();
/*
* Dump before doing post_sync shutdown ops
*/
crit_enter();
if ((howto & (RB_HALT|RB_DUMP)) == RB_DUMP && !cold) {
dumpsys();
}
/*
* Ok, now do things that assume all filesystem activity has
* been completed. This will also call the device shutdown
* methods.
*/
EVENTHANDLER_INVOKE(shutdown_post_sync, howto);
/* Now that we're going to really halt the system... */
EVENTHANDLER_INVOKE(shutdown_final, howto);
for(;;) ; /* safety against shutdown_reset not working */
/* NOTREACHED */
}
/*
* Halt or reboot the machine after syncing/dumping according to howto.
*/
void
cpu_reboot(int howto, char *what)
{
static int syncing;
static char str[256];
char *ap = str, *ap1 = ap;
/*
* Enable external interrupts in case someone is rebooting
* from a strange context via ddb.
*/
mtmsr(mfmsr() | PSL_EE);
boothowto = howto;
if (!cold && !(howto & RB_NOSYNC) && !syncing) {
syncing = 1;
vfs_shutdown(); /* sync */
resettodr(); /* set wall clock */
}
#ifdef MULTIPROCESSOR
/* Halt other CPU */
ppc_send_ipi(IPI_T_NOTME, PPC_IPI_HALT);
delay(100000); /* XXX */
#endif
splhigh();
if (!cold && (howto & RB_DUMP))
dumpsys();
doshutdownhooks();
if ((howto & RB_POWERDOWN) == RB_POWERDOWN) {
delay(1000000);
#if NCUDA > 0
cuda_poweroff();
#endif
#if NPMU > 0
pmu_poweroff();
#endif
#if NADB > 0
adb_poweroff();
printf("WARNING: powerdown failed!\n");
#endif
}
if (howto & RB_HALT) {
printf("halted\n\n");
/* flush cache for msgbuf */
__syncicache((void *)msgbuf_paddr, round_page(MSGBUFSIZE));
ppc_exit();
}
printf("rebooting\n\n");
if (what && *what) {
if (strlen(what) > sizeof str - 5)
printf("boot string too large, ignored\n");
else {
strcpy(str, what);
ap1 = ap = str + strlen(str);
*ap++ = ' ';
}
}
*ap++ = '-';
if (howto & RB_SINGLE)
*ap++ = 's';
if (howto & RB_KDB)
*ap++ = 'd';
*ap++ = 0;
if (ap[-2] == '-')
*ap1 = 0;
/* flush cache for msgbuf */
__syncicache((void *)msgbuf_paddr, round_page(MSGBUFSIZE));
#if NCUDA > 0
cuda_restart();
#endif
#if NPMU > 0
pmu_restart();
#endif
#if NADB > 0
adb_restart(); /* not return */
#endif
ppc_exit();
}