Merge tag 'for-linus-4.18' of git://github.com/cminyard/linux-ipmi

Pull IPMI updates from Corey Minyard:
 "It's been a busy release for the IPMI driver. Some notable changes:

   - A user was running into timeout issues doing maintenance commands
     over the IPMB network behind an IPMI controller.

     Extend the maintenance mode concept to messages over IPMB and allow
     the timeouts to be tuned.

   - Lots of cleanup, style fixing, some bugfixes, and such.

   - At least one user was having trouble with the way the IPMI driver
     would lock the i2c driver module it used.

     The IPMI driver was not designed for hotplug. However, hotplug is a
     reality now, so the IPMI driver was modified to support hotplug.

   - The proc interface code is now completely removed. Long live sysfs!"

* tag 'for-linus-4.18' of git://github.com/cminyard/linux-ipmi: (35 commits)
  ipmi: Properly release srcu locks on error conditions
  ipmi: NPCM7xx KCS BMC: enable interrupt to the host
  ipmi:bt: Set the timeout before doing a capabilities check
  ipmi: Remove the proc interface
  ipmi_ssif: Fix uninitialized variable issue
  ipmi: add an NPCM7xx KCS BMC driver
  ipmi_si: Clean up shutdown a bit
  ipmi_si: Rename intf_num to si_num
  ipmi: Remove smi->intf checks
  ipmi_ssif: Get rid of unused intf_num
  ipmi: Get rid of ipmi_user_t and ipmi_smi_t in include files
  ipmi: ipmi_unregister_smi() cannot fail, have it return void
  ipmi_devintf: Add an error return on invalid ioctls
  ipmi: Remove usecount function from interfaces
  ipmi_ssif: Remove usecount handling
  ipmi: Remove condition on interface shutdown
  ipmi_ssif: Convert over to a shutdown handler
  ipmi_si: Convert over to a shutdown handler
  ipmi: Rework locking and shutdown for hot remove
  ipmi: Fix some counter issues
  ...

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 */