spi.c

Go to the documentation of this file.

/*
 * SPI init/core code
 *
 * Copyright (C) 2005 David Brownell
 * Copyright (C) 2008 Secret Lab Technologies Ltd.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include <linux/kernel.h>
#include <linux/kmod.h>
#include <linux/device.h>
#include <linux/init.h>
#include <linux/cache.h>
#include <linux/mutex.h>
#include <linux/of_device.h>
#include <linux/of_irq.h>
#include <linux/slab.h>
#include <linux/mod_devicetable.h>
#include <linux/spi/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)
{
    struct spi_device   *spi = to_spi_device(dev);

    /* spi masters may cleanup for released devices */
    if (spi->master->cleanup)
        spi->master->cleanup(spi);

    spi_master_put(spi->master);
    kfree(spi);
}

static ssize_t
modalias_show(struct device *dev, struct device_attribute *a, char *buf)
{
    const struct spi_device *spi = to_spi_device(dev);

    return sprintf(buf, "%s%s\n", SPI_MODULE_PREFIX, spi->modalias);
}

static struct device_attribute spi_dev_attrs[] = {
    __ATTR_RO(modalias),
    __ATTR_NULL,
};

/* modalias support makes "modprobe $MODALIAS" new-style hotplug work,
 * and the sysfs version makes coldplug work too.
 */

static const struct spi_device_id *spi_match_id(const struct spi_device_id *id,
                        const struct spi_device *sdev)
{
    while (id->name[0]) {
        if (!strcmp(sdev->modalias, id->name))
            return id;
        id++;
    }
    return NULL;
}

const struct spi_device_id *spi_get_device_id(const struct spi_device *sdev)
{
    const struct spi_driver *sdrv = to_spi_driver(sdev->dev.driver);

    return spi_match_id(sdrv->id_table, sdev);
}
EXPORT_SYMBOL_GPL(spi_get_device_id);

static int spi_match_device(struct device *dev, struct device_driver *drv)
{
    const struct spi_device *spi = to_spi_device(dev);
    const struct spi_driver *sdrv = to_spi_driver(drv);

    /* Attempt an OF style match */
    if (of_driver_match_device(dev, drv))
        return 1;

    if (sdrv->id_table)
        return !!spi_match_id(sdrv->id_table, spi);

    return strcmp(spi->modalias, drv->name) == 0;
}

static int spi_uevent(struct device *dev, struct kobj_uevent_env *env)
{
    const struct spi_device     *spi = to_spi_device(dev);

    add_uevent_var(env, "MODALIAS=%s%s", SPI_MODULE_PREFIX, spi->modalias);
    return 0;
}

#ifdef CONFIG_PM_SLEEP
static int spi_legacy_suspend(struct device *dev, pm_message_t message)
{
    int         value = 0;
    struct spi_driver   *drv = to_spi_driver(dev->driver);

    /* suspend will stop irqs and dma; no more i/o */
    if (drv) {
        if (drv->suspend)
            value = drv->suspend(to_spi_device(dev), message);
        else
            dev_dbg(dev, "... can't suspend\n");
    }
    return value;
}

static int spi_legacy_resume(struct device *dev)
{
    int         value = 0;
    struct spi_driver   *drv = to_spi_driver(dev->driver);

    /* resume may restart the i/o queue */
    if (drv) {
        if (drv->resume)
            value = drv->resume(to_spi_device(dev));
        else
            dev_dbg(dev, "... can't resume\n");
    }
    return value;
}

static int spi_pm_suspend(struct device *dev)
{
    const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;

    if (pm)
        return pm_generic_suspend(dev);
    else
        return spi_legacy_suspend(dev, PMSG_SUSPEND);
}

static int spi_pm_resume(struct device *dev)
{
    const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;

    if (pm)
        return pm_generic_resume(dev);
    else
        return spi_legacy_resume(dev);
}

static int spi_pm_freeze(struct device *dev)
{
    const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;

    if (pm)
        return pm_generic_freeze(dev);
    else
        return spi_legacy_suspend(dev, PMSG_FREEZE);
}

static int spi_pm_thaw(struct device *dev)
{
    const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;

    if (pm)
        return pm_generic_thaw(dev);
    else
        return spi_legacy_resume(dev);
}

static int spi_pm_poweroff(struct device *dev)
{
    const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;

    if (pm)
        return pm_generic_poweroff(dev);
    else
        return spi_legacy_suspend(dev, PMSG_HIBERNATE);
}

