[linux-2.6-block.git] / include / linux / ipmi.h

/* SPDX-License-Identifier: GPL-2.0+ */
/*
 * ipmi.h
 *
 * MontaVista IPMI interface
 *
 * Author: MontaVista Software, Inc.
 *         Corey Minyard <minyard@mvista.com>
 *         source@mvista.com
 *
 * Copyright 2002 MontaVista Software Inc.
 *
 */
#ifndef __LINUX_IPMI_H
#define __LINUX_IPMI_H

#include <uapi/linux/ipmi.h>

#include <linux/list.h>
#include <linux/proc_fs.h>
#include <linux/acpi.h> /* For acpi_handle */

struct module;
struct device;

/*
 * Opaque type for a IPMI message user.  One of these is needed to
 * send and receive messages.
 */
struct ipmi_user;

/*
 * Stuff coming from the receive interface comes as one of these.
 * They are allocated, the receiver must free them with
 * ipmi_free_recv_msg() when done with the message.  The link is not
 * used after the message is delivered, so the upper layer may use the
 * link to build a linked list, if it likes.
 */
struct ipmi_recv_msg {
	struct list_head link;

	/*
	 * The type of message as defined in the "Receive Types"
	 * defines above.
	 */
	int              recv_type;

	struct ipmi_user *user;
	struct ipmi_addr addr;
	long             msgid;
	struct kernel_ipmi_msg  msg;

	/*
	 * The user_msg_data is the data supplied when a message was
	 * sent, if this is a response to a sent message.  If this is
	 * not a response to a sent message, then user_msg_data will
	 * be NULL.  If the user above is NULL, then this will be the
	 * intf.
	 */
	void             *user_msg_data;

	/*
	 * Call this when done with the message.  It will presumably free
	 * the message and do any other necessary cleanup.
	 */
	void (*done)(struct ipmi_recv_msg *msg);

	/*
	 * Place-holder for the data, don't make any assumptions about
	 * the size or existence of this, since it may change.
	 */
	unsigned char   msg_data[IPMI_MAX_MSG_LENGTH];
};

/* Allocate and free the receive message. */
void ipmi_free_recv_msg(struct ipmi_recv_msg *msg);

struct ipmi_user_hndl {
	/*
	 * Routine type to call when a message needs to be routed to
	 * the upper layer.  This will be called with some locks held,
	 * the only IPMI routines that can be called are ipmi_request
	 * and the alloc/free operations.  The handler_data is the
	 * variable supplied when the receive handler was registered.
	 */
	void (*ipmi_recv_hndl)(struct ipmi_recv_msg *msg,
			       void                 *user_msg_data);

	/*
	 * Called when the interface detects a watchdog pre-timeout.  If
	 * this is NULL, it will be ignored for the user.
	 */
	void (*ipmi_watchdog_pretimeout)(void *handler_data);

	/*
	 * If not NULL, called at panic time after the interface has
	 * been set up to handle run to completion.
	 */
	void (*ipmi_panic_handler)(void *handler_data);

	/*
	 * Called when the interface has been removed.  After this returns
	 * the user handle will be invalid.  The interface may or may
	 * not be usable when this is called, but it will return errors
	 * if it is not usable.
	 */
	void (*shutdown)(void *handler_data);
};

/* Create a new user of the IPMI layer on the given interface number. */
int ipmi_create_user(unsigned int          if_num,
		     const struct ipmi_user_hndl *handler,
		     void                  *handler_data,
		     struct ipmi_user      **user);

/*
 * Destroy the given user of the IPMI layer.  Note that after this
 * function returns, the system is guaranteed to not call any
 * callbacks for the user.  Thus as long as you destroy all the users
 * before you unload a module, you will be safe.  And if you destroy
 * the users before you destroy the callback structures, it should be
 * safe, too.
 */
int ipmi_destroy_user(struct ipmi_user *user);

/* Get the IPMI version of the BMC we are talking to. */
int ipmi_get_version(struct ipmi_user *user,
		     unsigned char *major,
		     unsigned char *minor);

/*
 * Set and get the slave address and LUN that we will use for our
 * source messages.  Note that this affects the interface, not just
 * this user, so it will affect all users of this interface.  This is
 * so some initialization code can come in and do the OEM-specific
 * things it takes to determine your address (if not the BMC) and set
 * it for everyone else.  Note that each channel can have its own
 * address.
 */
int ipmi_set_my_address(struct ipmi_user *user,
			unsigned int  channel,
			unsigned char address);
