12 files changed, 111 insertions, 124 deletions
diff --git a/drivers/spi/Kconfig b/drivers/spi/Kconfig
index a79e89f63b71..eea4eb83f352 100644
--- a/drivers/spi/Kconfig
+++ b/drivers/spi/Kconfig
@@ -270,6 +270,7 @@ config SPI_FSL_SPI
 config SPI_FSL_DSPI
        tristate "Freescale DSPI controller"
        select SPI_BITBANG
+        select REGMAP_MMIO
        depends on SOC_VF610 || COMPILE_TEST
        help
          This enables support for the Freescale DSPI controller in master
@@ -546,7 +547,7 @@ config SPI_DW_MID_DMA
 config SPI_DW_MMIO
        tristate "Memory-mapped io interface driver for DW SPI core"
-        depends on SPI_DESIGNWARE && HAVE_CLK
+        depends on SPI_DESIGNWARE
 #
 # There are lots of SPI device types, with sensors and memory
diff --git a/drivers/spi/spi-dw-mmio.c b/drivers/spi/spi-dw-mmio.c
index 9af56cdf1540..1492f5ee9aaa 100644
--- a/drivers/spi/spi-dw-mmio.c
+++ b/drivers/spi/spi-dw-mmio.c
@@ -66,7 +66,7 @@ static int dw_spi_mmio_probe(struct platform_device *pdev)
        if (ret)
                return ret;
-        dws->bus_num = 0;
+        dws->bus_num = pdev->id;
        dws->num_cs = 4;
        dws->max_freq = clk_get_rate(dwsmmio->clk);
diff --git a/drivers/spi/spi-dw.c b/drivers/spi/spi-dw.c
index bf98d63d92b3..712ac5629cd4 100644
--- a/drivers/spi/spi-dw.c
+++ b/drivers/spi/spi-dw.c
@@ -276,8 +276,7 @@ static void giveback(struct dw_spi *dws)
        queue_work(dws->workqueue, &dws->pump_messages);
        spin_unlock_irqrestore(&dws->lock, flags);
