1 /* 2 * ipmi_poweroff.c 3 * 4 * MontaVista IPMI Poweroff extension to sys_reboot 5 * 6 * Author: MontaVista Software, Inc. 7 * Steven Dake <sdake@mvista.com> 8 * Corey Minyard <cminyard@mvista.com> 9 * source@mvista.com 10 * 11 * Copyright 2002,2004 MontaVista Software Inc. 12 * 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. 17 * 18 * 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. 29 * 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. 33 */ 34 #include <linux/config.h> 35 #include <linux/module.h> 36 #include <linux/moduleparam.h> 37 #include <linux/proc_fs.h> 38 #include <linux/string.h> 39 #include <linux/completion.h> 40 #include <linux/pm.h> 41 #include <linux/kdev_t.h> 42 #include <linux/ipmi.h> 43 #include <linux/ipmi_smi.h> 44 45 #define PFX "IPMI poweroff: " 46 47 /* Definitions for controlling power off (if the system supports it). It 48 * conveniently matches the IPMI chassis control values. */ 49 #define IPMI_CHASSIS_POWER_DOWN 0 /* power down, the default. */ 50 #define IPMI_CHASSIS_POWER_CYCLE 0x02 /* power cycle */ 51 52 /* the IPMI data command */ 53 static int poweroff_powercycle; 54 55 /* parameter definition to allow user to flag power cycle */ 56 module_param(poweroff_powercycle, int, 0644); 57 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."); 58 59 /* Stuff from the get device id command. */ 60 static unsigned int mfg_id; 61 static unsigned int prod_id; 62 static unsigned char capabilities; 63 static unsigned char ipmi_version; 64 65 /* We use our own messages for this operation, we don't let the system 66 allocate them, since we may be in a panic situation. The whole 67 thing is single-threaded, anyway, so multiple messages are not 68 required. */ 69 static void dummy_smi_free(struct ipmi_smi_msg *msg) 70 { 71 } 72 static void dummy_recv_free(struct ipmi_recv_msg *msg) 73 { 74 } 75 static struct ipmi_smi_msg halt_smi_msg = 76 { 77 .done = dummy_smi_free 78 }; 79 static struct ipmi_recv_msg halt_recv_msg = 80 { 81 .done = dummy_recv_free 82 }; 83 84 85 /* 86 * Code to send a message and wait for the reponse. 87 */ 88 89 static void receive_handler(struct ipmi_recv_msg *recv_msg, void *handler_data) 90 { 91 struct completion *comp = recv_msg->user_msg_data; 92 93 if (comp) 94 complete(comp); 95 } 96 97 static struct ipmi_user_hndl ipmi_poweroff_handler = 98 { 99 .ipmi_recv_hndl = receive_handler 100 }; 101 102 103 static int ipmi_request_wait_for_response(ipmi_user_t user, 104 struct ipmi_addr *addr, 105 struct kernel_ipmi_msg *send_msg) 106 { 107 int rv; 108 struct completion comp; 109 110 init_completion(&comp); 111 112 rv = ipmi_request_supply_msgs(user, addr, 0, send_msg, &comp, 113 &halt_smi_msg, &halt_recv_msg, 0); 114 if (rv) 115 return rv; 116 117 wait_for_completion(&comp); 118 119 return halt_recv_msg.msg.data[0]; 120 } 121 122 /* We are in run-to-completion mode, no completion is desired. */ 123 static int ipmi_request_in_rc_mode(ipmi_user_t user, 124 struct ipmi_addr *addr, 125 struct kernel_ipmi_msg *send_msg) 126 { 127 int rv; 128 129 rv = ipmi_request_supply_msgs(user, addr, 0, send_msg, NULL, 130 &halt_smi_msg, &halt_recv_msg, 0); 131 if (rv) 132 return rv; 133 134 return halt_recv_msg.msg.data[0]; 135 } 136 137 /* 138 * ATCA Support 139 */ 140 141 #define IPMI_NETFN_ATCA 0x2c 142 #define IPMI_ATCA_SET_POWER_CMD 0x11 143 #define IPMI_ATCA_GET_ADDR_INFO_CMD 0x01 144 #define IPMI_PICMG_ID 0 145 146 static int ipmi_atca_detect (ipmi_user_t user) 147 { 148 struct ipmi_system_interface_addr smi_addr; 149 struct kernel_ipmi_msg send_msg; 150 int rv; 151 unsigned char data[1]; 152 153 /* 154 * Configure IPMI address for local access 155 */ 156 smi_addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE; 157 smi_addr.channel = IPMI_BMC_CHANNEL; 158 smi_addr.lun = 0; 159 160 /* 161 * Use get address info to check and see if we are ATCA 162 */ 163 send_msg.netfn = IPMI_NETFN_ATCA; 164 send_msg.cmd = IPMI_ATCA_GET_ADDR_INFO_CMD; 165 data[0] = IPMI_PICMG_ID; 166 send_msg.data = data; 167 send_msg.data_len = sizeof(data); 168 rv = ipmi_request_wait_for_response(user, 169 (struct ipmi_addr *) &smi_addr, 170 &send_msg); 171 return !rv; 172 } 173 174 static void ipmi_poweroff_atca (ipmi_user_t user) 175 { 176 struct ipmi_system_interface_addr smi_addr; 177 struct kernel_ipmi_msg send_msg; 178 int rv; 179 unsigned char data[4]; 180 181 /* 182 * Configure IPMI address for local access 183 */ 184 smi_addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE; 185 smi_addr.channel = IPMI_BMC_CHANNEL; 186 smi_addr.lun = 0; 187 188 printk(KERN_INFO PFX "Powering down via ATCA power command\n"); 189 190 /* 191 * Power down 192 */ 193 send_msg.netfn = IPMI_NETFN_ATCA; 194 send_msg.cmd = IPMI_ATCA_SET_POWER_CMD; 195 data[0] = IPMI_PICMG_ID; 196 data[1] = 0; /* FRU id */ 197 data[2] = 0; /* Power Level */ 198 data[3] = 0; /* Don't change saved presets */ 199 send_msg.data = data; 200 send_msg.data_len = sizeof (data); 201 rv = ipmi_request_in_rc_mode(user, 202 (struct ipmi_addr *) &smi_addr, 203 &send_msg); 204 if (rv) { 205 printk(KERN_ERR PFX "Unable to send ATCA powerdown message," 206 " IPMI error 0x%x\n", rv); 207 goto out; 208 } 209 210 out: 211 return; 212 } 213 214 /* 215 * CPI1 Support 216 */ 217 218 #define IPMI_NETFN_OEM_1 0xf8 219 #define OEM_GRP_CMD_SET_RESET_STATE 0x84 220 #define OEM_GRP_CMD_SET_POWER_STATE 0x82 221 #define IPMI_NETFN_OEM_8 0xf8 222 #define OEM_GRP_CMD_REQUEST_HOTSWAP_CTRL 0x80 223 #define OEM_GRP_CMD_GET_SLOT_GA 0xa3 224 #define IPMI_NETFN_SENSOR_EVT 0x10 225 #define IPMI_CMD_GET_EVENT_RECEIVER 0x01 226 227 #define IPMI_CPI1_PRODUCT_ID 0x000157 228 #define IPMI_CPI1_MANUFACTURER_ID 0x0108 229 230 static int ipmi_cpi1_detect (ipmi_user_t user) 231 { 232 return ((mfg_id == IPMI_CPI1_MANUFACTURER_ID) 233 && (prod_id == IPMI_CPI1_PRODUCT_ID)); 234 } 235 236 static void ipmi_poweroff_cpi1 (ipmi_user_t user) 237 { 238 struct ipmi_system_interface_addr smi_addr; 239 struct ipmi_ipmb_addr ipmb_addr; 240 struct kernel_ipmi_msg send_msg; 241 int rv; 242 unsigned char data[1]; 243 int slot; 244 unsigned char hotswap_ipmb; 245 unsigned char aer_addr; 246 unsigned char aer_lun; 247 248 /* 249 * Configure IPMI address for local access 250 */ 251 smi_addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE; 252 smi_addr.channel = IPMI_BMC_CHANNEL; 253 smi_addr.lun = 0; 254 255 printk(KERN_INFO PFX "Powering down via CPI1 power command\n"); 256 257 /* 258 * Get IPMI ipmb address 259 */ 260 send_msg.netfn = IPMI_NETFN_OEM_8 >> 2; 261 send_msg.cmd = OEM_GRP_CMD_GET_SLOT_GA; 262 send_msg.data = NULL; 263 send_msg.data_len = 0; 264 rv = ipmi_request_in_rc_mode(user, 265 (struct ipmi_addr *) &smi_addr, 266 &send_msg); 267 if (rv) 268 goto out; 269 slot = halt_recv_msg.msg.data[1]; 270 hotswap_ipmb = (slot > 9) ? (0xb0 + 2 * slot) : (0xae + 2 * slot); 271 272 /* 273 * Get active event receiver 274 */ 275 send_msg.netfn = IPMI_NETFN_SENSOR_EVT >> 2; 276 send_msg.cmd = IPMI_CMD_GET_EVENT_RECEIVER; 277 send_msg.data = NULL; 278 send_msg.data_len = 0; 279 rv = ipmi_request_in_rc_mode(user, 280 (struct ipmi_addr *) &smi_addr, 281 &send_msg); 282 if (rv) 283 goto out; 284 aer_addr = halt_recv_msg.msg.data[1]; 285 aer_lun = halt_recv_msg.msg.data[2]; 286 287 /* 288 * Setup IPMB address target instead of local target 289 */ 290 ipmb_addr.addr_type = IPMI_IPMB_ADDR_TYPE; 291 ipmb_addr.channel = 0; 292 ipmb_addr.slave_addr = aer_addr; 293 ipmb_addr.lun = aer_lun; 294 295 /* 296 * Send request hotswap control to remove blade from dpv 297 */ 298 send_msg.netfn = IPMI_NETFN_OEM_8 >> 2; 299 send_msg.cmd = OEM_GRP_CMD_REQUEST_HOTSWAP_CTRL; 300 send_msg.data = &hotswap_ipmb; 301 send_msg.data_len = 1; 302 ipmi_request_in_rc_mode(user, 303 (struct ipmi_addr *) &ipmb_addr, 304 &send_msg); 305 306 /* 307 * Set reset asserted 308 */ 309 send_msg.netfn = IPMI_NETFN_OEM_1 >> 2; 310 send_msg.cmd = OEM_GRP_CMD_SET_RESET_STATE; 311 send_msg.data = data; 312 data[0] = 1; /* Reset asserted state */ 313 send_msg.data_len = 1; 314 rv = ipmi_request_in_rc_mode(user, 315 (struct ipmi_addr *) &smi_addr, 316 &send_msg); 317 if (rv) 318 goto out; 319 320 /* 321 * Power down 322 */ 323 send_msg.netfn = IPMI_NETFN_OEM_1 >> 2; 324 send_msg.cmd = OEM_GRP_CMD_SET_POWER_STATE; 325 send_msg.data = data; 326 data[0] = 1; /* Power down state */ 327 send_msg.data_len = 1; 328 rv = ipmi_request_in_rc_mode(user, 329 (struct ipmi_addr *) &smi_addr, 330 &send_msg); 331 if (rv) 332 goto out; 333 334 out: 335 return; 336 } 337 338 /* 339 * ipmi_dell_chassis_detect() 340 * Dell systems with IPMI < 1.5 don't set the chassis capability bit 341 * but they can handle a chassis poweroff or powercycle command. 342 */ 343 344 #define DELL_IANA_MFR_ID {0xA2, 0x02, 0x00} 345 static int ipmi_dell_chassis_detect (ipmi_user_t user) 346 { 347 const char ipmi_version_major = ipmi_version & 0xF; 348 const char ipmi_version_minor = (ipmi_version >> 4) & 0xF; 349 const char mfr[3] = DELL_IANA_MFR_ID; 350 if (!memcmp(mfr, &mfg_id, sizeof(mfr)) && 351 ipmi_version_major <= 1 && 352 ipmi_version_minor < 5) 353 return 1; 354 return 0; 355 } 356 357 /* 358 * Standard chassis support 359 */ 360 361 #define IPMI_NETFN_CHASSIS_REQUEST 0 362 #define IPMI_CHASSIS_CONTROL_CMD 0x02 363 364 static int ipmi_chassis_detect (ipmi_user_t user) 365 { 366 /* Chassis support, use it. */ 367 return (capabilities & 0x80); 368 } 369 370 static void ipmi_poweroff_chassis (ipmi_user_t user) 371 { 372 struct ipmi_system_interface_addr smi_addr; 373 struct kernel_ipmi_msg send_msg; 374 int rv; 375 unsigned char data[1]; 376 377 /* 378 * Configure IPMI address for local access 379 */ 380 smi_addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE; 381 smi_addr.channel = IPMI_BMC_CHANNEL; 382 smi_addr.lun = 0; 383 384 powercyclefailed: 385 printk(KERN_INFO PFX "Powering %s via IPMI chassis control command\n", 386 (poweroff_powercycle ? "cycle" : "down")); 387 388 /* 389 * Power down 390 */ 391 send_msg.netfn = IPMI_NETFN_CHASSIS_REQUEST; 392 send_msg.cmd = IPMI_CHASSIS_CONTROL_CMD; 393 if (poweroff_powercycle) 394 data[0] = IPMI_CHASSIS_POWER_CYCLE; 395 else 396 data[0] = IPMI_CHASSIS_POWER_DOWN; 397 send_msg.data = data; 398 send_msg.data_len = sizeof(data); 399 rv = ipmi_request_in_rc_mode(user, 400 (struct ipmi_addr *) &smi_addr, 401 &send_msg); 402 if (rv) { 403 if (poweroff_powercycle) { 404 /* power cycle failed, default to power down */ 405 printk(KERN_ERR PFX "Unable to send chassis power " \ 406 "cycle message, IPMI error 0x%x\n", rv); 407 poweroff_powercycle = 0; 408 goto powercyclefailed; 409 } 410 411 printk(KERN_ERR PFX "Unable to send chassis power " \ 412 "down message, IPMI error 0x%x\n", rv); 413 } 414 } 415 416 417 /* Table of possible power off functions. */ 418 struct poweroff_function { 419 char *platform_type; 420 int (*detect)(ipmi_user_t user); 421 void (*poweroff_func)(ipmi_user_t user); 422 }; 423 424 static struct poweroff_function poweroff_functions[] = { 425 { .platform_type = "ATCA", 426 .detect = ipmi_atca_detect, 427 .poweroff_func = ipmi_poweroff_atca }, 428 { .platform_type = "CPI1", 429 .detect = ipmi_cpi1_detect, 430 .poweroff_func = ipmi_poweroff_cpi1 }, 431 { .platform_type = "chassis", 432 .detect = ipmi_dell_chassis_detect, 433 .poweroff_func = ipmi_poweroff_chassis }, 434 /* Chassis should generally be last, other things should override 435 it. */ 436 { .platform_type = "chassis", 437 .detect = ipmi_chassis_detect, 438 .poweroff_func = ipmi_poweroff_chassis }, 439 }; 440 #define NUM_PO_FUNCS (sizeof(poweroff_functions) \ 441 / sizeof(struct poweroff_function)) 442 443 444 /* Our local state. */ 445 static int ready = 0; 446 static ipmi_user_t ipmi_user; 447 static void (*specific_poweroff_func)(ipmi_user_t user) = NULL; 448 449 /* Holds the old poweroff function so we can restore it on removal. */ 450 static void (*old_poweroff_func)(void); 451 452 453 /* Called on a powerdown request. */ 454 static void ipmi_poweroff_function (void) 455 { 456 if (!ready) 457 return; 458 459 /* Use run-to-completion mode, since interrupts may be off. */ 460 ipmi_user_set_run_to_completion(ipmi_user, 1); 461 specific_poweroff_func(ipmi_user); 462 ipmi_user_set_run_to_completion(ipmi_user, 0); 463 } 464 465 /* Wait for an IPMI interface to be installed, the first one installed 466 will be grabbed by this code and used to perform the powerdown. */ 467 static void ipmi_po_new_smi(int if_num, struct device *device) 468 { 469 struct ipmi_system_interface_addr smi_addr; 470 struct kernel_ipmi_msg send_msg; 471 int rv; 472 int i; 473 474 if (ready) 475 return; 476 477 rv = ipmi_create_user(if_num, &ipmi_poweroff_handler, NULL, 478 &ipmi_user); 479 if (rv) { 480 printk(KERN_ERR PFX "could not create IPMI user, error %d\n", 481 rv); 482 return; 483 } 484 485 /* 486 * Do a get device ide and store some results, since this is 487 * used by several functions. 488 */ 489 smi_addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE; 490 smi_addr.channel = IPMI_BMC_CHANNEL; 491 smi_addr.lun = 0; 492 493 send_msg.netfn = IPMI_NETFN_APP_REQUEST; 494 send_msg.cmd = IPMI_GET_DEVICE_ID_CMD; 495 send_msg.data = NULL; 496 send_msg.data_len = 0; 497 rv = ipmi_request_wait_for_response(ipmi_user, 498 (struct ipmi_addr *) &smi_addr, 499 &send_msg); 500 if (rv) { 501 printk(KERN_ERR PFX "Unable to send IPMI get device id info," 502 " IPMI error 0x%x\n", rv); 503 goto out_err; 504 } 505 506 if (halt_recv_msg.msg.data_len < 12) { 507 printk(KERN_ERR PFX "(chassis) IPMI get device id info too," 508 " short, was %d bytes, needed %d bytes\n", 509 halt_recv_msg.msg.data_len, 12); 510 goto out_err; 511 } 512 513 mfg_id = (halt_recv_msg.msg.data[7] 514 | (halt_recv_msg.msg.data[8] << 8) 515 | (halt_recv_msg.msg.data[9] << 16)); 516 prod_id = (halt_recv_msg.msg.data[10] 517 | (halt_recv_msg.msg.data[11] << 8)); 518 capabilities = halt_recv_msg.msg.data[6]; 519 ipmi_version = halt_recv_msg.msg.data[5]; 520 521 522 /* Scan for a poweroff method */ 523 for (i = 0; i < NUM_PO_FUNCS; i++) { 524 if (poweroff_functions[i].detect(ipmi_user)) 525 goto found; 526 } 527 528 out_err: 529 printk(KERN_ERR PFX "Unable to find a poweroff function that" 530 " will work, giving up\n"); 531 ipmi_destroy_user(ipmi_user); 532 return; 533 534 found: 535 printk(KERN_INFO PFX "Found a %s style poweroff function\n", 536 poweroff_functions[i].platform_type); 537 specific_poweroff_func = poweroff_functions[i].poweroff_func; 538 old_poweroff_func = pm_power_off; 539 pm_power_off = ipmi_poweroff_function; 540 ready = 1; 541 } 542 543 static void ipmi_po_smi_gone(int if_num) 544 { 545 /* This can never be called, because once poweroff driver is 546 registered, the interface can't go away until the power 547 driver is unregistered. */ 548 } 549 550 static struct ipmi_smi_watcher smi_watcher = 551 { 552 .owner = THIS_MODULE, 553 .new_smi = ipmi_po_new_smi, 554 .smi_gone = ipmi_po_smi_gone 555 }; 556 557 558 #ifdef CONFIG_PROC_FS 559 #include <linux/sysctl.h> 560 561 static ctl_table ipmi_table[] = { 562 { .ctl_name = DEV_IPMI_POWEROFF_POWERCYCLE, 563 .procname = "poweroff_powercycle", 564 .data = &poweroff_powercycle, 565 .maxlen = sizeof(poweroff_powercycle), 566 .mode = 0644, 567 .proc_handler = &proc_dointvec }, 568 { } 569 }; 570 571 static ctl_table ipmi_dir_table[] = { 572 { .ctl_name = DEV_IPMI, 573 .procname = "ipmi", 574 .mode = 0555, 575 .child = ipmi_table }, 576 { } 577 }; 578 579 static ctl_table ipmi_root_table[] = { 580 { .ctl_name = CTL_DEV, 581 .procname = "dev", 582 .mode = 0555, 583 .child = ipmi_dir_table }, 584 { } 585 }; 586 587 static struct ctl_table_header *ipmi_table_header; 588 #endif /* CONFIG_PROC_FS */ 589 590 /* 591 * Startup and shutdown functions. 592 */ 593 static int ipmi_poweroff_init (void) 594 { 595 int rv; 596 597 printk ("Copyright (C) 2004 MontaVista Software -" 598 " IPMI Powerdown via sys_reboot.\n"); 599 600 if (poweroff_powercycle) 601 printk(KERN_INFO PFX "Power cycle is enabled.\n"); 602 603 #ifdef CONFIG_PROC_FS 604 ipmi_table_header = register_sysctl_table(ipmi_root_table, 1); 605 if (!ipmi_table_header) { 606 printk(KERN_ERR PFX "Unable to register powercycle sysctl\n"); 607 rv = -ENOMEM; 608 goto out_err; 609 } 610 #endif 611 612 rv = ipmi_smi_watcher_register(&smi_watcher); 613 614 #ifdef CONFIG_PROC_FS 615 if (rv) { 616 unregister_sysctl_table(ipmi_table_header); 617 printk(KERN_ERR PFX "Unable to register SMI watcher: %d\n", rv); 618 goto out_err; 619 } 620 #endif 621 622 out_err: 623 return rv; 624 } 625 626 #ifdef MODULE 627 static __exit void ipmi_poweroff_cleanup(void) 628 { 629 int rv; 630 631 #ifdef CONFIG_PROC_FS 632 unregister_sysctl_table(ipmi_table_header); 633 #endif 634 635 ipmi_smi_watcher_unregister(&smi_watcher); 636 637 if (ready) { 638 rv = ipmi_destroy_user(ipmi_user); 639 if (rv) 640 printk(KERN_ERR PFX "could not cleanup the IPMI" 641 " user: 0x%x\n", rv); 642 pm_power_off = old_poweroff_func; 643 } 644 } 645 module_exit(ipmi_poweroff_cleanup); 646 #endif 647 648 module_init(ipmi_poweroff_init); 649 MODULE_LICENSE("GPL"); 650 MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>"); 651 MODULE_DESCRIPTION("IPMI Poweroff extension to sys_reboot"); 652