14 files changed, 108 insertions, 77 deletions

diff --git a/drivers/spi/spi-bcm63xx.c b/drivers/spi/spi-bcm63xx.c
index 06858e04ec59..fee747030ee6 100644
--- a/drivers/spi/spi-bcm63xx.c
+++ b/drivers/spi/spi-bcm63xx.c
@@ -207,6 +207,9 @@ static void bcm63xx_spi_setup_transfer(struct spi_device *spi,
         u8 clk_cfg, reg;
         int i;
 
+        /* Default to lowest clock configuration */
+        clk_cfg = SPI_CLK_0_391MHZ;
+
         /* Find the closest clock configuration */
         for (i = 0; i < SPI_CLK_MASK; i++) {
                 if (t->speed_hz >= bcm63xx_spi_freq_table[i][0]) {
@@ -215,10 +218,6 @@ static void bcm63xx_spi_setup_transfer(struct spi_device *spi,
                 }
         }
 
-        /* No matching configuration found, default to lowest */
-        if (i == SPI_CLK_MASK)
-                clk_cfg = SPI_CLK_0_391MHZ;
-
         /* clear existing clock configuration bits of the register */
         reg = bcm_spi_readb(bs, SPI_CLK_CFG);
         reg &= ~SPI_CLK_MASK;
@@ -562,8 +561,8 @@ static int bcm63xx_spi_probe(struct platform_device *pdev)
                 goto out_clk_disable;
         }
 
-        dev_info(dev, "at 0x%08x (irq %d, FIFOs size %d)\n",
-                 r->start, irq, bs->fifo_size);
+        dev_info(dev, "at %pr (irq %d, FIFOs size %d)\n",
+                 r, irq, bs->fifo_size);
 
         return 0;
 
diff --git a/drivers/spi/spi-butterfly.c b/drivers/spi/spi-butterfly.c
index 9a95862986c8..22a31e4a1a11 100644
--- a/drivers/spi/spi-butterfly.c
+++ b/drivers/spi/spi-butterfly.c
@@ -27,7 +27,6 @@
 
 #include <linux/mtd/partitions.h>
 
-
 /*
  * This uses SPI to talk with an "AVR Butterfly", which is a $US20 card
  * with a battery powered AVR microcontroller and lots of goodies.  You
@@ -37,7 +36,6 @@
  * and use this custom parallel port cable.
  */
 
-
 /* DATA output bits (pins 2..9 == D0..D7) */
 #define butterfly_nreset (1 << 1)               /* pin 3 */
 
@@ -52,14 +50,11 @@
 /* CONTROL output bits */
 #define spi_cs_bit      PARPORT_CONTROL_SELECT  /* pin 17 */
 
-
-
 static inline struct butterfly *spidev_to_pp(struct spi_device *spi)
 {
         return spi->controller_data;
 }
 
-
 struct butterfly {
         /* REVISIT ... for now, this must be first */
         struct spi_bitbang      bitbang;
@@ -140,7 +135,6 @@ static void butterfly_chipselect(struct spi_device *spi, int value)
         parport_frob_control(pp->port, spi_cs_bit, value ? spi_cs_bit : 0);
 }
 
-
 /* we only needed to implement one mode here, and choose SPI_MODE_0 */
 
 #define spidelay(X)     do { } while (0)
@@ -149,9 +143,8 @@ static void butterfly_chipselect(struct spi_device *spi, int value)
 #include "spi-bitbang-txrx.h"
 
 static u32
-butterfly_txrx_word_mode0(struct spi_device *spi,
-                unsigned nsecs,
-                u32 word, u8 bits)
+butterfly_txrx_word_mode0(struct spi_device *spi, unsigned nsecs, u32 word,
+                          u8 bits)
 {
         return bitbang_txrx_be_cpha0(spi, nsecs, 0, 0, word, bits);
 }
@@ -186,7 +179,6 @@ static struct flash_platform_data flash = {
         .nr_parts       = ARRAY_SIZE(partitions),
 };
 
-
 /* REVISIT remove this ugly global and its "only one" limitation */
 static struct butterfly *butterfly;
 
@@ -197,6 +189,7 @@ static void butterfly_attach(struct parport *p)
         struct butterfly        *pp;
         struct spi_master       *master;
         struct device           *dev = p->physport->dev;
+        struct pardev_cb        butterfly_cb;
 
         if (butterfly || !dev)
                 return;
@@ -229,9 +222,9 @@ static void butterfly_attach(struct parport *p)
          * parport hookup
          */
         pp->port = p;
-        pd = parport_register_device(p, "spi_butterfly",
-                        NULL, NULL, NULL,
-                        0 /* FLAGS */, pp);
+        memset(&butterfly_cb, 0, sizeof(butterfly_cb));
+        butterfly_cb.private = pp;
+        pd = parport_register_dev_model(p, "spi_butterfly", &butterfly_cb, 0);
         if (!pd) {
                 status = -ENOMEM;
                 goto clean0;
@@ -262,7 +255,6 @@ static void butterfly_attach(struct parport *p)
         parport_write_data(pp->port, pp->lastbyte);
         msleep(100);
 
-
         /*
          * Start SPI ... for now, hide that we're two physical busses.
          */
@@ -283,7 +275,7 @@ static void butterfly_attach(struct parport *p)
         pp->dataflash = spi_new_device(pp->bitbang.master, &pp->info[0]);
         if (pp->dataflash)
                 pr_debug("%s: dataflash at %s\n", p->name,
-                                dev_name(&pp->dataflash->dev));
+                         dev_name(&pp->dataflash->dev));
 
         pr_info("%s: AVR Butterfly\n", p->name);
         butterfly = pp;
@@ -297,7 +289,7 @@ clean2:
 clean1:
         parport_unregister_device(pd);
 clean0:
-        (void) spi_master_put(pp->bitbang.master);
+        spi_master_put(pp->bitbang.master);
 done:
         pr_debug("%s: butterfly probe, fail %d\n", p->name, status);
 }