int ipmi_get_my_address(struct ipmi_user *user,
			unsigned int  channel,
			unsigned char *address);
int ipmi_set_my_LUN(struct ipmi_user *user,
		    unsigned int  channel,
		    unsigned char LUN);
int ipmi_get_my_LUN(struct ipmi_user *user,
		    unsigned int  channel,
		    unsigned char *LUN);

/*
 * Like ipmi_request, but lets you specify the number of retries and
 * the retry time.  The retries is the number of times the message
 * will be resent if no reply is received.  If set to -1, the default
 * value will be used.  The retry time is the time in milliseconds
 * between retries.  If set to zero, the default value will be
 * used.
 *
 * Don't use this unless you *really* have to.  It's primarily for the
 * IPMI over LAN converter; since the LAN stuff does its own retries,
 * it makes no sense to do it here.  However, this can be used if you
 * have unusual requirements.
 */
int ipmi_request_settime(struct ipmi_user *user,
			 struct ipmi_addr *addr,
			 long             msgid,
			 struct kernel_ipmi_msg  *msg,
			 void             *user_msg_data,
			 int              priority,
			 int              max_retries,
			 unsigned int     retry_time_ms);

/*
 * Like ipmi_request, but with messages supplied.  This will not
 * allocate any memory, and the messages may be statically allocated
 * (just make sure to do the "done" handling on them).  Note that this
 * is primarily for the watchdog timer, since it should be able to
 * send messages even if no memory is available.  This is subject to
 * change as the system changes, so don't use it unless you REALLY
 * have to.
 */
int ipmi_request_supply_msgs(struct ipmi_user     *user,
			     struct ipmi_addr     *addr,
			     long                 msgid,
			     struct kernel_ipmi_msg *msg,
			     void                 *user_msg_data,
			     void                 *supplied_smi,
			     struct ipmi_recv_msg *supplied_recv,
			     int                  priority);

/*
 * Poll the IPMI interface for the user.  This causes the IPMI code to
 * do an immediate check for information from the driver and handle
 * anything that is immediately pending.  This will not block in any
 * way.  This is useful if you need to spin waiting for something to
 * happen in the IPMI driver.
 */
void ipmi_poll_interface(struct ipmi_user *user);

/*
 * When commands come in to the SMS, the user can register to receive
 * them.  Only one user can be listening on a specific netfn/cmd/chan tuple
 * at a time, you will get an EBUSY error if the command is already
 * registered.  If a command is received that does not have a user
 * registered, the driver will automatically return the proper
 * error.  Channels are specified as a bitfield, use IPMI_CHAN_ALL to
 * mean all channels.
 */
int ipmi_register_for_cmd(struct ipmi_user *user,
			  unsigned char netfn,
			  unsigned char cmd,
			  unsigned int  chans);
int ipmi_unregister_for_cmd(struct ipmi_user *user,
			    unsigned char netfn,
			    unsigned char cmd,
			    unsigned int  chans);

/*
 * Go into a mode where the driver will not autonomously attempt to do
 * things with the interface.  It will still respond to attentions and
 * interrupts, and it will expect that commands will complete.  It
 * will not automatcially check for flags, events, or things of that
 * nature.
 *
 * This is primarily used for firmware upgrades.  The idea is that
 * when you go into firmware upgrade mode, you do this operation
 * and the driver will not attempt to do anything but what you tell
 * it or what the BMC asks for.
 *
 * Note that if you send a command that resets the BMC, the driver
 * will still expect a response from that command.  So the BMC should
 * reset itself *after* the response is sent.  Resetting before the
 * response is just silly.
 *
 * If in auto maintenance mode, the driver will automatically go into
 * maintenance mode for 30 seconds if it sees a cold reset, a warm
 * reset, or a firmware NetFN.  This means that code that uses only
 * firmware NetFN commands to do upgrades will work automatically
 * without change, assuming it sends a message every 30 seconds or
 * less.
 *
 * See the IPMI_MAINTENANCE_MODE_xxx defines for what the mode means.
 */
int ipmi_get_maintenance_mode(struct ipmi_user *user);
int ipmi_set_maintenance_mode(struct ipmi_user *user, int mode);

/*
 * When the user is created, it will not receive IPMI events by
 * default.  The user must set this to TRUE to get incoming events.
 * The first user that sets this to TRUE will receive all events that
 * have been queued while no one was waiting for events.
 */
