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 
27 static void ipmi_po_smi_gone(int if_num);
28 static 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 */
36 static int poweroff_powercycle;
37 
38 /* Which interface to use, -1 means the first we see. */
39 static int ifnum_to_use = -1;
40 
41 /* Our local state. */
42 static int ready;
43 static struct ipmi_user *ipmi_user;
44 static int ipmi_ifnum;
45 static void (*specific_poweroff_func)(struct ipmi_user *user);
46 
47 /* Holds the old poweroff function so we can restore it on removal. */
48 static void (*old_poweroff_func)(void);
49 
50 static 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 
63 module_param_call(ifnum_to_use, set_param_ifnum, param_get_int,
64 		  &ifnum_to_use, 0644);
65 MODULE_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 */
70 module_param(poweroff_powercycle, int, 0644);
71 MODULE_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. */
77 static unsigned int mfg_id;
78 static unsigned int prod_id;
79 static unsigned char capabilities;
80 static 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  */
88 static atomic_t dummy_count = ATOMIC_INIT(0);
89 static void dummy_smi_free(struct ipmi_smi_msg *msg)
90 {
91 	atomic_dec(&dummy_count);
92 }
93 static void dummy_recv_free(struct ipmi_recv_msg *msg)
94 {
95 	atomic_dec(&dummy_count);
96 }
97 static struct ipmi_smi_msg halt_smi_msg = INIT_IPMI_SMI_MSG(dummy_smi_free);
98 static 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 
105 static 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 
113 static const struct ipmi_user_hndl ipmi_poweroff_handler = {
114 	.ipmi_recv_hndl = receive_handler
115 };
116 
117 
118 static 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. */
138 static 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 
178 static void (*atca_oem_poweroff_hook)(struct ipmi_user *user);
179 
180 static 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 
207 static 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 
242 static 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 
306 static 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 
312 static 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}
421 static 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
442 static 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 
458 static int ipmi_chassis_detect(struct ipmi_user *user)
459 {
460 	/* Chassis support, use it. */
461 	return (capabilities & 0x80);
462 }
463 
464 static 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. */
512 struct poweroff_function {
513 	char *platform_type;
514 	int  (*detect)(struct ipmi_user *user);
515 	void (*poweroff_func)(struct ipmi_user *user);
516 };
517 
518 static 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. */
541 static 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. */
552 static 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 
630 static 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 
643 static 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 
653 static 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 };
661 
662 static struct ctl_table ipmi_dir_table[] = {
663 	{ .procname	= "ipmi",
664 	  .mode		= 0555,
665 	  .child	= ipmi_table },
666 	{ }
667 };
668 
669 static struct ctl_table ipmi_root_table[] = {
670 	{ .procname	= "dev",
671 	  .mode		= 0555,
672 	  .child	= ipmi_dir_table },
673 	{ }
674 };
675 
676 static struct ctl_table_header *ipmi_table_header;
677 #endif /* CONFIG_PROC_FS */
678 
679 /*
680  * Startup and shutdown functions.
681  */
682 static int __init ipmi_poweroff_init(void)
683 {
684 	int rv;
685 
686 	pr_info("Copyright (C) 2004 MontaVista Software - IPMI Powerdown via sys_reboot\n");
687 
688 	if (poweroff_powercycle)
689 		pr_info("Power cycle is enabled\n");
690 
691 #ifdef CONFIG_PROC_FS
692 	ipmi_table_header = register_sysctl_table(ipmi_root_table);
693 	if (!ipmi_table_header) {
694 		pr_err("Unable to register powercycle sysctl\n");
695 		rv = -ENOMEM;
696 		goto out_err;
697 	}
698 #endif
699 
700 	rv = ipmi_smi_watcher_register(&smi_watcher);
701 
702 #ifdef CONFIG_PROC_FS
703 	if (rv) {
704 		unregister_sysctl_table(ipmi_table_header);
705 		pr_err("Unable to register SMI watcher: %d\n", rv);
706 		goto out_err;
707 	}
708 
709  out_err:
710 #endif
711 	return rv;
712 }
713 
714 #ifdef MODULE
715 static void __exit ipmi_poweroff_cleanup(void)
716 {
717 	int rv;
718 
719 #ifdef CONFIG_PROC_FS
720 	unregister_sysctl_table(ipmi_table_header);
721 #endif
722 
723 	ipmi_smi_watcher_unregister(&smi_watcher);
724 
725 	if (ready) {
726 		rv = ipmi_destroy_user(ipmi_user);
727 		if (rv)
728 			pr_err("could not cleanup the IPMI user: 0x%x\n", rv);
729 		pm_power_off = old_poweroff_func;
730 	}
731 }
732 module_exit(ipmi_poweroff_cleanup);
733 #endif
734 
735 module_init(ipmi_poweroff_init);
736 MODULE_LICENSE("GPL");
737 MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>");
738 MODULE_DESCRIPTION("IPMI Poweroff extension to sys_reboot");
739