mei: bus: split RX and async notification callbacks

Split callbacks for RX and async notification events on mei bus to
eliminate synchronization problems and to open way for RX optimizations.

Signed-off-by: Alexander Usyskin <alexander.usyskin@intel.com>
Signed-off-by: Tomas Winkler <tomas.winkler@intel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

diff --git a/drivers/misc/mei/bus.c b/drivers/misc/mei/bus.c
index 483587f602491761701f9d247d09383b57dbdd9a..2fd254ecde2fa7cdf3af24871fa3b015fe3afcff 100644 (file)
--- a/drivers/misc/mei/bus.c
+++ b/drivers/misc/mei/bus.c
@@ -209,31 +209,40 @@ ssize_t mei_cldev_recv(struct mei_cl_device *cldev, u8 *buf, size_t length)
 EXPORT_SYMBOL_GPL(mei_cldev_recv);
 
 /**
- * mei_cl_bus_event_work  - dispatch rx event for a bus device
- *    and schedule new work
+ * mei_cl_bus_rx_work - dispatch rx event for a bus device
  *
  * @work: work
  */
-static void mei_cl_bus_event_work(struct work_struct *work)
+static void mei_cl_bus_rx_work(struct work_struct *work)
 {
        struct mei_cl_device *cldev;
        struct mei_device *bus;
 
-       cldev = container_of(work, struct mei_cl_device, event_work);
+       cldev = container_of(work, struct mei_cl_device, rx_work);
 
        bus = cldev->bus;
 
-       if (cldev->event_cb)
-               cldev->event_cb(cldev, cldev->events);
+       if (cldev->rx_cb)
+               cldev->rx_cb(cldev);
 
-       cldev->events = 0;
+       mutex_lock(&bus->device_lock);
+       mei_cl_read_start(cldev->cl, mei_cl_mtu(cldev->cl), NULL);
+       mutex_unlock(&bus->device_lock);
+}
 
-       /* Prepare for the next read */
-       if (cldev->events_mask & BIT(MEI_CL_EVENT_RX)) {
-               mutex_lock(&bus->device_lock);
-               mei_cl_read_start(cldev->cl, mei_cl_mtu(cldev->cl), NULL);
-               mutex_unlock(&bus->device_lock);
-       }
+/**
+ * mei_cl_bus_notif_work - dispatch FW notif event for a bus device
+ *
+ * @work: work
+ */
+static void mei_cl_bus_notif_work(struct work_struct *work)
+{
+       struct mei_cl_device *cldev;
+
+       cldev = container_of(work, struct mei_cl_device, notif_work);
+
+       if (cldev->notif_cb)
+               cldev->notif_cb(cldev);
 }
 
 /**
@@ -248,18 +257,13 @@ bool mei_cl_bus_notify_event(struct mei_cl *cl)
 {
        struct mei_cl_device *cldev = cl->cldev;
 
-       if (!cldev || !cldev->event_cb)
-               return false;
-
-       if (!(cldev->events_mask & BIT(MEI_CL_EVENT_NOTIF)))
+       if (!cldev || !cldev->notif_cb)
                return false;
 
        if (!cl->notify_ev)
                return false;
 
-       set_bit(MEI_CL_EVENT_NOTIF, &cldev->events);
-
-       schedule_work(&cldev->event_work);
+       schedule_work(&cldev->notif_work);
 
        cl->notify_ev = false;
 
@@ -267,7 +271,7 @@ bool mei_cl_bus_notify_event(struct mei_cl *cl)
 }
 
 /**
- * mei_cl_bus_rx_event  - schedule rx event
+ * mei_cl_bus_rx_event - schedule rx event
  *
  * @cl: host client
  *
@@ -278,64 +282,81 @@ bool mei_cl_bus_rx_event(struct mei_cl *cl)
 {
        struct mei_cl_device *cldev = cl->cldev;
 
-       if (!cldev || !cldev->event_cb)
-               return false;
-
-       if (!(cldev->events_mask & BIT(MEI_CL_EVENT_RX)))
+       if (!cldev || !cldev->rx_cb)
                return false;
 
-       set_bit(MEI_CL_EVENT_RX, &cldev->events);
-
-       schedule_work(&cldev->event_work);
+       schedule_work(&cldev->rx_work);
 
        return true;
 }
 
 /**
- * mei_cldev_register_event_cb - register event callback
+ * mei_cldev_register_rx_cb - register Rx event callback
  *
  * @cldev: me client devices
- * @event_cb: callback function
- * @events_mask: requested events bitmask
+ * @rx_cb: callback function
  *
  * Return: 0 on success
  *         -EALREADY if an callback is already registered
  *         <0 on other errors
  */
