2 files changed, 165 insertions, 117 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 */
diff --git a/include/linux/ipmi_smi.h b/include/linux/ipmi_smi.h
index af457b5a689e..7d5fd38d5282 100644
--- a/include/linux/ipmi_smi.h
+++ b/include/linux/ipmi_smi.h
@@ -22,8 +22,10 @@
 
 struct device;
 
-/* This files describes the interface for IPMI system management interface
-   drivers to bind into the IPMI message handler. */
+/*
+ * This files describes the interface for IPMI system management interface
+ * drivers to bind into the IPMI message handler.
+ */
 
 /* Structure for the low-level drivers. */
 typedef struct ipmi_smi *ipmi_smi_t;
@@ -61,12 +63,20 @@ struct ipmi_smi_msg {
 struct ipmi_smi_handlers {
         struct module *owner;
 
-        /* The low-level interface cannot start sending messages to
-           the upper layer until this function is called.  This may
-           not be NULL, the lower layer must take the interface from
-           this call. */
-        int (*start_processing)(void       *send_info,
-                                ipmi_smi_t new_intf);
+        /*
+         * The low-level interface cannot start sending messages to
+         * the upper layer until this function is called.  This may
+         * not be NULL, the lower layer must take the interface from
+         * this call.
+         */
+        int (*start_processing)(void            *send_info,
+                                struct ipmi_smi *new_intf);
+
+        /*
+         * When called, the low-level interface should disable all
+         * processing, it should be complete shut down when it returns.
+         */
+        void (*shutdown)(void *send_info);
 
         /*
          * Get the detailed private info of the low level interface and store
@@ -75,25 +85,31 @@ struct ipmi_smi_handlers {
          */
         int (*get_smi_info)(void *send_info, struct ipmi_smi_info *data);
 
-        /* Called to enqueue an SMI message to be sent.  This
-           operation is not allowed to fail.  If an error occurs, it
-           should report back the error in a received message.  It may
-           do this in the current call context, since no write locks
-           are held when this is run.  Message are delivered one at
-           a time by the message handler, a new message will not be
-           delivered until the previous message is returned. */
+        /*
+         * Called to enqueue an SMI message to be sent.  This
+         * operation is not allowed to fail.  If an error occurs, it
+         * should report back the error in a received message.  It may
+         * do this in the current call context, since no write locks
+         * are held when this is run.  Message are delivered one at
+         * a time by the message handler, a new message will not be
+         * delivered until the previous message is returned.
+         */
         void (*sender)(void                *send_info,
                        struct ipmi_smi_msg *msg);
 
-        /* Called by the upper layer to request that we try to get
-           events from the BMC we are attached to. */
+        /*
+         * Called by the upper layer to request that we try to get
+         * events from the BMC we are attached to.
+         */
         void (*request_events)(void *send_info);
 
-        /* Called by the upper layer when some user requires that the
-           interface watch for events, received messages, watchdog
-           pretimeouts, or not.  Used by the SMI to know if it should
-           watch for these.  This may be NULL if the SMI does not
-           implement it. */
+        /*
+         * Called by the upper layer when some user requires that the
+         * interface watch for events, received messages, watchdog
+         * pretimeouts, or not.  Used by the SMI to know if it should
+         * watch for these.  This may be NULL if the SMI does not
+         * implement it.
+         */
         void (*set_need_watch)(void *send_info, bool enable);
 
         /*
@@ -101,30 +117,29 @@ struct ipmi_smi_handlers {
          */
         void (*flush_messages)(void *send_info);
 
-        /* Called when the interface should go into "run to
-           completion" mode.  If this call sets the value to true, the
-           interface should make sure that all messages are flushed
-           out and that none are pending, and any new requests are run
-           to completion immediately. */
+        /*
+         * Called when the interface should go into "run to
+         * completion" mode.  If this call sets the value to true, the
+         * interface should make sure that all messages are flushed
+         * out and that none are pending, and any new requests are run
+         * to completion immediately.
+         */
         void (*set_run_to_completion)(void *send_info, bool run_to_completion);
 
-        /* Called to poll for work to do.  This is so upper layers can
-           poll for operations during things like crash dumps. */
+        /*
+         * Called to poll for work to do.  This is so upper layers can
+         * poll for operations during things like crash dumps.
+         */
         void (*poll)(void *send_info);
 
-        /* Enable/disable firmware maintenance mode.  Note that this
-           is *not* the modes defined, this is simply an on/off
-           setting.  The message handler does the mode handling.  Note
-           that this is called from interrupt context, so it cannot
-           block. */
+        /*
+         * Enable/disable firmware maintenance mode.  Note that this
+         * is *not* the modes defined, this is simply an on/off
+         * setting.  The message handler does the mode handling.  Note
+         * that this is called from interrupt context, so it cannot
+         * block.
+         */
         void (*set_maintenance_mode)(void *send_info, bool enable);
-
-        /* Tell the handler that we are using it/not using it.  The
-           message handler get the modules that this handler belongs
-           to; this function lets the SMI claim any modules that it
-           uses.  These may be NULL if this is not required. */
-        int (*inc_usecount)(void *send_info);
-        void (*dec_usecount)(void *send_info);
 };
 
 struct ipmi_device_id {
@@ -143,7 +158,8 @@ struct ipmi_device_id {
 #define ipmi_version_major(v) ((v)->ipmi_version & 0xf)
 #define ipmi_version_minor(v) ((v)->ipmi_version >> 4)
 
-/* Take a pointer to an IPMI response and extract device id information from
+/*
+ * Take a pointer to an IPMI response and extract device id information from
  * it. @netfn is in the IPMI_NETFN_ format, so may need to be shifted from
  * a SI response.
  */
@@ -187,12 +203,14 @@ static inline int ipmi_demangle_device_id(uint8_t netfn, uint8_t cmd,
         return 0;
 }
 
-/* Add a low-level interface to the IPMI driver.  Note that if the
-   interface doesn't know its slave address, it should pass in zero.
-   The low-level interface should not deliver any messages to the
-   upper layer until the start_processing() function in the handlers
-   is called, and the lower layer must get the interface from that
-   call. */
+/*
+ * Add a low-level interface to the IPMI driver.  Note that if the
+ * interface doesn't know its slave address, it should pass in zero.
+ * The low-level interface should not deliver any messages to the
+ * upper layer until the start_processing() function in the handlers
+ * is called, and the lower layer must get the interface from that
+ * call.
+ */
 int ipmi_register_smi(const struct ipmi_smi_handlers *handlers,
                       void                     *send_info,
                       struct device            *dev,
@@ -202,7 +220,7 @@ int ipmi_register_smi(const struct ipmi_smi_handlers *handlers,
  * Remove a low-level interface from the IPMI driver.  This will
  * return an error if the interface is still in use by a user.
  */
-int ipmi_unregister_smi(ipmi_smi_t intf);
+void ipmi_unregister_smi(struct ipmi_smi *intf);
 
 /*
  * The lower layer reports received messages through this interface.
@@ -210,11 +228,11 @@ int ipmi_unregister_smi(ipmi_smi_t intf);
  * the lower layer gets an error sending a message, it should format
  * an error response in the message response.
  */
-void ipmi_smi_msg_received(ipmi_smi_t          intf,
+void ipmi_smi_msg_received(struct ipmi_smi     *intf,
                            struct ipmi_smi_msg *msg);
 
 /* The lower layer received a watchdog pre-timeout on interface. */
-void ipmi_smi_watchdog_pretimeout(ipmi_smi_t intf);
+void ipmi_smi_watchdog_pretimeout(struct ipmi_smi *intf);
 
 struct ipmi_smi_msg *ipmi_alloc_smi_msg(void);
 static inline void ipmi_free_smi_msg(struct ipmi_smi_msg *msg)
@@ -222,13 +240,4 @@ static inline void ipmi_free_smi_msg(struct ipmi_smi_msg *msg)
         msg->done(msg);
 }
 
-#ifdef CONFIG_IPMI_PROC_INTERFACE
-/* Allow the lower layer to add things to the proc filesystem
-   directory for this interface.  Note that the entry will
-   automatically be dstroyed when the interface is destroyed. */
-int ipmi_smi_add_proc_entry(ipmi_smi_t smi, char *name,
-                            const struct file_operations *proc_ops,
-                            void *data);
-#endif
-
 #endif /* __LINUX_IPMI_SMI_H */