Merge tag 'spi-v4.13' of git://git.kernel.org/pub/scm/linux/kernel/git/broonie/spi

Pull spi updates from Mark Brown:
 "There's only one big change in this release but it's a very big
  change: Geert Uytterhoeven has implemented support for SPI slave mode.

  This feature has been on the cards since the subsystem was originally
  merged back in the mists of time so it's great that Geert stepped up
  and finally implemented it.

   - SPI slave support, together with wholesale renaming of SPI
     controllers from master to controller which went surprisingly
     smoothly. This is already used with Renesas SoCs and support is in
     the works for i.MX too.

   - New drivers for Meson SPICC and ST STM32"

* tag 'spi-v4.13' of git://git.kernel.org/pub/scm/linux/kernel/git/broonie/spi: (57 commits)
  spi: loopback-test: Fix kfree() NULL pointer error.
  spi: loopback-test: fix spelling mistake: "reruning" -> "rerunning"
  spi: sirf: fix spelling mistake: "registerred" -> "registered"
  spi: stm32: fix potential dereference null return value
  spi: stm32: enhance DMA error management
  spi: stm32: add runtime PM support
  spi: stm32: use normal conditional statements instead of ternary operator
  spi: stm32: replace st, spi-midi with st, spi-midi-ns to fit bindings
  spi: stm32: fix example with st, spi-midi-ns property
  spi: stm32: fix compatible to fit with new bindings
  spi: stm32: use SoC specific compatible
  spi: rockchip: Disable Runtime PM when chip select is asserted
  spi: rockchip: Set GPIO_SS flag to enable Slave Select with GPIO CS
  spi: atmel: fix corrupted data issue on SAM9 family SoCs
  spi: stm32: fix error check on mbr being -ve
  spi: add driver for STM32 SPI controller
  spi: Document the STM32 SPI bindings
  spi/bcm63xx: Fix checkpatch warnings
  spi: imx: Check for allocation failure earlier
  spi: mediatek: add spi support for mt2712 IC
  ...

4 files changed, 145 insertions, 81 deletions

diff --git a/include/linux/platform_data/spi-mt65xx.h b/include/linux/platform_data/spi-mt65xx.h
index 54b04483976c..ba4e4bb70262 100644
--- a/include/linux/platform_data/spi-mt65xx.h
+++ b/include/linux/platform_data/spi-mt65xx.h
@@ -16,5 +16,7 @@
 struct mtk_chip_config {
         u32 tx_mlsb;
         u32 rx_mlsb;
+        u32 cs_pol;
+        u32 sample_sel;
 };
 #endif