int ipmi_set_gets_events(struct ipmi_user *user, bool val);

/*
 * Called when a new SMI is registered.  This will also be called on
 * every existing interface when a new watcher is registered with
 * ipmi_smi_watcher_register().
 */
struct ipmi_smi_watcher {
	struct list_head link;

	/*
	 * You must set the owner to the current module, if you are in
	 * a module (generally just set it to "THIS_MODULE").
	 */
	struct module *owner;

	/*
	 * These two are called with read locks held for the interface
	 * the watcher list.  So you can add and remove users from the
	 * IPMI interface, send messages, etc., but you cannot add
	 * or remove SMI watchers or SMI interfaces.
	 */
	void (*new_smi)(int if_num, struct device *dev);
	void (*smi_gone)(int if_num);
};

int ipmi_smi_watcher_register(struct ipmi_smi_watcher *watcher);
int ipmi_smi_watcher_unregister(struct ipmi_smi_watcher *watcher);

/*
 * The following are various helper functions for dealing with IPMI
 * addresses.
 */

/* Return the maximum length of an IPMI address given it's type. */
unsigned int ipmi_addr_length(int addr_type);

/* Validate that the given IPMI address is valid. */
int ipmi_validate_addr(struct ipmi_addr *addr, int len);

/*
 * How did the IPMI driver find out about the device?
 */
enum ipmi_addr_src {
	SI_INVALID = 0, SI_HOTMOD, SI_HARDCODED, SI_SPMI, SI_ACPI, SI_SMBIOS,
	SI_PCI,	SI_DEVICETREE, SI_PLATFORM, SI_LAST
};
const char *ipmi_addr_src_to_str(enum ipmi_addr_src src);

union ipmi_smi_info_union {
#ifdef CONFIG_ACPI
	/*
	 * the acpi_info element is defined for the SI_ACPI
	 * address type
	 */
	struct {
		acpi_handle acpi_handle;
	} acpi_info;
#endif
};

struct ipmi_smi_info {
	enum ipmi_addr_src addr_src;

	/*
	 * Base device for the interface.  Don't forget to put this when
	 * you are done.
	 */
	struct device *dev;

	/*
	 * The addr_info provides more detailed info for some IPMI
	 * devices, depending on the addr_src.  Currently only SI_ACPI
	 * info is provided.
	 */
	union ipmi_smi_info_union addr_info;
};

/* This is to get the private info of struct ipmi_smi */
extern int ipmi_get_smi_info(int if_num, struct ipmi_smi_info *data);

#endif /* __LINUX_IPMI_H */
Commit	Line	Data
243ac210	1	/* SPDX-License-Identifier: GPL-2.0+ */
1da177e4 LT	2	/*
	3	* ipmi.h
	4	*
	5	* MontaVista IPMI interface
	6	*
	7	* Author: MontaVista Software, Inc.
	8	* Corey Minyard <minyard@mvista.com>
	9	* source@mvista.com
	10	*
	11	* Copyright 2002 MontaVista Software Inc.
	12	*
1da177e4	13	*/
1da177e4 LT	14	#ifndef __LINUX_IPMI_H
	15	#define __LINUX_IPMI_H
	16
607ca46e	17	#include <uapi/linux/ipmi.h>
1da177e4	18
1da177e4	19	#include <linux/list.h>
3b625943	20	#include <linux/proc_fs.h>
a11213fc	21	#include <linux/acpi.h> /* For acpi_handle */
3b625943	22
de477254	23	struct module;
313162d0	24	struct device;
de477254	25
6dc1181f CM	26	/*
	27	* Opaque type for a IPMI message user. One of these is needed to
	28	* send and receive messages.
	29	*/
4372ea94	30	struct ipmi_user;
1da177e4 LT	31
	32	/*
	33	* Stuff coming from the receive interface comes as one of these.
	34	* They are allocated, the receiver must free them with
	35	* ipmi_free_recv_msg() when done with the message. The link is not
	36	* used after the message is delivered, so the upper layer may use the
	37	* link to build a linked list, if it likes.
	38	*/
