sysctl: Drop & in front of every proc_handler.
[linux-2.6.git] / 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;
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 reponse.
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");