Merge tag 'char-misc-4.7-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/char-misc

Pull char / misc driver updates from Greg KH:
 "Here's the big char and misc driver update for 4.7-rc1.

  Lots of different tiny driver subsystems have updates here with new
  drivers and functionality.  Details in the shortlog.

  All have been in linux-next with no reported issues for a while"

* tag 'char-misc-4.7-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/gregkh/char-misc: (125 commits)
  mcb: Delete num_cells variable which is not required
  mcb: Fixed bar number assignment for the gdd
  mcb: Replace ioremap and request_region with the devm version
  mcb: Implement bus->dev.release callback
  mcb: export bus information via sysfs
  mcb: Correctly initialize the bus's device
  mei: bus: call mei_cl_read_start under device lock
  coresight: etb10: adjust read pointer only when needed
  coresight: configuring ETF in FIFO mode when acting as link
  coresight: tmc: implementing TMC-ETF AUX space API
  coresight: moving struct cs_buffers to header file
  coresight: tmc: keep track of memory width
  coresight: tmc: make sysFS and Perf mode mutually exclusive
  coresight: tmc: dump system memory content only when needed
  coresight: tmc: adding mode of operation for link/sinks
  coresight: tmc: getting rid of multiple read access
  coresight: tmc: allocating memory when needed
  coresight: tmc: making prepare/unprepare functions generic
  coresight: tmc: splitting driver in ETB/ETF and ETR components
  coresight: tmc: cleaning up header file
  ...

6 files changed, 57 insertions, 55 deletions

