void
kdb_reboot(void)
{
printf("KDB: reboot requested\n");
shutdown_nice(0);
}
/**
* Shutdown
*/
static void
hv_shutdown_cb(void *context)
{
uint8_t* buf;
hv_vmbus_channel* channel = context;
uint8_t execute_shutdown = 0;
hv_vmbus_icmsg_hdr* icmsghdrp;
uint32_t recv_len;
uint64_t request_id;
int ret;
hv_vmbus_shutdown_msg_data* shutdown_msg;
buf = receive_buffer[HV_SHUT_DOWN];
ret = hv_vmbus_channel_recv_packet(channel, buf, PAGE_SIZE,
&recv_len, &request_id);
if ((ret == 0) && recv_len > 0) {
icmsghdrp = (struct hv_vmbus_icmsg_hdr *)
&buf[sizeof(struct hv_vmbus_pipe_hdr)];
if (icmsghdrp->icmsgtype == HV_ICMSGTYPE_NEGOTIATE) {
hv_negotiate_version(icmsghdrp, NULL, buf);
} else {
shutdown_msg =
(struct hv_vmbus_shutdown_msg_data *)
&buf[sizeof(struct hv_vmbus_pipe_hdr) +
sizeof(struct hv_vmbus_icmsg_hdr)];
switch (shutdown_msg->flags) {
case 0:
case 1:
icmsghdrp->status = HV_S_OK;
execute_shutdown = 1;
if(bootverbose)
printf("Shutdown request received -"
" graceful shutdown initiated\n");
break;
default:
icmsghdrp->status = HV_E_FAIL;
execute_shutdown = 0;
printf("Shutdown request received -"
" Invalid request\n");
break;
}
}
icmsghdrp->icflags = HV_ICMSGHDRFLAG_TRANSACTION |
HV_ICMSGHDRFLAG_RESPONSE;
hv_vmbus_channel_send_packet(channel, buf,
recv_len, request_id,
HV_VMBUS_PACKET_TYPE_DATA_IN_BAND, 0);
}
if (execute_shutdown)
shutdown_nice(RB_POWEROFF);
}
/*
* Handle an overtemp situation.
*
* SPARCs have temperature sensors which generate interrupts
* if the machine's temperature exceeds a certain threshold.
* This handles the interrupt and powers off the machine.
* The same needs to be done to PCI controller drivers.
*/
static void
sbus_overtemp(void *arg)
{
printf("DANGER: OVER TEMPERATURE detected\nShutting down NOW.\n");
shutdown_nice(RB_POWEROFF);
}
/* Try to shut down in time in case of power failure. */
static void
sbus_pwrfail(void *arg)
{
printf("Power failure detected\nShutting down NOW.\n");
shutdown_nice(0);
}
static void
am335x_pmic_intr(void *arg)
{
struct am335x_pmic_softc *sc = (struct am335x_pmic_softc *)arg;
struct tps65217_status_reg status_reg;
struct tps65217_int_reg int_reg;
int rv;
char notify_buf[16];
THREAD_SLEEPING_OK();
rv = am335x_pmic_read(sc->sc_dev, TPS65217_INT_REG, (uint8_t *)&int_reg, 1);
if (rv != 0) {
device_printf(sc->sc_dev, "Cannot read interrupt register\n");
THREAD_NO_SLEEPING();
return;
}
rv = am335x_pmic_read(sc->sc_dev, TPS65217_STATUS_REG, (uint8_t *)&status_reg, 1);
if (rv != 0) {
device_printf(sc->sc_dev, "Cannot read status register\n");
THREAD_NO_SLEEPING();
return;
}
THREAD_NO_SLEEPING();
if (int_reg.pbi && status_reg.pb)
shutdown_nice(RB_POWEROFF);
if (int_reg.aci) {
snprintf(notify_buf, sizeof(notify_buf), "notify=0x%02x",
status_reg.acpwr);
devctl_notify_f("ACPI", "ACAD", "power", notify_buf, M_NOWAIT);
}
}
/* Try to shut down in time in case of power failure. */
static void
sbus_pwrfail(void *arg)
{
static int shutdown;
/* As the interrupt is cleared we may be called multiple times. */
if (shutdown != 0)
return;
shutdown++;
printf("Power failure detected\nShutting down NOW.\n");
shutdown_nice(0);
}
/*
* Handle an overtemp situation.
*
* SPARCs have temperature sensors which generate interrupts
* if the machine's temperature exceeds a certain threshold.
* This handles the interrupt and powers off the machine.
* The same needs to be done to PCI controller drivers.
*/
static void
sbus_overtemp(void *arg)
{
static int shutdown;
/* As the interrupt is cleared we may be called multiple times. */
if (shutdown != 0)
return;
shutdown++;
printf("DANGER: OVER TEMPERATURE detected\nShutting down NOW.\n");
shutdown_nice(RB_POWEROFF);
}
static int
vt_machine_kbdevent(int c)
{
switch (c) {
case SPCLKEY | DBG:
kdb_enter(KDB_WHY_BREAK, "manual escape to debugger");
return (1);
case SPCLKEY | RBT:
/* XXX: Make this configurable! */
shutdown_nice(0);
return (1);
case SPCLKEY | HALT:
shutdown_nice(RB_HALT);
return (1);
case SPCLKEY | PDWN:
shutdown_nice(RB_HALT|RB_POWEROFF);
return (1);
};
return (0);
}
static void
rst_tick(void *argp)
{
struct rst_softc *sc = argp;
if (sc->shutdown++ >= RST_TIMEOUT * RST_TICK) {
/* User released the button in morre than RST_TIMEOUT */
cpu_reset();
} else if ((RD4(sc, RST_SR) & RST_SR_NRSTL)) {
/* User released the button in less than RST_TIMEOUT */
sc->shutdown = 0;
device_printf(sc->sc_dev, "shutting down...\n");
shutdown_nice(0);
} else {
callout_reset(&sc->tick_ch, hz/RST_TICK, rst_tick, sc);
}
}
static void
xctrl_reboot()
{
shutdown_nice(0);
}
/*------------------------------ Event Handlers ------------------------------*/
static void
xctrl_poweroff()
{
shutdown_nice(RB_POWEROFF|RB_HALT);
}
/*
* Evaluate the condition of a thermal zone, take appropriate actions.
*/
static void
acpi_tz_monitor(void *Context)
{
struct acpi_tz_softc *sc;
struct timespec curtime;
int temp;
int i;
int newactive, newflags;
ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
sc = (struct acpi_tz_softc *)Context;
/* Get the current temperature. */
if (!acpi_tz_get_temperature(sc)) {
/* XXX disable zone? go to max cooling? */
return_VOID;
}
temp = sc->tz_temperature;
/*
* Work out what we ought to be doing right now.
*
* Note that the _ACx levels sort from hot to cold.
*/
newactive = TZ_ACTIVE_NONE;
for (i = TZ_NUMLEVELS - 1; i >= 0; i--) {
if (sc->tz_zone.ac[i] != -1 && temp >= sc->tz_zone.ac[i])
newactive = i;
}
/*
* We are going to get _ACx level down (colder side), but give a guaranteed
* minimum cooling run time if requested.
*/
if (acpi_tz_min_runtime > 0 && sc->tz_active != TZ_ACTIVE_NONE &&
sc->tz_active != TZ_ACTIVE_UNKNOWN &&
(newactive == TZ_ACTIVE_NONE || newactive > sc->tz_active)) {
getnanotime(&curtime);
timespecsub(&curtime, &sc->tz_cooling_started);
if (curtime.tv_sec < acpi_tz_min_runtime)
newactive = sc->tz_active;
}
/* Handle user override of active mode */
if (sc->tz_requested != TZ_ACTIVE_NONE && (newactive == TZ_ACTIVE_NONE
|| sc->tz_requested < newactive))
newactive = sc->tz_requested;
/* update temperature-related flags */
newflags = TZ_THFLAG_NONE;
if (sc->tz_zone.psv != -1 && temp >= sc->tz_zone.psv)
newflags |= TZ_THFLAG_PSV;
if (sc->tz_zone.hot != -1 && temp >= sc->tz_zone.hot)
newflags |= TZ_THFLAG_HOT;
if (sc->tz_zone.crt != -1 && temp >= sc->tz_zone.crt)
newflags |= TZ_THFLAG_CRT;
/* If the active cooling state has changed, we have to switch things. */
if (sc->tz_active == TZ_ACTIVE_UNKNOWN) {
/*
* We don't know which cooling device is on or off,
* so stop them all, because we now know which
* should be on (if any).
*/
for (i = 0; i < TZ_NUMLEVELS; i++) {
if (sc->tz_zone.al[i].Pointer != NULL) {
acpi_ForeachPackageObject(
(ACPI_OBJECT *)sc->tz_zone.al[i].Pointer,
acpi_tz_switch_cooler_off, sc);
}
}
/* now we know that all devices are off */
sc->tz_active = TZ_ACTIVE_NONE;
}
if (newactive != sc->tz_active) {
/* Turn off unneeded cooling devices that are on, if any are */
for (i = TZ_ACTIVE_LEVEL(sc->tz_active);
i < TZ_ACTIVE_LEVEL(newactive); i++) {
acpi_ForeachPackageObject(
(ACPI_OBJECT *)sc->tz_zone.al[i].Pointer,
acpi_tz_switch_cooler_off, sc);
}
/* Turn on cooling devices that are required, if any are */
for (i = TZ_ACTIVE_LEVEL(sc->tz_active) - 1;
i >= TZ_ACTIVE_LEVEL(newactive); i--) {
acpi_ForeachPackageObject(
(ACPI_OBJECT *)sc->tz_zone.al[i].Pointer,
acpi_tz_switch_cooler_on, sc);
}
ACPI_VPRINT(sc->tz_dev, acpi_device_get_parent_softc(sc->tz_dev),
"switched from %s to %s: %d.%dC\n",
acpi_tz_aclevel_string(sc->tz_active),
acpi_tz_aclevel_string(newactive), TZ_KELVTOC(temp));
sc->tz_active = newactive;
getnanotime(&sc->tz_cooling_started);
}
/* XXX (de)activate any passive cooling that may be required. */
/*
* If the temperature is at _HOT or _CRT, increment our event count.
* If it has occurred enough times, shutdown the system. This is
* needed because some systems will report an invalid high temperature
* for one poll cycle. It is suspected this is due to the embedded
* controller timing out. A typical value is 138C for one cycle on
* a system that is otherwise 65C.
*
* If we're almost at that threshold, notify the user through devd(8).
*/
if ((newflags & (TZ_THFLAG_HOT | TZ_THFLAG_CRT)) != 0) {
sc->tz_validchecks++;
if (sc->tz_validchecks == TZ_VALIDCHECKS) {
device_printf(sc->tz_dev,
"WARNING - current temperature (%d.%dC) exceeds safe limits\n",
TZ_KELVTOC(sc->tz_temperature));
shutdown_nice(RB_POWEROFF);
} else if (sc->tz_validchecks == TZ_NOTIFYCOUNT)
acpi_UserNotify("Thermal", sc->tz_handle, TZ_NOTIFY_CRITICAL);
} else {
sc->tz_validchecks = 0;
}
sc->tz_thflags = newflags;
return_VOID;
}
/**
* Shutdown
*/
static void
hv_shutdown_cb(struct vmbus_channel *channel, void *context)
{
uint8_t* buf;
uint8_t execute_shutdown = 0;
hv_vmbus_icmsg_hdr* icmsghdrp;
uint32_t recv_len;
uint64_t request_id;
int ret;
hv_vmbus_shutdown_msg_data* shutdown_msg;
hv_util_sc *softc;
softc = (hv_util_sc*)context;
buf = softc->receive_buffer;
recv_len = softc->ic_buflen;
ret = vmbus_chan_recv(channel, buf, &recv_len, &request_id);
KASSERT(ret != ENOBUFS, ("hvshutdown recvbuf is not large enough"));
/* XXX check recv_len to make sure that it contains enough data */
if ((ret == 0) && recv_len > 0) {
icmsghdrp = (struct hv_vmbus_icmsg_hdr *)
&buf[sizeof(struct hv_vmbus_pipe_hdr)];
if (icmsghdrp->icmsgtype == HV_ICMSGTYPE_NEGOTIATE) {
hv_negotiate_version(icmsghdrp, buf);
} else {
shutdown_msg =
(struct hv_vmbus_shutdown_msg_data *)
&buf[sizeof(struct hv_vmbus_pipe_hdr) +
sizeof(struct hv_vmbus_icmsg_hdr)];
switch (shutdown_msg->flags) {
case 0:
case 1:
icmsghdrp->status = HV_S_OK;
execute_shutdown = 1;
if(bootverbose)
printf("Shutdown request received -"
" graceful shutdown initiated\n");
break;
default:
icmsghdrp->status = HV_E_FAIL;
execute_shutdown = 0;
printf("Shutdown request received -"
" Invalid request\n");
break;
}
}
icmsghdrp->icflags = HV_ICMSGHDRFLAG_TRANSACTION |
HV_ICMSGHDRFLAG_RESPONSE;
vmbus_chan_send(channel, VMBUS_CHANPKT_TYPE_INBAND, 0,
buf, recv_len, request_id);
}
if (execute_shutdown)
shutdown_nice(RB_POWEROFF);
}
static void
xctrl_halt()
{
shutdown_nice(RB_HALT);
}