static int spi_pm_restore(struct device *dev)
{
    const struct dev_pm_ops *pm = dev->driver ? dev->driver->pm : NULL;

    if (pm)
        return pm_generic_restore(dev);
    else
        return spi_legacy_resume(dev);
}
#else
#define spi_pm_suspend  NULL
#define spi_pm_resume   NULL
#define spi_pm_freeze   NULL
#define spi_pm_thaw NULL
#define spi_pm_poweroff NULL
#define spi_pm_restore  NULL
#endif

static const struct dev_pm_ops spi_pm = {
    .suspend = spi_pm_suspend,
    .resume = spi_pm_resume,
    .freeze = spi_pm_freeze,
    .thaw = spi_pm_thaw,
    .poweroff = spi_pm_poweroff,
    .restore = spi_pm_restore,
    SET_RUNTIME_PM_OPS(
        pm_generic_runtime_suspend,
        pm_generic_runtime_resume,
        pm_generic_runtime_idle
    )
};

struct bus_type spi_bus_type = {
    .name       = "spi",
    .dev_attrs  = spi_dev_attrs,
    .match      = spi_match_device,
    .uevent     = spi_uevent,
    .pm     = &spi_pm,
};
EXPORT_SYMBOL_GPL(spi_bus_type);


static int spi_drv_probe(struct device *dev)
{
    const struct spi_driver     *sdrv = to_spi_driver(dev->driver);

    return sdrv->probe(to_spi_device(dev));
}

static int spi_drv_remove(struct device *dev)
{
    const struct spi_driver     *sdrv = to_spi_driver(dev->driver);

    return sdrv->remove(to_spi_device(dev));
}

static void spi_drv_shutdown(struct device *dev)
{
    const struct spi_driver     *sdrv = to_spi_driver(dev->driver);

    sdrv->shutdown(to_spi_device(dev));
}

int spi_register_driver(struct spi_driver *sdrv)
{
    sdrv->driver.bus = &spi_bus_type;
    if (sdrv->probe)
        sdrv->driver.probe = spi_drv_probe;
    if (sdrv->remove)
        sdrv->driver.remove = spi_drv_remove;
    if (sdrv->shutdown)
        sdrv->driver.shutdown = spi_drv_shutdown;
    return driver_register(&sdrv->driver);
}
EXPORT_SYMBOL_GPL(spi_register_driver);

/*-------------------------------------------------------------------------*/

/* SPI devices should normally not be created by SPI device drivers; that
 * would make them board-specific.  Similarly with SPI master drivers.
 * Device registration normally goes into like arch/.../mach.../board-YYY.c
 * with other readonly (flashable) information about mainboard devices.
 */

struct boardinfo {
    struct list_head    list;
    struct spi_board_info   board_info;
};

static LIST_HEAD(board_list);
static LIST_HEAD(spi_master_list);

/*
 * Used to protect add/del opertion for board_info list and
 * spi_master list, and their matching process
 */
static DEFINE_MUTEX(board_lock);

struct spi_device *spi_alloc_device(struct spi_master *master)
{
    struct spi_device   *spi;
    struct device       *dev = master->dev.parent;

    if (!spi_master_get(master))
        return NULL;

    spi = kzalloc(sizeof *spi, GFP_KERNEL);
    if (!spi) {
        dev_err(dev, "cannot alloc spi_device\n");
        spi_master_put(master);
        return NULL;
    }

    spi->master = master;
    spi->dev.parent = &master->dev;
    spi->dev.bus = &spi_bus_type;
    spi->dev.release = spidev_release;
    device_initialize(&spi->dev);
    return spi;
}
EXPORT_SYMBOL_GPL(spi_alloc_device);