diff --git a/drivers/misc/mei/amthif.c b/drivers/misc/mei/amthif.c
index 194360a5f782..a039a5df6f21 100644
--- a/drivers/misc/mei/amthif.c
+++ b/drivers/misc/mei/amthif.c
@@ -380,8 +380,10 @@ int mei_amthif_irq_read_msg(struct mei_cl *cl,
 
         dev = cl->dev;
 
-        if (dev->iamthif_state != MEI_IAMTHIF_READING)
+        if (dev->iamthif_state != MEI_IAMTHIF_READING) {
+                mei_irq_discard_msg(dev, mei_hdr);
                 return 0;
+        }
 
         ret = mei_cl_irq_read_msg(cl, mei_hdr, cmpl_list);
         if (ret)
diff --git a/drivers/misc/mei/bus.c b/drivers/misc/mei/bus.c
index 5d5996e39a67..1f33fea9299f 100644
--- a/drivers/misc/mei/bus.c
+++ b/drivers/misc/mei/bus.c
@@ -220,17 +220,23 @@ EXPORT_SYMBOL_GPL(mei_cldev_recv);
 static void mei_cl_bus_event_work(struct work_struct *work)
 {
         struct mei_cl_device *cldev;
+        struct mei_device *bus;
 
         cldev = container_of(work, struct mei_cl_device, event_work);
 
+        bus = cldev->bus;
+
         if (cldev->event_cb)
                 cldev->event_cb(cldev, cldev->events, cldev->event_context);
 
         cldev->events = 0;
 
         /* Prepare for the next read */
-        if (cldev->events_mask & BIT(MEI_CL_EVENT_RX))
+        if (cldev->events_mask & BIT(MEI_CL_EVENT_RX)) {
+                mutex_lock(&bus->device_lock);
                 mei_cl_read_start(cldev->cl, 0, NULL);
+                mutex_unlock(&bus->device_lock);
+        }
 }
 
 /**
@@ -304,6 +310,7 @@ int mei_cldev_register_event_cb(struct mei_cl_device *cldev,
                                 unsigned long events_mask,
                                 mei_cldev_event_cb_t event_cb, void *context)
 {
+        struct mei_device *bus = cldev->bus;
         int ret;
 
         if (cldev->event_cb)
@@ -316,15 +323,17 @@ int mei_cldev_register_event_cb(struct mei_cl_device *cldev,
         INIT_WORK(&cldev->event_work, mei_cl_bus_event_work);
 
         if (cldev->events_mask & BIT(MEI_CL_EVENT_RX)) {
+                mutex_lock(&bus->device_lock);
                 ret = mei_cl_read_start(cldev->cl, 0, NULL);
+                mutex_unlock(&bus->device_lock);
                 if (ret && ret != -EBUSY)
                         return ret;
         }
 
         if (cldev->events_mask & BIT(MEI_CL_EVENT_NOTIF)) {
-                mutex_lock(&cldev->cl->dev->device_lock);
+                mutex_lock(&bus->device_lock);
                 ret = mei_cl_notify_request(cldev->cl, NULL, event_cb ? 1 : 0);
-                mutex_unlock(&cldev->cl->dev->device_lock);
+                mutex_unlock(&bus->device_lock);
                 if (ret)
                         return ret;
         }
@@ -580,6 +589,7 @@ static int mei_cl_device_probe(struct device *dev)
         struct mei_cl_device *cldev;
         struct mei_cl_driver *cldrv;
         const struct mei_cl_device_id *id;
+        int ret;
 
         cldev = to_mei_cl_device(dev);
         cldrv = to_mei_cl_driver(dev->driver);
@@ -594,9 +604,12 @@ static int mei_cl_device_probe(struct device *dev)
         if (!id)
                 return -ENODEV;
 
-        __module_get(THIS_MODULE);
+        ret = cldrv->probe(cldev, id);
+        if (ret)
+                return ret;
 
-        return cldrv->probe(cldev, id);
+        __module_get(THIS_MODULE);
+        return 0;
 }
 
 /**
@@ -634,11 +647,8 @@ static ssize_t name_show(struct device *dev, struct device_attribute *a,
                              char *buf)
 {
         struct mei_cl_device *cldev = to_mei_cl_device(dev);
-        size_t len;
-
-        len = snprintf(buf, PAGE_SIZE, "%s", cldev->name);
 
-        return (len >= PAGE_SIZE) ? (PAGE_SIZE - 1) : len;
+        return scnprintf(buf, PAGE_SIZE, "%s", cldev->name);
 }
 static DEVICE_ATTR_RO(name);
 
@@ -647,11 +657,8 @@ static ssize_t uuid_show(struct device *dev, struct device_attribute *a,
 {
         struct mei_cl_device *cldev = to_mei_cl_device(dev);
         const uuid_le *uuid = mei_me_cl_uuid(cldev->me_cl);
-        size_t len;
 
-        len = snprintf(buf, PAGE_SIZE, "%pUl", uuid);
-
-        return (len >= PAGE_SIZE) ? (PAGE_SIZE - 1) : len;
+        return scnprintf(buf, PAGE_SIZE, "%pUl", uuid);
 }
 static DEVICE_ATTR_RO(uuid);
 
@@ -660,11 +667,8 @@ static ssize_t version_show(struct device *dev, struct device_attribute *a,
 {
         struct mei_cl_device *cldev = to_mei_cl_device(dev);
         u8 version = mei_me_cl_ver(cldev->me_cl);
-        size_t len;
-
-        len = snprintf(buf, PAGE_SIZE, "%02X", version);
 
-        return (len >= PAGE_SIZE) ? (PAGE_SIZE - 1) : len;
+        return scnprintf(buf, PAGE_SIZE, "%02X", version);
 }
 static DEVICE_ATTR_RO(version);
 
@@ -673,10 +677,8 @@ static ssize_t modalias_show(struct device *dev, struct device_attribute *a,
 {
         struct mei_cl_device *cldev = to_mei_cl_device(dev);
         const uuid_le *uuid = mei_me_cl_uuid(cldev->me_cl);
-        size_t len;
 
-        len = snprintf(buf, PAGE_SIZE, "mei:%s:%pUl:", cldev->name, uuid);
-        return (len >= PAGE_SIZE) ? (PAGE_SIZE - 1) : len;
+        return scnprintf(buf, PAGE_SIZE, "mei:%s:%pUl:", cldev->name, uuid);
 }
 static DEVICE_ATTR_RO(modalias);
 
diff --git a/drivers/misc/mei/client.c b/drivers/misc/mei/client.c
index bab17e4197b6..eed254da63a8 100644
--- a/drivers/misc/mei/client.c
+++ b/drivers/misc/mei/client.c
@@ -727,6 +727,11 @@ static void mei_cl_wake_all(struct mei_cl *cl)
                 cl_dbg(dev, cl, "Waking up waiting for event clients!\n");
                 wake_up_interruptible(&cl->ev_wait);
         }
+        /* synchronized under device mutex */
+        if (waitqueue_active(&cl->wait)) {
+                cl_dbg(dev, cl, "Waking up ctrl write clients!\n");
+                wake_up_interruptible(&cl->wait);
+        }
 }
 
 /**
@@ -879,12 +884,15 @@ static int __mei_cl_disconnect(struct mei_cl *cl)
         }
 
         mutex_unlock(&dev->device_lock);
-        wait_event_timeout(cl->wait, cl->state == MEI_FILE_DISCONNECT_REPLY,
+        wait_event_timeout(cl->wait,
+                           cl->state == MEI_FILE_DISCONNECT_REPLY ||
+                           cl->state == MEI_FILE_DISCONNECTED,
                            mei_secs_to_jiffies(MEI_CL_CONNECT_TIMEOUT));
         mutex_lock(&dev->device_lock);
 
         rets = cl->status;
-        if (cl->state != MEI_FILE_DISCONNECT_REPLY) {
+        if (cl->state != MEI_FILE_DISCONNECT_REPLY &&
+            cl->state != MEI_FILE_DISCONNECTED) {
                 cl_dbg(dev, cl, "timeout on disconnect from FW client.\n");
                 rets = -ETIME;
         }
@@ -1085,6 +1093,7 @@ int mei_cl_connect(struct mei_cl *cl, struct mei_me_client *me_cl,
         mutex_unlock(&dev->device_lock);
         wait_event_timeout(cl->wait,
                         (cl->state == MEI_FILE_CONNECTED ||
+                         cl->state == MEI_FILE_DISCONNECTED ||
                          cl->state == MEI_FILE_DISCONNECT_REQUIRED ||
                          cl->state == MEI_FILE_DISCONNECT_REPLY),
                         mei_secs_to_jiffies(MEI_CL_CONNECT_TIMEOUT));
@@ -1333,16 +1342,13 @@ int mei_cl_notify_request(struct mei_cl *cl,
         }
 
         mutex_unlock(&dev->device_lock);
-        wait_event_timeout(cl->wait, cl->notify_en == request,
-                        mei_secs_to_jiffies(MEI_CL_CONNECT_TIMEOUT));
+        wait_event_timeout(cl->wait,
+                           cl->notify_en == request || !mei_cl_is_connected(cl),
+                           mei_secs_to_jiffies(MEI_CL_CONNECT_TIMEOUT));
         mutex_lock(&dev->device_lock);
 
-        if (cl->notify_en != request) {
-                mei_io_list_flush(&dev->ctrl_rd_list, cl);
-                mei_io_list_flush(&dev->ctrl_wr_list, cl);
-                if (!cl->status)
-                        cl->status = -EFAULT;
-        }
+        if (cl->notify_en != request && !cl->status)
+                cl->status = -EFAULT;
 
         rets = cl->status;
 
@@ -1767,6 +1773,10 @@ void mei_cl_complete(struct mei_cl *cl, struct mei_cl_cb *cb)
                         wake_up(&cl->wait);
 
                 break;
+        case MEI_FOP_DISCONNECT_RSP:
+                mei_io_cb_free(cb);
+                mei_cl_set_disconnected(cl);
+                break;
         default:
                 BUG_ON(0);
         }
diff --git a/drivers/misc/mei/hbm.c b/drivers/misc/mei/hbm.c
index 5e305d2605f3..5aa606c8a827 100644
--- a/drivers/misc/mei/hbm.c
+++ b/drivers/misc/mei/hbm.c
@@ -113,8 +113,6 @@ void mei_hbm_idle(struct mei_device *dev)
  */
 void mei_hbm_reset(struct mei_device *dev)
 {
-        dev->me_client_index = 0;
-
         mei_me_cl_rm_all(dev);
 
         mei_hbm_idle(dev);
@@ -530,24 +528,22 @@ static void mei_hbm_cl_notify(struct mei_device *dev,
  * mei_hbm_prop_req - request property for a single client
  *
  * @dev: the device structure
+ * @start_idx: client index to start search
  *
  * Return: 0 on success and < 0 on failure
  */
-
-static int mei_hbm_prop_req(struct mei_device *dev)
+static int mei_hbm_prop_req(struct mei_device *dev, unsigned long start_idx)
 {
-
         struct mei_msg_hdr *mei_hdr = &dev->wr_msg.hdr;
         struct hbm_props_request *prop_req;
         const size_t len = sizeof(struct hbm_props_request);
-        unsigned long next_client_index;
+        unsigned long addr;
         int ret;
 
-        next_client_index = find_next_bit(dev->me_clients_map, MEI_CLIENTS_MAX,
-                                          dev->me_client_index);
+        addr = find_next_bit(dev->me_clients_map, MEI_CLIENTS_MAX, start_idx);
 
         /* We got all client properties */
-        if (next_client_index == MEI_CLIENTS_MAX) {
+        if (addr == MEI_CLIENTS_MAX) {
                 dev->hbm_state = MEI_HBM_STARTED;
                 mei_host_client_init(dev);
 
@@ -560,7 +556,7 @@ static int mei_hbm_prop_req(struct mei_device *dev)
         memset(prop_req, 0, sizeof(struct hbm_props_request));
 
         prop_req->hbm_cmd = HOST_CLIENT_PROPERTIES_REQ_CMD;
-        prop_req->me_addr = next_client_index;
+        prop_req->me_addr = addr;
 
         ret = mei_write_message(dev, mei_hdr, dev->wr_msg.data);
         if (ret) {
@@ -570,7 +566,6 @@ static int mei_hbm_prop_req(struct mei_device *dev)
         }
 
         dev->init_clients_timer = MEI_CLIENTS_INIT_TIMEOUT;
-        dev->me_client_index = next_client_index;
 
         return 0;
 }
@@ -882,8 +877,7 @@ static int mei_hbm_fw_disconnect_req(struct mei_device *dev,
                 cb = mei_io_cb_init(cl, MEI_FOP_DISCONNECT_RSP, NULL);
                 if (!cb)
                         return -ENOMEM;
-                cl_dbg(dev, cl, "add disconnect response as first\n");
-                list_add(&cb->list, &dev->ctrl_wr_list.list);
+                list_add_tail(&cb->list, &dev->ctrl_wr_list.list);
         }
         return 0;
 }
@@ -1152,10 +1146,8 @@ int mei_hbm_dispatch(struct mei_device *dev, struct mei_msg_hdr *hdr)
 
                 mei_hbm_me_cl_add(dev, props_res);
 
-                dev->me_client_index++;
-
                 /* request property for the next client */
-                if (mei_hbm_prop_req(dev))
+                if (mei_hbm_prop_req(dev, props_res->me_addr + 1))
                         return -EIO;
 
                 break;
@@ -1181,7 +1173,7 @@ int mei_hbm_dispatch(struct mei_device *dev, struct mei_msg_hdr *hdr)
                 dev->hbm_state = MEI_HBM_CLIENT_PROPERTIES;
 
                 /* first property request */
-                if (mei_hbm_prop_req(dev))
+                if (mei_hbm_prop_req(dev, 0))
                         return -EIO;
 
                 break;
diff --git a/drivers/misc/mei/interrupt.c b/drivers/misc/mei/interrupt.c
index 1e5cb1f704f8..3831a7ba2531 100644
--- a/drivers/misc/mei/interrupt.c
+++ b/drivers/misc/mei/interrupt.c
@@ -76,7 +76,6 @@ static inline int mei_cl_hbm_equal(struct mei_cl *cl,
  * @dev: mei device
  * @hdr: message header
  */
-static inline
 void mei_irq_discard_msg(struct mei_device *dev, struct mei_msg_hdr *hdr)
 {
         /*
@@ -194,10 +193,7 @@ static int mei_cl_irq_disconnect_rsp(struct mei_cl *cl, struct mei_cl_cb *cb,
                 return -EMSGSIZE;
 
         ret = mei_hbm_cl_disconnect_rsp(dev, cl);
-        mei_cl_set_disconnected(cl);
-        mei_io_cb_free(cb);
-        mei_me_cl_put(cl->me_cl);
-        cl->me_cl = NULL;
+        list_move_tail(&cb->list, &cmpl_list->list);
 
         return ret;
 }
diff --git a/drivers/misc/mei/mei_dev.h b/drivers/misc/mei/mei_dev.h
index db78e6d99456..c9e01021eadf 100644
--- a/drivers/misc/mei/mei_dev.h
+++ b/drivers/misc/mei/mei_dev.h
@@ -396,7 +396,6 @@ const char *mei_pg_state_str(enum mei_pg_state state);
  * @me_clients  : list of FW clients
  * @me_clients_map : FW clients bit map
  * @host_clients_map : host clients id pool
- * @me_client_index : last FW client index in enumeration
  *
  * @allow_fixed_address: allow user space to connect a fixed client
  * @override_fixed_address: force allow fixed address behavior
@@ -486,7 +485,6 @@ struct mei_device {
         struct list_head me_clients;
         DECLARE_BITMAP(me_clients_map, MEI_CLIENTS_MAX);
         DECLARE_BITMAP(host_clients_map, MEI_CLIENTS_MAX);
-        unsigned long me_client_index;
 
         bool allow_fixed_address;
         bool override_fixed_address;
@@ -704,6 +702,8 @@ bool mei_hbuf_acquire(struct mei_device *dev);
 
 bool mei_write_is_idle(struct mei_device *dev);
 
+void mei_irq_discard_msg(struct mei_device *dev, struct mei_msg_hdr *hdr);
+
 #if IS_ENABLED(CONFIG_DEBUG_FS)
 int mei_dbgfs_register(struct mei_device *dev, const char *name);
 void mei_dbgfs_deregister(struct mei_device *dev);