-        last_transfer = list_entry(msg->transfers.prev,
+        last_transfer = list_last_entry(&msg->transfers, struct spi_transfer,
-                                        struct spi_transfer,
                                        transfer_list);
        if (!last_transfer->cs_change && dws->cs_control)
@@ -439,12 +438,6 @@ static void pump_transfers(unsigned long data)
                if (transfer->speed_hz != speed) {
                        speed = transfer->speed_hz;
-                        if (speed > dws->max_freq) {
-                                printk(KERN_ERR "MRST SPI0: unsupported"
-                                        "freq: %dHz\n", speed);
-                                message->status = -EIO;
-                                goto early_exit;
-                        }
                        /* clk_div doesn't support odd number */
                        clk_div = dws->max_freq / speed;
@@ -671,12 +664,6 @@ static int dw_spi_setup(struct spi_device *spi)
        return 0;
 }
-static void dw_spi_cleanup(struct spi_device *spi)
-{
-        struct chip_data *chip = spi_get_ctldata(spi);
-        kfree(chip);
-}
 static int init_queue(struct dw_spi *dws)
 {
        INIT_LIST_HEAD(&dws->queue);
@@ -806,9 +793,9 @@ int dw_spi_add_host(struct device *dev, struct dw_spi *dws)
        master->bits_per_word_mask = SPI_BPW_MASK(8) | SPI_BPW_MASK(16);
        master->bus_num = dws->bus_num;
        master->num_chipselect = dws->num_cs;
-        master->cleanup = dw_spi_cleanup;
        master->setup = dw_spi_setup;
        master->transfer = dw_spi_transfer;
+        master->max_speed_hz = dws->max_freq;
        /* Basic HW init */
        spi_hw_init(dws);
diff --git a/drivers/spi/spi-efm32.c b/drivers/spi/spi-efm32.c
index f53bbea385c0..be44a3eeb5e8 100644
--- a/drivers/spi/spi-efm32.c
+++ b/drivers/spi/spi-efm32.c
@@ -287,17 +287,17 @@ static u32 efm32_spi_get_configured_location(struct efm32_spi_ddata *ddata)
        return (reg & REG_ROUTE_LOCATION__MASK) >> __ffs(REG_ROUTE_LOCATION__MASK);
 }
-static int efm32_spi_probe_dt(struct platform_device *pdev,
+static void efm32_spi_probe_dt(struct platform_device *pdev,
                struct spi_master *master, struct efm32_spi_ddata *ddata)
 {
        struct device_node *np = pdev->dev.of_node;
        u32 location;
        int ret;
-        if (!np)
+        ret = of_property_read_u32(np, "efm32,location", &location);
-                return 1;
+        if (ret)
+                /* fall back to old and (wrongly) generic property "location" */
-        ret = of_property_read_u32(np, "location", &location);
+                ret = of_property_read_u32(np, "location", &location);
        if (!ret) {
                dev_dbg(&pdev->dev, "using location %u\n", location);
        } else {
@@ -308,7 +308,6 @@ static int efm32_spi_probe_dt(struct platform_device *pdev,
        }
        ddata->pdata.location = location;
-        return 0;
 }
 static int efm32_spi_probe(struct platform_device *pdev)
@@ -318,9 +317,14 @@ static int efm32_spi_probe(struct platform_device *pdev)
        int ret;
        struct spi_master *master;
        struct device_node *np = pdev->dev.of_node;
-        unsigned int num_cs, i;
+        int num_cs, i;
+        if (!np)
+                return -EINVAL;
        num_cs = of_gpio_named_count(np, "cs-gpios");
+        if (num_cs < 0)
+                return num_cs;
        master = spi_alloc_master(&pdev->dev,
                        sizeof(*ddata) + num_cs * sizeof(unsigned));
@@ -412,23 +416,7 @@ static int efm32_spi_probe(struct platform_device *pdev)
                goto err;
        }
-        ret = efm32_spi_probe_dt(pdev, master, ddata);
+        efm32_spi_probe_dt(pdev, master, ddata);
-        if (ret > 0) {
-                /* not created by device tree */
-                const struct efm32_spi_pdata *pdata =
-                        dev_get_platdata(&pdev->dev);
-                if (pdata)
-                        ddata->pdata = *pdata;
-                else
-                        ddata->pdata.location =
-                                efm32_spi_get_configured_location(ddata);
-                master->bus_num = pdev->id;
-        } else if (ret < 0) {
-                goto err_disable_clk;
-        }
        efm32_spi_write32(ddata, 0, REG_IEN);
        efm32_spi_write32(ddata, REG_ROUTE_TXPEN | REG_ROUTE_RXPEN |
@@ -484,6 +472,9 @@ static int efm32_spi_remove(struct platform_device *pdev)
 static const struct of_device_id efm32_spi_dt_ids[] = {
        {
+                .compatible = "energymicro,efm32-spi",
+        }, {
+                /* doesn't follow the "vendor,device" scheme, don't use */
                .compatible = "efm32,spi",
        }, {
                /* sentinel */
diff --git a/drivers/spi/spi-ep93xx.c b/drivers/spi/spi-ep93xx.c
index 1bfaed6e4073..2f675d32df0e 100644
--- a/drivers/spi/spi-ep93xx.c
+++ b/drivers/spi/spi-ep93xx.c
@@ -73,8 +73,6 @@
 * @clk: clock for the controller
 * @regs_base: pointer to ioremap()'d registers
 * @sspdr_phys: physical address of the SSPDR register
- * @min_rate: minimum clock rate (in Hz) supported by the controller
- * @max_rate: maximum clock rate (in Hz) supported by the controller
 * @wait: wait here until given transfer is completed
 * @current_msg: message that is currently processed (or %NULL if none)
 * @tx: current byte in transfer to transmit
@@ -95,8 +93,6 @@ struct ep93xx_spi {
        struct clk                      *clk;
        void __iomem                    *regs_base;
        unsigned long                   sspdr_phys;
-        unsigned long                   min_rate;
-        unsigned long                   max_rate;
        struct completion               wait;
        struct spi_message              *current_msg;
        size_t                          tx;
@@ -199,9 +195,9 @@ static void ep93xx_spi_disable_interrupts(const struct ep93xx_spi *espi)
 * @div_scr: pointer to return the scr divider
 */
 static int ep93xx_spi_calc_divisors(const struct ep93xx_spi *espi,
-                                    unsigned long rate,
+                                    u32 rate, u8 *div_cpsr, u8 *div_scr)
-                                    u8 *div_cpsr, u8 *div_scr)
 {
+        struct spi_master *master = platform_get_drvdata(espi->pdev);
        unsigned long spi_clk_rate = clk_get_rate(espi->clk);
        int cpsr, scr;
@@ -210,7 +206,7 @@ static int ep93xx_spi_calc_divisors(const struct ep93xx_spi *espi,
         * controller. Note that minimum value is already checked in
         * ep93xx_spi_transfer_one_message().
         */
-        rate = clamp(rate, espi->min_rate, espi->max_rate);
+        rate = clamp(rate, master->min_speed_hz, master->max_speed_hz);
        /*
         * Calculate divisors so that we can get speed according the
@@ -735,13 +731,6 @@ static int ep93xx_spi_transfer_one_message(struct spi_master *master,
                                           struct spi_message *msg)
 {
        struct ep93xx_spi *espi = spi_master_get_devdata(master);
-        struct spi_transfer *t;
-        /* first validate each transfer */
-        list_for_each_entry(t, &msg->transfers, transfer_list) {
-                if (t->speed_hz < espi->min_rate)
-                        return -EINVAL;
-        }
        msg->state = NULL;
        msg->status = 0;
@@ -917,8 +906,8 @@ static int ep93xx_spi_probe(struct platform_device *pdev)
         * Calculate maximum and minimum supported clock rates
         * for the controller.
         */
-        espi->max_rate = clk_get_rate(espi->clk) / 2;
+        master->max_speed_hz = clk_get_rate(espi->clk) / 2;
-        espi->min_rate = clk_get_rate(espi->clk) / (254 * 256);
+        master->min_speed_hz = clk_get_rate(espi->clk) / (254 * 256);
        espi->pdev = pdev;
        espi->sspdr_phys = res->start + SSPDR;
diff --git a/drivers/spi/spi-fsl-dspi.c b/drivers/spi/spi-fsl-dspi.c
index a25392065d9b..d565eeee3bd8 100644
--- a/drivers/spi/spi-fsl-dspi.c
+++ b/drivers/spi/spi-fsl-dspi.c
@@ -18,6 +18,7 @@
 #include <linux/interrupt.h>
 #include <linux/errno.h>
 #include <linux/platform_device.h>
+#include <linux/regmap.h>
 #include <linux/sched.h>
 #include <linux/delay.h>
 #include <linux/io.h>
@@ -108,11 +109,11 @@ struct fsl_dspi {
        struct spi_bitbang      bitbang;
        struct platform_device  *pdev;
-        void __iomem            *base;
+        struct regmap           *regmap;
        int                     irq;
-        struct clk              *clk;
+        struct clk              *clk;
-        struct spi_transfer     *cur_transfer;
+        struct spi_transfer     *cur_transfer;
        struct chip_data        *cur_chip;
        size_t                  len;
        void                    *tx;
@@ -123,24 +124,17 @@ struct fsl_dspi {
        u8                      cs;
        u16                     void_write_data;
-        wait_queue_head_t       waitq;
+        wait_queue_head_t       waitq;
-        u32                     waitflags;
+        u32                     waitflags;
 };
 static inline int is_double_byte_mode(struct fsl_dspi *dspi)
 {
-        return ((readl(dspi->base + SPI_CTAR(dspi->cs)) & SPI_FRAME_BITS_MASK)
+        unsigned int val;
-                        == SPI_FRAME_BITS(8)) ? 0 : 1;
-}
-static void set_bit_mode(struct fsl_dspi *dspi, unsigned char bits)
+        regmap_read(dspi->regmap, SPI_CTAR(dspi->cs), &val);
-{
-        u32 temp;
-        temp = readl(dspi->base + SPI_CTAR(dspi->cs));
+        return ((val & SPI_FRAME_BITS_MASK) == SPI_FRAME_BITS(8)) ? 0 : 1;
-        temp &= ~SPI_FRAME_BITS_MASK;
-        temp |= SPI_FRAME_BITS(bits);
-        writel(temp, dspi->base + SPI_CTAR(dspi->cs));
 }
 static void hz_to_spi_baud(char *pbr, char *br, int speed_hz,
@@ -188,7 +182,8 @@ static int dspi_transfer_write(struct fsl_dspi *dspi)
         */
        if (tx_word && (dspi->len == 1)) {
                dspi->dataflags |= TRAN_STATE_WORD_ODD_NUM;
-                set_bit_mode(dspi, 8);
+                regmap_update_bits(dspi->regmap, SPI_CTAR(dspi->cs),
+                                SPI_FRAME_BITS_MASK, SPI_FRAME_BITS(8));
                tx_word = 0;
        }
@@ -238,7 +233,8 @@ static int dspi_transfer_write(struct fsl_dspi *dspi)
                        dspi_pushr |= SPI_PUSHR_CTCNT; /* clear counter */
                }
-                writel(dspi_pushr, dspi->base + SPI_PUSHR);
+                regmap_write(dspi->regmap, SPI_PUSHR, dspi_pushr);
                tx_count++;
        }
@@ -253,17 +249,23 @@ static int dspi_transfer_read(struct fsl_dspi *dspi)
        while ((dspi->rx < dspi->rx_end)
                        && (rx_count < DSPI_FIFO_SIZE)) {
                if (rx_word) {
+                        unsigned int val;
                        if ((dspi->rx_end - dspi->rx) == 1)
                                break;
-                        d = SPI_POPR_RXDATA(readl(dspi->base + SPI_POPR));
+                        regmap_read(dspi->regmap, SPI_POPR, &val);
+                        d = SPI_POPR_RXDATA(val);
                        if (!(dspi->dataflags & TRAN_STATE_RX_VOID))
                                *(u16 *)dspi->rx = d;
                        dspi->rx += 2;
                } else {
-                        d = SPI_POPR_RXDATA(readl(dspi->base + SPI_POPR));
+                        unsigned int val;
+                        regmap_read(dspi->regmap, SPI_POPR, &val);
+                        d = SPI_POPR_RXDATA(val);
                        if (!(dspi->dataflags & TRAN_STATE_RX_VOID))
                                *(u8 *)dspi->rx = d;
                        dspi->rx++;
@@ -295,13 +297,13 @@ static int dspi_txrx_transfer(struct spi_device *spi, struct spi_transfer *t)
        if (!dspi->tx)
                dspi->dataflags |= TRAN_STATE_TX_VOID;
-        writel(dspi->cur_chip->mcr_val, dspi->base + SPI_MCR);
+        regmap_write(dspi->regmap, SPI_MCR, dspi->cur_chip->mcr_val);
-        writel(dspi->cur_chip->ctar_val, dspi->base + SPI_CTAR(dspi->cs));
+        regmap_write(dspi->regmap, SPI_CTAR(dspi->cs), dspi->cur_chip->ctar_val);
-        writel(SPI_RSER_EOQFE, dspi->base + SPI_RSER);
+        regmap_write(dspi->regmap, SPI_RSER, SPI_RSER_EOQFE);
        if (t->speed_hz)
-                writel(dspi->cur_chip->ctar_val,
+                regmap_write(dspi->regmap, SPI_CTAR(dspi->cs),
-                                dspi->base + SPI_CTAR(dspi->cs));
+                                dspi->cur_chip->ctar_val);
        dspi_transfer_write(dspi);
@@ -315,7 +317,9 @@ static int dspi_txrx_transfer(struct spi_device *spi, struct spi_transfer *t)
 static void dspi_chipselect(struct spi_device *spi, int value)
 {
        struct fsl_dspi *dspi = spi_master_get_devdata(spi->master);
-        u32 pushr = readl(dspi->base + SPI_PUSHR);
+        unsigned int pushr;
+        regmap_read(dspi->regmap, SPI_PUSHR, &pushr);
        switch (value) {
        case BITBANG_CS_ACTIVE:
@@ -326,7 +330,7 @@ static void dspi_chipselect(struct spi_device *spi, int value)
                break;
        }
-        writel(pushr, dspi->base + SPI_PUSHR);
+        regmap_write(dspi->regmap, SPI_PUSHR, pushr);
 }
 static int dspi_setup_transfer(struct spi_device *spi, struct spi_transfer *t)
@@ -338,7 +342,8 @@ static int dspi_setup_transfer(struct spi_device *spi, struct spi_transfer *t)
        /* Only alloc on first setup */
        chip = spi_get_ctldata(spi);
        if (chip == NULL) {
-                chip = kcalloc(1, sizeof(struct chip_data), GFP_KERNEL);
+                chip = devm_kzalloc(&spi->dev, sizeof(struct chip_data),
+                                    GFP_KERNEL);
                if (!chip)
                        return -ENOMEM;
        }
@@ -349,7 +354,6 @@ static int dspi_setup_transfer(struct spi_device *spi, struct spi_transfer *t)
                fmsz = spi->bits_per_word - 1;
        } else {
                pr_err("Invalid wordsize\n");
-                kfree(chip);
                return -ENODEV;
        }
@@ -382,13 +386,15 @@ static irqreturn_t dspi_interrupt(int irq, void *dev_id)
 {
        struct fsl_dspi *dspi = (struct fsl_dspi *)dev_id;
-        writel(SPI_SR_EOQF, dspi->base + SPI_SR);
+        regmap_write(dspi->regmap, SPI_SR, SPI_SR_EOQF);
        dspi_transfer_read(dspi);
        if (!dspi->len) {
                if (dspi->dataflags & TRAN_STATE_WORD_ODD_NUM)
-                        set_bit_mode(dspi, 16);
+                        regmap_update_bits(dspi->regmap, SPI_CTAR(dspi->cs),
+                                SPI_FRAME_BITS_MASK, SPI_FRAME_BITS(16));
                dspi->waitflags = 1;
                wake_up_interruptible(&dspi->waitq);
        } else {
@@ -430,8 +436,13 @@ static int dspi_resume(struct device *dev)
 }
 #endif /* CONFIG_PM_SLEEP */
-static const struct dev_pm_ops dspi_pm = {
+static SIMPLE_DEV_PM_OPS(dspi_pm, dspi_suspend, dspi_resume);
-        SET_SYSTEM_SLEEP_PM_OPS(dspi_suspend, dspi_resume)
+static struct regmap_config dspi_regmap_config = {
+        .reg_bits = 32,
+        .val_bits = 32,
+        .reg_stride = 4,
+        .max_register = 0x88,
 };
 static int dspi_probe(struct platform_device *pdev)
@@ -440,6 +451,7 @@ static int dspi_probe(struct platform_device *pdev)
        struct spi_master *master;
        struct fsl_dspi *dspi;
        struct resource *res;
+        void __iomem *base;
        int ret = 0, cs_num, bus_num;
        master = spi_alloc_master(&pdev->dev, sizeof(struct fsl_dspi));
@@ -474,12 +486,24 @@ static int dspi_probe(struct platform_device *pdev)
        master->bus_num = bus_num;
        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        dspi->base = devm_ioremap_resource(&pdev->dev, res);
+        base = devm_ioremap_resource(&pdev->dev, res);
-        if (IS_ERR(dspi->base)) {
+        if (IS_ERR(base)) {
-                ret = PTR_ERR(dspi->base);
+                ret = PTR_ERR(base);
                goto out_master_put;
        }
+        dspi_regmap_config.lock_arg = dspi;
+        dspi_regmap_config.val_format_endian =
+                of_property_read_bool(np, "big-endian")
+                        ? REGMAP_ENDIAN_BIG : REGMAP_ENDIAN_DEFAULT;
+        dspi->regmap = devm_regmap_init_mmio_clk(&pdev->dev, "dspi", base,
+                                                &dspi_regmap_config);
+        if (IS_ERR(dspi->regmap)) {
+                dev_err(&pdev->dev, "failed to init regmap: %ld\n",
+                                PTR_ERR(dspi->regmap));
+                return PTR_ERR(dspi->regmap);
+        }
        dspi->irq = platform_get_irq(pdev, 0);
        if (dspi->irq < 0) {
                dev_err(&pdev->dev, "can't get platform irq\n");
diff --git a/drivers/spi/spi-fsl-espi.c b/drivers/spi/spi-fsl-espi.c
index 428dc7a6b62e..6fb2b75df821 100644
--- a/drivers/spi/spi-fsl-espi.c
+++ b/drivers/spi/spi-fsl-espi.c
@@ -219,13 +219,8 @@ static int fsl_espi_bufs(struct spi_device *spi, struct spi_transfer *t)
        struct mpc8xxx_spi *mpc8xxx_spi = spi_master_get_devdata(spi->master);
        struct fsl_espi_reg *reg_base = mpc8xxx_spi->reg_base;
        unsigned int len = t->len;
-        u8 bits_per_word;
        int ret;
-        bits_per_word = spi->bits_per_word;
-        if (t->bits_per_word)
-                bits_per_word = t->bits_per_word;
        mpc8xxx_spi->len = t->len;
        len = roundup(len, 4) / 4;
diff --git a/drivers/spi/spi-fsl-lib.c b/drivers/spi/spi-fsl-lib.c
index 0b75f26158ab..e5d45fca3551 100644
--- a/drivers/spi/spi-fsl-lib.c
+++ b/drivers/spi/spi-fsl-lib.c
@@ -200,7 +200,7 @@ int of_mpc8xxx_spi_probe(struct platform_device *ofdev)
        const void *prop;
        int ret = -ENOMEM;
-        pinfo = kzalloc(sizeof(*pinfo), GFP_KERNEL);
+        pinfo = devm_kzalloc(&ofdev->dev, sizeof(*pinfo), GFP_KERNEL);
        if (!pinfo)
                return -ENOMEM;
@@ -215,15 +215,13 @@ int of_mpc8xxx_spi_probe(struct platform_device *ofdev)
        pdata->sysclk = get_brgfreq();
        if (pdata->sysclk == -1) {
                pdata->sysclk = fsl_get_sys_freq();
-                if (pdata->sysclk == -1) {
+                if (pdata->sysclk == -1)
-                        ret = -ENODEV;
+                        return -ENODEV;
-                        goto err;
-                }
        }
 #else
        ret = of_property_read_u32(np, "clock-frequency", &pdata->sysclk);
        if (ret)
-                goto err;
+                return ret;
 #endif
        prop = of_get_property(np, "mode", NULL);
@@ -237,8 +235,4 @@ int of_mpc8xxx_spi_probe(struct platform_device *ofdev)
                pdata->flags = SPI_CPM_MODE | SPI_CPM1;
        return 0;
-err:
-        kfree(pinfo);
-        return ret;
 }
diff --git a/drivers/spi/spi-fsl-spi.c b/drivers/spi/spi-fsl-spi.c
index 119f7af94537..f35488ed62a9 100644
--- a/drivers/spi/spi-fsl-spi.c
+++ b/drivers/spi/spi-fsl-spi.c
@@ -239,12 +239,6 @@ static int fsl_spi_setup_transfer(struct spi_device *spi,
        if (!bits_per_word)
                bits_per_word = spi->bits_per_word;
-        /* Make sure its a bit width we support [4..16, 32] */
-        if ((bits_per_word < 4)
-            || ((bits_per_word > 16) && (bits_per_word != 32))
-            || (bits_per_word > mpc8xxx_spi->max_bits_per_word))
-                return -EINVAL;
        if (!hz)
                hz = spi->max_speed_hz;
@@ -362,18 +356,28 @@ static int fsl_spi_bufs(struct spi_device *spi, struct spi_transfer *t,
 static void fsl_spi_do_one_msg(struct spi_message *m)
 {
        struct spi_device *spi = m->spi;
-        struct spi_transfer *t;
+        struct spi_transfer *t, *first;
        unsigned int cs_change;
        const int nsecs = 50;
        int status;
-        cs_change = 1;
+        /* Don't allow changes if CS is active */
-        status = 0;
+        first = list_first_entry(&m->transfers, struct spi_transfer,
+                        transfer_list);
        list_for_each_entry(t, &m->transfers, transfer_list) {
-                if (t->bits_per_word || t->speed_hz) {
+                if ((first->bits_per_word != t->bits_per_word) ||
-                        /* Don't allow changes if CS is active */
+                        (first->speed_hz != t->speed_hz)) {
                        status = -EINVAL;
+                        dev_err(&spi->dev,
+                                "bits_per_word/speed_hz should be same for the same SPI transfer\n");
+                        return;
+                }
+        }
+        cs_change = 1;
+        status = -EINVAL;
+        list_for_each_entry(t, &m->transfers, transfer_list) {
+                if (t->bits_per_word || t->speed_hz) {
                        if (cs_change)
                                status = fsl_spi_setup_transfer(spi, t);
                        if (status < 0)
@@ -641,6 +645,10 @@ static struct spi_master * fsl_spi_probe(struct device *dev,
        if (mpc8xxx_spi->type == TYPE_GRLIB)
                fsl_spi_grlib_probe(dev);
+        master->bits_per_word_mask =
+                (SPI_BPW_RANGE_MASK(4, 16) | SPI_BPW_MASK(32)) &
+                SPI_BPW_RANGE_MASK(1, mpc8xxx_spi->max_bits_per_word);
        if (mpc8xxx_spi->flags & SPI_QE_CPU_MODE)
                mpc8xxx_spi->set_shifts = fsl_spi_qe_cpu_set_shifts;
diff --git a/drivers/spi/spi-gpio.c b/drivers/spi/spi-gpio.c
index b189b958432b..e97baf2f475c 100644
--- a/drivers/spi/spi-gpio.c
+++ b/drivers/spi/spi-gpio.c
@@ -250,7 +250,7 @@ static int spi_gpio_setup(struct spi_device *spi)
                /*
                 * ... otherwise, take it from spi->controller_data
                 */
-                cs = (unsigned int) spi->controller_data;
+                cs = (unsigned int)(uintptr_t) spi->controller_data;
        }
        if (!spi->controller_state) {
diff --git a/drivers/spi/spi-pl022.c b/drivers/spi/spi-pl022.c
index 2789b452e711..3c5b90559bec 100644
--- a/drivers/spi/spi-pl022.c
+++ b/drivers/spi/spi-pl022.c
@@ -459,9 +459,8 @@ static void giveback(struct pl022 *pl022)
        struct spi_transfer *last_transfer;
        pl022->next_msg_cs_active = false;
-        last_transfer = list_entry(pl022->cur_msg->transfers.prev,
+        last_transfer = list_last_entry(&pl022->cur_msg->transfers,
-                                        struct spi_transfer,
+                                        struct spi_transfer, transfer_list);
-                                        transfer_list);
        /* Delay if requested before any change in chip select */
        if (last_transfer->delay_usecs)
diff --git a/drivers/spi/spi-pxa2xx.c b/drivers/spi/spi-pxa2xx.c
index c702fc536a77..41185d0557fa 100644
--- a/drivers/spi/spi-pxa2xx.c
+++ b/drivers/spi/spi-pxa2xx.c
@@ -362,8 +362,7 @@ static void giveback(struct driver_data *drv_data)
        drv_data->cur_msg = NULL;
        drv_data->cur_transfer = NULL;
-        last_transfer = list_entry(msg->transfers.prev,
+        last_transfer = list_last_entry(&msg->transfers, struct spi_transfer,
-                                        struct spi_transfer,
                                        transfer_list);
        /* Delay if requested before any change in chip select */