Release 4.7 drivers/char/ipmi/ipmi_poweroff.c

/*
 * ipmi_poweroff.c
 *
 * MontaVista IPMI Poweroff extension to sys_reboot
 *
 * Author: MontaVista Software, Inc.
 *         Steven Dake <sdake@mvista.com>
 *         Corey Minyard <cminyard@mvista.com>
 *         source@mvista.com
 *
 * Copyright 2002,2004 MontaVista Software Inc.
 *
 *  This program is free software; you can redistribute it and/or modify it
 *  under the terms of the GNU General Public License as published by the
 *  Free Software Foundation; either version 2 of the License, or (at your
 *  option) any later version.
 *
 *
 *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
 *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 *  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 *  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 *  OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 *  ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
 *  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 *  USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *  You should have received a copy of the GNU General Public License along
 *  with this program; if not, write to the Free Software Foundation, Inc.,
 *  675 Mass Ave, Cambridge, MA 02139, USA.
 */
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/proc_fs.h>
#include <linux/string.h>
#include <linux/completion.h>
#include <linux/pm.h>
#include <linux/kdev_t.h>
#include <linux/ipmi.h>
#include <linux/ipmi_smi.h>


#define PFX "IPMI poweroff: "

static void ipmi_po_smi_gone(int if_num);
static void ipmi_po_new_smi(int if_num, struct device *device);

/* Definitions for controlling power off (if the system supports it).  It
 * conveniently matches the IPMI chassis control values. */

#define IPMI_CHASSIS_POWER_DOWN		0	
/* power down, the default. */

#define IPMI_CHASSIS_POWER_CYCLE	0x02	
/* power cycle */

/* the IPMI data command */

static int poweroff_powercycle;

/* Which interface to use, -1 means the first we see. */

static int ifnum_to_use = -1;

/* Our local state. */

static int ready;

static ipmi_user_t ipmi_user;

static int ipmi_ifnum;

static void (*specific_poweroff_func)(ipmi_user_t user);

/* Holds the old poweroff function so we can restore it on removal. */

static void (*old_poweroff_func)(void);



