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