@@ -325,16 +317,16 @@ static void butterfly_detach(struct parport *p)
         parport_release(pp->pd);
         parport_unregister_device(pp->pd);
 
-        (void) spi_master_put(pp->bitbang.master);
+        spi_master_put(pp->bitbang.master);
 }
 
 static struct parport_driver butterfly_driver = {
         .name =         "spi_butterfly",
-        .attach =       butterfly_attach,
+        .match_port =   butterfly_attach,
         .detach =       butterfly_detach,
+        .devmodel = true,
 };
 
-
 static int __init butterfly_init(void)
 {
         return parport_register_driver(&butterfly_driver);
diff --git a/drivers/spi/spi-cadence.c b/drivers/spi/spi-cadence.c
index 5a6749881ff9..121a4135b540 100644
--- a/drivers/spi/spi-cadence.c
+++ b/drivers/spi/spi-cadence.c
@@ -617,8 +617,7 @@ static int cdns_spi_remove(struct platform_device *pdev)
  */
 static int __maybe_unused cdns_spi_suspend(struct device *dev)
 {
-        struct platform_device *pdev = container_of(dev,
-                        struct platform_device, dev);
+        struct platform_device *pdev = to_platform_device(dev);
         struct spi_master *master = platform_get_drvdata(pdev);
         struct cdns_spi *xspi = spi_master_get_devdata(master);
 
@@ -641,8 +640,7 @@ static int __maybe_unused cdns_spi_suspend(struct device *dev)
  */
 static int __maybe_unused cdns_spi_resume(struct device *dev)
 {
-        struct platform_device *pdev = container_of(dev,
-                        struct platform_device, dev);
+        struct platform_device *pdev = to_platform_device(dev);
         struct spi_master *master = platform_get_drvdata(pdev);
         struct cdns_spi *xspi = spi_master_get_devdata(master);
         int ret = 0;
diff --git a/drivers/spi/spi-davinci.c b/drivers/spi/spi-davinci.c
index 7d3af3eacf57..fddb7a3be322 100644
--- a/drivers/spi/spi-davinci.c
+++ b/drivers/spi/spi-davinci.c
@@ -477,33 +477,33 @@ static int davinci_spi_check_error(struct davinci_spi *dspi, int int_status)
         struct device *sdev = dspi->bitbang.master->dev.parent;
 
         if (int_status & SPIFLG_TIMEOUT_MASK) {
-                dev_dbg(sdev, "SPI Time-out Error\n");
+                dev_err(sdev, "SPI Time-out Error\n");
                 return -ETIMEDOUT;
         }
         if (int_status & SPIFLG_DESYNC_MASK) {
-                dev_dbg(sdev, "SPI Desynchronization Error\n");
+                dev_err(sdev, "SPI Desynchronization Error\n");
                 return -EIO;
         }
         if (int_status & SPIFLG_BITERR_MASK) {
-                dev_dbg(sdev, "SPI Bit error\n");
+                dev_err(sdev, "SPI Bit error\n");
                 return -EIO;
         }
 
         if (dspi->version == SPI_VERSION_2) {
                 if (int_status & SPIFLG_DLEN_ERR_MASK) {
-                        dev_dbg(sdev, "SPI Data Length Error\n");
+                        dev_err(sdev, "SPI Data Length Error\n");
                         return -EIO;
                 }
                 if (int_status & SPIFLG_PARERR_MASK) {
-                        dev_dbg(sdev, "SPI Parity Error\n");
+                        dev_err(sdev, "SPI Parity Error\n");
                         return -EIO;
                 }
                 if (int_status & SPIFLG_OVRRUN_MASK) {
-                        dev_dbg(sdev, "SPI Data Overrun error\n");
+                        dev_err(sdev, "SPI Data Overrun error\n");
                         return -EIO;
                 }
                 if (int_status & SPIFLG_BUF_INIT_ACTIVE_MASK) {
-                        dev_dbg(sdev, "SPI Buffer Init Active\n");
+                        dev_err(sdev, "SPI Buffer Init Active\n");
                         return -EBUSY;
                 }
         }
@@ -703,7 +703,8 @@ static int davinci_spi_bufs(struct spi_device *spi, struct spi_transfer *t)
 
         /* Wait for the transfer to complete */
         if (spicfg->io_type != SPI_IO_TYPE_POLL) {
-                wait_for_completion_interruptible(&(dspi->done));
+                if (wait_for_completion_timeout(&dspi->done, HZ) == 0)
+                        errors = SPIFLG_TIMEOUT_MASK;
         } else {
                 while (dspi->rcount > 0 || dspi->wcount > 0) {
                         errors = davinci_spi_process_events(dspi);
diff --git a/drivers/spi/spi-dw-mid.c b/drivers/spi/spi-dw-mid.c
index bb1052e748f2..9185f6c08459 100644
--- a/drivers/spi/spi-dw-mid.c
+++ b/drivers/spi/spi-dw-mid.c
@@ -283,7 +283,7 @@ static void mid_spi_dma_stop(struct dw_spi *dws)
         }
 }
 
-static struct dw_spi_dma_ops mid_dma_ops = {
+static const struct dw_spi_dma_ops mid_dma_ops = {
         .dma_init       = mid_spi_dma_init,
         .dma_exit       = mid_spi_dma_exit,
         .dma_setup      = mid_spi_dma_setup,
diff --git a/drivers/spi/spi-dw.c b/drivers/spi/spi-dw.c
index 882cd6618cd5..c09bb745693a 100644
--- a/drivers/spi/spi-dw.c
+++ b/drivers/spi/spi-dw.c
@@ -425,7 +425,7 @@ static int dw_spi_setup(struct spi_device *spi)
                 chip->type = chip_info->type;
         }
 
-        chip->tmode = 0; /* Tx & Rx */
+        chip->tmode = SPI_TMOD_TR;
 
         if (gpio_is_valid(spi->cs_gpio)) {
                 ret = gpio_direction_output(spi->cs_gpio,
diff --git a/drivers/spi/spi-dw.h b/drivers/spi/spi-dw.h
index 35589a270468..61bc3cbab38d 100644
--- a/drivers/spi/spi-dw.h
+++ b/drivers/spi/spi-dw.h
@@ -130,7 +130,7 @@ struct dw_spi {
         struct dma_chan         *rxchan;
         unsigned long           dma_chan_busy;
         dma_addr_t              dma_addr; /* phy address of the Data register */
-        struct dw_spi_dma_ops   *dma_ops;
+        const struct dw_spi_dma_ops *dma_ops;
         void                    *dma_tx;
         void                    *dma_rx;
 
diff --git a/drivers/spi/spi-fsl-dspi.c b/drivers/spi/spi-fsl-dspi.c
index 59a11437db70..39412c9097c6 100644
--- a/drivers/spi/spi-fsl-dspi.c
+++ b/drivers/spi/spi-fsl-dspi.c
@@ -167,7 +167,7 @@ static inline int is_double_byte_mode(struct fsl_dspi *dspi)
 {
         unsigned int val;
 
-        regmap_read(dspi->regmap, SPI_CTAR(dspi->cs), &val);
+        regmap_read(dspi->regmap, SPI_CTAR(0), &val);
 
         return ((val & SPI_FRAME_BITS_MASK) == SPI_FRAME_BITS(8)) ? 0 : 1;
 }
@@ -257,7 +257,7 @@ static u32 dspi_data_to_pushr(struct fsl_dspi *dspi, int tx_word)
 
         return  SPI_PUSHR_TXDATA(d16) |
                 SPI_PUSHR_PCS(dspi->cs) |
-                SPI_PUSHR_CTAS(dspi->cs) |
+                SPI_PUSHR_CTAS(0) |
                 SPI_PUSHR_CONT;
 }
 
@@ -290,7 +290,7 @@ static int dspi_eoq_write(struct fsl_dspi *dspi)
                  */
                 if (tx_word && (dspi->len == 1)) {
                         dspi->dataflags |= TRAN_STATE_WORD_ODD_NUM;
-                        regmap_update_bits(dspi->regmap, SPI_CTAR(dspi->cs),
+                        regmap_update_bits(dspi->regmap, SPI_CTAR(0),
                                         SPI_FRAME_BITS_MASK, SPI_FRAME_BITS(8));
                         tx_word = 0;
                 }
@@ -339,7 +339,7 @@ static int dspi_tcfq_write(struct fsl_dspi *dspi)
 
         if (tx_word && (dspi->len == 1)) {
                 dspi->dataflags |= TRAN_STATE_WORD_ODD_NUM;
-                regmap_update_bits(dspi->regmap, SPI_CTAR(dspi->cs),
+                regmap_update_bits(dspi->regmap, SPI_CTAR(0),
                                 SPI_FRAME_BITS_MASK, SPI_FRAME_BITS(8));
                 tx_word = 0;
         }
@@ -407,7 +407,7 @@ static int dspi_transfer_one_message(struct spi_master *master,
                 regmap_update_bits(dspi->regmap, SPI_MCR,
                                 SPI_MCR_CLR_TXF | SPI_MCR_CLR_RXF,
                                 SPI_MCR_CLR_TXF | SPI_MCR_CLR_RXF);
-                regmap_write(dspi->regmap, SPI_CTAR(dspi->cs),
+                regmap_write(dspi->regmap, SPI_CTAR(0),
                                 dspi->cur_chip->ctar_val);
 
                 trans_mode = dspi->devtype_data->trans_mode;
@@ -566,7 +566,7 @@ static irqreturn_t dspi_interrupt(int irq, void *dev_id)
                 if (!dspi->len) {
                         if (dspi->dataflags & TRAN_STATE_WORD_ODD_NUM) {
                                 regmap_update_bits(dspi->regmap,
-                                                   SPI_CTAR(dspi->cs),
+                                                   SPI_CTAR(0),
                                                    SPI_FRAME_BITS_MASK,
                                                    SPI_FRAME_BITS(16));
                                 dspi->dataflags &= ~TRAN_STATE_WORD_ODD_NUM;
diff --git a/drivers/spi/spi-fsl-espi.c b/drivers/spi/spi-fsl-espi.c
index c27124a5ec8e..7fd6a4c009d2 100644
--- a/drivers/spi/spi-fsl-espi.c
+++ b/drivers/spi/spi-fsl-espi.c
@@ -643,6 +643,11 @@ static int fsl_espi_runtime_resume(struct device *dev)
 }
 #endif
 
+static size_t fsl_espi_max_transfer_size(struct spi_device *spi)
+{
+        return SPCOM_TRANLEN_MAX;
+}
+
 static struct spi_master * fsl_espi_probe(struct device *dev,
                 struct resource *mem, unsigned int irq)
 {
@@ -670,6 +675,7 @@ static struct spi_master * fsl_espi_probe(struct device *dev,
         master->cleanup = fsl_espi_cleanup;
         master->transfer_one_message = fsl_espi_do_one_msg;
         master->auto_runtime_pm = true;
+        master->max_transfer_size = fsl_espi_max_transfer_size;
 
         mpc8xxx_spi = spi_master_get_devdata(master);
 
diff --git a/drivers/spi/spi-mt65xx.c b/drivers/spi/spi-mt65xx.c
index 563954a61424..4895fe3944f1 100644
--- a/drivers/spi/spi-mt65xx.c
+++ b/drivers/spi/spi-mt65xx.c
@@ -323,7 +323,8 @@ static int mtk_spi_fifo_transfer(struct spi_master *master,
                                  struct spi_device *spi,
                                  struct spi_transfer *xfer)
 {
-        int cnt;
+        int cnt, remainder;
+        u32 reg_val;
         struct mtk_spi *mdata = spi_master_get_devdata(master);
 
         mdata->cur_transfer = xfer;
@@ -331,12 +332,16 @@ static int mtk_spi_fifo_transfer(struct spi_master *master,
         mtk_spi_prepare_transfer(master, xfer);
         mtk_spi_setup_packet(master);
 
-        if (xfer->len % 4)
-                cnt = xfer->len / 4 + 1;
-        else
-                cnt = xfer->len / 4;
+        cnt = xfer->len / 4;
         iowrite32_rep(mdata->base + SPI_TX_DATA_REG, xfer->tx_buf, cnt);
 
+        remainder = xfer->len % 4;
+        if (remainder > 0) {
+                reg_val = 0;
+                memcpy(&reg_val, xfer->tx_buf + (cnt * 4), remainder);
+                writel(reg_val, mdata->base + SPI_TX_DATA_REG);
+        }
+
         mtk_spi_enable_transfer(master);
 
         return 1;
@@ -410,7 +415,7 @@ static int mtk_spi_setup(struct spi_device *spi)
         if (!spi->controller_data)
                 spi->controller_data = (void *)&mtk_default_chip_info;
 
-        if (mdata->dev_comp->need_pad_sel)
+        if (mdata->dev_comp->need_pad_sel && gpio_is_valid(spi->cs_gpio))
                 gpio_direction_output(spi->cs_gpio, !(spi->mode & SPI_CS_HIGH));
 
         return 0;
@@ -418,7 +423,7 @@ static int mtk_spi_setup(struct spi_device *spi)
 
 static irqreturn_t mtk_spi_interrupt(int irq, void *dev_id)
 {
-        u32 cmd, reg_val, cnt;
+        u32 cmd, reg_val, cnt, remainder;
         struct spi_master *master = dev_id;
         struct mtk_spi *mdata = spi_master_get_devdata(master);
         struct spi_transfer *trans = mdata->cur_transfer;
@@ -431,12 +436,15 @@ static irqreturn_t mtk_spi_interrupt(int irq, void *dev_id)
 
         if (!master->can_dma(master, master->cur_msg->spi, trans)) {
                 if (trans->rx_buf) {
-                        if (mdata->xfer_len % 4)
-                                cnt = mdata->xfer_len / 4 + 1;
-                        else
-                                cnt = mdata->xfer_len / 4;
+                        cnt = mdata->xfer_len / 4;
                         ioread32_rep(mdata->base + SPI_RX_DATA_REG,
                                      trans->rx_buf, cnt);
+                        remainder = mdata->xfer_len % 4;
+                        if (remainder > 0) {
+                                reg_val = readl(mdata->base + SPI_RX_DATA_REG);
+                                memcpy(trans->rx_buf + (cnt * 4),
+                                        &reg_val, remainder);
+                        }
                 }
                 spi_finalize_current_transfer(master);
                 return IRQ_HANDLED;
@@ -632,13 +640,23 @@ static int mtk_spi_probe(struct platform_device *pdev)
                         goto err_put_master;
                 }
 
-                for (i = 0; i < master->num_chipselect; i++) {
-                        ret = devm_gpio_request(&pdev->dev, master->cs_gpios[i],
-                                                dev_name(&pdev->dev));
-                        if (ret) {
-                                dev_err(&pdev->dev,
-                                        "can't get CS GPIO %i\n", i);
-                                goto err_put_master;
+                if (!master->cs_gpios && master->num_chipselect > 1) {
+                        dev_err(&pdev->dev,
+                                "cs_gpios not specified and num_chipselect > 1\n");
+                        ret = -EINVAL;
+                        goto err_put_master;
+                }
+
+                if (master->cs_gpios) {
+                        for (i = 0; i < master->num_chipselect; i++) {
+                                ret = devm_gpio_request(&pdev->dev,
+                                                        master->cs_gpios[i],
+                                                        dev_name(&pdev->dev));
+                                if (ret) {
+                                        dev_err(&pdev->dev,
+                                                "can't get CS GPIO %i\n", i);
+                                        goto err_put_master;
+                                }
                         }
                 }
         }
diff --git a/drivers/spi/spi-pl022.c b/drivers/spi/spi-pl022.c
index 94af80676684..5e5fd77e2711 100644
--- a/drivers/spi/spi-pl022.c
+++ b/drivers/spi/spi-pl022.c
@@ -1171,19 +1171,31 @@ err_no_rxchan:
 static int pl022_dma_autoprobe(struct pl022 *pl022)
 {
         struct device *dev = &pl022->adev->dev;
+        struct dma_chan *chan;
+        int err;
 
         /* automatically configure DMA channels from platform, normally using DT */
-        pl022->dma_rx_channel = dma_request_slave_channel(dev, "rx");
-        if (!pl022->dma_rx_channel)
+        chan = dma_request_slave_channel_reason(dev, "rx");
+        if (IS_ERR(chan)) {
+                err = PTR_ERR(chan);
                 goto err_no_rxchan;
+        }
+
+        pl022->dma_rx_channel = chan;
 
-        pl022->dma_tx_channel = dma_request_slave_channel(dev, "tx");
-        if (!pl022->dma_tx_channel)
+        chan = dma_request_slave_channel_reason(dev, "tx");
+        if (IS_ERR(chan)) {
+                err = PTR_ERR(chan);
                 goto err_no_txchan;
+        }
+
+        pl022->dma_tx_channel = chan;
 
         pl022->dummypage = kmalloc(PAGE_SIZE, GFP_KERNEL);
-        if (!pl022->dummypage)
+        if (!pl022->dummypage) {
+                err = -ENOMEM;
                 goto err_no_dummypage;
+        }
 
         return 0;
 
@@ -1194,7 +1206,7 @@ err_no_txchan:
         dma_release_channel(pl022->dma_rx_channel);
         pl022->dma_rx_channel = NULL;
 err_no_rxchan:
-        return -ENODEV;
+        return err;
 }
                 
 static void terminate_dma(struct pl022 *pl022)
@@ -2236,6 +2248,10 @@ static int pl022_probe(struct amba_device *adev, const struct amba_id *id)
 
         /* Get DMA channels, try autoconfiguration first */
         status = pl022_dma_autoprobe(pl022);
+        if (status == -EPROBE_DEFER) {
+                dev_dbg(dev, "deferring probe to get DMA channel\n");
+                goto err_no_irq;
+        }
 
         /* If that failed, use channels from platform_info */
         if (status == 0)
diff --git a/drivers/spi/spi-sun4i.c b/drivers/spi/spi-sun4i.c
index fbb0a4d74e91..a6d936c68674 100644
--- a/drivers/spi/spi-sun4i.c
+++ b/drivers/spi/spi-sun4i.c
@@ -140,6 +140,9 @@ static void sun4i_spi_set_cs(struct spi_device *spi, bool enable)
         reg &= ~SUN4I_CTL_CS_MASK;
         reg |= SUN4I_CTL_CS(spi->chip_select);
 
+        /* We want to control the chip select manually */
+        reg |= SUN4I_CTL_CS_MANUAL;
+
         if (enable)
                 reg |= SUN4I_CTL_CS_LEVEL;
         else
@@ -222,9 +225,6 @@ static int sun4i_spi_transfer_one(struct spi_master *master,
         else
                 reg |= SUN4I_CTL_DHB;
 
-        /* We want to control the chip select manually */
-        reg |= SUN4I_CTL_CS_MANUAL;
-
         sun4i_spi_write(sspi, SUN4I_CTL_REG, reg);
 
         /* Ensure that we have a parent clock fast enough */
diff --git a/drivers/spi/spi.c b/drivers/spi/spi.c
index e2415be209d5..a678a7f1a65d 100644
--- a/drivers/spi/spi.c
+++ b/drivers/spi/spi.c
@@ -84,8 +84,7 @@ static ssize_t spi_device_##field##_show(struct device *dev,		\
                                          struct device_attribute *attr, \
                                         char *buf)                      \
 {                                                                       \
-        struct spi_device *spi = container_of(dev,                      \
-                                              struct spi_device, dev);  \
+        struct spi_device *spi = to_spi_device(dev);                    \
         return spi_statistics_##field##_show(&spi->statistics, buf);    \
 }                                                                       \
 static struct device_attribute dev_attr_spi_device_##field = {          \
@@ -376,6 +375,7 @@ static void spi_drv_shutdown(struct device *dev)
 
 /**
  * __spi_register_driver - register a SPI driver
+ * @owner: owner module of the driver to register
  * @sdrv: the driver to register
  * Context: can sleep
  *
@@ -1704,7 +1704,7 @@ struct spi_master *spi_alloc_master(struct device *dev, unsigned size)
         master->bus_num = -1;
         master->num_chipselect = 1;
         master->dev.class = &spi_master_class;
-        master->dev.parent = get_device(dev);
+        master->dev.parent = dev;
         spi_master_set_devdata(master, &master[1]);
 
         return master;
@@ -2130,6 +2130,7 @@ static int __spi_validate(struct spi_device *spi, struct spi_message *message)
          * Set transfer tx_nbits and rx_nbits as single transfer default
          * (SPI_NBITS_SINGLE) if it is not set for this transfer.
          */
+        message->frame_length = 0;
         list_for_each_entry(xfer, &message->transfers, transfer_list) {
                 message->frame_length += xfer->len;
                 if (!xfer->bits_per_word)
diff --git a/drivers/spi/spidev.c b/drivers/spi/spidev.c
index 91a0fcd72423..d0e7dfc647cf 100644
--- a/drivers/spi/spidev.c
+++ b/drivers/spi/spidev.c
@@ -651,11 +651,11 @@ static int spidev_release(struct inode *inode, struct file *filp)
                 kfree(spidev->rx_buffer);
                 spidev->rx_buffer = NULL;
 
+                spin_lock_irq(&spidev->spi_lock);
                 if (spidev->spi)
                         spidev->speed_hz = spidev->spi->max_speed_hz;
 
                 /* ... after we unbound from the underlying device? */
-                spin_lock_irq(&spidev->spi_lock);
                 dofree = (spidev->spi == NULL);
                 spin_unlock_irq(&spidev->spi_lock);