int spi_add_device(struct spi_device *spi)
{
    static DEFINE_MUTEX(spi_add_lock);
    struct device *dev = spi->master->dev.parent;
    struct device *d;
    int status;

    /* Chipselects are numbered 0..max; validate. */
    if (spi->chip_select >= spi->master->num_chipselect) {
        dev_err(dev, "cs%d >= max %d\n",
            spi->chip_select,
            spi->master->num_chipselect);
        return -EINVAL;
    }

    /* Set the bus ID string */
    dev_set_name(&spi->dev, "%s.%u", dev_name(&spi->master->dev),
            spi->chip_select);


    /* We need to make sure there's no other device with this
     * chipselect **BEFORE** we call setup(), else we'll trash
     * its configuration.  Lock against concurrent add() calls.
     */
    mutex_lock(&spi_add_lock);

    d = bus_find_device_by_name(&spi_bus_type, NULL, dev_name(&spi->dev));
    if (d != NULL) {
        dev_err(dev, "chipselect %d already in use\n",
                spi->chip_select);
        put_device(d);
        status = -EBUSY;
        goto done;
    }

    /* Drivers may modify this initial i/o setup, but will
     * normally rely on the device being setup.  Devices
     * using SPI_CS_HIGH can't coexist well otherwise...
     */
    status = spi_setup(spi);
    if (status < 0) {
        dev_err(dev, "can't setup %s, status %d\n",
                dev_name(&spi->dev), status);
        goto done;
    }

    /* Device may be bound to an active driver when this returns */
    status = device_add(&spi->dev);
    if (status < 0)
        dev_err(dev, "can't add %s, status %d\n",
                dev_name(&spi->dev), status);
    else
        dev_dbg(dev, "registered child %s\n", dev_name(&spi->dev));

done:
    mutex_unlock(&spi_add_lock);
    return status;
}
EXPORT_SYMBOL_GPL(spi_add_device);

struct spi_device *spi_new_device(struct spi_master *master,
                  struct spi_board_info *chip)
{
    struct spi_device   *proxy;
    int         status;

    /* NOTE:  caller did any chip->bus_num checks necessary.
     *
     * Also, unless we change the return value convention to use
     * error-or-pointer (not NULL-or-pointer), troubleshootability
     * suggests syslogged diagnostics are best here (ugh).
     */

    proxy = spi_alloc_device(master);
    if (!proxy)
        return NULL;

    WARN_ON(strlen(chip->modalias) >= sizeof(proxy->modalias));

    proxy->chip_select = chip->chip_select;
    proxy->max_speed_hz = chip->max_speed_hz;
    proxy->mode = chip->mode;
    proxy->irq = chip->irq;
    strlcpy(proxy->modalias, chip->modalias, sizeof(proxy->modalias));
    proxy->dev.platform_data = (void *) chip->platform_data;
    proxy->controller_data = chip->controller_data;
    proxy->controller_state = NULL;

    status = spi_add_device(proxy);
    if (status < 0) {
        spi_dev_put(proxy);
        return NULL;
    }

    return proxy;
}
EXPORT_SYMBOL_GPL(spi_new_device);

static void spi_match_master_to_boardinfo(struct spi_master *master,
                struct spi_board_info *bi)
{
    struct spi_device *dev;

    if (master->bus_num != bi->bus_num)
        return;

    dev = spi_new_device(master, bi);
    if (!dev)
        dev_err(master->dev.parent, "can't create new device for %s\n",
            bi->modalias);
}

int __devinit
spi_register_board_info(struct spi_board_info const *info, unsigned n)
{
    struct boardinfo *bi;
    int i;

    bi = kzalloc(n * sizeof(*bi), GFP_KERNEL);
    if (!bi)
        return -ENOMEM;

    for (i = 0; i < n; i++, bi++, info++) {
        struct spi_master *master;

        memcpy(&bi->board_info, info, sizeof(*info));
        mutex_lock(&board_lock);
        list_add_tail(&bi->list, &board_list);
        list_for_each_entry(master, &spi_master_list, list)
            spi_match_master_to_boardinfo(master, &bi->board_info);
        mutex_unlock(&board_lock);
    }

    return 0;
}

/*-------------------------------------------------------------------------*/

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 && master->unprepare_transfer_hardware) {
            ret = master->unprepare_transfer_hardware(master);
            if (ret) {
                spin_unlock_irqrestore(&master->queue_lock, flags);
                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 && master->prepare_transfer_hardware) {
        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, &param);
    }

    return 0;
}

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);

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;
}

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;
}

/*-------------------------------------------------------------------------*/

#if defined(CONFIG_OF) && !defined(CONFIG_SPARC)