-int mei_cldev_register_event_cb(struct mei_cl_device *cldev,
-                               unsigned long events_mask,
-                               mei_cldev_event_cb_t event_cb)
+int mei_cldev_register_rx_cb(struct mei_cl_device *cldev, mei_cldev_cb_t rx_cb)
 {
        struct mei_device *bus = cldev->bus;
        int ret;
 
-       if (cldev->event_cb)
+       if (!rx_cb)
+               return -EINVAL;
+       if (cldev->rx_cb)
                return -EALREADY;
 
-       cldev->events = 0;
-       cldev->events_mask = events_mask;
-       cldev->event_cb = event_cb;
-       INIT_WORK(&cldev->event_work, mei_cl_bus_event_work);
+       cldev->rx_cb = rx_cb;
+       INIT_WORK(&cldev->rx_work, mei_cl_bus_rx_work);
 
-       if (cldev->events_mask & BIT(MEI_CL_EVENT_RX)) {
-               mutex_lock(&bus->device_lock);
-               ret = mei_cl_read_start(cldev->cl, mei_cl_mtu(cldev->cl), NULL);
-               mutex_unlock(&bus->device_lock);
-               if (ret && ret != -EBUSY)
-                       return ret;
-       }
+       mutex_lock(&bus->device_lock);
+       ret = mei_cl_read_start(cldev->cl, mei_cl_mtu(cldev->cl), NULL);
+       mutex_unlock(&bus->device_lock);
+       if (ret && ret != -EBUSY)
+               return ret;
 
-       if (cldev->events_mask & BIT(MEI_CL_EVENT_NOTIF)) {
-               mutex_lock(&bus->device_lock);
-               ret = mei_cl_notify_request(cldev->cl, NULL, event_cb ? 1 : 0);
-               mutex_unlock(&bus->device_lock);
-               if (ret)
-                       return ret;
-       }
+       return 0;
+}
+EXPORT_SYMBOL_GPL(mei_cldev_register_rx_cb);
+
+/**
+ * mei_cldev_register_notif_cb - register FW notification event callback
+ *
+ * @cldev: me client devices
+ * @notif_cb: callback function
+ *
+ * Return: 0 on success
+ *         -EALREADY if an callback is already registered
+ *         <0 on other errors
+ */
+int mei_cldev_register_notif_cb(struct mei_cl_device *cldev,
+                               mei_cldev_cb_t notif_cb)
+{
+       struct mei_device *bus = cldev->bus;
+       int ret;
+
+       if (!notif_cb)
+               return -EINVAL;
+
+       if (cldev->notif_cb)
+               return -EALREADY;
+
+       cldev->notif_cb = notif_cb;
+       INIT_WORK(&cldev->notif_work, mei_cl_bus_notif_work);
+
+       mutex_lock(&bus->device_lock);
+       ret = mei_cl_notify_request(cldev->cl, NULL, 1);
+       mutex_unlock(&bus->device_lock);
+       if (ret)
+               return ret;
 
        return 0;
 }
