5 files changed, 162 insertions, 5 deletions

diff --git a/Documentation/i2c/smbus-protocol b/Documentation/i2c/smbus-protocol
index 6012b12b3510..14d4ec1be245 100644
--- a/Documentation/i2c/smbus-protocol
+++ b/Documentation/i2c/smbus-protocol
@@ -199,6 +199,12 @@ alerting device's address.
 
 [S] [HostAddr] [Wr] A [DevAddr] A [DataLow] A [DataHigh] A [P]
 
+This is implemented in the following way in the Linux kernel:
+* I2C bus drivers which support SMBus Host Notify should call
+  i2c_setup_smbus_host_notify() to setup SMBus Host Notify support.
+* I2C drivers for devices which can trigger SMBus Host Notify should implement
+  the optional alert() callback.
+
 
 Packet Error Checking (PEC)
 ===========================
diff --git a/drivers/i2c/i2c-smbus.c b/drivers/i2c/i2c-smbus.c
index 3b6765a4ebe9..f574995b41c1 100644
--- a/drivers/i2c/i2c-smbus.c
+++ b/drivers/i2c/i2c-smbus.c
@@ -33,7 +33,8 @@ struct i2c_smbus_alert {
 
 struct alert_data {
         unsigned short          addr;
-        u8                      flag:1;
+        enum i2c_alert_protocol type;
+        unsigned int            data;
 };
 
 /* If this is the alerting device, notify its driver */
@@ -56,8 +57,7 @@ static int smbus_do_alert(struct device *dev, void *addrp)
         if (client->dev.driver) {
                 driver = to_i2c_driver(client->dev.driver);
                 if (driver->alert)
-                        driver->alert(client, I2C_PROTOCOL_SMBUS_ALERT,
-                                      data->flag);
+                        driver->alert(client, data->type, data->data);
                 else
                         dev_warn(&client->dev, "no driver alert()!\n");
         } else
@@ -97,8 +97,9 @@ static void smbus_alert(struct work_struct *work)
                 if (status < 0)
                         break;
 
-                data.flag = status & 1;
+                data.data = status & 1;
                 data.addr = status >> 1;
+                data.type = I2C_PROTOCOL_SMBUS_ALERT;
 
                 if (data.addr == prev_addr) {
                         dev_warn(&ara->dev, "Duplicate SMBALERT# from dev "
@@ -106,7 +107,7 @@ static void smbus_alert(struct work_struct *work)
                         break;
                 }
                 dev_dbg(&ara->dev, "SMBALERT# from dev 0x%02x, flag %d\n",
-                        data.addr, data.flag);
+                        data.addr, data.data);
 
                 /* Notify driver for the device which issued the alert */
                 device_for_each_child(&ara->adapter->dev, &data,
@@ -240,6 +241,108 @@ int i2c_handle_smbus_alert(struct i2c_client *ara)
 }
 EXPORT_SYMBOL_GPL(i2c_handle_smbus_alert);
 
+static void smbus_host_notify_work(struct work_struct *work)
+{
+        struct alert_data alert;
+        struct i2c_adapter *adapter;
+        unsigned long flags;
+        u16 payload;
+        u8 addr;
+        struct smbus_host_notify *data;
+
+        data = container_of(work, struct smbus_host_notify, work);
+
+        spin_lock_irqsave(&data->lock, flags);
+        payload = data->payload;
+        addr = data->addr;
+        adapter = data->adapter;
+
+        /* clear the pending bit and release the spinlock */
+        data->pending = false;
+        spin_unlock_irqrestore(&data->lock, flags);
+
+        if (!adapter || !addr)
+                return;
+
+        alert.type = I2C_PROTOCOL_SMBUS_HOST_NOTIFY;
+        alert.addr = addr;
+        alert.data = payload;
+
+        device_for_each_child(&adapter->dev, &alert, smbus_do_alert);
+}
+
+/**
+ * i2c_setup_smbus_host_notify - Allocate a new smbus_host_notify for the given
+ * I2C adapter.
+ * @adapter: the adapter we want to associate a Host Notify function
+ *
+ * Returns a struct smbus_host_notify pointer on success, and NULL on failure.
+ * The resulting smbus_host_notify must not be freed afterwards, it is a
+ * managed resource already.
+ */
+struct smbus_host_notify *i2c_setup_smbus_host_notify(struct i2c_adapter *adap)
+{
+        struct smbus_host_notify *host_notify;
+
+        host_notify = devm_kzalloc(&adap->dev, sizeof(struct smbus_host_notify),
+                                   GFP_KERNEL);
+        if (!host_notify)
+                return NULL;
+
+        host_notify->adapter = adap;
+
+        spin_lock_init(&host_notify->lock);
+        INIT_WORK(&host_notify->work, smbus_host_notify_work);
+
+        return host_notify;
+}
+EXPORT_SYMBOL_GPL(i2c_setup_smbus_host_notify);
+
+/**
+ * i2c_handle_smbus_host_notify - Forward a Host Notify event to the correct
+ * I2C client.
+ * @host_notify: the struct host_notify attached to the relevant adapter
+ * @data: the Host Notify data which contains the payload and address of the
+ * client
+ * Context: can't sleep
+ *
+ * Helper function to be called from an I2C bus driver's interrupt
+ * handler. It will schedule the Host Notify work, in turn calling the
+ * corresponding I2C device driver's alert function.
+ *
+ * host_notify should be a valid pointer previously returned by
+ * i2c_setup_smbus_host_notify().
+ */
+int i2c_handle_smbus_host_notify(struct smbus_host_notify *host_notify,
+                                 unsigned short addr, unsigned int data)
+{
+        unsigned long flags;
+        struct i2c_adapter *adapter;
+
+        if (!host_notify || !host_notify->adapter)
+                return -EINVAL;
+
+        adapter = host_notify->adapter;
+
+        spin_lock_irqsave(&host_notify->lock, flags);
+
+        if (host_notify->pending) {
+                spin_unlock_irqrestore(&host_notify->lock, flags);
+                dev_warn(&adapter->dev, "Host Notify already scheduled.\n");
+                return -EBUSY;
+        }
+
+        host_notify->payload = data;
+        host_notify->addr = addr;
+
+        /* Mark that there is a pending notification and release the lock */
+        host_notify->pending = true;
+        spin_unlock_irqrestore(&host_notify->lock, flags);
+
+        return schedule_work(&host_notify->work);
+}
+EXPORT_SYMBOL_GPL(i2c_handle_smbus_host_notify);
+
 module_i2c_driver(smbalert_driver);
 
 MODULE_AUTHOR("Jean Delvare <jdelvare@suse.de>");
diff --git a/include/linux/i2c-smbus.h b/include/linux/i2c-smbus.h
index 8f1b086ca5bc..4ac95bbe53ef 100644
--- a/include/linux/i2c-smbus.h
+++ b/include/linux/i2c-smbus.h
@@ -23,6 +23,8 @@
 #define _LINUX_I2C_SMBUS_H
 
 #include <linux/i2c.h>
+#include <linux/spinlock.h>
+#include <linux/workqueue.h>
 
 
 /**
@@ -48,4 +50,46 @@ struct i2c_client *i2c_setup_smbus_alert(struct i2c_adapter *adapter,
                                          struct i2c_smbus_alert_setup *setup);
 int i2c_handle_smbus_alert(struct i2c_client *ara);
 
+/**
+ * smbus_host_notify - internal structure used by the Host Notify mechanism.
+ * @adapter: the I2C adapter associated with this struct
+ * @work: worker used to schedule the IRQ in the slave device
+ * @lock: spinlock to check if a notification is already pending
+ * @pending: flag set when a notification is pending (any new notification will
+ *              be rejected if pending is true)
+ * @payload: the actual payload of the Host Notify event
+ * @addr: the address of the slave device which raised the notification
+ *
+ * This struct needs to be allocated by i2c_setup_smbus_host_notify() and does
+ * not need to be freed. Internally, i2c_setup_smbus_host_notify() uses a
+ * managed resource to clean this up when the adapter get released.
+ */
+struct smbus_host_notify {
+        struct i2c_adapter      *adapter;
+        struct work_struct      work;
+        spinlock_t              lock;
+        bool                    pending;
+        u16                     payload;
+        u8                      addr;
+};
+
+#if IS_ENABLED(CONFIG_I2C_SMBUS)
+struct smbus_host_notify *i2c_setup_smbus_host_notify(struct i2c_adapter *adap);
+int i2c_handle_smbus_host_notify(struct smbus_host_notify *host_notify,
+                                 unsigned short addr, unsigned int data);
+#else
+static inline struct smbus_host_notify *
+i2c_setup_smbus_host_notify(struct i2c_adapter *adap)
+{
+        return NULL;
+}
+
+static inline int
+i2c_handle_smbus_host_notify(struct smbus_host_notify *host_notify,
+                             unsigned short addr, unsigned int data)
+{
+        return 0;
+}
+#endif /* I2C_SMBUS */
+
 #endif /* _LINUX_I2C_SMBUS_H */
diff --git a/include/linux/i2c.h b/include/linux/i2c.h
index 37a45dcd6592..fffdc270ca18 100644
--- a/include/linux/i2c.h
+++ b/include/linux/i2c.h
@@ -128,6 +128,7 @@ i2c_smbus_read_i2c_block_data_or_emulated(const struct i2c_client *client,
 
 enum i2c_alert_protocol {
         I2C_PROTOCOL_SMBUS_ALERT,
+        I2C_PROTOCOL_SMBUS_HOST_NOTIFY,
 };
 
 /**
@@ -184,6 +185,8 @@ struct i2c_driver {
          * The format and meaning of the data value depends on the protocol.
          * For the SMBus alert protocol, there is a single bit of data passed
          * as the alert response's low bit ("event flag").
+         * For the SMBus Host Notify protocol, the data corresponds to the
+         * 16-bit payload data reported by the slave device acting as master.
          */
         void (*alert)(struct i2c_client *, enum i2c_alert_protocol protocol,
                       unsigned int data);
diff --git a/include/uapi/linux/i2c.h b/include/uapi/linux/i2c.h
index adcbef4bff61..009e27bb9abe 100644
--- a/include/uapi/linux/i2c.h
+++ b/include/uapi/linux/i2c.h
@@ -102,6 +102,7 @@ struct i2c_msg {
 #define I2C_FUNC_SMBUS_WRITE_BLOCK_DATA 0x02000000
 #define I2C_FUNC_SMBUS_READ_I2C_BLOCK   0x04000000 /* I2C-like block xfer  */
 #define I2C_FUNC_SMBUS_WRITE_I2C_BLOCK  0x08000000 /* w/ 1-byte reg. addr. */
+#define I2C_FUNC_SMBUS_HOST_NOTIFY      0x10000000
 
 #define I2C_FUNC_SMBUS_BYTE             (I2C_FUNC_SMBUS_READ_BYTE | \
                                          I2C_FUNC_SMBUS_WRITE_BYTE)