Merge branch 'spi-5.4' into spi-next

1 files changed, 28 insertions, 25 deletions

diff --git a/drivers/spi/spi.c b/drivers/spi/spi.c
index 75ac046cae52..f8b4654a57d3 100644
--- a/drivers/spi/spi.c
+++ b/drivers/spi/spi.c
@@ -1265,8 +1265,9 @@ EXPORT_SYMBOL_GPL(spi_finalize_current_transfer);
  */
 static void __spi_pump_messages(struct spi_controller *ctlr, bool in_kthread)
 {
-        unsigned long flags;
+        struct spi_message *msg;
         bool was_busy = false;
+        unsigned long flags;
         int ret;
 
         /* Lock queue */
@@ -1325,10 +1326,10 @@ static void __spi_pump_messages(struct spi_controller *ctlr, bool in_kthread)
         }
 
         /* Extract head of queue */
-        ctlr->cur_msg =
-                list_first_entry(&ctlr->queue, struct spi_message, queue);
+        msg = list_first_entry(&ctlr->queue, struct spi_message, queue);
+        ctlr->cur_msg = msg;
 
-        list_del_init(&ctlr->cur_msg->queue);
+        list_del_init(&msg->queue);
         if (ctlr->busy)
                 was_busy = true;
         else
@@ -1361,7 +1362,7 @@ static void __spi_pump_messages(struct spi_controller *ctlr, bool in_kthread)
                         if (ctlr->auto_runtime_pm)
                                 pm_runtime_put(ctlr->dev.parent);
 
-                        ctlr->cur_msg->status = ret;
+                        msg->status = ret;
                         spi_finalize_current_message(ctlr);
 
                         mutex_unlock(&ctlr->io_mutex);
@@ -1369,28 +1370,28 @@ static void __spi_pump_messages(struct spi_controller *ctlr, bool in_kthread)
                 }
         }
 
-        trace_spi_message_start(ctlr->cur_msg);
+        trace_spi_message_start(msg);
 
         if (ctlr->prepare_message) {
-                ret = ctlr->prepare_message(ctlr, ctlr->cur_msg);
+                ret = ctlr->prepare_message(ctlr, msg);
                 if (ret) {
                         dev_err(&ctlr->dev, "failed to prepare message: %d\n",
                                 ret);
-                        ctlr->cur_msg->status = ret;
+                        msg->status = ret;
                         spi_finalize_current_message(ctlr);
                         goto out;
                 }
                 ctlr->cur_msg_prepared = true;
         }
 
-        ret = spi_map_msg(ctlr, ctlr->cur_msg);
+        ret = spi_map_msg(ctlr, msg);
         if (ret) {
-                ctlr->cur_msg->status = ret;
+                msg->status = ret;
                 spi_finalize_current_message(ctlr);
                 goto out;
         }
 