-EXPORT_SYMBOL_GPL(mei_cldev_register_event_cb);
+EXPORT_SYMBOL_GPL(mei_cldev_register_notif_cb);
 
 /**
  * mei_cldev_get_drvdata - driver data getter
@@ -471,8 +492,6 @@ int mei_cldev_disable(struct mei_cl_device *cldev)
 
        bus = cldev->bus;
 
-       cldev->event_cb = NULL;
-
        mutex_lock(&bus->device_lock);
 
        if (!mei_cl_is_connected(cl)) {
@@ -619,9 +638,13 @@ static int mei_cl_device_remove(struct device *dev)
        if (!cldev || !dev->driver)
                return 0;
 
-       if (cldev->event_cb) {
-               cldev->event_cb = NULL;
-               cancel_work_sync(&cldev->event_work);
+       if (cldev->rx_cb) {
+               cancel_work_sync(&cldev->rx_work);
+               cldev->rx_cb = NULL;
+       }
+       if (cldev->notif_cb) {
+               cancel_work_sync(&cldev->notif_work);
+               cldev->notif_cb = NULL;
        }
 
        cldrv = to_mei_cl_driver(dev->driver);

diff --git a/drivers/misc/mei/client.c b/drivers/misc/mei/client.c
index 46ee9155ada619d9d7160cc31090e6b231c4a391..9635b14b6011346f0c819147b1071c72d85025d5 100644 (file)
--- a/drivers/misc/mei/client.c
+++ b/drivers/misc/mei/client.c
@@ -673,6 +673,11 @@ int mei_cl_unlink(struct mei_cl *cl)
        list_del_init(&cl->link);
 
        cl->state = MEI_FILE_UNINITIALIZED;
+       cl->writing_state = MEI_IDLE;
+
+       WARN_ON(!list_empty(&cl->rd_completed) ||
+               !list_empty(&cl->rd_pending) ||
+               !list_empty(&cl->link));
 
        return 0;
 }

diff --git a/drivers/nfc/mei_phy.c b/drivers/nfc/mei_phy.c
index 03139c5a05e41548ec2449f02ae679cab7388c57..8a04c5e029998504d5c07c1c327746ecf324bf78 100644 (file)
--- a/drivers/nfc/mei_phy.c
+++ b/drivers/nfc/mei_phy.c
@@ -297,9 +297,11 @@ static int mei_nfc_recv(struct nfc_mei_phy *phy, u8 *buf, size_t length)
 }
 
 
-static void nfc_mei_event_cb(struct mei_cl_device *cldev, u32 events)
+static void nfc_mei_rx_cb(struct mei_cl_device *cldev)
 {
        struct nfc_mei_phy *phy = mei_cldev_get_drvdata(cldev);
+       struct sk_buff *skb;
+       int reply_size;
 
        if (!phy)
                return;
@@ -307,27 +309,22 @@ static void nfc_mei_event_cb(struct mei_cl_device *cldev, u32 events)
        if (phy->hard_fault != 0)
                return;
 
-       if (events & BIT(MEI_CL_EVENT_RX)) {
-               struct sk_buff *skb;
-               int reply_size;
-
-               skb = alloc_skb(MEI_NFC_MAX_READ, GFP_KERNEL);
-               if (!skb)
-                       return;
+       skb = alloc_skb(MEI_NFC_MAX_READ, GFP_KERNEL);
+       if (!skb)
+               return;
 
-               reply_size = mei_nfc_recv(phy, skb->data, MEI_NFC_MAX_READ);
-               if (reply_size < MEI_NFC_HEADER_SIZE) {
-                       kfree_skb(skb);
-                       return;
-               }
+       reply_size = mei_nfc_recv(phy, skb->data, MEI_NFC_MAX_READ);
+       if (reply_size < MEI_NFC_HEADER_SIZE) {
+               kfree_skb(skb);
+               return;
+       }
 
-               skb_put(skb, reply_size);
-               skb_pull(skb, MEI_NFC_HEADER_SIZE);
+       skb_put(skb, reply_size);
+       skb_pull(skb, MEI_NFC_HEADER_SIZE);
 
-               MEI_DUMP_SKB_IN("mei frame read", skb);
+       MEI_DUMP_SKB_IN("mei frame read", skb);
 
-               nfc_hci_recv_frame(phy->hdev, skb);
-       }
+       nfc_hci_recv_frame(phy->hdev, skb);
 }
 
 static int nfc_mei_phy_enable(void *phy_id)
@@ -358,8 +355,7 @@ static int nfc_mei_phy_enable(void *phy_id)
                goto err;
        }
 
-       r = mei_cldev_register_event_cb(phy->cldev, BIT(MEI_CL_EVENT_RX),
-                                       nfc_mei_event_cb);
+       r = mei_cldev_register_rx_cb(phy->cldev, nfc_mei_rx_cb);
        if (r) {
                pr_err("Event cb registration failed %d\n", r);
                goto err;

diff --git a/drivers/watchdog/mei_wdt.c b/drivers/watchdog/mei_wdt.c
index e0af52265511ff7181cfbd881d4701580cefc744..79b35515904e069fcb0f296975fedb59386e45c5 100644 (file)
--- a/drivers/watchdog/mei_wdt.c
+++ b/drivers/watchdog/mei_wdt.c
@@ -410,11 +410,11 @@ static void mei_wdt_unregister_work(struct work_struct *work)
 }
 
 /**
- * mei_wdt_event_rx - callback for data receive
+ * mei_wdt_rx - callback for data receive
  *
  * @cldev: bus device
  */
-static void mei_wdt_event_rx(struct mei_cl_device *cldev)
+static void mei_wdt_rx(struct mei_cl_device *cldev)
 {
        struct mei_wdt *wdt = mei_cldev_get_drvdata(cldev);
        struct mei_wdt_start_response res;
@@ -482,11 +482,11 @@ out:
 }
 
 /*
- * mei_wdt_notify_event - callback for event notification
+ * mei_wdt_notif - callback for event notification
  *
  * @cldev: bus device
  */
-static void mei_wdt_notify_event(struct mei_cl_device *cldev)
+static void mei_wdt_notif(struct mei_cl_device *cldev)
 {
        struct mei_wdt *wdt = mei_cldev_get_drvdata(cldev);
 
@@ -496,21 +496,6 @@ static void mei_wdt_notify_event(struct mei_cl_device *cldev)
        mei_wdt_register(wdt);
 }
 