static void of_register_spi_devices(struct spi_master *master)
{
    struct spi_device *spi;
    struct device_node *nc;
    const __be32 *prop;
    int rc;
    int len;

    if (!master->dev.of_node)
        return;

    for_each_child_of_node(master->dev.of_node, nc) {
        /* Alloc an spi_device */
        spi = spi_alloc_device(master);
        if (!spi) {
            dev_err(&master->dev, "spi_device alloc error for %s\n",
                nc->full_name);
            spi_dev_put(spi);
            continue;
        }

        /* Select device driver */
        if (of_modalias_node(nc, spi->modalias,
                     sizeof(spi->modalias)) < 0) {
            dev_err(&master->dev, "cannot find modalias for %s\n",
                nc->full_name);
            spi_dev_put(spi);
            continue;
        }

        /* Device address */
        prop = of_get_property(nc, "reg", &len);
        if (!prop || len < sizeof(*prop)) {
            dev_err(&master->dev, "%s has no 'reg' property\n",
                nc->full_name);
            spi_dev_put(spi);
            continue;
        }
        spi->chip_select = be32_to_cpup(prop);

        /* Mode (clock phase/polarity/etc.) */
        if (of_find_property(nc, "spi-cpha", NULL))
            spi->mode |= SPI_CPHA;
        if (of_find_property(nc, "spi-cpol", NULL))
            spi->mode |= SPI_CPOL;
        if (of_find_property(nc, "spi-cs-high", NULL))
            spi->mode |= SPI_CS_HIGH;

        /* Device speed */
        prop = of_get_property(nc, "spi-max-frequency", &len);
        if (!prop || len < sizeof(*prop)) {
            dev_err(&master->dev, "%s has no 'spi-max-frequency' property\n",
                nc->full_name);
            spi_dev_put(spi);
            continue;
        }
        spi->max_speed_hz = be32_to_cpup(prop);

        /* IRQ */
        spi->irq = irq_of_parse_and_map(nc, 0);

        /* Store a pointer to the node in the device structure */
        of_node_get(nc);
        spi->dev.of_node = nc;

        /* Register the new device */
        request_module(spi->modalias);
        rc = spi_add_device(spi);
        if (rc) {
            dev_err(&master->dev, "spi_device register error %s\n",
                nc->full_name);
            spi_dev_put(spi);
        }

    }
}
#else
static void of_register_spi_devices(struct spi_master *master) { }
#endif

static void spi_master_release(struct device *dev)
{
    struct spi_master *master;

    master = container_of(dev, struct spi_master, dev);
    kfree(master);
}

static struct class spi_master_class = {
    .name       = "spi_master",
    .owner      = THIS_MODULE,
    .dev_release    = spi_master_release,
};



struct spi_master *spi_alloc_master(struct device *dev, unsigned size)
{
    struct spi_master   *master;

    if (!dev)
        return NULL;

    master = kzalloc(size + sizeof *master, GFP_KERNEL);
    if (!master)
        return NULL;

    device_initialize(&master->dev);
    master->bus_num = -1;
    master->num_chipselect = 1;
    master->dev.class = &spi_master_class;
    master->dev.parent = get_device(dev);
    spi_master_set_devdata(master, &master[1]);

    return master;
}
EXPORT_SYMBOL_GPL(spi_alloc_master);

int spi_register_master(struct spi_master *master)
{
    static atomic_t     dyn_bus_id = ATOMIC_INIT((1<<15) - 1);
    struct device       *dev = master->dev.parent;
    struct boardinfo    *bi;
    int         status = -ENODEV;
    int         dynamic = 0;

    if (!dev)
        return -ENODEV;

    /* even if it's just one always-selected device, there must
     * be at least one chipselect
     */
    if (master->num_chipselect == 0)
        return -EINVAL;

    /* convention:  dynamically assigned bus IDs count down from the max */
    if (master->bus_num < 0) {
        /* FIXME switch to an IDR based scheme, something like
         * I2C now uses, so we can't run out of "dynamic" IDs
         */
        master->bus_num = atomic_dec_return(&dyn_bus_id);
        dynamic = 1;
    }

    spin_lock_init(&master->bus_lock_spinlock);
    mutex_init(&master->bus_lock_mutex);
    master->bus_lock_flag = 0;

    /* register the device, then userspace will see it.
     * registration fails if the bus ID is in use.
     */
    dev_set_name(&master->dev, "spi%u", master->bus_num);
    status = device_add(&master->dev);
    if (status < 0)
        goto done;
    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)
        dev_info(dev, "master is unqueued, this is deprecated\n");
    else {
        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)
        spi_match_master_to_boardinfo(master, &bi->board_info);
    mutex_unlock(&board_lock);

    /* Register devices from the device tree */
    of_register_spi_devices(master);
done:
    return status;
}
EXPORT_SYMBOL_GPL(spi_register_master);

