1 files changed, 96 insertions, 57 deletions

diff --git a/include/linux/ipmi.h b/include/linux/ipmi.h
index 8b0626cec980..41f5c086f670 100644
--- a/include/linux/ipmi.h
+++ b/include/linux/ipmi.h
@@ -23,8 +23,10 @@
 struct module;
 struct device;
 
-/* Opaque type for a IPMI message user.  One of these is needed to
-   send and receive messages. */
+/*
+ * Opaque type for a IPMI message user.  One of these is needed to
+ * send and receive messages.
+ */
 typedef struct ipmi_user *ipmi_user_t;
 
 /*
@@ -37,28 +39,36 @@ typedef struct ipmi_user *ipmi_user_t;
 struct ipmi_recv_msg {
         struct list_head link;
 
-        /* The type of message as defined in the "Receive Types"
-           defines above. */
+        /*
+         * The type of message as defined in the "Receive Types"
+         * defines above.
+         */
         int              recv_type;
 
-        ipmi_user_t      user;
+        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. */
+        /*
+         * 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. */
+        /*
+         * 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. */
+        /*
+         * 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];
 };
 
@@ -66,54 +76,77 @@ struct ipmi_recv_msg {
 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. */
+        /*
+         * 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. */
+        /*
+         * 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,
-                     ipmi_user_t           *user);
+                     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(ipmi_user_t 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(ipmi_user_t   user,
+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(ipmi_user_t   user,
+/*
+ * 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(ipmi_user_t   user,
+int ipmi_get_my_address(struct ipmi_user *user,
                         unsigned int  channel,
                         unsigned char *address);
-int ipmi_set_my_LUN(ipmi_user_t   user,
+int ipmi_set_my_LUN(struct ipmi_user *user,
                     unsigned int  channel,
                     unsigned char LUN);
-int ipmi_get_my_LUN(ipmi_user_t   user,
+int ipmi_get_my_LUN(struct ipmi_user *user,
                     unsigned int  channel,
                     unsigned char *LUN);
 
@@ -130,7 +163,7 @@ int ipmi_get_my_LUN(ipmi_user_t   user,
  * it makes no sense to do it here.  However, this can be used if you
  * have unusual requirements.
  */
-int ipmi_request_settime(ipmi_user_t      user,
+int ipmi_request_settime(struct ipmi_user *user,
                          struct ipmi_addr *addr,
                          long             msgid,
                          struct kernel_ipmi_msg  *msg,
@@ -148,7 +181,7 @@ int ipmi_request_settime(ipmi_user_t      user,
  * change as the system changes, so don't use it unless you REALLY
  * have to.
  */
-int ipmi_request_supply_msgs(ipmi_user_t          user,
+int ipmi_request_supply_msgs(struct ipmi_user     *user,
                              struct ipmi_addr     *addr,
                              long                 msgid,
                              struct kernel_ipmi_msg *msg,
@@ -164,7 +197,7 @@ int ipmi_request_supply_msgs(ipmi_user_t          user,
  * way.  This is useful if you need to spin waiting for something to
  * happen in the IPMI driver.
  */
-void ipmi_poll_interface(ipmi_user_t user);
+void ipmi_poll_interface(struct ipmi_user *user);
 
 /*
  * When commands come in to the SMS, the user can register to receive
@@ -175,11 +208,11 @@ void ipmi_poll_interface(ipmi_user_t user);
  * error.  Channels are specified as a bitfield, use IPMI_CHAN_ALL to
  * mean all channels.
  */
-int ipmi_register_for_cmd(ipmi_user_t   user,
+int ipmi_register_for_cmd(struct ipmi_user *user,
                           unsigned char netfn,
                           unsigned char cmd,
                           unsigned int  chans);
-int ipmi_unregister_for_cmd(ipmi_user_t   user,
+int ipmi_unregister_for_cmd(struct ipmi_user *user,
                             unsigned char netfn,
                             unsigned char cmd,
                             unsigned int  chans);
@@ -210,8 +243,8 @@ int ipmi_unregister_for_cmd(ipmi_user_t   user,
  *
  * See the IPMI_MAINTENANCE_MODE_xxx defines for what the mode means.
  */
-int ipmi_get_maintenance_mode(ipmi_user_t user);
-int ipmi_set_maintenance_mode(ipmi_user_t user, int mode);
+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
@@ -219,7 +252,7 @@ int ipmi_set_maintenance_mode(ipmi_user_t user, int mode);
  * 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(ipmi_user_t user, bool val);
+int ipmi_set_gets_events(struct ipmi_user *user, bool val);
 
 /*
  * Called when a new SMI is registered.  This will also be called on
@@ -229,14 +262,18 @@ int ipmi_set_gets_events(ipmi_user_t user, bool val);
 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"). */
+        /*
+         * 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. */
+        /*
+         * 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);
 };
@@ -244,8 +281,10 @@ struct ipmi_smi_watcher {
 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. */
+/*
+ * 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);
@@ -291,7 +330,7 @@ struct ipmi_smi_info {
         union ipmi_smi_info_union addr_info;
 };
 
-/* This is to get the private info of ipmi_smi_t */
+/* 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 */