c70d7499	39	struct ipmi_recv_msg {
1da177e4 LT	40	struct list_head link;
1da177e4 LT	41
6dc1181f CM	42	/*
	43	* The type of message as defined in the "Receive Types"
	44	* defines above.
	45	*/
1da177e4 LT	46	int recv_type;
1da177e4 LT	47
5ce1a7dc	48	struct ipmi_user *user;
1da177e4 LT	49	struct ipmi_addr addr;
	50	long msgid;
	51	struct kernel_ipmi_msg msg;
	52
6dc1181f CM	53	/*
	54	* The user_msg_data is the data supplied when a message was
	55	* sent, if this is a response to a sent message. If this is
	56	* not a response to a sent message, then user_msg_data will
	57	* be NULL. If the user above is NULL, then this will be the
	58	* intf.
	59	*/
1da177e4 LT	60	void *user_msg_data;
1da177e4 LT	61
6dc1181f CM	62	/*
	63	* Call this when done with the message. It will presumably free
	64	* the message and do any other necessary cleanup.
	65	*/
1da177e4 LT	66	void (done)(struct ipmi_recv_msg msg);
1da177e4 LT	67
6dc1181f CM	68	/*
	69	* Place-holder for the data, don't make any assumptions about
	70	* the size or existence of this, since it may change.
	71	*/
1da177e4 LT	72	unsigned char msg_data[IPMI_MAX_MSG_LENGTH];
	73	};
	74
	75	/* Allocate and free the receive message. */
393d2cc3	76	void ipmi_free_recv_msg(struct ipmi_recv_msg *msg);
1da177e4	77
c70d7499	78	struct ipmi_user_hndl {
6dc1181f CM	79	/*
	80	* Routine type to call when a message needs to be routed to
	81	* the upper layer. This will be called with some locks held,
	82	* the only IPMI routines that can be called are ipmi_request
	83	* and the alloc/free operations. The handler_data is the
	84	* variable supplied when the receive handler was registered.
	85	*/
1da177e4 LT	86	void (ipmi_recv_hndl)(struct ipmi_recv_msg msg,
	87	void *user_msg_data);
	88
6dc1181f CM	89	/*
	90	* Called when the interface detects a watchdog pre-timeout. If
	91	* this is NULL, it will be ignored for the user.
	92	*/
1da177e4	93	void (ipmi_watchdog_pretimeout)(void handler_data);
91e2dd0a CM	94
	95	/*
	96	* If not NULL, called at panic time after the interface has
	97	* been set up to handle run to completion.
	98	*/
	99	void (ipmi_panic_handler)(void handler_data);
b7780dab CM	100
	101	/*
	102	* Called when the interface has been removed. After this returns
	103	* the user handle will be invalid. The interface may or may
	104	* not be usable when this is called, but it will return errors
	105	* if it is not usable.
	106	*/
	107	void (shutdown)(void handler_data);
1da177e4 LT	108	};
	109
	110	/* Create a new user of the IPMI layer on the given interface number. */
	111	int ipmi_create_user(unsigned int if_num,
210af2a5	112	const struct ipmi_user_hndl *handler,
1da177e4	113	void *handler_data,
5ce1a7dc	114	struct ipmi_user **user);
1da177e4	115
6dc1181f CM	116	/*
	117	* Destroy the given user of the IPMI layer. Note that after this
	118	* function returns, the system is guaranteed to not call any
	119	* callbacks for the user. Thus as long as you destroy all the users
	120	* before you unload a module, you will be safe. And if you destroy
	121	* the users before you destroy the callback structures, it should be
	122	* safe, too.
	123	*/
5ce1a7dc	124	int ipmi_destroy_user(struct ipmi_user *user);
1da177e4 LT	125
1da177e4 LT	126	/* Get the IPMI version of the BMC we are talking to. */
5ce1a7dc	127	int ipmi_get_version(struct ipmi_user *user,
511d57dc CM	128	unsigned char *major,
511d57dc CM	129	unsigned char *minor);
1da177e4	130
6dc1181f CM	131	/*
	132	* Set and get the slave address and LUN that we will use for our
	133	* source messages. Note that this affects the interface, not just
	134	* this user, so it will affect all users of this interface. This is
	135	* so some initialization code can come in and do the OEM-specific
	136	* things it takes to determine your address (if not the BMC) and set
	137	* it for everyone else. Note that each channel can have its own
	138	* address.
	139	*/
