Merge master.kernel.org:/pub/scm/linux/kernel/git/torvalds/linux-2.6 into next

3 files changed, 167 insertions, 68 deletions

diff --git a/drivers/spi/mpc52xx_psc_spi.c b/drivers/spi/mpc52xx_psc_spi.c
index 681d62325d3d..604e5f0a2d95 100644
--- a/drivers/spi/mpc52xx_psc_spi.c
+++ b/drivers/spi/mpc52xx_psc_spi.c
@@ -17,7 +17,7 @@
 #include <linux/interrupt.h>
 
 #if defined(CONFIG_PPC_MERGE)
-#include <asm/of_platform.h>
+#include <linux/of_platform.h>
 #else
 #include <linux/platform_device.h>
 #endif
diff --git a/drivers/spi/spi_imx.c b/drivers/spi/spi_imx.c
index c730d05bfeb6..54ac7bea5f8c 100644
--- a/drivers/spi/spi_imx.c
+++ b/drivers/spi/spi_imx.c
@@ -29,6 +29,7 @@
 #include <linux/spi/spi.h>
 #include <linux/workqueue.h>
 #include <linux/delay.h>
+#include <linux/clk.h>
 
 #include <asm/io.h>
 #include <asm/irq.h>
@@ -250,6 +251,8 @@ struct driver_data {
         int tx_dma_needs_unmap;
         size_t tx_map_len;
         u32 dummy_dma_buf ____cacheline_aligned;
+
+        struct clk *clk;
 };
 
 /* Runtime state */
@@ -855,15 +858,15 @@ static irqreturn_t spi_int(int irq, void *dev_id)
         return drv_data->transfer_handler(drv_data);
 }
 
-static inline u32 spi_speed_hz(u32 data_rate)
+static inline u32 spi_speed_hz(struct driver_data *drv_data, u32 data_rate)
 {
-        return imx_get_perclk2() / (4 << ((data_rate) >> 13));
+        return clk_get_rate(drv_data->clk) / (4 << ((data_rate) >> 13));
 }
 
