+++ /dev/null
-commit ffbbdd21329f3e15eeca6df2d4bc11c04d9d91c0
-Author: Linus Walleij <linus.walleij@linaro.org>
-Date: Wed Feb 22 10:05:38 2012 +0100
-
- spi: create a message queueing infrastructure
-
- This rips the message queue in the PL022 driver out and pushes
- it into (optional) common infrastructure. Drivers that want to
- use the message pumping thread will need to define the new
- per-messags transfer methods and leave the deprecated transfer()
- method as NULL.
-
- Most of the design is described in the documentation changes that
- are included in this patch.
-
- Since there is a queue that need to be stopped when the system
- is suspending/resuming, two new calls are implemented for the
- device drivers to call in their suspend()/resume() functions:
- spi_master_suspend() and spi_master_resume().
-
- ChangeLog v1->v2:
- - Remove Kconfig entry and do not make the queue support optional
- at all, instead be more agressive and have it as part of the
- compulsory infrastructure.
- - If the .transfer() method is implemented, delete print a small
- deprecation notice and do not start the transfer pump.
- - Fix a bitrotted comment.
- ChangeLog v2->v3:
- - Fix up a problematic sequence courtesy of Chris Blair.
- - Stop rather than destroy the queue on suspend() courtesy of
- Chris Blair.
-
- Signed-off-by: Chris Blair <chris.blair@stericsson.com>
- Signed-off-by: Linus Walleij <linus.walleij@linaro.org>
- Tested-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
- Reviewed-by: Mark Brown <broonie@opensource.wolfsonmicro.com>
- Signed-off-by: Grant Likely <grant.likely@secretlab.ca>
-
-[Florian: dropped the changes on drivers/spi/spi-pl022.c, removed
-the dev_info() about unqueued drivers still using the master function]
-
---- a/Documentation/spi/spi-summary
-+++ b/Documentation/spi/spi-summary
-@@ -1,7 +1,7 @@
- Overview of Linux kernel SPI support
- ====================================
-
--21-May-2007
-+02-Feb-2012
-
- What is SPI?
- ------------
-@@ -483,9 +483,9 @@ also initialize its own internal state.
- and those methods.)
-
- After you initialize the spi_master, then use spi_register_master() to
--publish it to the rest of the system. At that time, device nodes for
--the controller and any predeclared spi devices will be made available,
--and the driver model core will take care of binding them to drivers.
-+publish it to the rest of the system. At that time, device nodes for the
-+controller and any predeclared spi devices will be made available, and
-+the driver model core will take care of binding them to drivers.
-
- If you need to remove your SPI controller driver, spi_unregister_master()
- will reverse the effect of spi_register_master().
-@@ -521,21 +521,53 @@ SPI MASTER METHODS
- ** When you code setup(), ASSUME that the controller
- ** is actively processing transfers for another device.
-
-- master->transfer(struct spi_device *spi, struct spi_message *message)
-- This must not sleep. Its responsibility is arrange that the
-- transfer happens and its complete() callback is issued. The two
-- will normally happen later, after other transfers complete, and
-- if the controller is idle it will need to be kickstarted.
--
- master->cleanup(struct spi_device *spi)
- Your controller driver may use spi_device.controller_state to hold
- state it dynamically associates with that device. If you do that,
- be sure to provide the cleanup() method to free that state.
-
-+ master->prepare_transfer_hardware(struct spi_master *master)
-+ This will be called by the queue mechanism to signal to the driver
-+ that a message is coming in soon, so the subsystem requests the
-+ driver to prepare the transfer hardware by issuing this call.
-+ This may sleep.
-+
-+ master->unprepare_transfer_hardware(struct spi_master *master)
-+ This will be called by the queue mechanism to signal to the driver
-+ that there are no more messages pending in the queue and it may
-+ relax the hardware (e.g. by power management calls). This may sleep.
-+
-+ master->transfer_one_message(struct spi_master *master,
-+ struct spi_message *mesg)
-+ The subsystem calls the driver to transfer a single message while
-+ queuing transfers that arrive in the meantime. When the driver is
-+ finished with this message, it must call
-+ spi_finalize_current_message() so the subsystem can issue the next
-+ transfer. This may sleep.
-+
-+ DEPRECATED METHODS
-+
-+ master->transfer(struct spi_device *spi, struct spi_message *message)
-+ This must not sleep. Its responsibility is arrange that the
-+ transfer happens and its complete() callback is issued. The two
-+ will normally happen later, after other transfers complete, and
-+ if the controller is idle it will need to be kickstarted. This
-+ method is not used on queued controllers and must be NULL if
-+ transfer_one_message() and (un)prepare_transfer_hardware() are
-+ implemented.
-+
-
- SPI MESSAGE QUEUE
-
--The bulk of the driver will be managing the I/O queue fed by transfer().
-+If you are happy with the standard queueing mechanism provided by the
-+SPI subsystem, just implement the queued methods specified above. Using
-+the message queue has the upside of centralizing a lot of code and
-+providing pure process-context execution of methods. The message queue
-+can also be elevated to realtime priority on high-priority SPI traffic.
-+
-+Unless the queueing mechanism in the SPI subsystem is selected, the bulk
-+of the driver will be managing the I/O queue fed by the now deprecated
-+function transfer().
-
- That queue could be purely conceptual. For example, a driver used only
- for low-frequency sensor access might be fine using synchronous PIO.
-@@ -561,4 +593,6 @@ Stephen Street
- Mark Underwood
- Andrew Victor
- Vitaly Wool
--
-+Grant Likely
-+Mark Brown
-+Linus Walleij
---- a/drivers/spi/spi.c
-+++ b/drivers/spi/spi.c
-@@ -30,6 +30,9 @@
- #include <linux/of_spi.h>
- #include <linux/pm_runtime.h>
- #include <linux/export.h>
-+#include <linux/sched.h>
-+#include <linux/delay.h>
-+#include <linux/kthread.h>
-
- static void spidev_release(struct device *dev)
- {
-@@ -507,6 +510,293 @@ spi_register_board_info(struct spi_board
-
- /*-------------------------------------------------------------------------*/
-
-+/**
-+ * spi_pump_messages - kthread work function which processes spi message queue
-+ * @work: pointer to kthread work struct contained in the master struct
-+ *
-+ * This function checks if there is any spi message in the queue that
-+ * needs processing and if so call out to the driver to initialize hardware
-+ * and transfer each message.
-+ *
-+ */
-+static void spi_pump_messages(struct kthread_work *work)
-+{
-+ struct spi_master *master =
-+ container_of(work, struct spi_master, pump_messages);
-+ unsigned long flags;
-+ bool was_busy = false;
-+ int ret;
-+
-+ /* Lock queue and check for queue work */
-+ spin_lock_irqsave(&master->queue_lock, flags);
-+ if (list_empty(&master->queue) || !master->running) {
-+ if (master->busy) {
-+ ret = master->unprepare_transfer_hardware(master);
-+ if (ret) {
-+ dev_err(&master->dev,
-+ "failed to unprepare transfer hardware\n");
-+ return;
-+ }
-+ }
-+ master->busy = false;
-+ spin_unlock_irqrestore(&master->queue_lock, flags);
-+ return;
-+ }
-+
-+ /* Make sure we are not already running a message */
-+ if (master->cur_msg) {
-+ spin_unlock_irqrestore(&master->queue_lock, flags);
-+ return;
-+ }
-+ /* Extract head of queue */
-+ master->cur_msg =
-+ list_entry(master->queue.next, struct spi_message, queue);
-+
-+ list_del_init(&master->cur_msg->queue);
-+ if (master->busy)
-+ was_busy = true;
-+ else
-+ master->busy = true;
-+ spin_unlock_irqrestore(&master->queue_lock, flags);
-+
-+ if (!was_busy) {
-+ ret = master->prepare_transfer_hardware(master);
-+ if (ret) {
-+ dev_err(&master->dev,
-+ "failed to prepare transfer hardware\n");
-+ return;
-+ }
-+ }
-+
-+ ret = master->transfer_one_message(master, master->cur_msg);
-+ if (ret) {
-+ dev_err(&master->dev,
-+ "failed to transfer one message from queue\n");
-+ return;
-+ }
-+}
-+
-+static int spi_init_queue(struct spi_master *master)
-+{
-+ struct sched_param param = { .sched_priority = MAX_RT_PRIO - 1 };
-+
-+ INIT_LIST_HEAD(&master->queue);
-+ spin_lock_init(&master->queue_lock);
-+
-+ master->running = false;
-+ master->busy = false;
-+
-+ init_kthread_worker(&master->kworker);
-+ master->kworker_task = kthread_run(kthread_worker_fn,
-+ &master->kworker,
-+ dev_name(&master->dev));
-+ if (IS_ERR(master->kworker_task)) {
-+ dev_err(&master->dev, "failed to create message pump task\n");
-+ return -ENOMEM;
-+ }
-+ init_kthread_work(&master->pump_messages, spi_pump_messages);
-+
-+ /*
-+ * Master config will indicate if this controller should run the
-+ * message pump with high (realtime) priority to reduce the transfer
-+ * latency on the bus by minimising the delay between a transfer
-+ * request and the scheduling of the message pump thread. Without this
-+ * setting the message pump thread will remain at default priority.
-+ */
-+ if (master->rt) {
-+ dev_info(&master->dev,
-+ "will run message pump with realtime priority\n");
-+ sched_setscheduler(master->kworker_task, SCHED_FIFO, ¶m);
-+ }
-+
-+ return 0;
-+}
-+
-+/**
-+ * spi_get_next_queued_message() - called by driver to check for queued
-+ * messages
-+ * @master: the master to check for queued messages
-+ *
-+ * If there are more messages in the queue, the next message is returned from
-+ * this call.
-+ */
-+struct spi_message *spi_get_next_queued_message(struct spi_master *master)
-+{
-+ struct spi_message *next;
-+ unsigned long flags;
-+
-+ /* get a pointer to the next message, if any */
-+ spin_lock_irqsave(&master->queue_lock, flags);
-+ if (list_empty(&master->queue))
-+ next = NULL;
-+ else
-+ next = list_entry(master->queue.next,
-+ struct spi_message, queue);
-+ spin_unlock_irqrestore(&master->queue_lock, flags);
-+
-+ return next;
-+}
-+EXPORT_SYMBOL_GPL(spi_get_next_queued_message);
-+
-+/**
-+ * spi_finalize_current_message() - the current message is complete
-+ * @master: the master to return the message to
-+ *
-+ * Called by the driver to notify the core that the message in the front of the
-+ * queue is complete and can be removed from the queue.
-+ */
-+void spi_finalize_current_message(struct spi_master *master)
-+{
-+ struct spi_message *mesg;
-+ unsigned long flags;
-+
-+ spin_lock_irqsave(&master->queue_lock, flags);
-+ mesg = master->cur_msg;
-+ master->cur_msg = NULL;
-+
-+ queue_kthread_work(&master->kworker, &master->pump_messages);
-+ spin_unlock_irqrestore(&master->queue_lock, flags);
-+
-+ mesg->state = NULL;
-+ if (mesg->complete)
-+ mesg->complete(mesg->context);
-+}
-+EXPORT_SYMBOL_GPL(spi_finalize_current_message);
-+
-+static int spi_start_queue(struct spi_master *master)
-+{
-+ unsigned long flags;
-+
-+ spin_lock_irqsave(&master->queue_lock, flags);
-+
-+ if (master->running || master->busy) {
-+ spin_unlock_irqrestore(&master->queue_lock, flags);
-+ return -EBUSY;
-+ }
-+
-+ master->running = true;
-+ master->cur_msg = NULL;
-+ spin_unlock_irqrestore(&master->queue_lock, flags);
-+
-+ queue_kthread_work(&master->kworker, &master->pump_messages);
-+
-+ return 0;
-+}
-+
-+static int spi_stop_queue(struct spi_master *master)
-+{
-+ unsigned long flags;
-+ unsigned limit = 500;
-+ int ret = 0;
-+
-+ spin_lock_irqsave(&master->queue_lock, flags);
-+
-+ /*
-+ * This is a bit lame, but is optimized for the common execution path.
-+ * A wait_queue on the master->busy could be used, but then the common
-+ * execution path (pump_messages) would be required to call wake_up or
-+ * friends on every SPI message. Do this instead.
-+ */
-+ while ((!list_empty(&master->queue) || master->busy) && limit--) {
-+ spin_unlock_irqrestore(&master->queue_lock, flags);
-+ msleep(10);
-+ spin_lock_irqsave(&master->queue_lock, flags);
-+ }
-+
-+ if (!list_empty(&master->queue) || master->busy)
-+ ret = -EBUSY;
-+ else
-+ master->running = false;
-+
-+ spin_unlock_irqrestore(&master->queue_lock, flags);
-+
-+ if (ret) {
-+ dev_warn(&master->dev,
-+ "could not stop message queue\n");
-+ return ret;
-+ }
-+ return ret;
-+}
-+
-+static int spi_destroy_queue(struct spi_master *master)
-+{
-+ int ret;
-+
-+ ret = spi_stop_queue(master);
-+
-+ /*
-+ * flush_kthread_worker will block until all work is done.
-+ * If the reason that stop_queue timed out is that the work will never
-+ * finish, then it does no good to call flush/stop thread, so
-+ * return anyway.
-+ */
-+ if (ret) {
-+ dev_err(&master->dev, "problem destroying queue\n");
-+ return ret;
-+ }
-+
-+ flush_kthread_worker(&master->kworker);
-+ kthread_stop(master->kworker_task);
-+
-+ return 0;
-+}
-+
-+/**
-+ * spi_queued_transfer - transfer function for queued transfers
-+ * @spi: spi device which is requesting transfer
-+ * @msg: spi message which is to handled is queued to driver queue
-+ */
-+static int spi_queued_transfer(struct spi_device *spi, struct spi_message *msg)
-+{
-+ struct spi_master *master = spi->master;
-+ unsigned long flags;
-+
-+ spin_lock_irqsave(&master->queue_lock, flags);
-+
-+ if (!master->running) {
-+ spin_unlock_irqrestore(&master->queue_lock, flags);
-+ return -ESHUTDOWN;
-+ }
-+ msg->actual_length = 0;
-+ msg->status = -EINPROGRESS;
-+
-+ list_add_tail(&msg->queue, &master->queue);
-+ if (master->running && !master->busy)
-+ queue_kthread_work(&master->kworker, &master->pump_messages);
-+
-+ spin_unlock_irqrestore(&master->queue_lock, flags);
-+ return 0;
-+}
-+
-+static int spi_master_initialize_queue(struct spi_master *master)
-+{
-+ int ret;
-+
-+ master->queued = true;
-+ master->transfer = spi_queued_transfer;
-+
-+ /* Initialize and start queue */
-+ ret = spi_init_queue(master);
-+ if (ret) {
-+ dev_err(&master->dev, "problem initializing queue\n");
-+ goto err_init_queue;
-+ }
-+ ret = spi_start_queue(master);
-+ if (ret) {
-+ dev_err(&master->dev, "problem starting queue\n");
-+ goto err_start_queue;
-+ }
-+
-+ return 0;
-+
-+err_start_queue:
-+err_init_queue:
-+ spi_destroy_queue(master);
-+ return ret;
-+}
-+
-+/*-------------------------------------------------------------------------*/
-+
- static void spi_master_release(struct device *dev)
- {
- struct spi_master *master;
-@@ -522,6 +812,7 @@ static struct class spi_master_class = {
- };
-
-
-+
- /**
- * spi_alloc_master - allocate SPI master controller
- * @dev: the controller, possibly using the platform_bus
-@@ -621,6 +912,15 @@ int spi_register_master(struct spi_maste
- dev_dbg(dev, "registered master %s%s\n", dev_name(&master->dev),
- dynamic ? " (dynamic)" : "");
-
-+ /* If we're using a queued driver, start the queue */
-+ if (!master->transfer) {
-+ status = spi_master_initialize_queue(master);
-+ if (status) {
-+ device_unregister(&master->dev);
-+ goto done;
-+ }
-+ }
-+
- mutex_lock(&board_lock);
- list_add_tail(&master->list, &spi_master_list);
- list_for_each_entry(bi, &board_list, list)
-@@ -636,7 +936,6 @@ done:
- }
- EXPORT_SYMBOL_GPL(spi_register_master);
-
--
- static int __unregister(struct device *dev, void *null)
- {
- spi_unregister_device(to_spi_device(dev));
-@@ -657,6 +956,11 @@ void spi_unregister_master(struct spi_ma
- {
- int dummy;
-
-+ if (master->queued) {
-+ if (spi_destroy_queue(master))
-+ dev_err(&master->dev, "queue remove failed\n");
-+ }
-+
- mutex_lock(&board_lock);
- list_del(&master->list);
- mutex_unlock(&board_lock);
-@@ -666,6 +970,37 @@ void spi_unregister_master(struct spi_ma
- }
- EXPORT_SYMBOL_GPL(spi_unregister_master);
-
-+int spi_master_suspend(struct spi_master *master)
-+{
-+ int ret;
-+
-+ /* Basically no-ops for non-queued masters */
-+ if (!master->queued)
-+ return 0;
-+
-+ ret = spi_stop_queue(master);
-+ if (ret)
-+ dev_err(&master->dev, "queue stop failed\n");
-+
-+ return ret;
-+}
-+EXPORT_SYMBOL_GPL(spi_master_suspend);
-+
-+int spi_master_resume(struct spi_master *master)
-+{
-+ int ret;
-+
-+ if (!master->queued)
-+ return 0;
-+
-+ ret = spi_start_queue(master);
-+ if (ret)
-+ dev_err(&master->dev, "queue restart failed\n");
-+
-+ return ret;
-+}
-+EXPORT_SYMBOL_GPL(spi_master_resume);
-+
- static int __spi_master_match(struct device *dev, void *data)
- {
- struct spi_master *m;
---- a/include/linux/spi/spi.h
-+++ b/include/linux/spi/spi.h
-@@ -22,6 +22,7 @@
- #include <linux/device.h>
- #include <linux/mod_devicetable.h>
- #include <linux/slab.h>
-+#include <linux/kthread.h>
-
- /*
- * INTERFACES between SPI master-side drivers and SPI infrastructure.
-@@ -235,6 +236,27 @@ static inline void spi_unregister_driver
- * the device whose settings are being modified.
- * @transfer: adds a message to the controller's transfer queue.
- * @cleanup: frees controller-specific state
-+ * @queued: whether this master is providing an internal message queue
-+ * @kworker: thread struct for message pump
-+ * @kworker_task: pointer to task for message pump kworker thread
-+ * @pump_messages: work struct for scheduling work to the message pump
-+ * @queue_lock: spinlock to syncronise access to message queue
-+ * @queue: message queue
-+ * @cur_msg: the currently in-flight message
-+ * @busy: message pump is busy
-+ * @running: message pump is running
-+ * @rt: whether this queue is set to run as a realtime task
-+ * @prepare_transfer_hardware: a message will soon arrive from the queue
-+ * so the subsystem requests the driver to prepare the transfer hardware
-+ * by issuing this call
-+ * @transfer_one_message: the subsystem calls the driver to transfer a single
-+ * message while queuing transfers that arrive in the meantime. When the
-+ * driver is finished with this message, it must call
-+ * spi_finalize_current_message() so the subsystem can issue the next
-+ * transfer
-+ * @prepare_transfer_hardware: there are currently no more messages on the
-+ * queue so the subsystem notifies the driver that it may relax the
-+ * hardware by issuing this call
- *
- * Each SPI master controller can communicate with one or more @spi_device
- * children. These make a small bus, sharing MOSI, MISO and SCK signals
-@@ -318,6 +340,28 @@ struct spi_master {
-
- /* called on release() to free memory provided by spi_master */
- void (*cleanup)(struct spi_device *spi);
-+
-+ /*
-+ * These hooks are for drivers that want to use the generic
-+ * master transfer queueing mechanism. If these are used, the
-+ * transfer() function above must NOT be specified by the driver.
-+ * Over time we expect SPI drivers to be phased over to this API.
-+ */
-+ bool queued;
-+ struct kthread_worker kworker;
-+ struct task_struct *kworker_task;
-+ struct kthread_work pump_messages;
-+ spinlock_t queue_lock;
-+ struct list_head queue;
-+ struct spi_message *cur_msg;
-+ bool busy;
-+ bool running;
-+ bool rt;
-+
-+ int (*prepare_transfer_hardware)(struct spi_master *master);
-+ int (*transfer_one_message)(struct spi_master *master,
-+ struct spi_message *mesg);
-+ int (*unprepare_transfer_hardware)(struct spi_master *master);
- };
-
- static inline void *spi_master_get_devdata(struct spi_master *master)
-@@ -343,6 +387,13 @@ static inline void spi_master_put(struct
- put_device(&master->dev);
- }
-
-+/* PM calls that need to be issued by the driver */
-+extern int spi_master_suspend(struct spi_master *master);
-+extern int spi_master_resume(struct spi_master *master);
-+
-+/* Calls the driver make to interact with the message queue */
-+extern struct spi_message *spi_get_next_queued_message(struct spi_master *master);
-+extern void spi_finalize_current_message(struct spi_master *master);
-
- /* the spi driver core manages memory for the spi_master classdev */
- extern struct spi_master *
projects / openwrt / svn-archive / archive.git / blobdiff