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