-/**
- * mei_wdt_event - callback for event receive
- *
- * @cldev: bus device
- * @events: event mask
- */
-static void mei_wdt_event(struct mei_cl_device *cldev, u32 events)
-{
-       if (events & BIT(MEI_CL_EVENT_RX))
-               mei_wdt_event_rx(cldev);
-
-       if (events & BIT(MEI_CL_EVENT_NOTIF))
-               mei_wdt_notify_event(cldev);
-}
-
 #if IS_ENABLED(CONFIG_DEBUG_FS)
 
 static ssize_t mei_dbgfs_read_activation(struct file *file, char __user *ubuf,
@@ -621,16 +606,17 @@ static int mei_wdt_probe(struct mei_cl_device *cldev,
                goto err_out;
        }
 
-       ret = mei_cldev_register_event_cb(wdt->cldev,
-                                         BIT(MEI_CL_EVENT_RX) |
-                                         BIT(MEI_CL_EVENT_NOTIF),
-                                         mei_wdt_event);
+       ret = mei_cldev_register_rx_cb(wdt->cldev, mei_wdt_rx);
+       if (ret) {
+               dev_err(&cldev->dev, "Could not reg rx event ret=%d\n", ret);
+               goto err_disable;
+       }
 
+       ret = mei_cldev_register_notif_cb(wdt->cldev, mei_wdt_notif);
        /* on legacy devices notification is not supported
-        * this doesn't fail the registration for RX event
         */
        if (ret && ret != -EOPNOTSUPP) {
-               dev_err(&cldev->dev, "Could not register event ret=%d\n", ret);
+               dev_err(&cldev->dev, "Could not reg notif event ret=%d\n", ret);
                goto err_disable;
        }
 

diff --git a/include/linux/mei_cl_bus.h b/include/linux/mei_cl_bus.h
index 4adb2e7c9f8471648ad580892aa3fd1a558430be..017f5232b3def878f51dbc8b4b4bb170fbbedbae 100644 (file)
--- a/include/linux/mei_cl_bus.h
+++ b/include/linux/mei_cl_bus.h
@@ -8,8 +8,7 @@
 struct mei_cl_device;
 struct mei_device;
 
-typedef void (*mei_cldev_event_cb_t)(struct mei_cl_device *cldev,
-                                    u32 events);
+typedef void (*mei_cldev_cb_t)(struct mei_cl_device *cldev);
 
 /**
  * struct mei_cl_device - MEI device handle
@@ -24,11 +23,12 @@ typedef void (*mei_cldev_event_cb_t)(struct mei_cl_device *cldev,
  * @me_cl: me client
  * @cl: mei client
  * @name: device name
- * @event_work: async work to execute event callback
- * @event_cb: Drivers register this callback to get asynchronous ME
- *     events (e.g. Rx buffer pending) notifications.
- * @events_mask: Events bit mask requested by driver.
- * @events: Events bitmask sent to the driver.
+ * @rx_work: async work to execute Rx event callback
+ * @rx_cb: Drivers register this callback to get asynchronous ME
+ *     Rx buffer pending notifications.
+ * @notif_work: async work to execute FW notif event callback
+ * @notif_cb: Drivers register this callback to get asynchronous ME
+ *     FW notification pending notifications.
  *
  * @do_match: wheather device can be matched with a driver
  * @is_added: device is already scanned
@@ -43,10 +43,10 @@ struct mei_cl_device {
        struct mei_cl *cl;
        char name[MEI_CL_NAME_SIZE];
 
-       struct work_struct event_work;
-       mei_cldev_event_cb_t event_cb;
-       unsigned long events_mask;
-       unsigned long events;
+       struct work_struct rx_work;
+       mei_cldev_cb_t rx_cb;
+       struct work_struct notif_work;
+       mei_cldev_cb_t notif_cb;
 
        unsigned int do_match:1;
        unsigned int is_added:1;
@@ -88,13 +88,9 @@ void mei_cldev_driver_unregister(struct mei_cl_driver *cldrv);
 ssize_t mei_cldev_send(struct mei_cl_device *cldev, u8 *buf, size_t length);
 ssize_t  mei_cldev_recv(struct mei_cl_device *cldev, u8 *buf, size_t length);
 
-int mei_cldev_register_event_cb(struct mei_cl_device *cldev,
-                               unsigned long event_mask,
-                               mei_cldev_event_cb_t read_cb);
-
-#define MEI_CL_EVENT_RX 0
-#define MEI_CL_EVENT_TX 1
-#define MEI_CL_EVENT_NOTIF 2
+int mei_cldev_register_rx_cb(struct mei_cl_device *cldev, mei_cldev_cb_t rx_cb);
+int mei_cldev_register_notif_cb(struct mei_cl_device *cldev,
+                               mei_cldev_cb_t notif_cb);
 
 const uuid_le *mei_cldev_uuid(const struct mei_cl_device *cldev);
 u8 mei_cldev_ver(const struct mei_cl_device *cldev);