5ce1a7dc	140	int ipmi_set_my_address(struct ipmi_user *user,
c14979b9 CM	141	unsigned int channel,
c14979b9 CM	142	unsigned char address);
5ce1a7dc	143	int ipmi_get_my_address(struct ipmi_user *user,
c14979b9 CM	144	unsigned int channel,
c14979b9 CM	145	unsigned char *address);
5ce1a7dc	146	int ipmi_set_my_LUN(struct ipmi_user *user,
c14979b9 CM	147	unsigned int channel,
c14979b9 CM	148	unsigned char LUN);
5ce1a7dc	149	int ipmi_get_my_LUN(struct ipmi_user *user,
c14979b9 CM	150	unsigned int channel,
c14979b9 CM	151	unsigned char *LUN);
1da177e4 LT	152
	153	/*
	154	* Like ipmi_request, but lets you specify the number of retries and
	155	* the retry time. The retries is the number of times the message
	156	* will be resent if no reply is received. If set to -1, the default
	157	* value will be used. The retry time is the time in milliseconds
	158	* between retries. If set to zero, the default value will be
	159	* used.
	160	*
	161	* Don't use this unless you really have to. It's primarily for the
	162	* IPMI over LAN converter; since the LAN stuff does its own retries,
	163	* it makes no sense to do it here. However, this can be used if you
	164	* have unusual requirements.
	165	*/
5ce1a7dc	166	int ipmi_request_settime(struct ipmi_user *user,
1da177e4 LT	167	struct ipmi_addr *addr,
	168	long msgid,
	169	struct kernel_ipmi_msg *msg,
	170	void *user_msg_data,
	171	int priority,
	172	int max_retries,
	173	unsigned int retry_time_ms);
	174
	175	/*
	176	* Like ipmi_request, but with messages supplied. This will not
	177	* allocate any memory, and the messages may be statically allocated
	178	* (just make sure to do the "done" handling on them). Note that this
	179	* is primarily for the watchdog timer, since it should be able to
	180	* send messages even if no memory is available. This is subject to
	181	* change as the system changes, so don't use it unless you REALLY
	182	* have to.
	183	*/
5ce1a7dc	184	int ipmi_request_supply_msgs(struct ipmi_user *user,
1da177e4 LT	185	struct ipmi_addr *addr,
	186	long msgid,
	187	struct kernel_ipmi_msg *msg,
	188	void *user_msg_data,
	189	void *supplied_smi,
	190	struct ipmi_recv_msg *supplied_recv,
	191	int priority);
	192
fcfa4724 CM	193	/*
	194	* Poll the IPMI interface for the user. This causes the IPMI code to
	195	* do an immediate check for information from the driver and handle
	196	* anything that is immediately pending. This will not block in any
bda4c30a CM	197	* way. This is useful if you need to spin waiting for something to
bda4c30a CM	198	* happen in the IPMI driver.
fcfa4724	199	*/
5ce1a7dc	200	void ipmi_poll_interface(struct ipmi_user *user);
fcfa4724	201
1da177e4 LT	202	/*
1da177e4 LT	203	* When commands come in to the SMS, the user can register to receive
c69c3127	204	* them. Only one user can be listening on a specific netfn/cmd/chan tuple
1da177e4 LT	205	* at a time, you will get an EBUSY error if the command is already
	206	* registered. If a command is received that does not have a user
	207	* registered, the driver will automatically return the proper
c69c3127 CM	208	* error. Channels are specified as a bitfield, use IPMI_CHAN_ALL to
c69c3127 CM	209	* mean all channels.
1da177e4	210	*/
5ce1a7dc	211	int ipmi_register_for_cmd(struct ipmi_user *user,
1da177e4	212	unsigned char netfn,
c69c3127 CM	213	unsigned char cmd,
c69c3127 CM	214	unsigned int chans);
5ce1a7dc	215	int ipmi_unregister_for_cmd(struct ipmi_user *user,
1da177e4	216	unsigned char netfn,
c69c3127 CM	217	unsigned char cmd,
c69c3127 CM	218	unsigned int chans);
1da177e4	219
b9675136 CM	220	/*
	221	* Go into a mode where the driver will not autonomously attempt to do
	222	* things with the interface. It will still respond to attentions and
	223	* interrupts, and it will expect that commands will complete. It
	224	* will not automatcially check for flags, events, or things of that
	225	* nature.
	226	*
	227	* This is primarily used for firmware upgrades. The idea is that
	228	* when you go into firmware upgrade mode, you do this operation
	229	* and the driver will not attempt to do anything but what you tell
	230	* it or what the BMC asks for.
	231	*
	232	* Note that if you send a command that resets the BMC, the driver
	233	* will still expect a response from that command. So the BMC should
	234	* reset itself after the response is sent. Resetting before the
	235	* response is just silly.
	236	*
	237	* If in auto maintenance mode, the driver will automatically go into
	238	* maintenance mode for 30 seconds if it sees a cold reset, a warm
	239	* reset, or a firmware NetFN. This means that code that uses only
	240	* firmware NetFN commands to do upgrades will work automatically
	241	* without change, assuming it sends a message every 30 seconds or
	242	* less.
	243	*
	244	* See the IPMI_MAINTENANCE_MODE_xxx defines for what the mode means.
	245	*/
