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