static int set_param_ifnum(const char *val, struct kernel_param *kp)
{
	int rv = param_set_int(val, kp);
	if (rv)
		return rv;
	if ((ifnum_to_use < 0) || (ifnum_to_use == ipmi_ifnum))
		return 0;

	ipmi_po_smi_gone(ipmi_ifnum);
	ipmi_po_new_smi(ifnum_to_use, NULL);
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
corey minyard
corey minyard
65
100.00%
1
100.00%
Total
65
100.00%
1
100.00%

module_param_call(ifnum_to_use, set_param_ifnum, param_get_int,
		  &ifnum_to_use, 0644);
MODULE_PARM_DESC(ifnum_to_use, "The interface number to use for the watchdog "
		 "timer.  Setting to -1 defaults to the first registered "
		 "interface");

/* parameter definition to allow user to flag power cycle */
module_param(poweroff_powercycle, int, 0644);
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.");

/* Stuff from the get device id command. */

static unsigned int mfg_id;

static unsigned int prod_id;

static unsigned char capabilities;

static unsigned char ipmi_version;

/*
 * We use our own messages for this operation, we don't let the system
 * allocate them, since we may be in a panic situation.  The whole
 * thing is single-threaded, anyway, so multiple messages are not
 * required.
 */

static atomic_t dummy_count = ATOMIC_INIT(0);


static void dummy_smi_free(struct ipmi_smi_msg *msg)
{
	atomic_dec(&dummy_count);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
corey minyard
corey minyard
17
100.00%
2
100.00%
Total
17
100.00%
2
100.00%



static void dummy_recv_free(struct ipmi_recv_msg *msg)
{
	atomic_dec(&dummy_count);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
corey minyard
corey minyard
17
100.00%
2
100.00%
Total
17
100.00%
2
100.00%


static struct ipmi_smi_msg halt_smi_msg = {
	.done = dummy_smi_free
};

static struct ipmi_recv_msg halt_recv_msg = {
	.done = dummy_recv_free
};


/*
 * Code to send a message and wait for the response.
 */



static void receive_handler(struct ipmi_recv_msg *recv_msg, void *handler_data)
{
	struct completion *comp = recv_msg->user_msg_data;

	if (comp)
		complete(comp);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
corey minyard
corey minyard
33
100.00%
2
100.00%
Total
33
100.00%
2
100.00%


static struct ipmi_user_hndl ipmi_poweroff_handler = {
	.ipmi_recv_hndl = receive_handler
};




static int ipmi_request_wait_for_response(ipmi_user_t            user,
					  struct ipmi_addr       *addr,
					  struct kernel_ipmi_msg *send_msg)
{
	int               rv;
	struct completion comp;

	init_completion(&comp);

	rv = ipmi_request_supply_msgs(user, addr, 0, send_msg, &comp,
				      &halt_smi_msg, &halt_recv_msg, 0);
	if (rv)
		return rv;

	wait_for_completion(&comp);

	return halt_recv_msg.msg.data[0];
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
corey minyard
corey minyard
79
100.00%
2
100.00%
Total
79
100.00%
2
100.00%

/* Wait for message to complete, spinning. */


static int ipmi_request_in_rc_mode(ipmi_user_t            user,
				   struct ipmi_addr       *addr,
				   struct kernel_ipmi_msg *send_msg)
{
	int rv;

	atomic_set(&dummy_count, 2);
	rv = ipmi_request_supply_msgs(user, addr, 0, send_msg, NULL,
				      &halt_smi_msg, &halt_recv_msg, 0);
	if (rv) {
		atomic_set(&dummy_count, 0);
		return rv;
	}

	/*
         * Spin until our message is done.
         */
	while (atomic_read(&dummy_count) > 0) {
		ipmi_poll_interface(user);
		cpu_relax();
	}

	return halt_recv_msg.msg.data[0];
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
corey minyard
corey minyard
101
100.00%
2
100.00%
Total
101
100.00%
2
100.00%

/*
 * ATCA Support
 */


#define IPMI_NETFN_ATCA			0x2c

#define IPMI_ATCA_SET_POWER_CMD		0x11

#define IPMI_ATCA_GET_ADDR_INFO_CMD	0x01

#define IPMI_PICMG_ID			0


#define IPMI_NETFN_OEM				0x2e

#define IPMI_ATCA_PPS_GRACEFUL_RESTART		0x11

#define IPMI_ATCA_PPS_IANA			"\x00\x40\x0A"

#define IPMI_MOTOROLA_MANUFACTURER_ID		0x0000A1

#define IPMI_MOTOROLA_PPS_IPMC_PRODUCT_ID	0x0051


static void (*atca_oem_poweroff_hook)(ipmi_user_t user);



static void pps_poweroff_atca(ipmi_user_t user)
{
	struct ipmi_system_interface_addr smi_addr;
	struct kernel_ipmi_msg            send_msg;
	int                               rv;
	/*
         * Configure IPMI address for local access
         */
	smi_addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
	smi_addr.channel = IPMI_BMC_CHANNEL;
	smi_addr.lun = 0;

	printk(KERN_INFO PFX "PPS powerdown hook used");

	send_msg.netfn = IPMI_NETFN_OEM;
	send_msg.cmd = IPMI_ATCA_PPS_GRACEFUL_RESTART;
	send_msg.data = IPMI_ATCA_PPS_IANA;
	send_msg.data_len = 3;
	rv = ipmi_request_in_rc_mode(user,
				     (struct ipmi_addr *) &smi_addr,
				     &send_msg);
	if (rv && rv != IPMI_UNKNOWN_ERR_COMPLETION_CODE) {
		printk(KERN_ERR PFX "Unable to send ATCA ,"
		       " IPMI error 0x%x\n", rv);
	}
	return;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
corey minyard
corey minyard
107
100.00%
2
100.00%
Total
107
100.00%
2
100.00%



static int ipmi_atca_detect(ipmi_user_t user)
{
	struct ipmi_system_interface_addr smi_addr;
	struct kernel_ipmi_msg            send_msg;
	int                               rv;
	unsigned char                     data[1];

	/*
         * Configure IPMI address for local access
         */
	smi_addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
	smi_addr.channel = IPMI_BMC_CHANNEL;
	smi_addr.lun = 0;

	/*
         * Use get address info to check and see if we are ATCA
         */
	send_msg.netfn = IPMI_NETFN_ATCA;
	send_msg.cmd = IPMI_ATCA_GET_ADDR_INFO_CMD;
	data[0] = IPMI_PICMG_ID;
	send_msg.data = data;
	send_msg.data_len = sizeof(data);
	rv = ipmi_request_wait_for_response(user,
					    (struct ipmi_addr *) &smi_addr,
					    &send_msg);

	printk(KERN_INFO PFX "ATCA Detect mfg 0x%X prod 0x%X\n",
	       mfg_id, prod_id);
	if ((mfg_id == IPMI_MOTOROLA_MANUFACTURER_ID)
	    && (prod_id == IPMI_MOTOROLA_PPS_IPMC_PRODUCT_ID)) {
		printk(KERN_INFO PFX
		       "Installing Pigeon Point Systems Poweroff Hook\n");
		atca_oem_poweroff_hook = pps_poweroff_atca;
	}
	return !rv;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
corey minyard
corey minyard
139
100.00%
3
100.00%
Total
139
100.00%
3
100.00%



static void ipmi_poweroff_atca(ipmi_user_t user)
{
	struct ipmi_system_interface_addr smi_addr;
	struct kernel_ipmi_msg            send_msg;
	int                               rv;
	unsigned char                     data[4];

	/*
         * Configure IPMI address for local access
         */
	smi_addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
	smi_addr.channel = IPMI_BMC_CHANNEL;
	smi_addr.lun = 0;

	printk(KERN_INFO PFX "Powering down via ATCA power command\n");

	/*
         * Power down
         */
	send_msg.netfn = IPMI_NETFN_ATCA;
	send_msg.cmd = IPMI_ATCA_SET_POWER_CMD;
	data[0] = IPMI_PICMG_ID;
	data[1] = 0; /* FRU id */
	data[2] = 0; /* Power Level */
	data[3] = 0; /* Don't change saved presets */
	send_msg.data = data;
	send_msg.data_len = sizeof(data);
	rv = ipmi_request_in_rc_mode(user,
				     (struct ipmi_addr *) &smi_addr,
				     &send_msg);
	/*
         * At this point, the system may be shutting down, and most
         * serial drivers (if used) will have interrupts turned off
         * it may be better to ignore IPMI_UNKNOWN_ERR_COMPLETION_CODE
         * return code
         */
	if (rv && rv != IPMI_UNKNOWN_ERR_COMPLETION_CODE) {
		printk(KERN_ERR PFX "Unable to send ATCA powerdown message,"
		       " IPMI error 0x%x\n", rv);
		goto out;
	}

	if (atca_oem_poweroff_hook)
		atca_oem_poweroff_hook(user);
 out:
	return;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
corey minyard
corey minyard
163
99.39%
3
75.00%
adrian bunk
adrian bunk
1
0.61%
1
25.00%
Total
164
100.00%
4
100.00%

/*
 * CPI1 Support
 */


#define IPMI_NETFN_OEM_1				0xf8

#define OEM_GRP_CMD_SET_RESET_STATE		0x84

#define OEM_GRP_CMD_SET_POWER_STATE		0x82

#define IPMI_NETFN_OEM_8				0xf8

#define OEM_GRP_CMD_REQUEST_HOTSWAP_CTRL	0x80

#define OEM_GRP_CMD_GET_SLOT_GA			0xa3

#define IPMI_NETFN_SENSOR_EVT			0x10

#define IPMI_CMD_GET_EVENT_RECEIVER		0x01


#define IPMI_CPI1_PRODUCT_ID		0x000157

#define IPMI_CPI1_MANUFACTURER_ID	0x0108



static int ipmi_cpi1_detect(ipmi_user_t user)
{
	return ((mfg_id == IPMI_CPI1_MANUFACTURER_ID)
		&& (prod_id == IPMI_CPI1_PRODUCT_ID));
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
corey minyard
corey minyard
24
100.00%
1
100.00%
Total
24
100.00%
1
100.00%



static void ipmi_poweroff_cpi1(ipmi_user_t user)
{
	struct ipmi_system_interface_addr smi_addr;
	struct ipmi_ipmb_addr             ipmb_addr;
	struct kernel_ipmi_msg            send_msg;
	int                               rv;
	unsigned char                     data[1];
	int                               slot;
	unsigned char                     hotswap_ipmb;
	unsigned char                     aer_addr;
	unsigned char                     aer_lun;

	/*
         * Configure IPMI address for local access
         */
	smi_addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
	smi_addr.channel = IPMI_BMC_CHANNEL;
	smi_addr.lun = 0;

	printk(KERN_INFO PFX "Powering down via CPI1 power command\n");

	/*
         * Get IPMI ipmb address
         */
	send_msg.netfn = IPMI_NETFN_OEM_8 >> 2;
	send_msg.cmd = OEM_GRP_CMD_GET_SLOT_GA;
	send_msg.data = NULL;
	send_msg.data_len = 0;
	rv = ipmi_request_in_rc_mode(user,
				     (struct ipmi_addr *) &smi_addr,
				     &send_msg);
	if (rv)
		goto out;
	slot = halt_recv_msg.msg.data[1];
	hotswap_ipmb = (slot > 9) ? (0xb0 + 2 * slot) : (0xae + 2 * slot);

	/*
         * Get active event receiver
         */
	send_msg.netfn = IPMI_NETFN_SENSOR_EVT >> 2;
	send_msg.cmd = IPMI_CMD_GET_EVENT_RECEIVER;
	send_msg.data = NULL;
	send_msg.data_len = 0;
	rv = ipmi_request_in_rc_mode(user,
				     (struct ipmi_addr *) &smi_addr,
				     &send_msg);
	if (rv)
		goto out;
	aer_addr = halt_recv_msg.msg.data[1];
	aer_lun = halt_recv_msg.msg.data[2];

	/*
         * Setup IPMB address target instead of local target
         */
	ipmb_addr.addr_type = IPMI_IPMB_ADDR_TYPE;
	ipmb_addr.channel = 0;
	ipmb_addr.slave_addr = aer_addr;
	ipmb_addr.lun = aer_lun;

	/*
         * Send request hotswap control to remove blade from dpv
         */
	send_msg.netfn = IPMI_NETFN_OEM_8 >> 2;
	send_msg.cmd = OEM_GRP_CMD_REQUEST_HOTSWAP_CTRL;
	send_msg.data = &hotswap_ipmb;
	send_msg.data_len = 1;
	ipmi_request_in_rc_mode(user,
				(struct ipmi_addr *) &ipmb_addr,
				&send_msg);

	/*
         * Set reset asserted
         */
	send_msg.netfn = IPMI_NETFN_OEM_1 >> 2;
	send_msg.cmd = OEM_GRP_CMD_SET_RESET_STATE;
	send_msg.data = data;
	data[0] = 1; /* Reset asserted state */
	send_msg.data_len = 1;
	rv = ipmi_request_in_rc_mode(user,
				     (struct ipmi_addr *) &smi_addr,
				     &send_msg);
	if (rv)
		goto out;

	/*
         * Power down
         */
	send_msg.netfn = IPMI_NETFN_OEM_1 >> 2;
	send_msg.cmd = OEM_GRP_CMD_SET_POWER_STATE;
	send_msg.data = data;
	data[0] = 1; /* Power down state */
	send_msg.data_len = 1;
	rv = ipmi_request_in_rc_mode(user,
				     (struct ipmi_addr *) &smi_addr,
				     &send_msg);
	if (rv)
		goto out;

 out:
	return;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
corey minyard
corey minyard
424
100.00%
2
100.00%
Total
424
100.00%
2
100.00%

/*
 * ipmi_dell_chassis_detect()
 * Dell systems with IPMI < 1.5 don't set the chassis capability bit
 * but they can handle a chassis poweroff or powercycle command.
 */


#define DELL_IANA_MFR_ID {0xA2, 0x02, 0x00}


static int ipmi_dell_chassis_detect(ipmi_user_t user)
{
	const char ipmi_version_major = ipmi_version & 0xF;
	const char ipmi_version_minor = (ipmi_version >> 4) & 0xF;
	const char mfr[3] = DELL_IANA_MFR_ID;
	if (!memcmp(mfr, &mfg_id, sizeof(mfr)) &&
	    ipmi_version_major <= 1 &&
	    ipmi_version_minor < 5)
		return 1;
	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
corey minyard
corey minyard
68
100.00%
1
100.00%
Total
68
100.00%
1
100.00%

/*
 * Standard chassis support
 */


#define IPMI_NETFN_CHASSIS_REQUEST	0

#define IPMI_CHASSIS_CONTROL_CMD	0x02



static int ipmi_chassis_detect(ipmi_user_t user)
{
	/* Chassis support, use it. */
	return (capabilities & 0x80);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
corey minyard
corey minyard
17
100.00%
1
100.00%
Total
17
100.00%
1
100.00%



static void ipmi_poweroff_chassis(ipmi_user_t user)
{
	struct ipmi_system_interface_addr smi_addr;
	struct kernel_ipmi_msg            send_msg;
	int                               rv;
	unsigned char                     data[1];

	/*
         * Configure IPMI address for local access
         */
	smi_addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
	smi_addr.channel = IPMI_BMC_CHANNEL;
	smi_addr.lun = 0;

 powercyclefailed:
	printk(KERN_INFO PFX "Powering %s via IPMI chassis control command\n",
		(poweroff_powercycle ? "cycle" : "down"));

	/*
         * Power down
         */
	send_msg.netfn = IPMI_NETFN_CHASSIS_REQUEST;
	send_msg.cmd = IPMI_CHASSIS_CONTROL_CMD;
	if (poweroff_powercycle)
		data[0] = IPMI_CHASSIS_POWER_CYCLE;
	else
		data[0] = IPMI_CHASSIS_POWER_DOWN;
	send_msg.data = data;
	send_msg.data_len = sizeof(data);
	rv = ipmi_request_in_rc_mode(user,
				     (struct ipmi_addr *) &smi_addr,
				     &send_msg);
	if (rv) {
		if (poweroff_powercycle) {
			/* power cycle failed, default to power down */
			printk(KERN_ERR PFX "Unable to send chassis power " \
			       "cycle message, IPMI error 0x%x\n", rv);
			poweroff_powercycle = 0;
			goto powercyclefailed;
		}

		printk(KERN_ERR PFX "Unable to send chassis power " \
		       "down message, IPMI error 0x%x\n", rv);
	}
}


Contributors
Person
Tokens
Prop
Commits
CommitProp
corey minyard
corey minyard
165
100.00%
4
100.00%
Total
165
100.00%
4
100.00%

/* Table of possible power off functions. */

struct poweroff_function {
	
char *platform_type;
	
int  (*detect)(ipmi_user_t user);
	
void (*poweroff_func)(ipmi_user_t user);
};


static struct poweroff_function poweroff_functions[] = {
	{ .platform_type	= "ATCA",
	  .detect		= ipmi_atca_detect,
	  .poweroff_func	= ipmi_poweroff_atca },
	{ .platform_type	= "CPI1",
	  .detect		= ipmi_cpi1_detect,
	  .poweroff_func	= ipmi_poweroff_cpi1 },
	{ .platform_type	= "chassis",
	  .detect		= ipmi_dell_chassis_detect,
	  .poweroff_func	= ipmi_poweroff_chassis },
	/* Chassis should generally be last, other things should override
           it. */
	{ .platform_type	= "chassis",
	  .detect		= ipmi_chassis_detect,
	  .poweroff_func	= ipmi_poweroff_chassis },
};

#define NUM_PO_FUNCS (sizeof(poweroff_functions) \
                      / sizeof(struct poweroff_function))


/* Called on a powerdown request. */


static void ipmi_poweroff_function(void)
{
	if (!ready)
		return;

	/* Use run-to-completion mode, since interrupts may be off. */
	specific_poweroff_func(ipmi_user);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
corey minyard
corey minyard
20
100.00%
1
100.00%
Total
20
100.00%
1
100.00%

/* Wait for an IPMI interface to be installed, the first one installed
   will be grabbed by this code and used to perform the powerdown. */


static void ipmi_po_new_smi(int if_num, struct device *device)
{
	struct ipmi_system_interface_addr smi_addr;
	struct kernel_ipmi_msg            send_msg;
	int                               rv;
	int                               i;

	if (ready)
		return;

	if ((ifnum_to_use >= 0) && (ifnum_to_use != if_num))
		return;

	rv = ipmi_create_user(if_num, &ipmi_poweroff_handler, NULL,
			      &ipmi_user);
	if (rv) {
		printk(KERN_ERR PFX "could not create IPMI user, error %d\n",
		       rv);
		return;
	}

	ipmi_ifnum = if_num;

	/*
         * Do a get device ide and store some results, since this is
         * used by several functions.
         */
	smi_addr.addr_type = IPMI_SYSTEM_INTERFACE_ADDR_TYPE;
	smi_addr.channel = IPMI_BMC_CHANNEL;
	smi_addr.lun = 0;

	send_msg.netfn = IPMI_NETFN_APP_REQUEST;
	send_msg.cmd = IPMI_GET_DEVICE_ID_CMD;
	send_msg.data = NULL;
	send_msg.data_len = 0;
	rv = ipmi_request_wait_for_response(ipmi_user,
					    (struct ipmi_addr *) &smi_addr,
					    &send_msg);
	if (rv) {
		printk(KERN_ERR PFX "Unable to send IPMI get device id info,"
		       " IPMI error 0x%x\n", rv);
		goto out_err;
	}

	if (halt_recv_msg.msg.data_len < 12) {
		printk(KERN_ERR PFX "(chassis) IPMI get device id info too,"
		       " short, was %d bytes, needed %d bytes\n",
		       halt_recv_msg.msg.data_len, 12);
		goto out_err;
	}

	mfg_id = (halt_recv_msg.msg.data[7]
		  | (halt_recv_msg.msg.data[8] << 8)
		  | (halt_recv_msg.msg.data[9] << 16));
	prod_id = (halt_recv_msg.msg.data[10]
		   | (halt_recv_msg.msg.data[11] << 8));
	capabilities = halt_recv_msg.msg.data[6];
	ipmi_version = halt_recv_msg.msg.data[5];


	/* Scan for a poweroff method */
	for (i = 0; i < NUM_PO_FUNCS; i++) {
		if (poweroff_functions[i].detect(ipmi_user))
			goto found;
	}

 out_err:
	printk(KERN_ERR PFX "Unable to find a poweroff function that"
	       " will work, giving up\n");
	ipmi_destroy_user(ipmi_user);
	return;

 found:
	printk(KERN_INFO PFX "Found a %s style poweroff function\n",
	       poweroff_functions[i].platform_type);
	specific_poweroff_func = poweroff_functions[i].poweroff_func;
	old_poweroff_func = pm_power_off;
	pm_power_off = ipmi_poweroff_function;
	ready = 1;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
corey minyard
corey minyard
350
99.72%
5
83.33%
al viro
al viro
1
0.28%
1
16.67%
Total
351
100.00%
6
100.00%



static void ipmi_po_smi_gone(int if_num)
{
	if (!ready)
		return;

	if (ipmi_ifnum != if_num)
		return;

	ready = 0;
	ipmi_destroy_user(ipmi_user);
	pm_power_off = old_poweroff_func;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
corey minyard
corey minyard
35
100.00%
2
100.00%
Total
35
100.00%
2
100.00%


static struct ipmi_smi_watcher smi_watcher = {
	.owner    = THIS_MODULE,
	.new_smi  = ipmi_po_new_smi,
	.smi_gone = ipmi_po_smi_gone
};


#ifdef CONFIG_PROC_FS
#include <linux/sysctl.h>


static struct ctl_table ipmi_table[] = {
	{ .procname	= "poweroff_powercycle",
	  .data		= &poweroff_powercycle,
	  .maxlen	= sizeof(poweroff_powercycle),
	  .mode		= 0644,
	  .proc_handler	= proc_dointvec },
	{ }
};


static struct ctl_table ipmi_dir_table[] = {
	{ .procname	= "ipmi",
	  .mode		= 0555,
	  .child	= ipmi_table },
	{ }
};


static struct ctl_table ipmi_root_table[] = {
	{ .procname	= "dev",
	  .mode		= 0555,
	  .child	= ipmi_dir_table },
	{ }
};


static struct ctl_table_header *ipmi_table_header;
#endif /* CONFIG_PROC_FS */

/*
 * Startup and shutdown functions.
 */


static int __init ipmi_poweroff_init(void)
{
	int rv;

	printk(KERN_INFO "Copyright (C) 2004 MontaVista Software -"
	       " IPMI Powerdown via sys_reboot.\n");

	if (poweroff_powercycle)
		printk(KERN_INFO PFX "Power cycle is enabled.\n");

#ifdef CONFIG_PROC_FS
	ipmi_table_header = register_sysctl_table(ipmi_root_table);
	if (!ipmi_table_header) {
		printk(KERN_ERR PFX "Unable to register powercycle sysctl\n");
		rv = -ENOMEM;
		goto out_err;
	}
#endif

	rv = ipmi_smi_watcher_register(&smi_watcher);

#ifdef CONFIG_PROC_FS
	if (rv) {
		unregister_sysctl_table(ipmi_table_header);
		printk(KERN_ERR PFX "Unable to register SMI watcher: %d\n", rv);
		goto out_err;
	}

 out_err:
#endif
	return rv;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
corey minyard
corey minyard
95
93.14%
4
50.00%
adrian bunk
adrian bunk
3
2.94%
1
12.50%
randy dunlap
randy dunlap
2
1.96%
1
12.50%
dan aloni
dan aloni
1
0.98%
1
12.50%
peter huewe
peter huewe
1
0.98%
1
12.50%
Total
102
100.00%
8
100.00%

#ifdef MODULE


static void __exit ipmi_poweroff_cleanup(void)
{
	int rv;

#ifdef CONFIG_PROC_FS
	unregister_sysctl_table(ipmi_table_header);
#endif

	ipmi_smi_watcher_unregister(&smi_watcher);

	if (ready) {
		rv = ipmi_destroy_user(ipmi_user);
		if (rv)
			printk(KERN_ERR PFX "could not cleanup the IPMI"
			       " user: 0x%x\n", rv);
		pm_power_off = old_poweroff_func;
	}
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
corey minyard
corey minyard
57
98.28%
3
75.00%
peter huewe
peter huewe
1
1.72%
1
25.00%
Total
58
100.00%
4
100.00%


module_exit(ipmi_poweroff_cleanup);
#endif


module_init(ipmi_poweroff_init);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Corey Minyard <minyard@mvista.com>");
MODULE_DESCRIPTION("IPMI Poweroff extension to sys_reboot");
Overall Contributors
Person
Tokens
Prop
Commits
CommitProp
corey minyard
corey minyard
2542
98.22%
14
56.00%
randy dunlap
randy dunlap
29
1.12%
2
8.00%
adrian bunk
adrian bunk
4
0.15%
2
8.00%
joe perches
joe perches
3
0.12%
1
4.00%
olaf hering
olaf hering
3
0.12%
1
4.00%
al viro
al viro
3
0.12%
2
8.00%
peter huewe
peter huewe
2
0.08%
1
4.00%
lucas de marchi
lucas de marchi
1
0.04%
1
4.00%
dan aloni
dan aloni
1
0.04%
1
4.00%
Total
2588
100.00%
25
100.00%
  
Directory: drivers/char/ipmi

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.