-static u32 spi_data_rate(u32 speed_hz)
+static u32 spi_data_rate(struct driver_data *drv_data, u32 speed_hz)
 {
         u32 div;
-        u32 quantized_hz = imx_get_perclk2() >> 2;
+        u32 quantized_hz = clk_get_rate(drv_data->clk) >> 2;
 
         for (div = SPI_PERCLK2_DIV_MIN;
                 div <= SPI_PERCLK2_DIV_MAX;
@@ -947,7 +950,7 @@ static void pump_transfers(unsigned long data)
         tmp = transfer->speed_hz;
         if (tmp == 0)
                 tmp = chip->max_speed_hz;
-        tmp = spi_data_rate(tmp);
+        tmp = spi_data_rate(drv_data, tmp);
         u32_EDIT(control, SPI_CONTROL_DATARATE, tmp);
 
         writel(control, regs + SPI_CONTROL);
@@ -1109,7 +1112,7 @@ static int transfer(struct spi_device *spi, struct spi_message *msg)
         msg->actual_length = 0;
 
         /* Per transfer setup check */
-        min_speed_hz = spi_speed_hz(SPI_CONTROL_DATARATE_MIN);
+        min_speed_hz = spi_speed_hz(drv_data, SPI_CONTROL_DATARATE_MIN);
         max_speed_hz = spi->max_speed_hz;
         list_for_each_entry(trans, &msg->transfers, transfer_list) {
                 tmp = trans->bits_per_word;
@@ -1176,6 +1179,7 @@ msg_rejected:
    applied and notified to the calling driver. */
 static int setup(struct spi_device *spi)
 {
+        struct driver_data *drv_data = spi_master_get_devdata(spi->master);
         struct spi_imx_chip *chip_info;
         struct chip_data *chip;
         int first_setup = 0;
@@ -1304,14 +1308,14 @@ static int setup(struct spi_device *spi)
         chip->n_bytes = (tmp <= 8) ? 1 : 2;
 
         /* SPI datarate */
-        tmp = spi_data_rate(spi->max_speed_hz);
+        tmp = spi_data_rate(drv_data, spi->max_speed_hz);
         if (tmp == SPI_CONTROL_DATARATE_BAD) {
                 status = -EINVAL;
                 dev_err(&spi->dev,
                         "setup - "
                         "HW min speed (%d Hz) exceeds required "
                         "max speed (%d Hz)\n",
-                        spi_speed_hz(SPI_CONTROL_DATARATE_MIN),
+                        spi_speed_hz(drv_data, SPI_CONTROL_DATARATE_MIN),
                         spi->max_speed_hz);
                 if (first_setup)
                         goto err_first_setup;
@@ -1321,7 +1325,7 @@ static int setup(struct spi_device *spi)
         } else {
                 u32_EDIT(chip->control, SPI_CONTROL_DATARATE, tmp);
                 /* Actual rounded max_speed_hz */
-                tmp = spi_speed_hz(tmp);
+                tmp = spi_speed_hz(drv_data, tmp);
                 spi->max_speed_hz = tmp;
                 chip->max_speed_hz = tmp;
         }
@@ -1352,7 +1356,7 @@ static int setup(struct spi_device *spi)
                 chip->period & SPI_PERIOD_WAIT,
                 spi->mode,
                 spi->bits_per_word,
-                spi_speed_hz(SPI_CONTROL_DATARATE_MIN),
+                spi_speed_hz(drv_data, SPI_CONTROL_DATARATE_MIN),
                 spi->max_speed_hz);
         return status;
 
@@ -1465,6 +1469,14 @@ static int __init spi_imx_probe(struct platform_device *pdev)
                 goto err_no_pdata;
         }
 
+        drv_data->clk = clk_get(&pdev->dev, "perclk2");
+        if (IS_ERR(drv_data->clk)) {
+                dev_err(&pdev->dev, "probe - cannot get get\n");
+                status = PTR_ERR(drv_data->clk);
+                goto err_no_clk;
+        }
+        clk_enable(drv_data->clk);
+
         /* Allocate master with space for drv_data */
         master = spi_alloc_master(dev, sizeof(struct driver_data));
         if (!master) {
@@ -1526,24 +1538,24 @@ static int __init spi_imx_probe(struct platform_device *pdev)
         drv_data->rx_channel = -1;
         if (platform_info->enable_dma) {
                 /* Get rx DMA channel */
-                status = imx_dma_request_by_prio(&drv_data->rx_channel,
-                        "spi_imx_rx", DMA_PRIO_HIGH);
-                if (status < 0) {
+                drv_data->rx_channel = imx_dma_request_by_prio("spi_imx_rx",
+                                                               DMA_PRIO_HIGH);
+                if (drv_data->rx_channel < 0) {
                         dev_err(dev,
                                 "probe - problem (%d) requesting rx channel\n",
-                                status);
+                                drv_data->rx_channel);
                         goto err_no_rxdma;
                 } else
                         imx_dma_setup_handlers(drv_data->rx_channel, NULL,
                                                 dma_err_handler, drv_data);
 
                 /* Get tx DMA channel */
-                status = imx_dma_request_by_prio(&drv_data->tx_channel,
-                                                "spi_imx_tx", DMA_PRIO_MEDIUM);
-                if (status < 0) {
+                drv_data->tx_channel = imx_dma_request_by_prio("spi_imx_tx",
+                                                               DMA_PRIO_MEDIUM);
+                if (drv_data->tx_channel < 0) {
                         dev_err(dev,
                                 "probe - problem (%d) requesting tx channel\n",
-                                status);
+                                drv_data->tx_channel);
                         imx_dma_free(drv_data->rx_channel);
                         goto err_no_txdma;
                 } else
@@ -1623,6 +1635,9 @@ err_no_iores:
         spi_master_put(master);
 
 err_no_pdata:
+        clk_disable(drv_data->clk);
+        clk_put(drv_data->clk);
+err_no_clk:
 err_no_mem:
         return status;
 }
@@ -1662,6 +1677,9 @@ static int __exit spi_imx_remove(struct platform_device *pdev)
         if (irq >= 0)
                 free_irq(irq, drv_data);
 
+        clk_disable(drv_data->clk);
+        clk_put(drv_data->clk);
+
         /* Release map resources */
         iounmap(drv_data->regs);
         release_resource(drv_data->ioarea);
diff --git a/drivers/spi/spidev.c b/drivers/spi/spidev.c
index b3518ca9f04e..ddbe1a5e970e 100644
--- a/drivers/spi/spidev.c
+++ b/drivers/spi/spidev.c
@@ -25,10 +25,12 @@
 #include <linux/ioctl.h>
 #include <linux/fs.h>
 #include <linux/device.h>
+#include <linux/err.h>
 #include <linux/list.h>
 #include <linux/errno.h>
 #include <linux/mutex.h>
 #include <linux/slab.h>
+#include <linux/smp_lock.h>
 
 #include <linux/spi/spi.h>
 #include <linux/spi/spidev.h>
@@ -67,10 +69,12 @@ static unsigned long	minors[N_SPI_MINORS / BITS_PER_LONG];
                                 | SPI_LSB_FIRST | SPI_3WIRE | SPI_LOOP)
 
 struct spidev_data {
-        struct device           dev;
+        dev_t                   devt;
+        spinlock_t              spi_lock;
         struct spi_device       *spi;
         struct list_head        device_entry;
 
+        /* buffer is NULL unless this device is open (users > 0) */
         struct mutex            buf_lock;
         unsigned                users;
         u8                      *buffer;
@@ -85,12 +89,75 @@ MODULE_PARM_DESC(bufsiz, "data bytes in biggest supported SPI message");
 
 /*-------------------------------------------------------------------------*/
 
+/*
+ * We can't use the standard synchronous wrappers for file I/O; we
+ * need to protect against async removal of the underlying spi_device.
+ */
+static void spidev_complete(void *arg)
+{
+        complete(arg);
+}
+
+static ssize_t
+spidev_sync(struct spidev_data *spidev, struct spi_message *message)
+{
+        DECLARE_COMPLETION_ONSTACK(done);
+        int status;
+
+        message->complete = spidev_complete;
+        message->context = &done;
+
+        spin_lock_irq(&spidev->spi_lock);
+        if (spidev->spi == NULL)
+                status = -ESHUTDOWN;
+        else
+                status = spi_async(spidev->spi, message);
+        spin_unlock_irq(&spidev->spi_lock);
+
+        if (status == 0) {
+                wait_for_completion(&done);
+                status = message->status;
+                if (status == 0)
+                        status = message->actual_length;
+        }
+        return status;
+}
+
+static inline ssize_t
+spidev_sync_write(struct spidev_data *spidev, size_t len)
+{
+        struct spi_transfer     t = {
+                        .tx_buf         = spidev->buffer,
+                        .len            = len,
+                };
+        struct spi_message      m;
+
+        spi_message_init(&m);
+        spi_message_add_tail(&t, &m);
+        return spidev_sync(spidev, &m);
+}
+
+static inline ssize_t
+spidev_sync_read(struct spidev_data *spidev, size_t len)
+{
+        struct spi_transfer     t = {
+                        .rx_buf         = spidev->buffer,
+                        .len            = len,
+                };
+        struct spi_message      m;
+
+        spi_message_init(&m);
+        spi_message_add_tail(&t, &m);
+        return spidev_sync(spidev, &m);
+}
+
+/*-------------------------------------------------------------------------*/
+
 /* Read-only message with current device setup */
 static ssize_t
 spidev_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
 {
         struct spidev_data      *spidev;
-        struct spi_device       *spi;
         ssize_t                 status = 0;
 
         /* chipselect only toggles at start or end of operation */
@@ -98,18 +165,17 @@ spidev_read(struct file *filp, char __user *buf, size_t count, loff_t *f_pos)
                 return -EMSGSIZE;
 
         spidev = filp->private_data;
-        spi = spidev->spi;
 
         mutex_lock(&spidev->buf_lock);
-        status = spi_read(spi, spidev->buffer, count);
-        if (status == 0) {
+        status = spidev_sync_read(spidev, count);
+        if (status > 0) {
                 unsigned long   missing;
 
-                missing = copy_to_user(buf, spidev->buffer, count);
-                if (count && missing == count)
+                missing = copy_to_user(buf, spidev->buffer, status);
+                if (missing == status)
                         status = -EFAULT;
                 else
-                        status = count - missing;
+                        status = status - missing;
         }
         mutex_unlock(&spidev->buf_lock);
 
@@ -122,7 +188,6 @@ spidev_write(struct file *filp, const char __user *buf,
                 size_t count, loff_t *f_pos)
 {
         struct spidev_data      *spidev;
-        struct spi_device       *spi;
         ssize_t                 status = 0;
         unsigned long           missing;
 
@@ -131,14 +196,11 @@ spidev_write(struct file *filp, const char __user *buf,
                 return -EMSGSIZE;
 
         spidev = filp->private_data;
-        spi = spidev->spi;
 
         mutex_lock(&spidev->buf_lock);
         missing = copy_from_user(spidev->buffer, buf, count);
         if (missing == 0) {
-                status = spi_write(spi, spidev->buffer, count);
-                if (status == 0)
-                        status = count;
+                status = spidev_sync_write(spidev, count);
         } else
                 status = -EFAULT;
         mutex_unlock(&spidev->buf_lock);
@@ -153,7 +215,6 @@ static int spidev_message(struct spidev_data *spidev,
         struct spi_transfer     *k_xfers;
         struct spi_transfer     *k_tmp;
         struct spi_ioc_transfer *u_tmp;
-        struct spi_device       *spi = spidev->spi;
         unsigned                n, total;
         u8                      *buf;
         int                     status = -EFAULT;
@@ -215,7 +276,7 @@ static int spidev_message(struct spidev_data *spidev,
                 spi_message_add_tail(k_tmp, &msg);
         }
 
-        status = spi_sync(spi, &msg);
+        status = spidev_sync(spidev, &msg);
         if (status < 0)
                 goto done;
 
@@ -269,8 +330,16 @@ spidev_ioctl(struct inode *inode, struct file *filp,
         if (err)
                 return -EFAULT;
 
+        /* guard against device removal before, or while,
+         * we issue this ioctl.
+         */
         spidev = filp->private_data;
-        spi = spidev->spi;
+        spin_lock_irq(&spidev->spi_lock);
+        spi = spi_dev_get(spidev->spi);
+        spin_unlock_irq(&spidev->spi_lock);
+
+        if (spi == NULL)
+                return -ESHUTDOWN;
 
         switch (cmd) {
         /* read requests */
@@ -356,8 +425,10 @@ spidev_ioctl(struct inode *inode, struct file *filp,
         default:
                 /* segmented and/or full-duplex I/O request */
                 if (_IOC_NR(cmd) != _IOC_NR(SPI_IOC_MESSAGE(0))
-                                || _IOC_DIR(cmd) != _IOC_WRITE)
-                        return -ENOTTY;
+                                || _IOC_DIR(cmd) != _IOC_WRITE) {
+                        retval = -ENOTTY;
+                        break;
+                }
 
                 tmp = _IOC_SIZE(cmd);
                 if ((tmp % sizeof(struct spi_ioc_transfer)) != 0) {
@@ -385,6 +456,7 @@ spidev_ioctl(struct inode *inode, struct file *filp,
                 kfree(ioc);
                 break;
         }
+        spi_dev_put(spi);
         return retval;
 }
 
@@ -393,10 +465,11 @@ static int spidev_open(struct inode *inode, struct file *filp)
         struct spidev_data      *spidev;
         int                     status = -ENXIO;
 
+        lock_kernel();
         mutex_lock(&device_list_lock);
 
         list_for_each_entry(spidev, &device_list, device_entry) {
-                if (spidev->dev.devt == inode->i_rdev) {
+                if (spidev->devt == inode->i_rdev) {
                         status = 0;
                         break;
                 }
@@ -418,6 +491,7 @@ static int spidev_open(struct inode *inode, struct file *filp)
                 pr_debug("spidev: nothing for minor %d\n", iminor(inode));
 
         mutex_unlock(&device_list_lock);
+        unlock_kernel();
         return status;
 }
 
@@ -429,10 +503,22 @@ static int spidev_release(struct inode *inode, struct file *filp)
         mutex_lock(&device_list_lock);
         spidev = filp->private_data;
         filp->private_data = NULL;
+
+        /* last close? */
         spidev->users--;
         if (!spidev->users) {
+                int             dofree;
+
                 kfree(spidev->buffer);
                 spidev->buffer = NULL;
+
+                /* ... after we unbound from the underlying device? */
+                spin_lock_irq(&spidev->spi_lock);
+                dofree = (spidev->spi == NULL);
+                spin_unlock_irq(&spidev->spi_lock);
+
+                if (dofree)
+                        kfree(spidev);
         }
         mutex_unlock(&device_list_lock);
 
@@ -459,19 +545,7 @@ static struct file_operations spidev_fops = {
  * It also simplifies memory management.
  */
 
-static void spidev_classdev_release(struct device *dev)
-{
-        struct spidev_data      *spidev;
-
-        spidev = container_of(dev, struct spidev_data, dev);
-        kfree(spidev);
-}
-
-static struct class spidev_class = {
-        .name           = "spidev",
-        .owner          = THIS_MODULE,
-        .dev_release    = spidev_classdev_release,
-};
+static struct class *spidev_class;
 
 /*-------------------------------------------------------------------------*/
 
@@ -488,6 +562,7 @@ static int spidev_probe(struct spi_device *spi)
 
         /* Initialize the driver data */
         spidev->spi = spi;
+        spin_lock_init(&spidev->spi_lock);
         mutex_init(&spidev->buf_lock);
 
         INIT_LIST_HEAD(&spidev->device_entry);
@@ -498,20 +573,20 @@ static int spidev_probe(struct spi_device *spi)
         mutex_lock(&device_list_lock);
         minor = find_first_zero_bit(minors, N_SPI_MINORS);
         if (minor < N_SPI_MINORS) {
-                spidev->dev.parent = &spi->dev;
-                spidev->dev.class = &spidev_class;
-                spidev->dev.devt = MKDEV(SPIDEV_MAJOR, minor);
-                snprintf(spidev->dev.bus_id, sizeof spidev->dev.bus_id,
+                struct device *dev;
+
+                spidev->devt = MKDEV(SPIDEV_MAJOR, minor);
+                dev = device_create(spidev_class, &spi->dev, spidev->devt,
                                 "spidev%d.%d",
                                 spi->master->bus_num, spi->chip_select);
-                status = device_register(&spidev->dev);
+                status = IS_ERR(dev) ? PTR_ERR(dev) : 0;
         } else {
                 dev_dbg(&spi->dev, "no minor number available!\n");
                 status = -ENODEV;
         }
         if (status == 0) {
                 set_bit(minor, minors);
-                dev_set_drvdata(&spi->dev, spidev);
+                spi_set_drvdata(spi, spidev);
                 list_add(&spidev->device_entry, &device_list);
         }
         mutex_unlock(&device_list_lock);
@@ -524,15 +599,21 @@ static int spidev_probe(struct spi_device *spi)
 
 static int spidev_remove(struct spi_device *spi)
 {
-        struct spidev_data      *spidev = dev_get_drvdata(&spi->dev);
+        struct spidev_data      *spidev = spi_get_drvdata(spi);
 
-        mutex_lock(&device_list_lock);
+        /* make sure ops on existing fds can abort cleanly */
+        spin_lock_irq(&spidev->spi_lock);
+        spidev->spi = NULL;
+        spi_set_drvdata(spi, NULL);
+        spin_unlock_irq(&spidev->spi_lock);
 
+        /* prevent new opens */
+        mutex_lock(&device_list_lock);
         list_del(&spidev->device_entry);
-        dev_set_drvdata(&spi->dev, NULL);
-        clear_bit(MINOR(spidev->dev.devt), minors);
-        device_unregister(&spidev->dev);
-
+        device_destroy(spidev_class, spidev->devt);
+        clear_bit(MINOR(spidev->devt), minors);
+        if (spidev->users == 0)
+                kfree(spidev);
         mutex_unlock(&device_list_lock);
 
         return 0;
@@ -568,15 +649,15 @@ static int __init spidev_init(void)
         if (status < 0)
                 return status;
 
-        status = class_register(&spidev_class);
-        if (status < 0) {
+        spidev_class = class_create(THIS_MODULE, "spidev");
+        if (IS_ERR(spidev_class)) {
                 unregister_chrdev(SPIDEV_MAJOR, spidev_spi.driver.name);
-                return status;
+                return PTR_ERR(spidev_class);
         }
 
         status = spi_register_driver(&spidev_spi);
         if (status < 0) {
-                class_unregister(&spidev_class);
+                class_destroy(spidev_class);
                 unregister_chrdev(SPIDEV_MAJOR, spidev_spi.driver.name);
         }
         return status;
@@ -586,7 +667,7 @@ module_init(spidev_init);
 static void __exit spidev_exit(void)
 {
         spi_unregister_driver(&spidev_spi);
-        class_unregister(&spidev_class);
+        class_destroy(spidev_class);
         unregister_chrdev(SPIDEV_MAJOR, spidev_spi.driver.name);
 }
 module_exit(spidev_exit);