static int __unregister(struct device *dev, void *null)
{
    spi_unregister_device(to_spi_device(dev));
    return 0;
}

void spi_unregister_master(struct spi_master *master)
{
    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);

    dummy = device_for_each_child(&master->dev, NULL, __unregister);
    device_unregister(&master->dev);
}
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;
    u16 *bus_num = data;

    m = container_of(dev, struct spi_master, dev);
    return m->bus_num == *bus_num;
}

struct spi_master *spi_busnum_to_master(u16 bus_num)
{
    struct device       *dev;
    struct spi_master   *master = NULL;

    dev = class_find_device(&spi_master_class, NULL, &bus_num,
                __spi_master_match);
    if (dev)
        master = container_of(dev, struct spi_master, dev);
    /* reference got in class_find_device */
    return master;
}
EXPORT_SYMBOL_GPL(spi_busnum_to_master);


/*-------------------------------------------------------------------------*/

/* Core methods for SPI master protocol drivers.  Some of the
 * other core methods are currently defined as inline functions.
 */

int spi_setup(struct spi_device *spi)
{
    unsigned    bad_bits;
    int     status;

    /* help drivers fail *cleanly* when they need options
     * that aren't supported with their current master
     */
    bad_bits = spi->mode & ~spi->master->mode_bits;
    if (bad_bits) {
        dev_err(&spi->dev, "setup: unsupported mode bits %x\n",
            bad_bits);
        return -EINVAL;
    }

    if (!spi->bits_per_word)
        spi->bits_per_word = 8;

    status = spi->master->setup(spi);

    dev_dbg(&spi->dev, "setup mode %d, %s%s%s%s"
                "%u bits/w, %u Hz max --> %d\n",
            (int) (spi->mode & (SPI_CPOL | SPI_CPHA)),
            (spi->mode & SPI_CS_HIGH) ? "cs_high, " : "",
            (spi->mode & SPI_LSB_FIRST) ? "lsb, " : "",
            (spi->mode & SPI_3WIRE) ? "3wire, " : "",
            (spi->mode & SPI_LOOP) ? "loopback, " : "",
            spi->bits_per_word, spi->max_speed_hz,
            status);

    return status;
}
EXPORT_SYMBOL_GPL(spi_setup);

static int __spi_async(struct spi_device *spi, struct spi_message *message)
{
    struct spi_master *master = spi->master;

    /* Half-duplex links include original MicroWire, and ones with
     * only one data pin like SPI_3WIRE (switches direction) or where
     * either MOSI or MISO is missing.  They can also be caused by
     * software limitations.
     */
    if ((master->flags & SPI_MASTER_HALF_DUPLEX)
            || (spi->mode & SPI_3WIRE)) {
        struct spi_transfer *xfer;
        unsigned flags = master->flags;

        list_for_each_entry(xfer, &message->transfers, transfer_list) {
            if (xfer->rx_buf && xfer->tx_buf)
                return -EINVAL;
            if ((flags & SPI_MASTER_NO_TX) && xfer->tx_buf)
                return -EINVAL;
            if ((flags & SPI_MASTER_NO_RX) && xfer->rx_buf)
                return -EINVAL;
        }
    }

    message->spi = spi;
    message->status = -EINPROGRESS;
    return master->transfer(spi, message);
}

int spi_async(struct spi_device *spi, struct spi_message *message)
{
    struct spi_master *master = spi->master;
    int ret;
    unsigned long flags;

    spin_lock_irqsave(&master->bus_lock_spinlock, flags);

    if (master->bus_lock_flag)
        ret = -EBUSY;
    else
        ret = __spi_async(spi, message);

    spin_unlock_irqrestore(&master->bus_lock_spinlock, flags);

    return ret;
}
EXPORT_SYMBOL_GPL(spi_async);

int spi_async_locked(struct spi_device *spi, struct spi_message *message)
{
    struct spi_master *master = spi->master;
    int ret;
    unsigned long flags;

    spin_lock_irqsave(&master->bus_lock_spinlock, flags);

    ret = __spi_async(spi, message);

    spin_unlock_irqrestore(&master->bus_lock_spinlock, flags);

    return ret;

}
EXPORT_SYMBOL_GPL(spi_async_locked);


/*-------------------------------------------------------------------------*/

/* Utility methods for SPI master protocol drivers, layered on
 * top of the core.  Some other utility methods are defined as
 * inline functions.
 */

static void spi_complete(void *arg)
{
    complete(arg);
}

