blob: 9f2e3be2c5b8b37d059d9aca5d2f4677753ce034 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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 */
Linus Torvalds1da177e2005-04-16 15:20:36 -070034#include <linux/module.h>
Corey Minyard3b625942005-06-23 22:01:42 -070035#include <linux/moduleparam.h>
36#include <linux/proc_fs.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070037#include <linux/string.h>
Corey Minyard77cf3972005-06-23 22:01:44 -070038#include <linux/completion.h>
Olaf Heringe933b6d2006-03-24 03:16:15 -080039#include <linux/pm.h>
Corey Minyard77cf3972005-06-23 22:01:44 -070040#include <linux/kdev_t.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070041#include <linux/ipmi.h>
42#include <linux/ipmi_smi.h>
43
44#define PFX "IPMI poweroff: "
Linus Torvalds1da177e2005-04-16 15:20:36 -070045
Corey Minyardb2c03942006-12-06 20:41:00 -080046static void ipmi_po_smi_gone(int if_num);
47static void ipmi_po_new_smi(int if_num, struct device *device);
48
Corey Minyard3b625942005-06-23 22:01:42 -070049/* 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 */
Corey Minyard8c702e12005-09-06 15:18:46 -070055static int poweroff_powercycle;
Corey Minyard3b625942005-06-23 22:01:42 -070056
Corey Minyardb2c03942006-12-06 20:41:00 -080057/* Which interface to use, -1 means the first we see. */
58static int ifnum_to_use = -1;
59
60/* Our local state. */
Randy Dunlap0c8204b2006-12-10 02:19:06 -080061static int ready;
Corey Minyardb2c03942006-12-06 20:41:00 -080062static ipmi_user_t ipmi_user;
63static int ipmi_ifnum;
Randy Dunlap0c8204b2006-12-10 02:19:06 -080064static void (*specific_poweroff_func)(ipmi_user_t user);
Corey Minyardb2c03942006-12-06 20:41:00 -080065
66/* Holds the old poweroff function so we can restore it on removal. */
67static void (*old_poweroff_func)(void);
68
69static 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
82module_param_call(ifnum_to_use, set_param_ifnum, param_get_int,
83 &ifnum_to_use, 0644);
84MODULE_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
Corey Minyard3b625942005-06-23 22:01:42 -070088/* parameter definition to allow user to flag power cycle */
Corey Minyarda9d014a2005-09-27 21:45:35 -070089module_param(poweroff_powercycle, int, 0644);
Corey Minyard36c7dc42008-04-29 01:01:12 -070090MODULE_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.");
Corey Minyard3b625942005-06-23 22:01:42 -070094
Linus Torvalds1da177e2005-04-16 15:20:36 -070095/* Stuff from the get device id command. */
96static unsigned int mfg_id;
97static unsigned int prod_id;
98static unsigned char capabilities;
Corey Minyard168524d2005-09-06 15:18:43 -070099static unsigned char ipmi_version;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100
Corey Minyard36c7dc42008-04-29 01:01:12 -0700101/*
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 */
Corey Minyardbda4c302008-04-29 01:01:02 -0700107static atomic_t dummy_count = ATOMIC_INIT(0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108static void dummy_smi_free(struct ipmi_smi_msg *msg)
109{
Corey Minyardbda4c302008-04-29 01:01:02 -0700110 atomic_dec(&dummy_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111}
112static void dummy_recv_free(struct ipmi_recv_msg *msg)
113{
Corey Minyardbda4c302008-04-29 01:01:02 -0700114 atomic_dec(&dummy_count);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115}
Corey Minyard36c7dc42008-04-29 01:01:12 -0700116static struct ipmi_smi_msg halt_smi_msg = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117 .done = dummy_smi_free
118};
Corey Minyard36c7dc42008-04-29 01:01:12 -0700119static struct ipmi_recv_msg halt_recv_msg = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700120 .done = dummy_recv_free
121};
122
123
124/*
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300125 * Code to send a message and wait for the response.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126 */
127
128static void receive_handler(struct ipmi_recv_msg *recv_msg, void *handler_data)
129{
Corey Minyard77cf3972005-06-23 22:01:44 -0700130 struct completion *comp = recv_msg->user_msg_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131
Corey Minyard77cf3972005-06-23 22:01:44 -0700132 if (comp)
133 complete(comp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134}
135
Corey Minyard36c7dc42008-04-29 01:01:12 -0700136static struct ipmi_user_hndl ipmi_poweroff_handler = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137 .ipmi_recv_hndl = receive_handler
138};
139
140
141static int ipmi_request_wait_for_response(ipmi_user_t user,
142 struct ipmi_addr *addr,
143 struct kernel_ipmi_msg *send_msg)
144{
Corey Minyard77cf3972005-06-23 22:01:44 -0700145 int rv;
146 struct completion comp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147
Corey Minyard77cf3972005-06-23 22:01:44 -0700148 init_completion(&comp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149
Corey Minyard77cf3972005-06-23 22:01:44 -0700150 rv = ipmi_request_supply_msgs(user, addr, 0, send_msg, &comp,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151 &halt_smi_msg, &halt_recv_msg, 0);
152 if (rv)
153 return rv;
154
Corey Minyard77cf3972005-06-23 22:01:44 -0700155 wait_for_completion(&comp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156
157 return halt_recv_msg.msg.data[0];
158}
159
Corey Minyardbda4c302008-04-29 01:01:02 -0700160/* Wait for message to complete, spinning. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161static int ipmi_request_in_rc_mode(ipmi_user_t user,
162 struct ipmi_addr *addr,
163 struct kernel_ipmi_msg *send_msg)
164{
Corey Minyard77cf3972005-06-23 22:01:44 -0700165 int rv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700166
Corey Minyardbda4c302008-04-29 01:01:02 -0700167 atomic_set(&dummy_count, 2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700168 rv = ipmi_request_supply_msgs(user, addr, 0, send_msg, NULL,
169 &halt_smi_msg, &halt_recv_msg, 0);
Corey Minyardbda4c302008-04-29 01:01:02 -0700170 if (rv) {
171 atomic_set(&dummy_count, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172 return rv;
Corey Minyardbda4c302008-04-29 01:01:02 -0700173 }
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 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700182
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
Corey Minyard7d8ba962006-12-06 20:41:09 -0800195#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
Randy Dunlap0c8204b2006-12-10 02:19:06 -0800201static void (*atca_oem_poweroff_hook)(ipmi_user_t user);
Corey Minyard7d8ba962006-12-06 20:41:09 -0800202
Corey Minyard36c7dc42008-04-29 01:01:12 -0700203static void pps_poweroff_atca(ipmi_user_t user)
Corey Minyard7d8ba962006-12-06 20:41:09 -0800204{
Corey Minyard36c7dc42008-04-29 01:01:12 -0700205 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;
Corey Minyard7d8ba962006-12-06 20:41:09 -0800214
Corey Minyard36c7dc42008-04-29 01:01:12 -0700215 printk(KERN_INFO PFX "PPS powerdown hook used");
Corey Minyard7d8ba962006-12-06 20:41:09 -0800216
Corey Minyard36c7dc42008-04-29 01:01:12 -0700217 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 }
Corey Minyard7d8ba962006-12-06 20:41:09 -0800228 return;
229}
230
Corey Minyard36c7dc42008-04-29 01:01:12 -0700231static int ipmi_atca_detect(ipmi_user_t user)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232{
233 struct ipmi_system_interface_addr smi_addr;
234 struct kernel_ipmi_msg send_msg;
235 int rv;
236 unsigned char data[1];
237
Corey Minyard36c7dc42008-04-29 01:01:12 -0700238 /*
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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244
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);
Corey Minyard7d8ba962006-12-06 20:41:09 -0800256
Corey Minyard36c7dc42008-04-29 01:01:12 -0700257 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");
Corey Minyard7d8ba962006-12-06 20:41:09 -0800263 atca_oem_poweroff_hook = pps_poweroff_atca;
264 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700265 return !rv;
266}
267
Corey Minyard36c7dc42008-04-29 01:01:12 -0700268static void ipmi_poweroff_atca(ipmi_user_t user)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269{
270 struct ipmi_system_interface_addr smi_addr;
271 struct kernel_ipmi_msg send_msg;
272 int rv;
273 unsigned char data[4];
274
Corey Minyard36c7dc42008-04-29 01:01:12 -0700275 /*
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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281
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;
Corey Minyard36c7dc42008-04-29 01:01:12 -0700294 send_msg.data_len = sizeof(data);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295 rv = ipmi_request_in_rc_mode(user,
296 (struct ipmi_addr *) &smi_addr,
297 &send_msg);
Corey Minyard36c7dc42008-04-29 01:01:12 -0700298 /*
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) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305 printk(KERN_ERR PFX "Unable to send ATCA powerdown message,"
306 " IPMI error 0x%x\n", rv);
307 goto out;
308 }
309
Corey Minyard36c7dc42008-04-29 01:01:12 -0700310 if (atca_oem_poweroff_hook)
Adrian Bunkadf535e2008-04-29 01:01:17 -0700311 atca_oem_poweroff_hook(user);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312 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
Corey Minyard36c7dc42008-04-29 01:01:12 -0700332static int ipmi_cpi1_detect(ipmi_user_t user)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333{
334 return ((mfg_id == IPMI_CPI1_MANUFACTURER_ID)
335 && (prod_id == IPMI_CPI1_PRODUCT_ID));
336}
337
Corey Minyard36c7dc42008-04-29 01:01:12 -0700338static void ipmi_poweroff_cpi1(ipmi_user_t user)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339{
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
Corey Minyard36c7dc42008-04-29 01:01:12 -0700350 /*
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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356
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/*
Corey Minyard168524d2005-09-06 15:18:43 -0700441 * 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}
Corey Minyard36c7dc42008-04-29 01:01:12 -0700447static int ipmi_dell_chassis_detect(ipmi_user_t user)
Corey Minyard168524d2005-09-06 15:18:43 -0700448{
449 const char ipmi_version_major = ipmi_version & 0xF;
450 const char ipmi_version_minor = (ipmi_version >> 4) & 0xF;
Corey Minyard8a3628d2006-03-31 02:30:40 -0800451 const char mfr[3] = DELL_IANA_MFR_ID;
Corey Minyard168524d2005-09-06 15:18:43 -0700452 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/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460 * Standard chassis support
461 */
462
463#define IPMI_NETFN_CHASSIS_REQUEST 0
464#define IPMI_CHASSIS_CONTROL_CMD 0x02
465
Corey Minyard36c7dc42008-04-29 01:01:12 -0700466static int ipmi_chassis_detect(ipmi_user_t user)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467{
468 /* Chassis support, use it. */
469 return (capabilities & 0x80);
470}
471
Corey Minyard36c7dc42008-04-29 01:01:12 -0700472static void ipmi_poweroff_chassis(ipmi_user_t user)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473{
474 struct ipmi_system_interface_addr smi_addr;
475 struct kernel_ipmi_msg send_msg;
476 int rv;
477 unsigned char data[1];
478
Corey Minyard36c7dc42008-04-29 01:01:12 -0700479 /*
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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485
Corey Minyard3b625942005-06-23 22:01:42 -0700486 powercyclefailed:
487 printk(KERN_INFO PFX "Powering %s via IPMI chassis control command\n",
Corey Minyard8c702e12005-09-06 15:18:46 -0700488 (poweroff_powercycle ? "cycle" : "down"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489
490 /*
491 * Power down
492 */
493 send_msg.netfn = IPMI_NETFN_CHASSIS_REQUEST;
494 send_msg.cmd = IPMI_CHASSIS_CONTROL_CMD;
Corey Minyard8c702e12005-09-06 15:18:46 -0700495 if (poweroff_powercycle)
496 data[0] = IPMI_CHASSIS_POWER_CYCLE;
497 else
498 data[0] = IPMI_CHASSIS_POWER_DOWN;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700499 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) {
Corey Minyard8c702e12005-09-06 15:18:46 -0700505 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;
Corey Minyard3b625942005-06-23 22:01:42 -0700511 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512
Corey Minyard8c702e12005-09-06 15:18:46 -0700513 printk(KERN_ERR PFX "Unable to send chassis power " \
514 "down message, IPMI error 0x%x\n", rv);
515 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700516}
517
518
519/* Table of possible power off functions. */
520struct poweroff_function {
521 char *platform_type;
522 int (*detect)(ipmi_user_t user);
523 void (*poweroff_func)(ipmi_user_t user);
524};
525
526static 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 },
Corey Minyard168524d2005-09-06 15:18:43 -0700533 { .platform_type = "chassis",
534 .detect = ipmi_dell_chassis_detect,
535 .poweroff_func = ipmi_poweroff_chassis },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 /* 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700546/* Called on a powerdown request. */
Corey Minyard36c7dc42008-04-29 01:01:12 -0700547static void ipmi_poweroff_function(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548{
549 if (!ready)
550 return;
551
552 /* Use run-to-completion mode, since interrupts may be off. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553 specific_poweroff_func(ipmi_user);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554}
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. */
Corey Minyard50c812b2006-03-26 01:37:21 -0800558static void ipmi_po_new_smi(int if_num, struct device *device)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700559{
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
Corey Minyardb2c03942006-12-06 20:41:00 -0800568 if ((ifnum_to_use >= 0) && (ifnum_to_use != if_num))
569 return;
570
Corey Minyard3b625942005-06-23 22:01:42 -0700571 rv = ipmi_create_user(if_num, &ipmi_poweroff_handler, NULL,
572 &ipmi_user);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573 if (rv) {
574 printk(KERN_ERR PFX "could not create IPMI user, error %d\n",
575 rv);
576 return;
577 }
578
Corey Minyardb2c03942006-12-06 20:41:00 -0800579 ipmi_ifnum = if_num;
580
Corey Minyard36c7dc42008-04-29 01:01:12 -0700581 /*
582 * Do a get device ide and store some results, since this is
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583 * used by several functions.
Corey Minyard36c7dc42008-04-29 01:01:12 -0700584 */
585 smi_addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
586 smi_addr.channel = IPMI_BMC_CHANNEL;
587 smi_addr.lun = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588
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];
Corey Minyard168524d2005-09-06 15:18:43 -0700615 ipmi_version = halt_recv_msg.msg.data[5];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616
617
618 /* Scan for a poweroff method */
Corey Minyarde8b33612005-09-06 15:18:45 -0700619 for (i = 0; i < NUM_PO_FUNCS; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620 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
639static void ipmi_po_smi_gone(int if_num)
640{
Corey Minyardb2c03942006-12-06 20:41:00 -0800641 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650}
651
Corey Minyard36c7dc42008-04-29 01:01:12 -0700652static struct ipmi_smi_watcher smi_watcher = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653 .owner = THIS_MODULE,
654 .new_smi = ipmi_po_new_smi,
655 .smi_gone = ipmi_po_smi_gone
656};
657
658
Corey Minyard3b625942005-06-23 22:01:42 -0700659#ifdef CONFIG_PROC_FS
Corey Minyard8c702e12005-09-06 15:18:46 -0700660#include <linux/sysctl.h>
Corey Minyard3b625942005-06-23 22:01:42 -0700661
Joe Perchesa1514272013-06-13 19:37:35 -0700662static struct ctl_table ipmi_table[] = {
Eric W. Biederman894d2492009-11-05 14:34:02 -0800663 { .procname = "poweroff_powercycle",
Corey Minyard8c702e12005-09-06 15:18:46 -0700664 .data = &poweroff_powercycle,
665 .maxlen = sizeof(poweroff_powercycle),
666 .mode = 0644,
Eric W. Biederman6d456112009-11-16 03:11:48 -0800667 .proc_handler = proc_dointvec },
Corey Minyard8c702e12005-09-06 15:18:46 -0700668 { }
669};
Corey Minyard3b625942005-06-23 22:01:42 -0700670
Joe Perchesa1514272013-06-13 19:37:35 -0700671static struct ctl_table ipmi_dir_table[] = {
Eric W. Biederman894d2492009-11-05 14:34:02 -0800672 { .procname = "ipmi",
Corey Minyard8c702e12005-09-06 15:18:46 -0700673 .mode = 0555,
674 .child = ipmi_table },
675 { }
676};
Corey Minyard3b625942005-06-23 22:01:42 -0700677
Joe Perchesa1514272013-06-13 19:37:35 -0700678static struct ctl_table ipmi_root_table[] = {
Eric W. Biederman894d2492009-11-05 14:34:02 -0800679 { .procname = "dev",
Corey Minyard8c702e12005-09-06 15:18:46 -0700680 .mode = 0555,
681 .child = ipmi_dir_table },
682 { }
683};
Corey Minyard3b625942005-06-23 22:01:42 -0700684
Corey Minyard8c702e12005-09-06 15:18:46 -0700685static struct ctl_table_header *ipmi_table_header;
Corey Minyard3b625942005-06-23 22:01:42 -0700686#endif /* CONFIG_PROC_FS */
687
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688/*
689 * Startup and shutdown functions.
690 */
Peter Huewe0e6b9e82009-08-23 01:46:55 +0200691static int __init ipmi_poweroff_init(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692{
Corey Minyard8c702e12005-09-06 15:18:46 -0700693 int rv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694
Corey Minyard36c7dc42008-04-29 01:01:12 -0700695 printk(KERN_INFO "Copyright (C) 2004 MontaVista Software -"
696 " IPMI Powerdown via sys_reboot.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700697
Corey Minyard8c702e12005-09-06 15:18:46 -0700698 if (poweroff_powercycle)
699 printk(KERN_INFO PFX "Power cycle is enabled.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700
Corey Minyard8c702e12005-09-06 15:18:46 -0700701#ifdef CONFIG_PROC_FS
Eric W. Biederman0b4d4142007-02-14 00:34:09 -0800702 ipmi_table_header = register_sysctl_table(ipmi_root_table);
Corey Minyard8c702e12005-09-06 15:18:46 -0700703 if (!ipmi_table_header) {
704 printk(KERN_ERR PFX "Unable to register powercycle sysctl\n");
705 rv = -ENOMEM;
706 goto out_err;
Corey Minyard3b625942005-06-23 22:01:42 -0700707 }
Corey Minyard8c702e12005-09-06 15:18:46 -0700708#endif
Corey Minyard3b625942005-06-23 22:01:42 -0700709
710 rv = ipmi_smi_watcher_register(&smi_watcher);
Adrian Bunkbe4f1bb2006-01-09 20:51:36 -0800711
712#ifdef CONFIG_PROC_FS
Corey Minyard3b625942005-06-23 22:01:42 -0700713 if (rv) {
Corey Minyard8c702e12005-09-06 15:18:46 -0700714 unregister_sysctl_table(ipmi_table_header);
Corey Minyard3b625942005-06-23 22:01:42 -0700715 printk(KERN_ERR PFX "Unable to register SMI watcher: %d\n", rv);
716 goto out_err;
717 }
718
Corey Minyard3b625942005-06-23 22:01:42 -0700719 out_err:
Randy Dunlap1aa16ee2006-12-06 20:41:20 -0800720#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721 return rv;
722}
723
724#ifdef MODULE
Peter Huewe0e6b9e82009-08-23 01:46:55 +0200725static void __exit ipmi_poweroff_cleanup(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726{
727 int rv;
728
Corey Minyard3b625942005-06-23 22:01:42 -0700729#ifdef CONFIG_PROC_FS
Corey Minyard8c702e12005-09-06 15:18:46 -0700730 unregister_sysctl_table(ipmi_table_header);
Corey Minyard3b625942005-06-23 22:01:42 -0700731#endif
732
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733 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}
743module_exit(ipmi_poweroff_cleanup);
744#endif
745
746module_init(ipmi_poweroff_init);
747MODULE_LICENSE("GPL");
Corey Minyard1fdd75b2005-09-06 15:18:42 -0700748MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>");
749MODULE_DESCRIPTION("IPMI Poweroff extension to sys_reboot");