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/module.h>
35 #include <linux/moduleparam.h>
36 #include <linux/proc_fs.h>
37 #include <linux/string.h>
38 #include <linux/completion.h>
39 #include <linux/pm.h>
40 #include <linux/kdev_t.h>
41 #include <linux/ipmi.h>
42 #include <linux/ipmi_smi.h>
43 
44 #define PFX "IPMI poweroff: "
45 
46 static void ipmi_po_smi_gone(int if_num);
47 static void ipmi_po_new_smi(int if_num, struct device *device);
48 
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 */
53 
54 /* the IPMI data command */
55 static int poweroff_powercycle;
56 
57 /* Which interface to use, -1 means the first we see. */
58 static int ifnum_to_use = -1;
59 
60 /* Our local state. */
61 static int ready;
62 static ipmi_user_t ipmi_user;
63 static int ipmi_ifnum;
64 static void (*specific_poweroff_func)(ipmi_user_t user);
65 
66 /* Holds the old poweroff function so we can restore it on removal. */
67 static void (*old_poweroff_func)(void);
68 
69 static int set_param_ifnum(const char *val, struct kernel_param *kp)
70 {
71 	int rv = param_set_int(val, kp);
72 	if (rv)
73 		return rv;
74 	if ((ifnum_to_use < 0) || (ifnum_to_use == ipmi_ifnum))
75 		return 0;
76 
77 	ipmi_po_smi_gone(ipmi_ifnum);
78 	ipmi_po_new_smi(ifnum_to_use, NULL);
79 	return 0;
80 }
81 
82 module_param_call(ifnum_to_use, set_param_ifnum, param_get_int,
83 		  &ifnum_to_use, 0644);
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 "
86 		 "interface");
87 
88 /* parameter definition to allow user to flag power cycle */
89 module_param(poweroff_powercycle, int, 0644);
90 MODULE_PARM_DESC(poweroff_powercycle,
91 		 " Set to non-zero to enable power cycle instead of power"
92 		 " down. Power cycle is contingent on hardware support,"
93 		 " otherwise it defaults back to power down.");
94 
95 /* Stuff from the get device id command. */
96 static unsigned int mfg_id;
97 static unsigned int prod_id;
98 static unsigned char capabilities;
99 static unsigned char ipmi_version;
100 
101 /*
102  * We use our own messages for this operation, we don't let the system
103  * allocate them, since we may be in a panic situation.  The whole
104  * thing is single-threaded, anyway, so multiple messages are not
105  * required.
106  */
107 static atomic_t dummy_count = ATOMIC_INIT(0);
108 static void dummy_smi_free(struct ipmi_smi_msg *msg)
109 {
110 	atomic_dec(&dummy_count);
111 }
112 static void dummy_recv_free(struct ipmi_recv_msg *msg)
113 {
114 	atomic_dec(&dummy_count);
115 }
116 static struct ipmi_smi_msg halt_smi_msg = {
117 	.done = dummy_smi_free
118 };
119 static struct ipmi_recv_msg halt_recv_msg = {
120 	.done = dummy_recv_free
121 };
122 
123 
124 /*
125  * Code to send a message and wait for the response.
126  */
127 
128 static void receive_handler(struct ipmi_recv_msg *recv_msg, void *handler_data)
129 {
130 	struct completion *comp = recv_msg->user_msg_data;
131 
132 	if (comp)
133 		complete(comp);
134 }
135 
136 static struct ipmi_user_hndl ipmi_poweroff_handler = {
137 	.ipmi_recv_hndl = receive_handler
138 };
139 
140 
141 static int ipmi_request_wait_for_response(ipmi_user_t            user,
142 					  struct ipmi_addr       *addr,
143 					  struct kernel_ipmi_msg *send_msg)
144 {
145 	int               rv;
146 	struct completion comp;
147 
148 	init_completion(&comp);
149 
150 	rv = ipmi_request_supply_msgs(user, addr, 0, send_msg, &comp,
151 				      &halt_smi_msg, &halt_recv_msg, 0);
152 	if (rv)
153 		return rv;
154 
155 	wait_for_completion(&comp);
156 
157 	return halt_recv_msg.msg.data[0];
158 }
159 
160 /* Wait for message to complete, spinning. */
161 static int ipmi_request_in_rc_mode(ipmi_user_t            user,
162 				   struct ipmi_addr       *addr,
163 				   struct kernel_ipmi_msg *send_msg)
164 {
165 	int rv;
166 
167 	atomic_set(&dummy_count, 2);
168 	rv = ipmi_request_supply_msgs(user, addr, 0, send_msg, NULL,
169 				      &halt_smi_msg, &halt_recv_msg, 0);
170 	if (rv) {
171 		atomic_set(&dummy_count, 0);
172 		return rv;
173 	}
174 
175 	/*
176 	 * Spin until our message is done.
177 	 */
178 	while (atomic_read(&dummy_count) > 0) {
179 		ipmi_poll_interface(user);
180 		cpu_relax();
181 	}
182 
183 	return halt_recv_msg.msg.data[0];
184 }
185 
186 /*
187  * ATCA Support
188  */
189 
190 #define IPMI_NETFN_ATCA			0x2c
191 #define IPMI_ATCA_SET_POWER_CMD		0x11
192 #define IPMI_ATCA_GET_ADDR_INFO_CMD	0x01
193 #define IPMI_PICMG_ID			0
194 
195 #define IPMI_NETFN_OEM				0x2e
196 #define IPMI_ATCA_PPS_GRACEFUL_RESTART		0x11
197 #define IPMI_ATCA_PPS_IANA			"\x00\x40\x0A"
198 #define IPMI_MOTOROLA_MANUFACTURER_ID		0x0000A1
199 #define IPMI_MOTOROLA_PPS_IPMC_PRODUCT_ID	0x0051
200 
201 static void (*atca_oem_poweroff_hook)(ipmi_user_t user);
202 
203 static void pps_poweroff_atca(ipmi_user_t user)
204 {
205 	struct ipmi_system_interface_addr smi_addr;
206 	struct kernel_ipmi_msg            send_msg;
207 	int                               rv;
208 	/*
209 	 * Configure IPMI address for local access
210 	 */
211 	smi_addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
212 	smi_addr.channel = IPMI_BMC_CHANNEL;
213 	smi_addr.lun = 0;
214 
215 	printk(KERN_INFO PFX "PPS powerdown hook used");
216 
217 	send_msg.netfn = IPMI_NETFN_OEM;
218 	send_msg.cmd = IPMI_ATCA_PPS_GRACEFUL_RESTART;
219 	send_msg.data = IPMI_ATCA_PPS_IANA;
220 	send_msg.data_len = 3;
221 	rv = ipmi_request_in_rc_mode(user,
222 				     (struct ipmi_addr *) &smi_addr,
223 				     &send_msg);
224 	if (rv && rv != IPMI_UNKNOWN_ERR_COMPLETION_CODE) {
225 		printk(KERN_ERR PFX "Unable to send ATCA ,"
226 		       " IPMI error 0x%x\n", rv);
227 	}
228 	return;
229 }
230 
231 static int ipmi_atca_detect(ipmi_user_t user)
232 {
233 	struct ipmi_system_interface_addr smi_addr;
234 	struct kernel_ipmi_msg            send_msg;
235 	int                               rv;
236 	unsigned char                     data[1];
237 
238 	/*
239 	 * Configure IPMI address for local access
240 	 */
241 	smi_addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
242 	smi_addr.channel = IPMI_BMC_CHANNEL;
243 	smi_addr.lun = 0;
244 
245 	/*
246 	 * Use get address info to check and see if we are ATCA
247 	 */
248 	send_msg.netfn = IPMI_NETFN_ATCA;
249 	send_msg.cmd = IPMI_ATCA_GET_ADDR_INFO_CMD;
250 	data[0] = IPMI_PICMG_ID;
251 	send_msg.data = data;
252 	send_msg.data_len = sizeof(data);
253 	rv = ipmi_request_wait_for_response(user,
254 					    (struct ipmi_addr *) &smi_addr,
255 					    &send_msg);
256 
257 	printk(KERN_INFO PFX "ATCA Detect mfg 0x%X prod 0x%X\n",
258 	       mfg_id, prod_id);
259 	if ((mfg_id == IPMI_MOTOROLA_MANUFACTURER_ID)
260 	    && (prod_id == IPMI_MOTOROLA_PPS_IPMC_PRODUCT_ID)) {
261 		printk(KERN_INFO PFX
262 		       "Installing Pigeon Point Systems Poweroff Hook\n");
263 		atca_oem_poweroff_hook = pps_poweroff_atca;
264 	}
265 	return !rv;
266 }
267 
268 static void ipmi_poweroff_atca(ipmi_user_t user)
269 {
270 	struct ipmi_system_interface_addr smi_addr;
271 	struct kernel_ipmi_msg            send_msg;
272 	int                               rv;
273 	unsigned char                     data[4];
274 
275 	/*
276 	 * Configure IPMI address for local access
277 	 */
278 	smi_addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
279 	smi_addr.channel = IPMI_BMC_CHANNEL;
280 	smi_addr.lun = 0;
281 
282 	printk(KERN_INFO PFX "Powering down via ATCA power command\n");
283 
284 	/*
285 	 * Power down
286 	 */
287 	send_msg.netfn = IPMI_NETFN_ATCA;
288 	send_msg.cmd = IPMI_ATCA_SET_POWER_CMD;
289 	data[0] = IPMI_PICMG_ID;
290 	data[1] = 0; /* FRU id */
291 	data[2] = 0; /* Power Level */
292 	data[3] = 0; /* Don't change saved presets */
293 	send_msg.data = data;
294 	send_msg.data_len = sizeof(data);
295 	rv = ipmi_request_in_rc_mode(user,
296 				     (struct ipmi_addr *) &smi_addr,
297 				     &send_msg);
298 	/*
299 	 * At this point, the system may be shutting down, and most
300 	 * serial drivers (if used) will have interrupts turned off
301 	 * it may be better to ignore IPMI_UNKNOWN_ERR_COMPLETION_CODE
302 	 * return code
303 	 */
304 	if (rv && rv != IPMI_UNKNOWN_ERR_COMPLETION_CODE) {
305 		printk(KERN_ERR PFX "Unable to send ATCA powerdown message,"
306 		       " IPMI error 0x%x\n", rv);
307 		goto out;
308 	}
309 
310 	if (atca_oem_poweroff_hook)
311 		atca_oem_poweroff_hook(user);
312  out:
313 	return;
314 }
315 
316 /*
317  * CPI1 Support
318  */
319 
320 #define IPMI_NETFN_OEM_1				0xf8
321 #define OEM_GRP_CMD_SET_RESET_STATE		0x84
322 #define OEM_GRP_CMD_SET_POWER_STATE		0x82
323 #define IPMI_NETFN_OEM_8				0xf8
324 #define OEM_GRP_CMD_REQUEST_HOTSWAP_CTRL	0x80
325 #define OEM_GRP_CMD_GET_SLOT_GA			0xa3
326 #define IPMI_NETFN_SENSOR_EVT			0x10
327 #define IPMI_CMD_GET_EVENT_RECEIVER		0x01
328 
329 #define IPMI_CPI1_PRODUCT_ID		0x000157
330 #define IPMI_CPI1_MANUFACTURER_ID	0x0108
331 
332 static int ipmi_cpi1_detect(ipmi_user_t user)
333 {
334 	return ((mfg_id == IPMI_CPI1_MANUFACTURER_ID)
335 		&& (prod_id == IPMI_CPI1_PRODUCT_ID));
336 }
337 
338 static void ipmi_poweroff_cpi1(ipmi_user_t user)
339 {
340 	struct ipmi_system_interface_addr smi_addr;
341 	struct ipmi_ipmb_addr             ipmb_addr;
342 	struct kernel_ipmi_msg            send_msg;
343 	int                               rv;
344 	unsigned char                     data[1];
345 	int                               slot;
346 	unsigned char                     hotswap_ipmb;
347 	unsigned char                     aer_addr;
348 	unsigned char                     aer_lun;
349 
350 	/*
351 	 * Configure IPMI address for local access
352 	 */
353 	smi_addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
354 	smi_addr.channel = IPMI_BMC_CHANNEL;
355 	smi_addr.lun = 0;
356 
357 	printk(KERN_INFO PFX "Powering down via CPI1 power command\n");
358 
359 	/*
360 	 * Get IPMI ipmb address
361 	 */
362 	send_msg.netfn = IPMI_NETFN_OEM_8 >> 2;
363 	send_msg.cmd = OEM_GRP_CMD_GET_SLOT_GA;
364 	send_msg.data = NULL;
365 	send_msg.data_len = 0;
366 	rv = ipmi_request_in_rc_mode(user,
367 				     (struct ipmi_addr *) &smi_addr,
368 				     &send_msg);
369 	if (rv)
370 		goto out;
371 	slot = halt_recv_msg.msg.data[1];
372 	hotswap_ipmb = (slot > 9) ? (0xb0 + 2 * slot) : (0xae + 2 * slot);
373 
374 	/*
375 	 * Get active event receiver
376 	 */
377 	send_msg.netfn = IPMI_NETFN_SENSOR_EVT >> 2;
378 	send_msg.cmd = IPMI_CMD_GET_EVENT_RECEIVER;
379 	send_msg.data = NULL;
380 	send_msg.data_len = 0;
381 	rv = ipmi_request_in_rc_mode(user,
382 				     (struct ipmi_addr *) &smi_addr,
383 				     &send_msg);
384 	if (rv)
385 		goto out;
386 	aer_addr = halt_recv_msg.msg.data[1];
387 	aer_lun = halt_recv_msg.msg.data[2];
388 
389 	/*
390 	 * Setup IPMB address target instead of local target
391 	 */
392 	ipmb_addr.addr_type = IPMI_IPMB_ADDR_TYPE;
393 	ipmb_addr.channel = 0;
394 	ipmb_addr.slave_addr = aer_addr;
395 	ipmb_addr.lun = aer_lun;
396 
397 	/*
398 	 * Send request hotswap control to remove blade from dpv
399 	 */
400 	send_msg.netfn = IPMI_NETFN_OEM_8 >> 2;
401 	send_msg.cmd = OEM_GRP_CMD_REQUEST_HOTSWAP_CTRL;
402 	send_msg.data = &hotswap_ipmb;
403 	send_msg.data_len = 1;
404 	ipmi_request_in_rc_mode(user,
405 				(struct ipmi_addr *) &ipmb_addr,
406 				&send_msg);
407 
408 	/*
409 	 * Set reset asserted
410 	 */
411 	send_msg.netfn = IPMI_NETFN_OEM_1 >> 2;
412 	send_msg.cmd = OEM_GRP_CMD_SET_RESET_STATE;
413 	send_msg.data = data;
414 	data[0] = 1; /* Reset asserted state */
415 	send_msg.data_len = 1;
416 	rv = ipmi_request_in_rc_mode(user,
417 				     (struct ipmi_addr *) &smi_addr,
418 				     &send_msg);
419 	if (rv)
420 		goto out;
421 
422 	/*
423 	 * Power down
424 	 */
425 	send_msg.netfn = IPMI_NETFN_OEM_1 >> 2;
426 	send_msg.cmd = OEM_GRP_CMD_SET_POWER_STATE;
427 	send_msg.data = data;
428 	data[0] = 1; /* Power down state */
429 	send_msg.data_len = 1;
430 	rv = ipmi_request_in_rc_mode(user,
431 				     (struct ipmi_addr *) &smi_addr,
432 				     &send_msg);
433 	if (rv)
434 		goto out;
435 
436  out:
437 	return;
438 }
439 
440 /*
441  * ipmi_dell_chassis_detect()
442  * Dell systems with IPMI < 1.5 don't set the chassis capability bit
443  * but they can handle a chassis poweroff or powercycle command.
444  */
445 
446 #define DELL_IANA_MFR_ID {0xA2, 0x02, 0x00}
447 static int ipmi_dell_chassis_detect(ipmi_user_t user)
448 {
449 	const char ipmi_version_major = ipmi_version & 0xF;
450 	const char ipmi_version_minor = (ipmi_version >> 4) & 0xF;
451 	const char mfr[3] = DELL_IANA_MFR_ID;
452 	if (!memcmp(mfr, &mfg_id, sizeof(mfr)) &&
453 	    ipmi_version_major <= 1 &&
454 	    ipmi_version_minor < 5)
455 		return 1;
456 	return 0;
457 }
458 
459 /*
460  * Standard chassis support
461  */
462 
463 #define IPMI_NETFN_CHASSIS_REQUEST	0
464 #define IPMI_CHASSIS_CONTROL_CMD	0x02
465 
466 static int ipmi_chassis_detect(ipmi_user_t user)
467 {
468 	/* Chassis support, use it. */
469 	return (capabilities & 0x80);
470 }
471 
472 static void ipmi_poweroff_chassis(ipmi_user_t user)
473 {
474 	struct ipmi_system_interface_addr smi_addr;
475 	struct kernel_ipmi_msg            send_msg;
476 	int                               rv;
477 	unsigned char                     data[1];
478 
479 	/*
480 	 * Configure IPMI address for local access
481 	 */
482 	smi_addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
483 	smi_addr.channel = IPMI_BMC_CHANNEL;
484 	smi_addr.lun = 0;
485 
486  powercyclefailed:
487 	printk(KERN_INFO PFX "Powering %s via IPMI chassis control command\n",
488 		(poweroff_powercycle ? "cycle" : "down"));
489 
490 	/*
491 	 * Power down
492 	 */
493 	send_msg.netfn = IPMI_NETFN_CHASSIS_REQUEST;
494 	send_msg.cmd = IPMI_CHASSIS_CONTROL_CMD;
495 	if (poweroff_powercycle)
496 		data[0] = IPMI_CHASSIS_POWER_CYCLE;
497 	else
498 		data[0] = IPMI_CHASSIS_POWER_DOWN;
499 	send_msg.data = data;
500 	send_msg.data_len = sizeof(data);
501 	rv = ipmi_request_in_rc_mode(user,
502 				     (struct ipmi_addr *) &smi_addr,
503 				     &send_msg);
504 	if (rv) {
505 		if (poweroff_powercycle) {
506 			/* power cycle failed, default to power down */
507 			printk(KERN_ERR PFX "Unable to send chassis power " \
508 			       "cycle message, IPMI error 0x%x\n", rv);
509 			poweroff_powercycle = 0;
510 			goto powercyclefailed;
511 		}
512 
513 		printk(KERN_ERR PFX "Unable to send chassis power " \
514 		       "down message, IPMI error 0x%x\n", rv);
515 	}
516 }
517 
518 
519 /* Table of possible power off functions. */
520 struct poweroff_function {
521 	char *platform_type;
522 	int  (*detect)(ipmi_user_t user);
523 	void (*poweroff_func)(ipmi_user_t user);
524 };
525 
526 static struct poweroff_function poweroff_functions[] = {
527 	{ .platform_type	= "ATCA",
528 	  .detect		= ipmi_atca_detect,
529 	  .poweroff_func	= ipmi_poweroff_atca },
530 	{ .platform_type	= "CPI1",
531 	  .detect		= ipmi_cpi1_detect,
532 	  .poweroff_func	= ipmi_poweroff_cpi1 },
533 	{ .platform_type	= "chassis",
534 	  .detect		= ipmi_dell_chassis_detect,
535 	  .poweroff_func	= ipmi_poweroff_chassis },
536 	/* Chassis should generally be last, other things should override
537 	   it. */
538 	{ .platform_type	= "chassis",
539 	  .detect		= ipmi_chassis_detect,
540 	  .poweroff_func	= ipmi_poweroff_chassis },
541 };
542 #define NUM_PO_FUNCS (sizeof(poweroff_functions) \
543 		      / sizeof(struct poweroff_function))
544 
545 
546 /* Called on a powerdown request. */
547 static 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. */
558 static 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 
639 static 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 
652 static 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 
662 static 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 
671 static ctl_table ipmi_dir_table[] = {
672 	{ .procname	= "ipmi",
673 	  .mode		= 0555,
674 	  .child	= ipmi_table },
675 	{ }
676 };
677 
678 static ctl_table ipmi_root_table[] = {
679 	{ .procname	= "dev",
680 	  .mode		= 0555,
681 	  .child	= ipmi_dir_table },
682 	{ }
683 };
684 
685 static struct ctl_table_header *ipmi_table_header;
686 #endif /* CONFIG_PROC_FS */
687 
688 /*
689  * Startup and shutdown functions.
690  */
691 static 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
725 static 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 }
743 module_exit(ipmi_poweroff_cleanup);
744 #endif
745 
746 module_init(ipmi_poweroff_init);
747 MODULE_LICENSE("GPL");
748 MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>");
749 MODULE_DESCRIPTION("IPMI Poweroff extension to sys_reboot");
750