4 * MontaVista IPMI Poweroff extension to sys_reboot
6 * Author: MontaVista Software, Inc.
7 * Steven Dake <sdake@mvista.com>
8 * Corey Minyard <cminyard@mvista.com>
11 * Copyright 2002,2004 MontaVista Software Inc.
13 * This program is free software; you can redistribute it and/or modify it
14 * under the terms of the GNU General Public License as published by the
15 * Free Software Foundation; either version 2 of the License, or (at your
16 * option) any later version.
19 * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
20 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
21 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
22 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
23 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
24 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
25 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
26 * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
27 * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
28 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30 * You should have received a copy of the GNU General Public License along
31 * with this program; if not, write to the Free Software Foundation, Inc.,
32 * 675 Mass Ave, Cambridge, MA 02139, USA.
34 #include <linux/module.h>
35 #include <linux/moduleparam.h>
36 #include <linux/proc_fs.h>
37 #include <linux/string.h>
38 #include <linux/completion.h>
40 #include <linux/kdev_t.h>
41 #include <linux/ipmi.h>
42 #include <linux/ipmi_smi.h>
44 #define PFX "IPMI poweroff: "
46 static void ipmi_po_smi_gone(int if_num);
47 static void ipmi_po_new_smi(int if_num, struct device *device);
49 /* Definitions for controlling power off (if the system supports it). It
50 * conveniently matches the IPMI chassis control values. */
51 #define IPMI_CHASSIS_POWER_DOWN 0 /* power down, the default. */
52 #define IPMI_CHASSIS_POWER_CYCLE 0x02 /* power cycle */
54 /* the IPMI data command */
55 static int poweroff_powercycle;
57 /* Which interface to use, -1 means the first we see. */
58 static int ifnum_to_use = -1;
60 /* Our local state. */
62 static ipmi_user_t ipmi_user;
63 static int ipmi_ifnum;
64 static void (*specific_poweroff_func)(ipmi_user_t user) = NULL;
66 /* Holds the old poweroff function so we can restore it on removal. */
67 static void (*old_poweroff_func)(void);
69 static int set_param_ifnum(const char *val, struct kernel_param *kp)
71 int rv = param_set_int(val, kp);
74 if ((ifnum_to_use < 0) || (ifnum_to_use == ipmi_ifnum))
77 ipmi_po_smi_gone(ipmi_ifnum);
78 ipmi_po_new_smi(ifnum_to_use, NULL);
82 module_param_call(ifnum_to_use, set_param_ifnum, param_get_int,
84 MODULE_PARM_DESC(ifnum_to_use, "The interface number to use for the watchdog "
85 "timer. Setting to -1 defaults to the first registered "
88 /* parameter definition to allow user to flag power cycle */
89 module_param(poweroff_powercycle, int, 0644);
90 MODULE_PARM_DESC(poweroff_powercycle, " Set to non-zero to enable power cycle instead of power down. Power cycle is contingent on hardware support, otherwise it defaults back to power down.");
92 /* Stuff from the get device id command. */
93 static unsigned int mfg_id;
94 static unsigned int prod_id;
95 static unsigned char capabilities;
96 static unsigned char ipmi_version;
98 /* We use our own messages for this operation, we don't let the system
99 allocate them, since we may be in a panic situation. The whole
100 thing is single-threaded, anyway, so multiple messages are not
102 static void dummy_smi_free(struct ipmi_smi_msg *msg)
105 static void dummy_recv_free(struct ipmi_recv_msg *msg)
108 static struct ipmi_smi_msg halt_smi_msg =
110 .done = dummy_smi_free
112 static struct ipmi_recv_msg halt_recv_msg =
114 .done = dummy_recv_free
119 * Code to send a message and wait for the reponse.
122 static void receive_handler(struct ipmi_recv_msg *recv_msg, void *handler_data)
124 struct completion *comp = recv_msg->user_msg_data;
130 static struct ipmi_user_hndl ipmi_poweroff_handler =
132 .ipmi_recv_hndl = receive_handler
136 static int ipmi_request_wait_for_response(ipmi_user_t user,
137 struct ipmi_addr *addr,
138 struct kernel_ipmi_msg *send_msg)
141 struct completion comp;
143 init_completion(&comp);
145 rv = ipmi_request_supply_msgs(user, addr, 0, send_msg, &comp,
146 &halt_smi_msg, &halt_recv_msg, 0);
150 wait_for_completion(&comp);
152 return halt_recv_msg.msg.data[0];
155 /* We are in run-to-completion mode, no completion is desired. */
156 static int ipmi_request_in_rc_mode(ipmi_user_t user,
157 struct ipmi_addr *addr,
158 struct kernel_ipmi_msg *send_msg)
162 rv = ipmi_request_supply_msgs(user, addr, 0, send_msg, NULL,
163 &halt_smi_msg, &halt_recv_msg, 0);
167 return halt_recv_msg.msg.data[0];
174 #define IPMI_NETFN_ATCA 0x2c
175 #define IPMI_ATCA_SET_POWER_CMD 0x11
176 #define IPMI_ATCA_GET_ADDR_INFO_CMD 0x01
177 #define IPMI_PICMG_ID 0
179 static int ipmi_atca_detect (ipmi_user_t user)
181 struct ipmi_system_interface_addr smi_addr;
182 struct kernel_ipmi_msg send_msg;
184 unsigned char data[1];
187 * Configure IPMI address for local access
189 smi_addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
190 smi_addr.channel = IPMI_BMC_CHANNEL;
194 * Use get address info to check and see if we are ATCA
196 send_msg.netfn = IPMI_NETFN_ATCA;
197 send_msg.cmd = IPMI_ATCA_GET_ADDR_INFO_CMD;
198 data[0] = IPMI_PICMG_ID;
199 send_msg.data = data;
200 send_msg.data_len = sizeof(data);
201 rv = ipmi_request_wait_for_response(user,
202 (struct ipmi_addr *) &smi_addr,
207 static void ipmi_poweroff_atca (ipmi_user_t user)
209 struct ipmi_system_interface_addr smi_addr;
210 struct kernel_ipmi_msg send_msg;
212 unsigned char data[4];
215 * Configure IPMI address for local access
217 smi_addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
218 smi_addr.channel = IPMI_BMC_CHANNEL;
221 printk(KERN_INFO PFX "Powering down via ATCA power command\n");
226 send_msg.netfn = IPMI_NETFN_ATCA;
227 send_msg.cmd = IPMI_ATCA_SET_POWER_CMD;
228 data[0] = IPMI_PICMG_ID;
229 data[1] = 0; /* FRU id */
230 data[2] = 0; /* Power Level */
231 data[3] = 0; /* Don't change saved presets */
232 send_msg.data = data;
233 send_msg.data_len = sizeof (data);
234 rv = ipmi_request_in_rc_mode(user,
235 (struct ipmi_addr *) &smi_addr,
238 printk(KERN_ERR PFX "Unable to send ATCA powerdown message,"
239 " IPMI error 0x%x\n", rv);
251 #define IPMI_NETFN_OEM_1 0xf8
252 #define OEM_GRP_CMD_SET_RESET_STATE 0x84
253 #define OEM_GRP_CMD_SET_POWER_STATE 0x82
254 #define IPMI_NETFN_OEM_8 0xf8
255 #define OEM_GRP_CMD_REQUEST_HOTSWAP_CTRL 0x80
256 #define OEM_GRP_CMD_GET_SLOT_GA 0xa3
257 #define IPMI_NETFN_SENSOR_EVT 0x10
258 #define IPMI_CMD_GET_EVENT_RECEIVER 0x01
260 #define IPMI_CPI1_PRODUCT_ID 0x000157
261 #define IPMI_CPI1_MANUFACTURER_ID 0x0108
263 static int ipmi_cpi1_detect (ipmi_user_t user)
265 return ((mfg_id == IPMI_CPI1_MANUFACTURER_ID)
266 && (prod_id == IPMI_CPI1_PRODUCT_ID));
269 static void ipmi_poweroff_cpi1 (ipmi_user_t user)
271 struct ipmi_system_interface_addr smi_addr;
272 struct ipmi_ipmb_addr ipmb_addr;
273 struct kernel_ipmi_msg send_msg;
275 unsigned char data[1];
277 unsigned char hotswap_ipmb;
278 unsigned char aer_addr;
279 unsigned char aer_lun;
282 * Configure IPMI address for local access
284 smi_addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
285 smi_addr.channel = IPMI_BMC_CHANNEL;
288 printk(KERN_INFO PFX "Powering down via CPI1 power command\n");
291 * Get IPMI ipmb address
293 send_msg.netfn = IPMI_NETFN_OEM_8 >> 2;
294 send_msg.cmd = OEM_GRP_CMD_GET_SLOT_GA;
295 send_msg.data = NULL;
296 send_msg.data_len = 0;
297 rv = ipmi_request_in_rc_mode(user,
298 (struct ipmi_addr *) &smi_addr,
302 slot = halt_recv_msg.msg.data[1];
303 hotswap_ipmb = (slot > 9) ? (0xb0 + 2 * slot) : (0xae + 2 * slot);
306 * Get active event receiver
308 send_msg.netfn = IPMI_NETFN_SENSOR_EVT >> 2;
309 send_msg.cmd = IPMI_CMD_GET_EVENT_RECEIVER;
310 send_msg.data = NULL;
311 send_msg.data_len = 0;
312 rv = ipmi_request_in_rc_mode(user,
313 (struct ipmi_addr *) &smi_addr,
317 aer_addr = halt_recv_msg.msg.data[1];
318 aer_lun = halt_recv_msg.msg.data[2];
321 * Setup IPMB address target instead of local target
323 ipmb_addr.addr_type = IPMI_IPMB_ADDR_TYPE;
324 ipmb_addr.channel = 0;
325 ipmb_addr.slave_addr = aer_addr;
326 ipmb_addr.lun = aer_lun;
329 * Send request hotswap control to remove blade from dpv
331 send_msg.netfn = IPMI_NETFN_OEM_8 >> 2;
332 send_msg.cmd = OEM_GRP_CMD_REQUEST_HOTSWAP_CTRL;
333 send_msg.data = &hotswap_ipmb;
334 send_msg.data_len = 1;
335 ipmi_request_in_rc_mode(user,
336 (struct ipmi_addr *) &ipmb_addr,
342 send_msg.netfn = IPMI_NETFN_OEM_1 >> 2;
343 send_msg.cmd = OEM_GRP_CMD_SET_RESET_STATE;
344 send_msg.data = data;
345 data[0] = 1; /* Reset asserted state */
346 send_msg.data_len = 1;
347 rv = ipmi_request_in_rc_mode(user,
348 (struct ipmi_addr *) &smi_addr,
356 send_msg.netfn = IPMI_NETFN_OEM_1 >> 2;
357 send_msg.cmd = OEM_GRP_CMD_SET_POWER_STATE;
358 send_msg.data = data;
359 data[0] = 1; /* Power down state */
360 send_msg.data_len = 1;
361 rv = ipmi_request_in_rc_mode(user,
362 (struct ipmi_addr *) &smi_addr,
372 * ipmi_dell_chassis_detect()
373 * Dell systems with IPMI < 1.5 don't set the chassis capability bit
374 * but they can handle a chassis poweroff or powercycle command.
377 #define DELL_IANA_MFR_ID {0xA2, 0x02, 0x00}
378 static int ipmi_dell_chassis_detect (ipmi_user_t user)
380 const char ipmi_version_major = ipmi_version & 0xF;
381 const char ipmi_version_minor = (ipmi_version >> 4) & 0xF;
382 const char mfr[3] = DELL_IANA_MFR_ID;
383 if (!memcmp(mfr, &mfg_id, sizeof(mfr)) &&
384 ipmi_version_major <= 1 &&
385 ipmi_version_minor < 5)
391 * Standard chassis support
394 #define IPMI_NETFN_CHASSIS_REQUEST 0
395 #define IPMI_CHASSIS_CONTROL_CMD 0x02
397 static int ipmi_chassis_detect (ipmi_user_t user)
399 /* Chassis support, use it. */
400 return (capabilities & 0x80);
403 static void ipmi_poweroff_chassis (ipmi_user_t user)
405 struct ipmi_system_interface_addr smi_addr;
406 struct kernel_ipmi_msg send_msg;
408 unsigned char data[1];
411 * Configure IPMI address for local access
413 smi_addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
414 smi_addr.channel = IPMI_BMC_CHANNEL;
418 printk(KERN_INFO PFX "Powering %s via IPMI chassis control command\n",
419 (poweroff_powercycle ? "cycle" : "down"));
424 send_msg.netfn = IPMI_NETFN_CHASSIS_REQUEST;
425 send_msg.cmd = IPMI_CHASSIS_CONTROL_CMD;
426 if (poweroff_powercycle)
427 data[0] = IPMI_CHASSIS_POWER_CYCLE;
429 data[0] = IPMI_CHASSIS_POWER_DOWN;
430 send_msg.data = data;
431 send_msg.data_len = sizeof(data);
432 rv = ipmi_request_in_rc_mode(user,
433 (struct ipmi_addr *) &smi_addr,
436 if (poweroff_powercycle) {
437 /* power cycle failed, default to power down */
438 printk(KERN_ERR PFX "Unable to send chassis power " \
439 "cycle message, IPMI error 0x%x\n", rv);
440 poweroff_powercycle = 0;
441 goto powercyclefailed;
444 printk(KERN_ERR PFX "Unable to send chassis power " \
445 "down message, IPMI error 0x%x\n", rv);
450 /* Table of possible power off functions. */
451 struct poweroff_function {
453 int (*detect)(ipmi_user_t user);
454 void (*poweroff_func)(ipmi_user_t user);
457 static struct poweroff_function poweroff_functions[] = {
458 { .platform_type = "ATCA",
459 .detect = ipmi_atca_detect,
460 .poweroff_func = ipmi_poweroff_atca },
461 { .platform_type = "CPI1",
462 .detect = ipmi_cpi1_detect,
463 .poweroff_func = ipmi_poweroff_cpi1 },
464 { .platform_type = "chassis",
465 .detect = ipmi_dell_chassis_detect,
466 .poweroff_func = ipmi_poweroff_chassis },
467 /* Chassis should generally be last, other things should override
469 { .platform_type = "chassis",
470 .detect = ipmi_chassis_detect,
471 .poweroff_func = ipmi_poweroff_chassis },
473 #define NUM_PO_FUNCS (sizeof(poweroff_functions) \
474 / sizeof(struct poweroff_function))
477 /* Called on a powerdown request. */
478 static void ipmi_poweroff_function (void)
483 /* Use run-to-completion mode, since interrupts may be off. */
484 ipmi_user_set_run_to_completion(ipmi_user, 1);
485 specific_poweroff_func(ipmi_user);
486 ipmi_user_set_run_to_completion(ipmi_user, 0);
489 /* Wait for an IPMI interface to be installed, the first one installed
490 will be grabbed by this code and used to perform the powerdown. */
491 static void ipmi_po_new_smi(int if_num, struct device *device)
493 struct ipmi_system_interface_addr smi_addr;
494 struct kernel_ipmi_msg send_msg;
501 if ((ifnum_to_use >= 0) && (ifnum_to_use != if_num))
504 rv = ipmi_create_user(if_num, &ipmi_poweroff_handler, NULL,
507 printk(KERN_ERR PFX "could not create IPMI user, error %d\n",
515 * Do a get device ide and store some results, since this is
516 * used by several functions.
518 smi_addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
519 smi_addr.channel = IPMI_BMC_CHANNEL;
522 send_msg.netfn = IPMI_NETFN_APP_REQUEST;
523 send_msg.cmd = IPMI_GET_DEVICE_ID_CMD;
524 send_msg.data = NULL;
525 send_msg.data_len = 0;
526 rv = ipmi_request_wait_for_response(ipmi_user,
527 (struct ipmi_addr *) &smi_addr,
530 printk(KERN_ERR PFX "Unable to send IPMI get device id info,"
531 " IPMI error 0x%x\n", rv);
535 if (halt_recv_msg.msg.data_len < 12) {
536 printk(KERN_ERR PFX "(chassis) IPMI get device id info too,"
537 " short, was %d bytes, needed %d bytes\n",
538 halt_recv_msg.msg.data_len, 12);
542 mfg_id = (halt_recv_msg.msg.data[7]
543 | (halt_recv_msg.msg.data[8] << 8)
544 | (halt_recv_msg.msg.data[9] << 16));
545 prod_id = (halt_recv_msg.msg.data[10]
546 | (halt_recv_msg.msg.data[11] << 8));
547 capabilities = halt_recv_msg.msg.data[6];
548 ipmi_version = halt_recv_msg.msg.data[5];
551 /* Scan for a poweroff method */
552 for (i = 0; i < NUM_PO_FUNCS; i++) {
553 if (poweroff_functions[i].detect(ipmi_user))
558 printk(KERN_ERR PFX "Unable to find a poweroff function that"
559 " will work, giving up\n");
560 ipmi_destroy_user(ipmi_user);
564 printk(KERN_INFO PFX "Found a %s style poweroff function\n",
565 poweroff_functions[i].platform_type);
566 specific_poweroff_func = poweroff_functions[i].poweroff_func;
567 old_poweroff_func = pm_power_off;
568 pm_power_off = ipmi_poweroff_function;
572 static void ipmi_po_smi_gone(int if_num)
577 if (ipmi_ifnum != if_num)
581 ipmi_destroy_user(ipmi_user);
582 pm_power_off = old_poweroff_func;
585 static struct ipmi_smi_watcher smi_watcher =
587 .owner = THIS_MODULE,
588 .new_smi = ipmi_po_new_smi,
589 .smi_gone = ipmi_po_smi_gone
593 #ifdef CONFIG_PROC_FS
594 #include <linux/sysctl.h>
596 static ctl_table ipmi_table[] = {
597 { .ctl_name = DEV_IPMI_POWEROFF_POWERCYCLE,
598 .procname = "poweroff_powercycle",
599 .data = &poweroff_powercycle,
600 .maxlen = sizeof(poweroff_powercycle),
602 .proc_handler = &proc_dointvec },
606 static ctl_table ipmi_dir_table[] = {
607 { .ctl_name = DEV_IPMI,
610 .child = ipmi_table },
614 static ctl_table ipmi_root_table[] = {
615 { .ctl_name = CTL_DEV,
618 .child = ipmi_dir_table },
622 static struct ctl_table_header *ipmi_table_header;
623 #endif /* CONFIG_PROC_FS */
626 * Startup and shutdown functions.
628 static int ipmi_poweroff_init (void)
632 printk ("Copyright (C) 2004 MontaVista Software -"
633 " IPMI Powerdown via sys_reboot.\n");
635 if (poweroff_powercycle)
636 printk(KERN_INFO PFX "Power cycle is enabled.\n");
638 #ifdef CONFIG_PROC_FS
639 ipmi_table_header = register_sysctl_table(ipmi_root_table, 1);
640 if (!ipmi_table_header) {
641 printk(KERN_ERR PFX "Unable to register powercycle sysctl\n");
647 rv = ipmi_smi_watcher_register(&smi_watcher);
649 #ifdef CONFIG_PROC_FS
651 unregister_sysctl_table(ipmi_table_header);
652 printk(KERN_ERR PFX "Unable to register SMI watcher: %d\n", rv);
662 static __exit void ipmi_poweroff_cleanup(void)
666 #ifdef CONFIG_PROC_FS
667 unregister_sysctl_table(ipmi_table_header);
670 ipmi_smi_watcher_unregister(&smi_watcher);
673 rv = ipmi_destroy_user(ipmi_user);
675 printk(KERN_ERR PFX "could not cleanup the IPMI"
676 " user: 0x%x\n", rv);
677 pm_power_off = old_poweroff_func;
680 module_exit(ipmi_poweroff_cleanup);
683 module_init(ipmi_poweroff_init);
684 MODULE_LICENSE("GPL");
685 MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>");
686 MODULE_DESCRIPTION("IPMI Poweroff extension to sys_reboot");