-        ret = ctlr->transfer_one_message(ctlr, ctlr->cur_msg);
+        ret = ctlr->transfer_one_message(ctlr, msg);
         if (ret) {
                 dev_err(&ctlr->dev,
                         "failed to transfer one message from queue\n");
@@ -1434,7 +1435,7 @@ static void spi_pump_messages(struct kthread_work *work)
  */
 static void spi_set_thread_rt(struct spi_controller *ctlr)
 {
-        struct sched_param param = { .sched_priority = MAX_RT_PRIO - 1 };
+        struct sched_param param = { .sched_priority = MAX_RT_PRIO / 2 };
 
         dev_info(&ctlr->dev,
                 "will run message pump with realtime priority\n");
@@ -2105,8 +2106,8 @@ static int match_true(struct device *dev, void *data)
         return 1;
 }
 
-static ssize_t spi_slave_show(struct device *dev,
-                              struct device_attribute *attr, char *buf)
+static ssize_t slave_show(struct device *dev, struct device_attribute *attr,
+                          char *buf)
 {
         struct spi_controller *ctlr = container_of(dev, struct spi_controller,
                                                    dev);
@@ -2117,9 +2118,8 @@ static ssize_t spi_slave_show(struct device *dev,
                        child ? to_spi_device(child)->modalias : NULL);
 }
 
-static ssize_t spi_slave_store(struct device *dev,
-                               struct device_attribute *attr, const char *buf,
-                               size_t count)
+static ssize_t slave_store(struct device *dev, struct device_attribute *attr,
+                           const char *buf, size_t count)
 {
         struct spi_controller *ctlr = container_of(dev, struct spi_controller,
                                                    dev);
@@ -2157,7 +2157,7 @@ static ssize_t spi_slave_store(struct device *dev,
         return count;
 }
 
-static DEVICE_ATTR(slave, 0644, spi_slave_show, spi_slave_store);
+static DEVICE_ATTR_RW(slave);
 
 static struct attribute *spi_slave_attrs[] = {
         &dev_attr_slave.attr,
@@ -2188,8 +2188,10 @@ extern struct class spi_slave_class;	/* dummy */
  * __spi_alloc_controller - allocate an SPI master or slave controller
  * @dev: the controller, possibly using the platform_bus
  * @size: how much zeroed driver-private data to allocate; the pointer to this
- *      memory is in the driver_data field of the returned device,
- *      accessible with spi_controller_get_devdata().
+ *      memory is in the driver_data field of the returned device, accessible
+ *      with spi_controller_get_devdata(); the memory is cacheline aligned;
+ *      drivers granting DMA access to portions of their private data need to
+ *      round up @size using ALIGN(size, dma_get_cache_alignment()).
  * @slave: flag indicating whether to allocate an SPI master (false) or SPI
  *      slave (true) controller
  * Context: can sleep
@@ -2211,11 +2213,12 @@ struct spi_controller *__spi_alloc_controller(struct device *dev,
                                               unsigned int size, bool slave)
 {
         struct spi_controller   *ctlr;
+        size_t ctlr_size = ALIGN(sizeof(*ctlr), dma_get_cache_alignment());
 
         if (!dev)
                 return NULL;
 
-        ctlr = kzalloc(size + sizeof(*ctlr), GFP_KERNEL);
+        ctlr = kzalloc(size + ctlr_size, GFP_KERNEL);
         if (!ctlr)
                 return NULL;
 
@@ -2229,14 +2232,14 @@ struct spi_controller *__spi_alloc_controller(struct device *dev,
                 ctlr->dev.class = &spi_master_class;
         ctlr->dev.parent = dev;
         pm_suspend_ignore_children(&ctlr->dev, true);
-        spi_controller_set_devdata(ctlr, &ctlr[1]);
+        spi_controller_set_devdata(ctlr, (void *)ctlr + ctlr_size);
 
         return ctlr;
 }
 EXPORT_SYMBOL_GPL(__spi_alloc_controller);
 
 #ifdef CONFIG_OF
-static int of_spi_register_master(struct spi_controller *ctlr)
+static int of_spi_get_gpio_numbers(struct spi_controller *ctlr)
 {
         int nb, i, *cs;
         struct device_node *np = ctlr->dev.of_node;
@@ -2269,7 +2272,7 @@ static int of_spi_register_master(struct spi_controller *ctlr)
         return 0;
 }
 #else
-static int of_spi_register_master(struct spi_controller *ctlr)
+static int of_spi_get_gpio_numbers(struct spi_controller *ctlr)
 {
         return 0;
 }
@@ -2456,7 +2459,7 @@ int spi_register_controller(struct spi_controller *ctlr)
                         ctlr->mode_bits |= SPI_CS_HIGH;
                 } else {
                         /* Legacy code path for GPIOs from DT */
-                        status = of_spi_register_master(ctlr);
+                        status = of_spi_get_gpio_numbers(ctlr);
                         if (status)
                                 return status;
                 }