static int __spi_sync(struct spi_device *spi, struct spi_message *message,
              int bus_locked)
{
    DECLARE_COMPLETION_ONSTACK(done);
    int status;
    struct spi_master *master = spi->master;

    message->complete = spi_complete;
    message->context = &done;

    if (!bus_locked)
        mutex_lock(&master->bus_lock_mutex);

    status = spi_async_locked(spi, message);

    if (!bus_locked)
        mutex_unlock(&master->bus_lock_mutex);

    if (status == 0) {
        wait_for_completion(&done);
        status = message->status;
    }
    message->context = NULL;
    return status;
}

int spi_sync(struct spi_device *spi, struct spi_message *message)
{
    return __spi_sync(spi, message, 0);
}
EXPORT_SYMBOL_GPL(spi_sync);

int spi_sync_locked(struct spi_device *spi, struct spi_message *message)
{
    return __spi_sync(spi, message, 1);
}
EXPORT_SYMBOL_GPL(spi_sync_locked);

int spi_bus_lock(struct spi_master *master)
{
    unsigned long flags;

    mutex_lock(&master->bus_lock_mutex);

    spin_lock_irqsave(&master->bus_lock_spinlock, flags);
    master->bus_lock_flag = 1;
    spin_unlock_irqrestore(&master->bus_lock_spinlock, flags);

    /* mutex remains locked until spi_bus_unlock is called */

    return 0;
}
EXPORT_SYMBOL_GPL(spi_bus_lock);

int spi_bus_unlock(struct spi_master *master)
{
    master->bus_lock_flag = 0;

    mutex_unlock(&master->bus_lock_mutex);

    return 0;
}
EXPORT_SYMBOL_GPL(spi_bus_unlock);

/* portable code must never pass more than 32 bytes */
#define SPI_BUFSIZ  max(32,SMP_CACHE_BYTES)

static u8   *buf;

int spi_write_then_read(struct spi_device *spi,
        const void *txbuf, unsigned n_tx,
        void *rxbuf, unsigned n_rx)
{
    static DEFINE_MUTEX(lock);

    int         status;
    struct spi_message  message;
    struct spi_transfer x[2];
    u8          *local_buf;

    /* Use preallocated DMA-safe buffer.  We can't avoid copying here,
     * (as a pure convenience thing), but we can keep heap costs
     * out of the hot path ...
     */
    if ((n_tx + n_rx) > SPI_BUFSIZ)
        return -EINVAL;

    spi_message_init(&message);
    memset(x, 0, sizeof x);
    if (n_tx) {
        x[0].len = n_tx;
        spi_message_add_tail(&x[0], &message);
    }
    if (n_rx) {
        x[1].len = n_rx;
        spi_message_add_tail(&x[1], &message);
    }

    /* ... unless someone else is using the pre-allocated buffer */
    if (!mutex_trylock(&lock)) {
        local_buf = kmalloc(SPI_BUFSIZ, GFP_KERNEL);
        if (!local_buf)
            return -ENOMEM;
    } else
        local_buf = buf;

    memcpy(local_buf, txbuf, n_tx);
    x[0].tx_buf = local_buf;
    x[1].rx_buf = local_buf + n_tx;

    /* do the i/o */
    status = spi_sync(spi, &message);
    if (status == 0)
        memcpy(rxbuf, x[1].rx_buf, n_rx);

    if (x[0].tx_buf == buf)
        mutex_unlock(&lock);
    else
        kfree(local_buf);

    return status;
}
EXPORT_SYMBOL_GPL(spi_write_then_read);

/*-------------------------------------------------------------------------*/

static int __init spi_init(void)
{
    int status;

    buf = kmalloc(SPI_BUFSIZ, GFP_KERNEL);
    if (!buf) {
        status = -ENOMEM;
        goto err0;
    }

    status = bus_register(&spi_bus_type);
    if (status < 0)
        goto err1;

    status = class_register(&spi_master_class);
    if (status < 0)
        goto err2;
    return 0;

err2:
    bus_unregister(&spi_bus_type);
err1:
    kfree(buf);
    buf = NULL;
err0:
    return status;
}

/* board_info is normally registered in arch_initcall(),
 * but even essential drivers wait till later
 *
 * REVISIT only boardinfo really needs static linking. the rest (device and
 * driver registration) _could_ be dynamically linked (modular) ... costs
 * include needing to have boardinfo data structures be much more public.
 */
postcore_initcall(spi_init);