diff --git a/include/linux/pxa2xx_ssp.h b/include/linux/pxa2xx_ssp.h
index a0522328d7aa..8461b18e4608 100644
--- a/include/linux/pxa2xx_ssp.h
+++ b/include/linux/pxa2xx_ssp.h
@@ -196,6 +196,7 @@ enum pxa_ssp_type {
         LPSS_BSW_SSP,
         LPSS_SPT_SSP,
         LPSS_BXT_SSP,
+        LPSS_CNL_SSP,
 };
 
 struct ssp_device {
diff --git a/include/linux/spi/sh_msiof.h b/include/linux/spi/sh_msiof.h
index b087a85f5f72..f74b581f242f 100644
--- a/include/linux/spi/sh_msiof.h
+++ b/include/linux/spi/sh_msiof.h
@@ -1,10 +1,16 @@
 #ifndef __SPI_SH_MSIOF_H__
 #define __SPI_SH_MSIOF_H__
 
+enum {
+        MSIOF_SPI_MASTER,
+        MSIOF_SPI_SLAVE,
+};
+
 struct sh_msiof_spi_info {
         int tx_fifo_override;
         int rx_fifo_override;
         u16 num_chipselect;
+        int mode;
         unsigned int dma_tx_id;
         unsigned int dma_rx_id;
         u32 dtdl;
diff --git a/include/linux/spi/spi.h b/include/linux/spi/spi.h
index 935bd2854ff1..7b2170bfd6e7 100644
--- a/include/linux/spi/spi.h
+++ b/include/linux/spi/spi.h
@@ -24,13 +24,13 @@
 
 struct dma_chan;
 struct property_entry;
-struct spi_master;
+struct spi_controller;
 struct spi_transfer;
 struct spi_flash_read_message;
 
 /*
- * INTERFACES between SPI master-side drivers and SPI infrastructure.
- * (There's no SPI slave support for Linux yet...)
+ * INTERFACES between SPI master-side drivers and SPI slave protocol handlers,
+ * and SPI infrastructure.
  */
 extern struct bus_type spi_bus_type;
 
@@ -84,7 +84,7 @@ struct spi_statistics {
 
 void spi_statistics_add_transfer_stats(struct spi_statistics *stats,
                                        struct spi_transfer *xfer,
-                                       struct spi_master *master);
+                                       struct spi_controller *ctlr);
 
 #define SPI_STATISTICS_ADD_TO_FIELD(stats, field, count)        \
         do {                                                    \
@@ -98,13 +98,14 @@ void spi_statistics_add_transfer_stats(struct spi_statistics *stats,
         SPI_STATISTICS_ADD_TO_FIELD(stats, field, 1)
 
 /**
- * struct spi_device - Master side proxy for an SPI slave device
+ * struct spi_device - Controller side proxy for an SPI slave device
  * @dev: Driver model representation of the device.
- * @master: SPI controller used with the device.
+ * @controller: SPI controller used with the device.
+ * @master: Copy of controller, for backwards compatibility.
  * @max_speed_hz: Maximum clock rate to be used with this chip
  *      (on this board); may be changed by the device's driver.
  *      The spi_transfer.speed_hz can override this for each transfer.
- * @chip_select: Chipselect, distinguishing chips handled by @master.
+ * @chip_select: Chipselect, distinguishing chips handled by @controller.
  * @mode: The spi mode defines how data is clocked out and in.
  *      This may be changed by the device's driver.
  *      The "active low" default for chipselect mode can be overridden
@@ -140,7 +141,8 @@ void spi_statistics_add_transfer_stats(struct spi_statistics *stats,
  */
 struct spi_device {
         struct device           dev;
-        struct spi_master       *master;
+        struct spi_controller   *controller;
+        struct spi_controller   *master;        /* compatibility layer */
         u32                     max_speed_hz;
         u8                      chip_select;
         u8                      bits_per_word;
@@ -198,7 +200,7 @@ static inline void spi_dev_put(struct spi_device *spi)
                 put_device(&spi->dev);
 }
 
-/* ctldata is for the bus_master driver's runtime state */
+/* ctldata is for the bus_controller driver's runtime state */
 static inline void *spi_get_ctldata(struct spi_device *spi)
 {
         return spi->controller_state;
@@ -292,9 +294,9 @@ static inline void spi_unregister_driver(struct spi_driver *sdrv)
                         spi_unregister_driver)
 
 /**
- * struct spi_master - interface to SPI master controller
+ * struct spi_controller - interface to SPI master or slave controller
  * @dev: device interface to this driver
- * @list: link with the global spi_master list
+ * @list: link with the global spi_controller list
  * @bus_num: board-specific (and often SOC-specific) identifier for a
  *      given SPI controller.
  * @num_chipselect: chipselects are used to distinguish individual
@@ -311,6 +313,7 @@ static inline void spi_unregister_driver(struct spi_driver *sdrv)
  * @min_speed_hz: Lowest supported transfer speed
  * @max_speed_hz: Highest supported transfer speed
  * @flags: other constraints relevant to this driver
+ * @slave: indicates that this is an SPI slave controller
  * @max_transfer_size: function that returns the max transfer size for
  *      a &spi_device; may be %NULL, so the default %SIZE_MAX will be used.
  * @max_message_size: function that returns the max message size for
@@ -326,8 +329,8 @@ static inline void spi_unregister_driver(struct spi_driver *sdrv)
  *      the device whose settings are being modified.
  * @transfer: adds a message to the controller's transfer queue.
  * @cleanup: frees controller-specific state
- * @can_dma: determine whether this master supports DMA
- * @queued: whether this master is providing an internal message queue
+ * @can_dma: determine whether this controller supports DMA
+ * @queued: whether this controller is providing an internal message queue
  * @kworker: thread struct for message pump
  * @kworker_task: pointer to task for message pump kworker thread
  * @pump_messages: work struct for scheduling work to the message pump
@@ -374,6 +377,7 @@ static inline void spi_unregister_driver(struct spi_driver *sdrv)
  * @handle_err: the subsystem calls the driver to handle an error that occurs
  *              in the generic implementation of transfer_one_message().
  * @unprepare_message: undo any work done by prepare_message().
+ * @slave_abort: abort the ongoing transfer request on an SPI slave controller
  * @spi_flash_read: to support spi-controller hardwares that provide
  *                  accelerated interface to read from flash devices.
  * @spi_flash_can_dma: analogous to can_dma() interface, but for
@@ -382,7 +386,7 @@ static inline void spi_unregister_driver(struct spi_driver *sdrv)
  * @cs_gpios: Array of GPIOs to use as chip select lines; one per CS
  *      number. Any individual value may be -ENOENT for CS lines that
  *      are not GPIOs (driven by the SPI controller itself).
- * @statistics: statistics for the spi_master
+ * @statistics: statistics for the spi_controller
  * @dma_tx: DMA transmit channel
  * @dma_rx: DMA receive channel
  * @dummy_rx: dummy receive buffer for full-duplex devices
@@ -391,7 +395,7 @@ static inline void spi_unregister_driver(struct spi_driver *sdrv)
  *      what Linux expects, this optional hook can be used to translate
  *      between the two.
  *
- * Each SPI master controller can communicate with one or more @spi_device
+ * Each SPI controller can communicate with one or more @spi_device
  * children.  These make a small bus, sharing MOSI, MISO and SCK signals
  * but not chip select signals.  Each device may be configured to use a
  * different clock rate, since those shared signals are ignored unless
@@ -402,7 +406,7 @@ static inline void spi_unregister_driver(struct spi_driver *sdrv)
  * an SPI slave device.  For each such message it queues, it calls the
  * message's completion function when the transaction completes.
  */
-struct spi_master {
+struct spi_controller {
         struct device   dev;
 
         struct list_head list;
@@ -440,12 +444,16 @@ struct spi_master {
 
         /* other constraints relevant to this driver */
         u16                     flags;
-#define SPI_MASTER_HALF_DUPLEX  BIT(0)          /* can't do full duplex */
-#define SPI_MASTER_NO_RX        BIT(1)          /* can't do buffer read */
-#define SPI_MASTER_NO_TX        BIT(2)          /* can't do buffer write */
-#define SPI_MASTER_MUST_RX      BIT(3)          /* requires rx */
-#define SPI_MASTER_MUST_TX      BIT(4)          /* requires tx */
-#define SPI_MASTER_GPIO_SS      BIT(5)          /* GPIO CS must select slave */
+#define SPI_CONTROLLER_HALF_DUPLEX      BIT(0)  /* can't do full duplex */
+#define SPI_CONTROLLER_NO_RX            BIT(1)  /* can't do buffer read */
+#define SPI_CONTROLLER_NO_TX            BIT(2)  /* can't do buffer write */
+#define SPI_CONTROLLER_MUST_RX          BIT(3)  /* requires rx */
+#define SPI_CONTROLLER_MUST_TX          BIT(4)  /* requires tx */
+
+#define SPI_MASTER_GPIO_SS              BIT(5)  /* GPIO CS must select slave */
+
+        /* flag indicating this is an SPI slave controller */
+        bool                    slave;
 
         /*
          * on some hardware transfer / message size may be constrained
@@ -480,8 +488,8 @@ struct spi_master {
          *   any other request management
          * + To a given spi_device, message queueing is pure fifo
          *
-         * + The master's main job is to process its message queue,
-         *   selecting a chip then transferring data
+         * + The controller's main job is to process its message queue,
+         *   selecting a chip (for masters), then transferring data
          * + If there are multiple spi_device children, the i/o queue
          *   arbitration algorithm is unspecified (round robin, fifo,
          *   priority, reservations, preemption, etc)
@@ -494,7 +502,7 @@ struct spi_master {
         int                     (*transfer)(struct spi_device *spi,
                                                 struct spi_message *mesg);
 
-        /* called on release() to free memory provided by spi_master */
+        /* called on release() to free memory provided by spi_controller */
         void                    (*cleanup)(struct spi_device *spi);
 
         /*
@@ -504,13 +512,13 @@ struct spi_master {
          * not modify or store xfer and dma_tx and dma_rx must be set
          * while the device is prepared.
          */
-        bool                    (*can_dma)(struct spi_master *master,
+        bool                    (*can_dma)(struct spi_controller *ctlr,
                                            struct spi_device *spi,
                                            struct spi_transfer *xfer);
 
         /*
          * These hooks are for drivers that want to use the generic
-         * master transfer queueing mechanism. If these are used, the
+         * controller transfer queueing mechanism. If these are used, the
          * transfer() function above must NOT be specified by the driver.
          * Over time we expect SPI drivers to be phased over to this API.
          */
@@ -531,14 +539,15 @@ struct spi_master {
         struct completion               xfer_completion;
         size_t                          max_dma_len;
 
-        int (*prepare_transfer_hardware)(struct spi_master *master);
-        int (*transfer_one_message)(struct spi_master *master,
+        int (*prepare_transfer_hardware)(struct spi_controller *ctlr);
+        int (*transfer_one_message)(struct spi_controller *ctlr,
                                     struct spi_message *mesg);
-        int (*unprepare_transfer_hardware)(struct spi_master *master);
-        int (*prepare_message)(struct spi_master *master,
+        int (*unprepare_transfer_hardware)(struct spi_controller *ctlr);
+        int (*prepare_message)(struct spi_controller *ctlr,
                                struct spi_message *message);
-        int (*unprepare_message)(struct spi_master *master,
+        int (*unprepare_message)(struct spi_controller *ctlr,
                                  struct spi_message *message);
+        int (*slave_abort)(struct spi_controller *ctlr);
         int (*spi_flash_read)(struct  spi_device *spi,
                               struct spi_flash_read_message *msg);
         bool (*spi_flash_can_dma)(struct spi_device *spi,
@@ -550,9 +559,9 @@ struct spi_master {
          * of transfer_one_message() provied by the core.
          */
         void (*set_cs)(struct spi_device *spi, bool enable);
-        int (*transfer_one)(struct spi_master *master, struct spi_device *spi,
+        int (*transfer_one)(struct spi_controller *ctlr, struct spi_device *spi,
                             struct spi_transfer *transfer);
-        void (*handle_err)(struct spi_master *master,
+        void (*handle_err)(struct spi_controller *ctlr,
                            struct spi_message *message);
 
         /* gpio chip select */
@@ -569,57 +578,78 @@ struct spi_master {
         void                    *dummy_rx;
         void                    *dummy_tx;
 
-        int (*fw_translate_cs)(struct spi_master *master, unsigned cs);
+        int (*fw_translate_cs)(struct spi_controller *ctlr, unsigned cs);
 };
 
-static inline void *spi_master_get_devdata(struct spi_master *master)
+static inline void *spi_controller_get_devdata(struct spi_controller *ctlr)
 {
-        return dev_get_drvdata(&master->dev);
+        return dev_get_drvdata(&ctlr->dev);
 }
 
-static inline void spi_master_set_devdata(struct spi_master *master, void *data)
+static inline void spi_controller_set_devdata(struct spi_controller *ctlr,
+                                              void *data)
 {
-        dev_set_drvdata(&master->dev, data);
+        dev_set_drvdata(&ctlr->dev, data);
 }
 
-static inline struct spi_master *spi_master_get(struct spi_master *master)
+static inline struct spi_controller *spi_controller_get(struct spi_controller *ctlr)
 {
-        if (!master || !get_device(&master->dev))
+        if (!ctlr || !get_device(&ctlr->dev))
                 return NULL;
-        return master;
+        return ctlr;
+}
+
+static inline void spi_controller_put(struct spi_controller *ctlr)
+{
+        if (ctlr)
+                put_device(&ctlr->dev);
 }
 
-static inline void spi_master_put(struct spi_master *master)
+static inline bool spi_controller_is_slave(struct spi_controller *ctlr)
 {
-        if (master)
-                put_device(&master->dev);
+        return IS_ENABLED(CONFIG_SPI_SLAVE) && ctlr->slave;
 }
 
 /* PM calls that need to be issued by the driver */
-extern int spi_master_suspend(struct spi_master *master);
-extern int spi_master_resume(struct spi_master *master);
+extern int spi_controller_suspend(struct spi_controller *ctlr);
+extern int spi_controller_resume(struct spi_controller *ctlr);
 
 /* Calls the driver make to interact with the message queue */
-extern struct spi_message *spi_get_next_queued_message(struct spi_master *master);
-extern void spi_finalize_current_message(struct spi_master *master);
-extern void spi_finalize_current_transfer(struct spi_master *master);
+extern struct spi_message *spi_get_next_queued_message(struct spi_controller *ctlr);
+extern void spi_finalize_current_message(struct spi_controller *ctlr);
+extern void spi_finalize_current_transfer(struct spi_controller *ctlr);
 
-/* the spi driver core manages memory for the spi_master classdev */
-extern struct spi_master *
-spi_alloc_master(struct device *host, unsigned size);
+/* the spi driver core manages memory for the spi_controller classdev */
+extern struct spi_controller *__spi_alloc_controller(struct device *host,
+                                                unsigned int size, bool slave);
 
-extern int spi_register_master(struct spi_master *master);
-extern int devm_spi_register_master(struct device *dev,
-                                    struct spi_master *master);
-extern void spi_unregister_master(struct spi_master *master);
+static inline struct spi_controller *spi_alloc_master(struct device *host,
+                                                      unsigned int size)
+{
+        return __spi_alloc_controller(host, size, false);
+}
 
-extern struct spi_master *spi_busnum_to_master(u16 busnum);
+static inline struct spi_controller *spi_alloc_slave(struct device *host,
+                                                     unsigned int size)
+{
+        if (!IS_ENABLED(CONFIG_SPI_SLAVE))
+                return NULL;
+
+        return __spi_alloc_controller(host, size, true);
+}
+
+extern int spi_register_controller(struct spi_controller *ctlr);
+extern int devm_spi_register_controller(struct device *dev,
+                                        struct spi_controller *ctlr);
+extern void spi_unregister_controller(struct spi_controller *ctlr);
+
+extern struct spi_controller *spi_busnum_to_master(u16 busnum);
 
 /*
  * SPI resource management while processing a SPI message
  */
 
-typedef void (*spi_res_release_t)(struct spi_master *master,
+typedef void (*spi_res_release_t)(struct spi_controller *ctlr,
                                   struct spi_message *msg,
                                   void *res);
 
@@ -644,7 +674,7 @@ extern void *spi_res_alloc(struct spi_device *spi,
 extern void spi_res_add(struct spi_message *message, void *res);
 extern void spi_res_free(void *res);
 
-extern void spi_res_release(struct spi_master *master,
+extern void spi_res_release(struct spi_controller *ctlr,
                             struct spi_message *message);
 
 /*---------------------------------------------------------------------------*/
@@ -828,7 +858,7 @@ struct spi_message {
 
         /* for optional use by whatever driver currently owns the
          * spi_message ...  between calls to spi_async and then later
-         * complete(), that's the spi_master controller driver.
+         * complete(), that's the spi_controller controller driver.
          */
         struct list_head        queue;
         void                    *state;
@@ -912,25 +942,27 @@ extern int spi_setup(struct spi_device *spi);
 extern int spi_async(struct spi_device *spi, struct spi_message *message);
 extern int spi_async_locked(struct spi_device *spi,
                             struct spi_message *message);
+extern int spi_slave_abort(struct spi_device *spi);
 
 static inline size_t
 spi_max_message_size(struct spi_device *spi)
 {
-        struct spi_master *master = spi->master;
-        if (!master->max_message_size)
+        struct spi_controller *ctlr = spi->controller;
+
+        if (!ctlr->max_message_size)
                 return SIZE_MAX;
-        return master->max_message_size(spi);
+        return ctlr->max_message_size(spi);
 }
 
 static inline size_t
 spi_max_transfer_size(struct spi_device *spi)
 {
-        struct spi_master *master = spi->master;
+        struct spi_controller *ctlr = spi->controller;
         size_t tr_max = SIZE_MAX;
         size_t msg_max = spi_max_message_size(spi);
 
-        if (master->max_transfer_size)
-                tr_max = master->max_transfer_size(spi);
+        if (ctlr->max_transfer_size)
+                tr_max = ctlr->max_transfer_size(spi);
 
         /* transfer size limit must not be greater than messsage size limit */
         return min(tr_max, msg_max);
@@ -941,7 +973,7 @@ spi_max_transfer_size(struct spi_device *spi)
 /* SPI transfer replacement methods which make use of spi_res */
 
 struct spi_replaced_transfers;
-typedef void (*spi_replaced_release_t)(struct spi_master *master,
+typedef void (*spi_replaced_release_t)(struct spi_controller *ctlr,
                                        struct spi_message *msg,
                                        struct spi_replaced_transfers *res);
 /**
@@ -985,7 +1017,7 @@ extern struct spi_replaced_transfers *spi_replace_transfers(
 
 /* SPI transfer transformation methods */
 
-extern int spi_split_transfers_maxsize(struct spi_master *master,
+extern int spi_split_transfers_maxsize(struct spi_controller *ctlr,
                                        struct spi_message *msg,
                                        size_t maxsize,
                                        gfp_t gfp);
@@ -999,8 +1031,8 @@ extern int spi_split_transfers_maxsize(struct spi_master *master,
 
 extern int spi_sync(struct spi_device *spi, struct spi_message *message);
 extern int spi_sync_locked(struct spi_device *spi, struct spi_message *message);
-extern int spi_bus_lock(struct spi_master *master);
-extern int spi_bus_unlock(struct spi_master *master);
+extern int spi_bus_lock(struct spi_controller *ctlr);
+extern int spi_bus_unlock(struct spi_controller *ctlr);
 
 /**
  * spi_sync_transfer - synchronous SPI data transfer
@@ -1185,9 +1217,9 @@ struct spi_flash_read_message {
 /* SPI core interface for flash read support */
 static inline bool spi_flash_read_supported(struct spi_device *spi)
 {
-        return spi->master->spi_flash_read &&
-               (!spi->master->flash_read_supported ||
-               spi->master->flash_read_supported(spi));
+        return spi->controller->spi_flash_read &&
+               (!spi->controller->flash_read_supported ||
+               spi->controller->flash_read_supported(spi));
 }
 
 int spi_flash_read(struct spi_device *spi,
@@ -1220,7 +1252,7 @@ int spi_flash_read(struct spi_device *spi,
  * @irq: Initializes spi_device.irq; depends on how the board is wired.
  * @max_speed_hz: Initializes spi_device.max_speed_hz; based on limits
  *      from the chip datasheet and board-specific signal quality issues.
- * @bus_num: Identifies which spi_master parents the spi_device; unused
+ * @bus_num: Identifies which spi_controller parents the spi_device; unused
  *      by spi_new_device(), and otherwise depends on board wiring.
  * @chip_select: Initializes spi_device.chip_select; depends on how
  *      the board is wired.
@@ -1261,7 +1293,7 @@ struct spi_board_info {
 
 
         /* bus_num is board specific and matches the bus_num of some
-         * spi_master that will probably be registered later.
+         * spi_controller that will probably be registered later.
          *
          * chip_select reflects how this chip is wired to that master;
          * it's less than num_chipselect.
@@ -1295,7 +1327,7 @@ spi_register_board_info(struct spi_board_info const *info, unsigned n)
 /* If you're hotplugging an adapter with devices (parport, usb, etc)
  * use spi_new_device() to describe each device.  You can also call
  * spi_unregister_device() to start making that device vanish, but
- * normally that would be handled by spi_unregister_master().
+ * normally that would be handled by spi_unregister_controller().
  *
  * You can also use spi_alloc_device() and spi_add_device() to use a two
  * stage registration sequence for each spi_device.  This gives the caller
@@ -1304,13 +1336,13 @@ spi_register_board_info(struct spi_board_info const *info, unsigned n)
  * be defined using the board info.
  */
 extern struct spi_device *
-spi_alloc_device(struct spi_master *master);
+spi_alloc_device(struct spi_controller *ctlr);
 
 extern int
 spi_add_device(struct spi_device *spi);
 
 extern struct spi_device *
-spi_new_device(struct spi_master *, struct spi_board_info *);
+spi_new_device(struct spi_controller *, struct spi_board_info *);
 
 extern void spi_unregister_device(struct spi_device *spi);
 
@@ -1318,9 +1350,32 @@ extern const struct spi_device_id *
 spi_get_device_id(const struct spi_device *sdev);
 
 static inline bool
-spi_transfer_is_last(struct spi_master *master, struct spi_transfer *xfer)
+spi_transfer_is_last(struct spi_controller *ctlr, struct spi_transfer *xfer)
 {
-        return list_is_last(&xfer->transfer_list, &master->cur_msg->transfers);
+        return list_is_last(&xfer->transfer_list, &ctlr->cur_msg->transfers);
 }
 
+
+/* Compatibility layer */
+#define spi_master                      spi_controller
+
+#define SPI_MASTER_HALF_DUPLEX          SPI_CONTROLLER_HALF_DUPLEX
+#define SPI_MASTER_NO_RX                SPI_CONTROLLER_NO_RX
+#define SPI_MASTER_NO_TX                SPI_CONTROLLER_NO_TX
+#define SPI_MASTER_MUST_RX              SPI_CONTROLLER_MUST_RX
+#define SPI_MASTER_MUST_TX              SPI_CONTROLLER_MUST_TX
+
+#define spi_master_get_devdata(_ctlr)   spi_controller_get_devdata(_ctlr)
+#define spi_master_set_devdata(_ctlr, _data)    \
+        spi_controller_set_devdata(_ctlr, _data)
+#define spi_master_get(_ctlr)           spi_controller_get(_ctlr)
+#define spi_master_put(_ctlr)           spi_controller_put(_ctlr)
+#define spi_master_suspend(_ctlr)       spi_controller_suspend(_ctlr)
+#define spi_master_resume(_ctlr)        spi_controller_resume(_ctlr)
+
+#define spi_register_master(_ctlr)      spi_register_controller(_ctlr)
+#define devm_spi_register_master(_dev, _ctlr) \
+        devm_spi_register_controller(_dev, _ctlr)
+#define spi_unregister_master(_ctlr)    spi_unregister_controller(_ctlr)
+
 #endif /* __LINUX_SPI_H */