--- /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 / commitdiff