5ce1a7dc CM	246	int ipmi_get_maintenance_mode(struct ipmi_user *user);
5ce1a7dc CM	247	int ipmi_set_maintenance_mode(struct ipmi_user *user, int mode);
b9675136	248
1da177e4 LT	249	/*
	250	* When the user is created, it will not receive IPMI events by
	251	* default. The user must set this to TRUE to get incoming events.
	252	* The first user that sets this to TRUE will receive all events that
	253	* have been queued while no one was waiting for events.
	254	*/
5ce1a7dc	255	int ipmi_set_gets_events(struct ipmi_user *user, bool val);
1da177e4 LT	256
	257	/*
	258	* Called when a new SMI is registered. This will also be called on
	259	* every existing interface when a new watcher is registered with
	260	* ipmi_smi_watcher_register().
	261	*/
c70d7499	262	struct ipmi_smi_watcher {
1da177e4 LT	263	struct list_head link;
1da177e4 LT	264
6dc1181f CM	265	/*
	266	* You must set the owner to the current module, if you are in
	267	* a module (generally just set it to "THIS_MODULE").
	268	*/
1da177e4 LT	269	struct module *owner;
1da177e4 LT	270
6dc1181f CM	271	/*
	272	* These two are called with read locks held for the interface
	273	* the watcher list. So you can add and remove users from the
	274	* IPMI interface, send messages, etc., but you cannot add
	275	* or remove SMI watchers or SMI interfaces.
	276	*/
50c812b2	277	void (new_smi)(int if_num, struct device dev);
1da177e4 LT	278	void (*smi_gone)(int if_num);
	279	};
	280
	281	int ipmi_smi_watcher_register(struct ipmi_smi_watcher *watcher);
	282	int ipmi_smi_watcher_unregister(struct ipmi_smi_watcher *watcher);
	283
6dc1181f CM	284	/*
	285	* The following are various helper functions for dealing with IPMI
	286	* addresses.
	287	*/
1da177e4 LT	288
	289	/* Return the maximum length of an IPMI address given it's type. */
	290	unsigned int ipmi_addr_length(int addr_type);
	291
	292	/* Validate that the given IPMI address is valid. */
	293	int ipmi_validate_addr(struct ipmi_addr *addr, int len);
	294
16f4232c ZY	295	/*
	296	* How did the IPMI driver find out about the device?
	297	*/
	298	enum ipmi_addr_src {
	299	SI_INVALID = 0, SI_HOTMOD, SI_HARDCODED, SI_SPMI, SI_ACPI, SI_SMBIOS,
95e300c0	300	SI_PCI, SI_DEVICETREE, SI_PLATFORM, SI_LAST
16f4232c	301	};
7e50387b	302	const char *ipmi_addr_src_to_str(enum ipmi_addr_src src);
16f4232c ZY	303
16f4232c ZY	304	union ipmi_smi_info_union {
a11213fc	305	#ifdef CONFIG_ACPI
16f4232c ZY	306	/*
	307	* the acpi_info element is defined for the SI_ACPI
	308	* address type
	309	*/
	310	struct {
a11213fc	311	acpi_handle acpi_handle;
16f4232c	312	} acpi_info;
a11213fc	313	#endif
16f4232c ZY	314	};
	315
	316	struct ipmi_smi_info {
	317	enum ipmi_addr_src addr_src;
	318
	319	/*
	320	* Base device for the interface. Don't forget to put this when
	321	* you are done.
	322	*/
	323	struct device *dev;
	324
	325	/*
	326	* The addr_info provides more detailed info for some IPMI
	327	* devices, depending on the addr_src. Currently only SI_ACPI
	328	* info is provided.
	329	*/
	330	union ipmi_smi_info_union addr_info;
	331	};
	332
5ce1a7dc	333	/* This is to get the private info of struct ipmi_smi */
16f4232c ZY	334	extern int ipmi_get_smi_info(int if_num, struct ipmi_smi_info *data);
16f4232c ZY	335
1da177e4	336	#endif /* __LINUX_IPMI_H */