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