1243ac210SCorey Minyard // SPDX-License-Identifier: GPL-2.0+ 21da177e4SLinus Torvalds /* 31da177e4SLinus Torvalds * ipmi_poweroff.c 41da177e4SLinus Torvalds * 51da177e4SLinus Torvalds * MontaVista IPMI Poweroff extension to sys_reboot 61da177e4SLinus Torvalds * 71da177e4SLinus Torvalds * Author: MontaVista Software, Inc. 81da177e4SLinus Torvalds * Steven Dake <sdake@mvista.com> 91da177e4SLinus Torvalds * Corey Minyard <cminyard@mvista.com> 101da177e4SLinus Torvalds * source@mvista.com 111da177e4SLinus Torvalds * 121da177e4SLinus Torvalds * Copyright 2002,2004 MontaVista Software Inc. 131da177e4SLinus Torvalds */ 141da177e4SLinus Torvalds #include <linux/module.h> 153b625943SCorey Minyard #include <linux/moduleparam.h> 163b625943SCorey Minyard #include <linux/proc_fs.h> 171da177e4SLinus Torvalds #include <linux/string.h> 1877cf3973SCorey Minyard #include <linux/completion.h> 19e933b6d6SOlaf Hering #include <linux/pm.h> 2077cf3973SCorey Minyard #include <linux/kdev_t.h> 211da177e4SLinus Torvalds #include <linux/ipmi.h> 221da177e4SLinus Torvalds #include <linux/ipmi_smi.h> 231da177e4SLinus Torvalds 241da177e4SLinus Torvalds #define PFX "IPMI poweroff: " 251da177e4SLinus Torvalds 26b2c03941SCorey Minyard static void ipmi_po_smi_gone(int if_num); 27b2c03941SCorey Minyard static void ipmi_po_new_smi(int if_num, struct device *device); 28b2c03941SCorey Minyard 293b625943SCorey Minyard /* Definitions for controlling power off (if the system supports it). It 303b625943SCorey Minyard * conveniently matches the IPMI chassis control values. */ 313b625943SCorey Minyard #define IPMI_CHASSIS_POWER_DOWN 0 /* power down, the default. */ 323b625943SCorey Minyard #define IPMI_CHASSIS_POWER_CYCLE 0x02 /* power cycle */ 333b625943SCorey Minyard 343b625943SCorey Minyard /* the IPMI data command */ 358c702e16SCorey Minyard static int poweroff_powercycle; 363b625943SCorey Minyard 37b2c03941SCorey Minyard /* Which interface to use, -1 means the first we see. */ 38b2c03941SCorey Minyard static int ifnum_to_use = -1; 39b2c03941SCorey Minyard 40b2c03941SCorey Minyard /* Our local state. */ 410c8204b3SRandy Dunlap static int ready; 42b2c03941SCorey Minyard static ipmi_user_t ipmi_user; 43b2c03941SCorey Minyard static int ipmi_ifnum; 440c8204b3SRandy Dunlap static void (*specific_poweroff_func)(ipmi_user_t user); 45b2c03941SCorey Minyard 46b2c03941SCorey Minyard /* Holds the old poweroff function so we can restore it on removal. */ 47b2c03941SCorey Minyard static void (*old_poweroff_func)(void); 48b2c03941SCorey Minyard 49e4dca7b7SKees Cook static int set_param_ifnum(const char *val, const struct kernel_param *kp) 50b2c03941SCorey Minyard { 51b2c03941SCorey Minyard int rv = param_set_int(val, kp); 52b2c03941SCorey Minyard if (rv) 53b2c03941SCorey Minyard return rv; 54b2c03941SCorey Minyard if ((ifnum_to_use < 0) || (ifnum_to_use == ipmi_ifnum)) 55b2c03941SCorey Minyard return 0; 56b2c03941SCorey Minyard 57b2c03941SCorey Minyard ipmi_po_smi_gone(ipmi_ifnum); 58b2c03941SCorey Minyard ipmi_po_new_smi(ifnum_to_use, NULL); 59b2c03941SCorey Minyard return 0; 60b2c03941SCorey Minyard } 61b2c03941SCorey Minyard 62b2c03941SCorey Minyard module_param_call(ifnum_to_use, set_param_ifnum, param_get_int, 63b2c03941SCorey Minyard &ifnum_to_use, 0644); 64b2c03941SCorey Minyard MODULE_PARM_DESC(ifnum_to_use, "The interface number to use for the watchdog " 65b2c03941SCorey Minyard "timer. Setting to -1 defaults to the first registered " 66b2c03941SCorey Minyard "interface"); 67b2c03941SCorey Minyard 683b625943SCorey Minyard /* parameter definition to allow user to flag power cycle */ 69a9d014afSCorey Minyard module_param(poweroff_powercycle, int, 0644); 7036c7dc44SCorey Minyard MODULE_PARM_DESC(poweroff_powercycle, 7136c7dc44SCorey Minyard " Set to non-zero to enable power cycle instead of power" 7236c7dc44SCorey Minyard " down. Power cycle is contingent on hardware support," 7336c7dc44SCorey Minyard " otherwise it defaults back to power down."); 743b625943SCorey Minyard 751da177e4SLinus Torvalds /* Stuff from the get device id command. */ 761da177e4SLinus Torvalds static unsigned int mfg_id; 771da177e4SLinus Torvalds static unsigned int prod_id; 781da177e4SLinus Torvalds static unsigned char capabilities; 79168524d6SCorey Minyard static unsigned char ipmi_version; 801da177e4SLinus Torvalds 8136c7dc44SCorey Minyard /* 8236c7dc44SCorey Minyard * We use our own messages for this operation, we don't let the system 8336c7dc44SCorey Minyard * allocate them, since we may be in a panic situation. The whole 8436c7dc44SCorey Minyard * thing is single-threaded, anyway, so multiple messages are not 8536c7dc44SCorey Minyard * required. 8636c7dc44SCorey Minyard */ 87bda4c30aSCorey Minyard static atomic_t dummy_count = ATOMIC_INIT(0); 881da177e4SLinus Torvalds static void dummy_smi_free(struct ipmi_smi_msg *msg) 891da177e4SLinus Torvalds { 90bda4c30aSCorey Minyard atomic_dec(&dummy_count); 911da177e4SLinus Torvalds } 921da177e4SLinus Torvalds static void dummy_recv_free(struct ipmi_recv_msg *msg) 931da177e4SLinus Torvalds { 94bda4c30aSCorey Minyard atomic_dec(&dummy_count); 951da177e4SLinus Torvalds } 9636c7dc44SCorey Minyard static struct ipmi_smi_msg halt_smi_msg = { 971da177e4SLinus Torvalds .done = dummy_smi_free 981da177e4SLinus Torvalds }; 9936c7dc44SCorey Minyard static struct ipmi_recv_msg halt_recv_msg = { 1001da177e4SLinus Torvalds .done = dummy_recv_free 1011da177e4SLinus Torvalds }; 1021da177e4SLinus Torvalds 1031da177e4SLinus Torvalds 1041da177e4SLinus Torvalds /* 10525985edcSLucas De Marchi * Code to send a message and wait for the response. 1061da177e4SLinus Torvalds */ 1071da177e4SLinus Torvalds 1081da177e4SLinus Torvalds static void receive_handler(struct ipmi_recv_msg *recv_msg, void *handler_data) 1091da177e4SLinus Torvalds { 11077cf3973SCorey Minyard struct completion *comp = recv_msg->user_msg_data; 1111da177e4SLinus Torvalds 11277cf3973SCorey Minyard if (comp) 11377cf3973SCorey Minyard complete(comp); 1141da177e4SLinus Torvalds } 1151da177e4SLinus Torvalds 116e6dd76a6SBhumika Goyal static const struct ipmi_user_hndl ipmi_poweroff_handler = { 1171da177e4SLinus Torvalds .ipmi_recv_hndl = receive_handler 1181da177e4SLinus Torvalds }; 1191da177e4SLinus Torvalds 1201da177e4SLinus Torvalds 1211da177e4SLinus Torvalds static int ipmi_request_wait_for_response(ipmi_user_t user, 1221da177e4SLinus Torvalds struct ipmi_addr *addr, 1231da177e4SLinus Torvalds struct kernel_ipmi_msg *send_msg) 1241da177e4SLinus Torvalds { 1251da177e4SLinus Torvalds int rv; 12677cf3973SCorey Minyard struct completion comp; 1271da177e4SLinus Torvalds 12877cf3973SCorey Minyard init_completion(&comp); 1291da177e4SLinus Torvalds 13077cf3973SCorey Minyard rv = ipmi_request_supply_msgs(user, addr, 0, send_msg, &comp, 1311da177e4SLinus Torvalds &halt_smi_msg, &halt_recv_msg, 0); 1321da177e4SLinus Torvalds if (rv) 1331da177e4SLinus Torvalds return rv; 1341da177e4SLinus Torvalds 13577cf3973SCorey Minyard wait_for_completion(&comp); 1361da177e4SLinus Torvalds 1371da177e4SLinus Torvalds return halt_recv_msg.msg.data[0]; 1381da177e4SLinus Torvalds } 1391da177e4SLinus Torvalds 140bda4c30aSCorey Minyard /* Wait for message to complete, spinning. */ 1411da177e4SLinus Torvalds static int ipmi_request_in_rc_mode(ipmi_user_t user, 1421da177e4SLinus Torvalds struct ipmi_addr *addr, 1431da177e4SLinus Torvalds struct kernel_ipmi_msg *send_msg) 1441da177e4SLinus Torvalds { 1451da177e4SLinus Torvalds int rv; 1461da177e4SLinus Torvalds 147bda4c30aSCorey Minyard atomic_set(&dummy_count, 2); 1481da177e4SLinus Torvalds rv = ipmi_request_supply_msgs(user, addr, 0, send_msg, NULL, 1491da177e4SLinus Torvalds &halt_smi_msg, &halt_recv_msg, 0); 150bda4c30aSCorey Minyard if (rv) { 151bda4c30aSCorey Minyard atomic_set(&dummy_count, 0); 1521da177e4SLinus Torvalds return rv; 153bda4c30aSCorey Minyard } 154bda4c30aSCorey Minyard 155bda4c30aSCorey Minyard /* 156bda4c30aSCorey Minyard * Spin until our message is done. 157bda4c30aSCorey Minyard */ 158bda4c30aSCorey Minyard while (atomic_read(&dummy_count) > 0) { 159bda4c30aSCorey Minyard ipmi_poll_interface(user); 160bda4c30aSCorey Minyard cpu_relax(); 161bda4c30aSCorey Minyard } 1621da177e4SLinus Torvalds 1631da177e4SLinus Torvalds return halt_recv_msg.msg.data[0]; 1641da177e4SLinus Torvalds } 1651da177e4SLinus Torvalds 1661da177e4SLinus Torvalds /* 1671da177e4SLinus Torvalds * ATCA Support 1681da177e4SLinus Torvalds */ 1691da177e4SLinus Torvalds 1701da177e4SLinus Torvalds #define IPMI_NETFN_ATCA 0x2c 1711da177e4SLinus Torvalds #define IPMI_ATCA_SET_POWER_CMD 0x11 1721da177e4SLinus Torvalds #define IPMI_ATCA_GET_ADDR_INFO_CMD 0x01 1731da177e4SLinus Torvalds #define IPMI_PICMG_ID 0 1741da177e4SLinus Torvalds 1757d8ba966SCorey Minyard #define IPMI_NETFN_OEM 0x2e 1767d8ba966SCorey Minyard #define IPMI_ATCA_PPS_GRACEFUL_RESTART 0x11 1777d8ba966SCorey Minyard #define IPMI_ATCA_PPS_IANA "\x00\x40\x0A" 1787d8ba966SCorey Minyard #define IPMI_MOTOROLA_MANUFACTURER_ID 0x0000A1 1797d8ba966SCorey Minyard #define IPMI_MOTOROLA_PPS_IPMC_PRODUCT_ID 0x0051 1807d8ba966SCorey Minyard 1810c8204b3SRandy Dunlap static void (*atca_oem_poweroff_hook)(ipmi_user_t user); 1827d8ba966SCorey Minyard 1837d8ba966SCorey Minyard static void pps_poweroff_atca(ipmi_user_t user) 1847d8ba966SCorey Minyard { 1857d8ba966SCorey Minyard struct ipmi_system_interface_addr smi_addr; 1867d8ba966SCorey Minyard struct kernel_ipmi_msg send_msg; 1877d8ba966SCorey Minyard int rv; 1887d8ba966SCorey Minyard /* 1897d8ba966SCorey Minyard * Configure IPMI address for local access 1907d8ba966SCorey Minyard */ 1917d8ba966SCorey Minyard smi_addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE; 1927d8ba966SCorey Minyard smi_addr.channel = IPMI_BMC_CHANNEL; 1937d8ba966SCorey Minyard smi_addr.lun = 0; 1947d8ba966SCorey Minyard 1957d8ba966SCorey Minyard printk(KERN_INFO PFX "PPS powerdown hook used"); 1967d8ba966SCorey Minyard 1977d8ba966SCorey Minyard send_msg.netfn = IPMI_NETFN_OEM; 1987d8ba966SCorey Minyard send_msg.cmd = IPMI_ATCA_PPS_GRACEFUL_RESTART; 1997d8ba966SCorey Minyard send_msg.data = IPMI_ATCA_PPS_IANA; 2007d8ba966SCorey Minyard send_msg.data_len = 3; 2017d8ba966SCorey Minyard rv = ipmi_request_in_rc_mode(user, 2027d8ba966SCorey Minyard (struct ipmi_addr *) &smi_addr, 2037d8ba966SCorey Minyard &send_msg); 2047d8ba966SCorey Minyard if (rv && rv != IPMI_UNKNOWN_ERR_COMPLETION_CODE) { 2057d8ba966SCorey Minyard printk(KERN_ERR PFX "Unable to send ATCA ," 2067d8ba966SCorey Minyard " IPMI error 0x%x\n", rv); 2077d8ba966SCorey Minyard } 2087d8ba966SCorey Minyard return; 2097d8ba966SCorey Minyard } 2107d8ba966SCorey Minyard 2111da177e4SLinus Torvalds static int ipmi_atca_detect(ipmi_user_t user) 2121da177e4SLinus Torvalds { 2131da177e4SLinus Torvalds struct ipmi_system_interface_addr smi_addr; 2141da177e4SLinus Torvalds struct kernel_ipmi_msg send_msg; 2151da177e4SLinus Torvalds int rv; 2161da177e4SLinus Torvalds unsigned char data[1]; 2171da177e4SLinus Torvalds 2181da177e4SLinus Torvalds /* 2191da177e4SLinus Torvalds * Configure IPMI address for local access 2201da177e4SLinus Torvalds */ 2211da177e4SLinus Torvalds smi_addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE; 2221da177e4SLinus Torvalds smi_addr.channel = IPMI_BMC_CHANNEL; 2231da177e4SLinus Torvalds smi_addr.lun = 0; 2241da177e4SLinus Torvalds 2251da177e4SLinus Torvalds /* 2261da177e4SLinus Torvalds * Use get address info to check and see if we are ATCA 2271da177e4SLinus Torvalds */ 2281da177e4SLinus Torvalds send_msg.netfn = IPMI_NETFN_ATCA; 2291da177e4SLinus Torvalds send_msg.cmd = IPMI_ATCA_GET_ADDR_INFO_CMD; 2301da177e4SLinus Torvalds data[0] = IPMI_PICMG_ID; 2311da177e4SLinus Torvalds send_msg.data = data; 2321da177e4SLinus Torvalds send_msg.data_len = sizeof(data); 2331da177e4SLinus Torvalds rv = ipmi_request_wait_for_response(user, 2341da177e4SLinus Torvalds (struct ipmi_addr *) &smi_addr, 2351da177e4SLinus Torvalds &send_msg); 2367d8ba966SCorey Minyard 23736c7dc44SCorey Minyard printk(KERN_INFO PFX "ATCA Detect mfg 0x%X prod 0x%X\n", 23836c7dc44SCorey Minyard mfg_id, prod_id); 2397d8ba966SCorey Minyard if ((mfg_id == IPMI_MOTOROLA_MANUFACTURER_ID) 2407d8ba966SCorey Minyard && (prod_id == IPMI_MOTOROLA_PPS_IPMC_PRODUCT_ID)) { 24136c7dc44SCorey Minyard printk(KERN_INFO PFX 24236c7dc44SCorey Minyard "Installing Pigeon Point Systems Poweroff Hook\n"); 2437d8ba966SCorey Minyard atca_oem_poweroff_hook = pps_poweroff_atca; 2447d8ba966SCorey Minyard } 2451da177e4SLinus Torvalds return !rv; 2461da177e4SLinus Torvalds } 2471da177e4SLinus Torvalds 2481da177e4SLinus Torvalds static void ipmi_poweroff_atca(ipmi_user_t user) 2491da177e4SLinus Torvalds { 2501da177e4SLinus Torvalds struct ipmi_system_interface_addr smi_addr; 2511da177e4SLinus Torvalds struct kernel_ipmi_msg send_msg; 2521da177e4SLinus Torvalds int rv; 2531da177e4SLinus Torvalds unsigned char data[4]; 2541da177e4SLinus Torvalds 2551da177e4SLinus Torvalds /* 2561da177e4SLinus Torvalds * Configure IPMI address for local access 2571da177e4SLinus Torvalds */ 2581da177e4SLinus Torvalds smi_addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE; 2591da177e4SLinus Torvalds smi_addr.channel = IPMI_BMC_CHANNEL; 2601da177e4SLinus Torvalds smi_addr.lun = 0; 2611da177e4SLinus Torvalds 2621da177e4SLinus Torvalds printk(KERN_INFO PFX "Powering down via ATCA power command\n"); 2631da177e4SLinus Torvalds 2641da177e4SLinus Torvalds /* 2651da177e4SLinus Torvalds * Power down 2661da177e4SLinus Torvalds */ 2671da177e4SLinus Torvalds send_msg.netfn = IPMI_NETFN_ATCA; 2681da177e4SLinus Torvalds send_msg.cmd = IPMI_ATCA_SET_POWER_CMD; 2691da177e4SLinus Torvalds data[0] = IPMI_PICMG_ID; 2701da177e4SLinus Torvalds data[1] = 0; /* FRU id */ 2711da177e4SLinus Torvalds data[2] = 0; /* Power Level */ 2721da177e4SLinus Torvalds data[3] = 0; /* Don't change saved presets */ 2731da177e4SLinus Torvalds send_msg.data = data; 2741da177e4SLinus Torvalds send_msg.data_len = sizeof(data); 2751da177e4SLinus Torvalds rv = ipmi_request_in_rc_mode(user, 2761da177e4SLinus Torvalds (struct ipmi_addr *) &smi_addr, 2771da177e4SLinus Torvalds &send_msg); 27836c7dc44SCorey Minyard /* 27936c7dc44SCorey Minyard * At this point, the system may be shutting down, and most 28036c7dc44SCorey Minyard * serial drivers (if used) will have interrupts turned off 28136c7dc44SCorey Minyard * it may be better to ignore IPMI_UNKNOWN_ERR_COMPLETION_CODE 28236c7dc44SCorey Minyard * return code 28336c7dc44SCorey Minyard */ 2847d8ba966SCorey Minyard if (rv && rv != IPMI_UNKNOWN_ERR_COMPLETION_CODE) { 2851da177e4SLinus Torvalds printk(KERN_ERR PFX "Unable to send ATCA powerdown message," 2861da177e4SLinus Torvalds " IPMI error 0x%x\n", rv); 2871da177e4SLinus Torvalds goto out; 2881da177e4SLinus Torvalds } 2891da177e4SLinus Torvalds 2907d8ba966SCorey Minyard if (atca_oem_poweroff_hook) 291adf535eeSAdrian Bunk atca_oem_poweroff_hook(user); 2921da177e4SLinus Torvalds out: 2931da177e4SLinus Torvalds return; 2941da177e4SLinus Torvalds } 2951da177e4SLinus Torvalds 2961da177e4SLinus Torvalds /* 2971da177e4SLinus Torvalds * CPI1 Support 2981da177e4SLinus Torvalds */ 2991da177e4SLinus Torvalds 3001da177e4SLinus Torvalds #define IPMI_NETFN_OEM_1 0xf8 3011da177e4SLinus Torvalds #define OEM_GRP_CMD_SET_RESET_STATE 0x84 3021da177e4SLinus Torvalds #define OEM_GRP_CMD_SET_POWER_STATE 0x82 3031da177e4SLinus Torvalds #define IPMI_NETFN_OEM_8 0xf8 3041da177e4SLinus Torvalds #define OEM_GRP_CMD_REQUEST_HOTSWAP_CTRL 0x80 3051da177e4SLinus Torvalds #define OEM_GRP_CMD_GET_SLOT_GA 0xa3 3061da177e4SLinus Torvalds #define IPMI_NETFN_SENSOR_EVT 0x10 3071da177e4SLinus Torvalds #define IPMI_CMD_GET_EVENT_RECEIVER 0x01 3081da177e4SLinus Torvalds 3091da177e4SLinus Torvalds #define IPMI_CPI1_PRODUCT_ID 0x000157 3101da177e4SLinus Torvalds #define IPMI_CPI1_MANUFACTURER_ID 0x0108 3111da177e4SLinus Torvalds 3121da177e4SLinus Torvalds static int ipmi_cpi1_detect(ipmi_user_t user) 3131da177e4SLinus Torvalds { 3141da177e4SLinus Torvalds return ((mfg_id == IPMI_CPI1_MANUFACTURER_ID) 3151da177e4SLinus Torvalds && (prod_id == IPMI_CPI1_PRODUCT_ID)); 3161da177e4SLinus Torvalds } 3171da177e4SLinus Torvalds 3181da177e4SLinus Torvalds static void ipmi_poweroff_cpi1(ipmi_user_t user) 3191da177e4SLinus Torvalds { 3201da177e4SLinus Torvalds struct ipmi_system_interface_addr smi_addr; 3211da177e4SLinus Torvalds struct ipmi_ipmb_addr ipmb_addr; 3221da177e4SLinus Torvalds struct kernel_ipmi_msg send_msg; 3231da177e4SLinus Torvalds int rv; 3241da177e4SLinus Torvalds unsigned char data[1]; 3251da177e4SLinus Torvalds int slot; 3261da177e4SLinus Torvalds unsigned char hotswap_ipmb; 3271da177e4SLinus Torvalds unsigned char aer_addr; 3281da177e4SLinus Torvalds unsigned char aer_lun; 3291da177e4SLinus Torvalds 3301da177e4SLinus Torvalds /* 3311da177e4SLinus Torvalds * Configure IPMI address for local access 3321da177e4SLinus Torvalds */ 3331da177e4SLinus Torvalds smi_addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE; 3341da177e4SLinus Torvalds smi_addr.channel = IPMI_BMC_CHANNEL; 3351da177e4SLinus Torvalds smi_addr.lun = 0; 3361da177e4SLinus Torvalds 3371da177e4SLinus Torvalds printk(KERN_INFO PFX "Powering down via CPI1 power command\n"); 3381da177e4SLinus Torvalds 3391da177e4SLinus Torvalds /* 3401da177e4SLinus Torvalds * Get IPMI ipmb address 3411da177e4SLinus Torvalds */ 3421da177e4SLinus Torvalds send_msg.netfn = IPMI_NETFN_OEM_8 >> 2; 3431da177e4SLinus Torvalds send_msg.cmd = OEM_GRP_CMD_GET_SLOT_GA; 3441da177e4SLinus Torvalds send_msg.data = NULL; 3451da177e4SLinus Torvalds send_msg.data_len = 0; 3461da177e4SLinus Torvalds rv = ipmi_request_in_rc_mode(user, 3471da177e4SLinus Torvalds (struct ipmi_addr *) &smi_addr, 3481da177e4SLinus Torvalds &send_msg); 3491da177e4SLinus Torvalds if (rv) 3501da177e4SLinus Torvalds goto out; 3511da177e4SLinus Torvalds slot = halt_recv_msg.msg.data[1]; 3521da177e4SLinus Torvalds hotswap_ipmb = (slot > 9) ? (0xb0 + 2 * slot) : (0xae + 2 * slot); 3531da177e4SLinus Torvalds 3541da177e4SLinus Torvalds /* 3551da177e4SLinus Torvalds * Get active event receiver 3561da177e4SLinus Torvalds */ 3571da177e4SLinus Torvalds send_msg.netfn = IPMI_NETFN_SENSOR_EVT >> 2; 3581da177e4SLinus Torvalds send_msg.cmd = IPMI_CMD_GET_EVENT_RECEIVER; 3591da177e4SLinus Torvalds send_msg.data = NULL; 3601da177e4SLinus Torvalds send_msg.data_len = 0; 3611da177e4SLinus Torvalds rv = ipmi_request_in_rc_mode(user, 3621da177e4SLinus Torvalds (struct ipmi_addr *) &smi_addr, 3631da177e4SLinus Torvalds &send_msg); 3641da177e4SLinus Torvalds if (rv) 3651da177e4SLinus Torvalds goto out; 3661da177e4SLinus Torvalds aer_addr = halt_recv_msg.msg.data[1]; 3671da177e4SLinus Torvalds aer_lun = halt_recv_msg.msg.data[2]; 3681da177e4SLinus Torvalds 3691da177e4SLinus Torvalds /* 3701da177e4SLinus Torvalds * Setup IPMB address target instead of local target 3711da177e4SLinus Torvalds */ 3721da177e4SLinus Torvalds ipmb_addr.addr_type = IPMI_IPMB_ADDR_TYPE; 3731da177e4SLinus Torvalds ipmb_addr.channel = 0; 3741da177e4SLinus Torvalds ipmb_addr.slave_addr = aer_addr; 3751da177e4SLinus Torvalds ipmb_addr.lun = aer_lun; 3761da177e4SLinus Torvalds 3771da177e4SLinus Torvalds /* 3781da177e4SLinus Torvalds * Send request hotswap control to remove blade from dpv 3791da177e4SLinus Torvalds */ 3801da177e4SLinus Torvalds send_msg.netfn = IPMI_NETFN_OEM_8 >> 2; 3811da177e4SLinus Torvalds send_msg.cmd = OEM_GRP_CMD_REQUEST_HOTSWAP_CTRL; 3821da177e4SLinus Torvalds send_msg.data = &hotswap_ipmb; 3831da177e4SLinus Torvalds send_msg.data_len = 1; 3841da177e4SLinus Torvalds ipmi_request_in_rc_mode(user, 3851da177e4SLinus Torvalds (struct ipmi_addr *) &ipmb_addr, 3861da177e4SLinus Torvalds &send_msg); 3871da177e4SLinus Torvalds 3881da177e4SLinus Torvalds /* 3891da177e4SLinus Torvalds * Set reset asserted 3901da177e4SLinus Torvalds */ 3911da177e4SLinus Torvalds send_msg.netfn = IPMI_NETFN_OEM_1 >> 2; 3921da177e4SLinus Torvalds send_msg.cmd = OEM_GRP_CMD_SET_RESET_STATE; 3931da177e4SLinus Torvalds send_msg.data = data; 3941da177e4SLinus Torvalds data[0] = 1; /* Reset asserted state */ 3951da177e4SLinus Torvalds send_msg.data_len = 1; 3961da177e4SLinus Torvalds rv = ipmi_request_in_rc_mode(user, 3971da177e4SLinus Torvalds (struct ipmi_addr *) &smi_addr, 3981da177e4SLinus Torvalds &send_msg); 3991da177e4SLinus Torvalds if (rv) 4001da177e4SLinus Torvalds goto out; 4011da177e4SLinus Torvalds 4021da177e4SLinus Torvalds /* 4031da177e4SLinus Torvalds * Power down 4041da177e4SLinus Torvalds */ 4051da177e4SLinus Torvalds send_msg.netfn = IPMI_NETFN_OEM_1 >> 2; 4061da177e4SLinus Torvalds send_msg.cmd = OEM_GRP_CMD_SET_POWER_STATE; 4071da177e4SLinus Torvalds send_msg.data = data; 4081da177e4SLinus Torvalds data[0] = 1; /* Power down state */ 4091da177e4SLinus Torvalds send_msg.data_len = 1; 4101da177e4SLinus Torvalds rv = ipmi_request_in_rc_mode(user, 4111da177e4SLinus Torvalds (struct ipmi_addr *) &smi_addr, 4121da177e4SLinus Torvalds &send_msg); 4131da177e4SLinus Torvalds if (rv) 4141da177e4SLinus Torvalds goto out; 4151da177e4SLinus Torvalds 4161da177e4SLinus Torvalds out: 4171da177e4SLinus Torvalds return; 4181da177e4SLinus Torvalds } 4191da177e4SLinus Torvalds 4201da177e4SLinus Torvalds /* 421168524d6SCorey Minyard * ipmi_dell_chassis_detect() 422168524d6SCorey Minyard * Dell systems with IPMI < 1.5 don't set the chassis capability bit 423168524d6SCorey Minyard * but they can handle a chassis poweroff or powercycle command. 424168524d6SCorey Minyard */ 425168524d6SCorey Minyard 426168524d6SCorey Minyard #define DELL_IANA_MFR_ID {0xA2, 0x02, 0x00} 427168524d6SCorey Minyard static int ipmi_dell_chassis_detect(ipmi_user_t user) 428168524d6SCorey Minyard { 429168524d6SCorey Minyard const char ipmi_version_major = ipmi_version & 0xF; 430168524d6SCorey Minyard const char ipmi_version_minor = (ipmi_version >> 4) & 0xF; 431168524d6SCorey Minyard const char mfr[3] = DELL_IANA_MFR_ID; 432168524d6SCorey Minyard if (!memcmp(mfr, &mfg_id, sizeof(mfr)) && 433168524d6SCorey Minyard ipmi_version_major <= 1 && 434168524d6SCorey Minyard ipmi_version_minor < 5) 435168524d6SCorey Minyard return 1; 436168524d6SCorey Minyard return 0; 437168524d6SCorey Minyard } 438168524d6SCorey Minyard 439168524d6SCorey Minyard /* 440c6185e28SHelge Deller * ipmi_hp_chassis_detect() 441c6185e28SHelge Deller * HP PA-RISC servers rp3410/rp3440, the C8000 workstation and the rx2600 and 442c6185e28SHelge Deller * zx6000 machines support IPMI vers 1 and don't set the chassis capability bit 443c6185e28SHelge Deller * but they can handle a chassis poweroff or powercycle command. 444c6185e28SHelge Deller */ 445c6185e28SHelge Deller 446c6185e28SHelge Deller #define HP_IANA_MFR_ID 0x0b 447c6185e28SHelge Deller #define HP_BMC_PROD_ID 0x8201 448c6185e28SHelge Deller static int ipmi_hp_chassis_detect(ipmi_user_t user) 449c6185e28SHelge Deller { 450c6185e28SHelge Deller if (mfg_id == HP_IANA_MFR_ID 451c6185e28SHelge Deller && prod_id == HP_BMC_PROD_ID 452c6185e28SHelge Deller && ipmi_version == 1) 453c6185e28SHelge Deller return 1; 454c6185e28SHelge Deller return 0; 455c6185e28SHelge Deller } 456c6185e28SHelge Deller 457c6185e28SHelge Deller /* 4581da177e4SLinus Torvalds * Standard chassis support 4591da177e4SLinus Torvalds */ 4601da177e4SLinus Torvalds 4611da177e4SLinus Torvalds #define IPMI_NETFN_CHASSIS_REQUEST 0 4621da177e4SLinus Torvalds #define IPMI_CHASSIS_CONTROL_CMD 0x02 4631da177e4SLinus Torvalds 4641da177e4SLinus Torvalds static int ipmi_chassis_detect(ipmi_user_t user) 4651da177e4SLinus Torvalds { 4661da177e4SLinus Torvalds /* Chassis support, use it. */ 4671da177e4SLinus Torvalds return (capabilities & 0x80); 4681da177e4SLinus Torvalds } 4691da177e4SLinus Torvalds 4701da177e4SLinus Torvalds static void ipmi_poweroff_chassis(ipmi_user_t user) 4711da177e4SLinus Torvalds { 4721da177e4SLinus Torvalds struct ipmi_system_interface_addr smi_addr; 4731da177e4SLinus Torvalds struct kernel_ipmi_msg send_msg; 4741da177e4SLinus Torvalds int rv; 4751da177e4SLinus Torvalds unsigned char data[1]; 4761da177e4SLinus Torvalds 4771da177e4SLinus Torvalds /* 4781da177e4SLinus Torvalds * Configure IPMI address for local access 4791da177e4SLinus Torvalds */ 4801da177e4SLinus Torvalds smi_addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE; 4811da177e4SLinus Torvalds smi_addr.channel = IPMI_BMC_CHANNEL; 4821da177e4SLinus Torvalds smi_addr.lun = 0; 4831da177e4SLinus Torvalds 4843b625943SCorey Minyard powercyclefailed: 4853b625943SCorey Minyard printk(KERN_INFO PFX "Powering %s via IPMI chassis control command\n", 4868c702e16SCorey Minyard (poweroff_powercycle ? "cycle" : "down")); 4871da177e4SLinus Torvalds 4881da177e4SLinus Torvalds /* 4891da177e4SLinus Torvalds * Power down 4901da177e4SLinus Torvalds */ 4911da177e4SLinus Torvalds send_msg.netfn = IPMI_NETFN_CHASSIS_REQUEST; 4921da177e4SLinus Torvalds send_msg.cmd = IPMI_CHASSIS_CONTROL_CMD; 4938c702e16SCorey Minyard if (poweroff_powercycle) 4948c702e16SCorey Minyard data[0] = IPMI_CHASSIS_POWER_CYCLE; 4958c702e16SCorey Minyard else 4968c702e16SCorey Minyard data[0] = IPMI_CHASSIS_POWER_DOWN; 4971da177e4SLinus Torvalds send_msg.data = data; 4981da177e4SLinus Torvalds send_msg.data_len = sizeof(data); 4991da177e4SLinus Torvalds rv = ipmi_request_in_rc_mode(user, 5001da177e4SLinus Torvalds (struct ipmi_addr *) &smi_addr, 5011da177e4SLinus Torvalds &send_msg); 5021da177e4SLinus Torvalds if (rv) { 5038c702e16SCorey Minyard if (poweroff_powercycle) { 5043b625943SCorey Minyard /* power cycle failed, default to power down */ 5053b625943SCorey Minyard printk(KERN_ERR PFX "Unable to send chassis power " \ 5063b625943SCorey Minyard "cycle message, IPMI error 0x%x\n", rv); 5078c702e16SCorey Minyard poweroff_powercycle = 0; 5083b625943SCorey Minyard goto powercyclefailed; 5098c702e16SCorey Minyard } 5103b625943SCorey Minyard 5113b625943SCorey Minyard printk(KERN_ERR PFX "Unable to send chassis power " \ 5123b625943SCorey Minyard "down message, IPMI error 0x%x\n", rv); 5133b625943SCorey Minyard } 5141da177e4SLinus Torvalds } 5151da177e4SLinus Torvalds 5161da177e4SLinus Torvalds 5171da177e4SLinus Torvalds /* Table of possible power off functions. */ 5181da177e4SLinus Torvalds struct poweroff_function { 5191da177e4SLinus Torvalds char *platform_type; 5201da177e4SLinus Torvalds int (*detect)(ipmi_user_t user); 5211da177e4SLinus Torvalds void (*poweroff_func)(ipmi_user_t user); 5221da177e4SLinus Torvalds }; 5231da177e4SLinus Torvalds 5241da177e4SLinus Torvalds static struct poweroff_function poweroff_functions[] = { 5251da177e4SLinus Torvalds { .platform_type = "ATCA", 5261da177e4SLinus Torvalds .detect = ipmi_atca_detect, 5271da177e4SLinus Torvalds .poweroff_func = ipmi_poweroff_atca }, 5281da177e4SLinus Torvalds { .platform_type = "CPI1", 5291da177e4SLinus Torvalds .detect = ipmi_cpi1_detect, 5301da177e4SLinus Torvalds .poweroff_func = ipmi_poweroff_cpi1 }, 531168524d6SCorey Minyard { .platform_type = "chassis", 532168524d6SCorey Minyard .detect = ipmi_dell_chassis_detect, 533168524d6SCorey Minyard .poweroff_func = ipmi_poweroff_chassis }, 534c6185e28SHelge Deller { .platform_type = "chassis", 535c6185e28SHelge Deller .detect = ipmi_hp_chassis_detect, 536c6185e28SHelge Deller .poweroff_func = ipmi_poweroff_chassis }, 5371da177e4SLinus Torvalds /* Chassis should generally be last, other things should override 5381da177e4SLinus Torvalds it. */ 5391da177e4SLinus Torvalds { .platform_type = "chassis", 5401da177e4SLinus Torvalds .detect = ipmi_chassis_detect, 5411da177e4SLinus Torvalds .poweroff_func = ipmi_poweroff_chassis }, 5421da177e4SLinus Torvalds }; 543e8824babSColin Ian King #define NUM_PO_FUNCS ARRAY_SIZE(poweroff_functions) 5441da177e4SLinus Torvalds 5451da177e4SLinus Torvalds 5461da177e4SLinus Torvalds /* Called on a powerdown request. */ 5471da177e4SLinus Torvalds static void ipmi_poweroff_function(void) 5481da177e4SLinus Torvalds { 5491da177e4SLinus Torvalds if (!ready) 5501da177e4SLinus Torvalds return; 5511da177e4SLinus Torvalds 5521da177e4SLinus Torvalds /* Use run-to-completion mode, since interrupts may be off. */ 5531da177e4SLinus Torvalds specific_poweroff_func(ipmi_user); 5541da177e4SLinus Torvalds } 5551da177e4SLinus Torvalds 5561da177e4SLinus Torvalds /* Wait for an IPMI interface to be installed, the first one installed 5571da177e4SLinus Torvalds will be grabbed by this code and used to perform the powerdown. */ 55850c812b2SCorey Minyard static void ipmi_po_new_smi(int if_num, struct device *device) 5591da177e4SLinus Torvalds { 5601da177e4SLinus Torvalds struct ipmi_system_interface_addr smi_addr; 5611da177e4SLinus Torvalds struct kernel_ipmi_msg send_msg; 5621da177e4SLinus Torvalds int rv; 5631da177e4SLinus Torvalds int i; 5641da177e4SLinus Torvalds 5651da177e4SLinus Torvalds if (ready) 5661da177e4SLinus Torvalds return; 5671da177e4SLinus Torvalds 568b2c03941SCorey Minyard if ((ifnum_to_use >= 0) && (ifnum_to_use != if_num)) 569b2c03941SCorey Minyard return; 570b2c03941SCorey Minyard 5713b625943SCorey Minyard rv = ipmi_create_user(if_num, &ipmi_poweroff_handler, NULL, 5723b625943SCorey Minyard &ipmi_user); 5731da177e4SLinus Torvalds if (rv) { 5741da177e4SLinus Torvalds printk(KERN_ERR PFX "could not create IPMI user, error %d\n", 5751da177e4SLinus Torvalds rv); 5761da177e4SLinus Torvalds return; 5771da177e4SLinus Torvalds } 5781da177e4SLinus Torvalds 579b2c03941SCorey Minyard ipmi_ifnum = if_num; 580b2c03941SCorey Minyard 5811da177e4SLinus Torvalds /* 5821da177e4SLinus Torvalds * Do a get device ide and store some results, since this is 5831da177e4SLinus Torvalds * used by several functions. 5841da177e4SLinus Torvalds */ 5851da177e4SLinus Torvalds smi_addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE; 5861da177e4SLinus Torvalds smi_addr.channel = IPMI_BMC_CHANNEL; 5871da177e4SLinus Torvalds smi_addr.lun = 0; 5881da177e4SLinus Torvalds 5891da177e4SLinus Torvalds send_msg.netfn = IPMI_NETFN_APP_REQUEST; 5901da177e4SLinus Torvalds send_msg.cmd = IPMI_GET_DEVICE_ID_CMD; 5911da177e4SLinus Torvalds send_msg.data = NULL; 5921da177e4SLinus Torvalds send_msg.data_len = 0; 5931da177e4SLinus Torvalds rv = ipmi_request_wait_for_response(ipmi_user, 5941da177e4SLinus Torvalds (struct ipmi_addr *) &smi_addr, 5951da177e4SLinus Torvalds &send_msg); 5961da177e4SLinus Torvalds if (rv) { 5971da177e4SLinus Torvalds printk(KERN_ERR PFX "Unable to send IPMI get device id info," 5981da177e4SLinus Torvalds " IPMI error 0x%x\n", rv); 5991da177e4SLinus Torvalds goto out_err; 6001da177e4SLinus Torvalds } 6011da177e4SLinus Torvalds 6021da177e4SLinus Torvalds if (halt_recv_msg.msg.data_len < 12) { 6031da177e4SLinus Torvalds printk(KERN_ERR PFX "(chassis) IPMI get device id info too," 6041da177e4SLinus Torvalds " short, was %d bytes, needed %d bytes\n", 6051da177e4SLinus Torvalds halt_recv_msg.msg.data_len, 12); 6061da177e4SLinus Torvalds goto out_err; 6071da177e4SLinus Torvalds } 6081da177e4SLinus Torvalds 6091da177e4SLinus Torvalds mfg_id = (halt_recv_msg.msg.data[7] 6101da177e4SLinus Torvalds | (halt_recv_msg.msg.data[8] << 8) 6111da177e4SLinus Torvalds | (halt_recv_msg.msg.data[9] << 16)); 6121da177e4SLinus Torvalds prod_id = (halt_recv_msg.msg.data[10] 6131da177e4SLinus Torvalds | (halt_recv_msg.msg.data[11] << 8)); 6141da177e4SLinus Torvalds capabilities = halt_recv_msg.msg.data[6]; 615168524d6SCorey Minyard ipmi_version = halt_recv_msg.msg.data[5]; 6161da177e4SLinus Torvalds 6171da177e4SLinus Torvalds 6181da177e4SLinus Torvalds /* Scan for a poweroff method */ 6191da177e4SLinus Torvalds for (i = 0; i < NUM_PO_FUNCS; i++) { 6201da177e4SLinus Torvalds if (poweroff_functions[i].detect(ipmi_user)) 6211da177e4SLinus Torvalds goto found; 6221da177e4SLinus Torvalds } 6231da177e4SLinus Torvalds 6241da177e4SLinus Torvalds out_err: 6251da177e4SLinus Torvalds printk(KERN_ERR PFX "Unable to find a poweroff function that" 6261da177e4SLinus Torvalds " will work, giving up\n"); 6271da177e4SLinus Torvalds ipmi_destroy_user(ipmi_user); 6281da177e4SLinus Torvalds return; 6291da177e4SLinus Torvalds 6301da177e4SLinus Torvalds found: 6311da177e4SLinus Torvalds printk(KERN_INFO PFX "Found a %s style poweroff function\n", 6321da177e4SLinus Torvalds poweroff_functions[i].platform_type); 6331da177e4SLinus Torvalds specific_poweroff_func = poweroff_functions[i].poweroff_func; 6341da177e4SLinus Torvalds old_poweroff_func = pm_power_off; 6351da177e4SLinus Torvalds pm_power_off = ipmi_poweroff_function; 6361da177e4SLinus Torvalds ready = 1; 6371da177e4SLinus Torvalds } 6381da177e4SLinus Torvalds 6391da177e4SLinus Torvalds static void ipmi_po_smi_gone(int if_num) 6401da177e4SLinus Torvalds { 641b2c03941SCorey Minyard if (!ready) 642b2c03941SCorey Minyard return; 643b2c03941SCorey Minyard 644b2c03941SCorey Minyard if (ipmi_ifnum != if_num) 645b2c03941SCorey Minyard return; 646b2c03941SCorey Minyard 647b2c03941SCorey Minyard ready = 0; 648b2c03941SCorey Minyard ipmi_destroy_user(ipmi_user); 649b2c03941SCorey Minyard pm_power_off = old_poweroff_func; 6501da177e4SLinus Torvalds } 6511da177e4SLinus Torvalds 65236c7dc44SCorey Minyard static struct ipmi_smi_watcher smi_watcher = { 6531da177e4SLinus Torvalds .owner = THIS_MODULE, 6541da177e4SLinus Torvalds .new_smi = ipmi_po_new_smi, 6551da177e4SLinus Torvalds .smi_gone = ipmi_po_smi_gone 6561da177e4SLinus Torvalds }; 6571da177e4SLinus Torvalds 6581da177e4SLinus Torvalds 6593b625943SCorey Minyard #ifdef CONFIG_PROC_FS 6608c702e16SCorey Minyard #include <linux/sysctl.h> 6613b625943SCorey Minyard 662a151427eSJoe Perches static struct ctl_table ipmi_table[] = { 663894d2491SEric W. Biederman { .procname = "poweroff_powercycle", 6648c702e16SCorey Minyard .data = &poweroff_powercycle, 6658c702e16SCorey Minyard .maxlen = sizeof(poweroff_powercycle), 6668c702e16SCorey Minyard .mode = 0644, 6676d456111SEric W. Biederman .proc_handler = proc_dointvec }, 6688c702e16SCorey Minyard { } 6698c702e16SCorey Minyard }; 6703b625943SCorey Minyard 671a151427eSJoe Perches static struct ctl_table ipmi_dir_table[] = { 672894d2491SEric W. Biederman { .procname = "ipmi", 6738c702e16SCorey Minyard .mode = 0555, 6748c702e16SCorey Minyard .child = ipmi_table }, 6758c702e16SCorey Minyard { } 6768c702e16SCorey Minyard }; 6773b625943SCorey Minyard 678a151427eSJoe Perches static struct ctl_table ipmi_root_table[] = { 679894d2491SEric W. Biederman { .procname = "dev", 6808c702e16SCorey Minyard .mode = 0555, 6818c702e16SCorey Minyard .child = ipmi_dir_table }, 6828c702e16SCorey Minyard { } 6838c702e16SCorey Minyard }; 6843b625943SCorey Minyard 6858c702e16SCorey Minyard static struct ctl_table_header *ipmi_table_header; 6863b625943SCorey Minyard #endif /* CONFIG_PROC_FS */ 6873b625943SCorey Minyard 6881da177e4SLinus Torvalds /* 6891da177e4SLinus Torvalds * Startup and shutdown functions. 6901da177e4SLinus Torvalds */ 6910e6b9e8cSPeter Huewe static int __init ipmi_poweroff_init(void) 6921da177e4SLinus Torvalds { 6931da177e4SLinus Torvalds int rv; 6941da177e4SLinus Torvalds 695e5fa4998SDan Aloni printk(KERN_INFO "Copyright (C) 2004 MontaVista Software -" 6961fdd75bdSCorey Minyard " IPMI Powerdown via sys_reboot.\n"); 6971da177e4SLinus Torvalds 6988c702e16SCorey Minyard if (poweroff_powercycle) 6993b625943SCorey Minyard printk(KERN_INFO PFX "Power cycle is enabled.\n"); 7001da177e4SLinus Torvalds 7018c702e16SCorey Minyard #ifdef CONFIG_PROC_FS 7020b4d4147SEric W. Biederman ipmi_table_header = register_sysctl_table(ipmi_root_table); 7038c702e16SCorey Minyard if (!ipmi_table_header) { 7048c702e16SCorey Minyard printk(KERN_ERR PFX "Unable to register powercycle sysctl\n"); 7058c702e16SCorey Minyard rv = -ENOMEM; 7068c702e16SCorey Minyard goto out_err; 7073b625943SCorey Minyard } 7088c702e16SCorey Minyard #endif 7093b625943SCorey Minyard 7103b625943SCorey Minyard rv = ipmi_smi_watcher_register(&smi_watcher); 711be4f1bb2SAdrian Bunk 712be4f1bb2SAdrian Bunk #ifdef CONFIG_PROC_FS 7133b625943SCorey Minyard if (rv) { 7148c702e16SCorey Minyard unregister_sysctl_table(ipmi_table_header); 7153b625943SCorey Minyard printk(KERN_ERR PFX "Unable to register SMI watcher: %d\n", rv); 7163b625943SCorey Minyard goto out_err; 7173b625943SCorey Minyard } 7183b625943SCorey Minyard 7193b625943SCorey Minyard out_err: 7201aa16eeaSRandy Dunlap #endif 7211da177e4SLinus Torvalds return rv; 7221da177e4SLinus Torvalds } 7231da177e4SLinus Torvalds 7241da177e4SLinus Torvalds #ifdef MODULE 7250e6b9e8cSPeter Huewe static void __exit ipmi_poweroff_cleanup(void) 7261da177e4SLinus Torvalds { 7271da177e4SLinus Torvalds int rv; 7281da177e4SLinus Torvalds 7293b625943SCorey Minyard #ifdef CONFIG_PROC_FS 7308c702e16SCorey Minyard unregister_sysctl_table(ipmi_table_header); 7313b625943SCorey Minyard #endif 7323b625943SCorey Minyard 7331da177e4SLinus Torvalds ipmi_smi_watcher_unregister(&smi_watcher); 7341da177e4SLinus Torvalds 7351da177e4SLinus Torvalds if (ready) { 7361da177e4SLinus Torvalds rv = ipmi_destroy_user(ipmi_user); 7371da177e4SLinus Torvalds if (rv) 7381da177e4SLinus Torvalds printk(KERN_ERR PFX "could not cleanup the IPMI" 7391da177e4SLinus Torvalds " user: 0x%x\n", rv); 7401da177e4SLinus Torvalds pm_power_off = old_poweroff_func; 7411da177e4SLinus Torvalds } 7421da177e4SLinus Torvalds } 7431da177e4SLinus Torvalds module_exit(ipmi_poweroff_cleanup); 7441da177e4SLinus Torvalds #endif 7451da177e4SLinus Torvalds 7461da177e4SLinus Torvalds module_init(ipmi_poweroff_init); 7471da177e4SLinus Torvalds MODULE_LICENSE("GPL"); 7481fdd75bdSCorey Minyard MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>"); 7491fdd75bdSCorey Minyard MODULE_DESCRIPTION("IPMI Poweroff extension to sys_reboot"); 750