aboutsummaryrefslogtreecommitdiffstats
path: root/meta-rcar-gen3-adas/recipes-kernel/linux
diff options
context:
space:
mode:
Diffstat (limited to 'meta-rcar-gen3-adas/recipes-kernel/linux')
-rw-r--r--meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas/0040-arm64-dts-renesas-add-ADAS-boards.patch44
-rw-r--r--meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas/0083-spi-Document-DT-bindings-for-SPI-controllers-in-slav.patch118
-rw-r--r--meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas/0084-spi-core-Add-support-for-registering-SPI-slave-contr.patch445
-rw-r--r--meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas/0085-spi-Document-SPI-slave-controller-support.patch66
-rw-r--r--meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas/0086-spi-sh-msiof-Add-slave-mode-support.patch209
-rw-r--r--meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas/0087-spi-slave-Add-SPI-slave-handler-reporting-uptime-at-.patch182
-rw-r--r--meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas/0088-spi-slave-Add-SPI-slave-handler-controlling-system-s.patch205
-rw-r--r--meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas/0089-spi-Generalize-SPI-master-to-controller.patch3048
-rw-r--r--meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas/0090-spidev-Do-not-automatically-bind-to-MSIOF-spi-may-be.patch26
-rw-r--r--meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas/v3msk.cfg3
-rw-r--r--meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas_4.9.bbappend8
11 files changed, 4348 insertions, 6 deletions
diff --git a/meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas/0040-arm64-dts-renesas-add-ADAS-boards.patch b/meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas/0040-arm64-dts-renesas-add-ADAS-boards.patch
index 483ba45..4d914f1 100644
--- a/meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas/0040-arm64-dts-renesas-add-ADAS-boards.patch
+++ b/meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas/0040-arm64-dts-renesas-add-ADAS-boards.patch
@@ -65,10 +65,10 @@ Signed-off-by: Vladimir Barinov <vladimir.barinov@cogentembedded.com>
.../boot/dts/renesas/r8a7797-eagle-function.dts | 62 +
arch/arm64/boot/dts/renesas/r8a7797-eagle.dts | 575 +++++++
arch/arm64/boot/dts/renesas/r8a7797-v3msk-kf.dts | 578 +++++++
- arch/arm64/boot/dts/renesas/r8a7797-v3msk-vbm.dts | 518 ++++++
+ arch/arm64/boot/dts/renesas/r8a7797-v3msk-vbm.dts | 550 ++++++
arch/arm64/boot/dts/renesas/r8a7797-v3msk-view.dts | 298 ++++
arch/arm64/boot/dts/renesas/r8a7797-v3msk.dts | 314 ++++
- arch/arm64/boot/dts/renesas/r8a7798-condor.dts | 939 +++++++++++
+ arch/arm64/boot/dts/renesas/r8a7798-condor.dts | 940 +++++++++++
arch/arm64/boot/dts/renesas/ulcb-kf-cn11.dtsi | 545 ++++++
arch/arm64/boot/dts/renesas/ulcb-kf-most.dtsi | 30 +
arch/arm64/boot/dts/renesas/ulcb-kf-sd3.dtsi | 46 +
@@ -77,7 +77,7 @@ Signed-off-by: Vladimir Barinov <vladimir.barinov@cogentembedded.com>
arch/arm64/boot/dts/renesas/ulcb-vb.dtsi | 1726 +++++++++++++++++++
arch/arm64/boot/dts/renesas/ulcb-vb2.dtsi | 1772 ++++++++++++++++++++
arch/arm64/boot/dts/renesas/ulcb-vbm.dtsi | 578 +++++++
- 47 files changed, 20099 insertions(+)
+ 47 files changed, 20132 insertions(+)
create mode 100644 arch/arm64/boot/dts/renesas/legacy/Makefile
create mode 100644 arch/arm64/boot/dts/renesas/legacy/r8a7795-es1-h3ulcb-kf-v0.dts
create mode 100644 arch/arm64/boot/dts/renesas/legacy/r8a7795-es1-h3ulcb-kf-v1.dts
@@ -11617,10 +11617,10 @@ index 0000000..b92fe83
+};
diff --git a/arch/arm64/boot/dts/renesas/r8a7797-v3msk-vbm.dts b/arch/arm64/boot/dts/renesas/r8a7797-v3msk-vbm.dts
new file mode 100644
-index 0000000..26f8c70
+index 0000000..8612f64
--- /dev/null
+++ b/arch/arm64/boot/dts/renesas/r8a7797-v3msk-vbm.dts
-@@ -0,0 +1,518 @@
+@@ -0,0 +1,550 @@
+/*
+ * Device Tree Source for the V3MSK Videobox Mini board on r8a7797
+ *
@@ -11987,6 +11987,28 @@ index 0000000..26f8c70
+ };
+};
+
++&msiof1 {
++ pinctrl-0 = <&msiof1_pins>;
++ pinctrl-names = "default";
++ cs-gpios = <&gpio3 3 0>;
++
++ status = "okay";
++ spidev@0 {
++ compatible = "spidev";
++ reg = <0>;
++ spi-max-frequency = <66666666>;
++ };
++
++};
++
++&msiof3 {
++ pinctrl-0 = <&msiof3_pins>;
++ pinctrl-names = "default";
++
++ status = "okay";
++ slave;
++};
++
+&pfc {
+ canfd0_pins: canfd0 {
+ groups = "canfd0_data_a";
@@ -12003,6 +12025,16 @@ index 0000000..26f8c70
+ function = "i2c1";
+ };
+
++ msiof1_pins: msiof1 {
++ groups = "msiof1_clk", "msiof1_txd", "msiof1_rxd";
++ function = "msiof1";
++ };
++
++ msiof3_pins: msiof3 {
++ groups = "msiof3_clk", "msiof3_txd", "msiof3_rxd", "msiof3_sync";
++ function = "msiof3";
++ };
++
+ scif3_pins: scif3 {
+ groups = "scif3_data";
+ function = "scif3";
@@ -12765,7 +12797,7 @@ index 0000000..91d10c5
+};
diff --git a/arch/arm64/boot/dts/renesas/r8a7798-condor.dts b/arch/arm64/boot/dts/renesas/r8a7798-condor.dts
new file mode 100644
-index 0000000..ed9cc28
+index 0000000..b236d66
--- /dev/null
+++ b/arch/arm64/boot/dts/renesas/r8a7798-condor.dts
@@ -0,0 +1,940 @@
diff --git a/meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas/0083-spi-Document-DT-bindings-for-SPI-controllers-in-slav.patch b/meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas/0083-spi-Document-DT-bindings-for-SPI-controllers-in-slav.patch
new file mode 100644
index 0000000..0266378
--- /dev/null
+++ b/meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas/0083-spi-Document-DT-bindings-for-SPI-controllers-in-slav.patch
@@ -0,0 +1,118 @@
+From c71da12ba9738ac1441fb431100cb03662ba9ac1 Mon Sep 17 00:00:00 2001
+From: Geert Uytterhoeven <geert+renesas@glider.be>
+Date: Fri, 17 Jun 2016 18:05:32 +0200
+Subject: [PATCH 1/7] spi: Document DT bindings for SPI controllers in slave
+ mode
+
+Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
+Reviewed-by: Rob Herring <robh@kernel.org>
+---
+ Documentation/devicetree/bindings/spi/spi-bus.txt | 76 ++++++++++++---------
+ 1 file changed, 45 insertions(+), 31 deletions(-)
+
+diff --git a/Documentation/devicetree/bindings/spi/spi-bus.txt b/Documentation/devicetree/bindings/spi/spi-bus.txt
+index 4b1d6e7..1f6e86f 100644
+--- a/Documentation/devicetree/bindings/spi/spi-bus.txt
++++ b/Documentation/devicetree/bindings/spi/spi-bus.txt
+@@ -1,17 +1,23 @@
+ SPI (Serial Peripheral Interface) busses
+
+-SPI busses can be described with a node for the SPI master device
+-and a set of child nodes for each SPI slave on the bus. For this
+-discussion, it is assumed that the system's SPI controller is in
+-SPI master mode. This binding does not describe SPI controllers
+-in slave mode.
++SPI busses can be described with a node for the SPI controller device
++and a set of child nodes for each SPI slave on the bus. The system's SPI
++controller may be described for use in SPI master mode or in SPI slave mode,
++but not for both at the same time.
+
+-The SPI master node requires the following properties:
++The SPI controller node requires the following properties:
++- compatible - Name of SPI bus controller following generic names
++ recommended practice.
++
++In master mode, the SPI controller node requires the following additional
++properties:
+ - #address-cells - number of cells required to define a chip select
+ address on the SPI bus.
+ - #size-cells - should be zero.
+-- compatible - name of SPI bus controller following generic names
+- recommended practice.
++
++In slave mode, the SPI controller node requires one additional property:
++- spi-slave - Empty property.
++
+ No other properties are required in the SPI bus node. It is assumed
+ that a driver for an SPI bus device will understand that it is an SPI bus.
+ However, the binding does not attempt to define the specific method for
+@@ -21,7 +27,7 @@ assumption that board specific platform code will be used to manage
+ chip selects. Individual drivers can define additional properties to
+ support describing the chip select layout.
+
+-Optional properties:
++Optional properties (master mode only):
+ - cs-gpios - gpios chip select.
+ - num-cs - total number of chipselects.
+
+@@ -41,28 +47,36 @@ cs1 : native
+ cs2 : &gpio1 1 0
+ cs3 : &gpio1 2 0
+
+-SPI slave nodes must be children of the SPI master node and can
+-contain the following properties.
+-- reg - (required) chip select address of device.
+-- compatible - (required) name of SPI device following generic names
+- recommended practice.
+-- spi-max-frequency - (required) Maximum SPI clocking speed of device in Hz.
+-- spi-cpol - (optional) Empty property indicating device requires
+- inverse clock polarity (CPOL) mode.
+-- spi-cpha - (optional) Empty property indicating device requires
+- shifted clock phase (CPHA) mode.
+-- spi-cs-high - (optional) Empty property indicating device requires
+- chip select active high.
+-- spi-3wire - (optional) Empty property indicating device requires
+- 3-wire mode.
+-- spi-lsb-first - (optional) Empty property indicating device requires
+- LSB first mode.
+-- spi-tx-bus-width - (optional) The bus width (number of data wires) that is
+- used for MOSI. Defaults to 1 if not present.
+-- spi-rx-bus-width - (optional) The bus width (number of data wires) that is
+- used for MISO. Defaults to 1 if not present.
+-- spi-rx-delay-us - (optional) Microsecond delay after a read transfer.
+-- spi-tx-delay-us - (optional) Microsecond delay after a write transfer.
++
++SPI slave nodes must be children of the SPI controller node.
++
++In master mode, one or more slave nodes (up to the number of chip selects) can
++be present. Required properties are:
++- compatible - Name of SPI device following generic names recommended
++ practice.
++- reg - Chip select address of device.
++- spi-max-frequency - Maximum SPI clocking speed of device in Hz.
++
++In slave mode, the (single) slave node is optional.
++If present, it must be called "slave". Required properties are:
++- compatible - Name of SPI device following generic names recommended
++ practice.
++
++All slave nodes can contain the following optional properties:
++- spi-cpol - Empty property indicating device requires inverse clock
++ polarity (CPOL) mode.
++- spi-cpha - Empty property indicating device requires shifted clock
++ phase (CPHA) mode.
++- spi-cs-high - Empty property indicating device requires chip select
++ active high.
++- spi-3wire - Empty property indicating device requires 3-wire mode.
++- spi-lsb-first - Empty property indicating device requires LSB first mode.
++- spi-tx-bus-width - The bus width (number of data wires) that is used for MOSI.
++ Defaults to 1 if not present.
++- spi-rx-bus-width - The bus width (number of data wires) that is used for MISO.
++ Defaults to 1 if not present.
++- spi-rx-delay-us - Microsecond delay after a read transfer.
++- spi-tx-delay-us - Microsecond delay after a write transfer.
+
+ Some SPI controllers and devices support Dual and Quad SPI transfer mode.
+ It allows data in the SPI system to be transferred using 2 wires (DUAL) or 4
+--
+1.7.10.4
diff --git a/meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas/0084-spi-core-Add-support-for-registering-SPI-slave-contr.patch b/meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas/0084-spi-core-Add-support-for-registering-SPI-slave-contr.patch
new file mode 100644
index 0000000..780459c
--- /dev/null
+++ b/meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas/0084-spi-core-Add-support-for-registering-SPI-slave-contr.patch
@@ -0,0 +1,445 @@
+From 069206bafab71d97d2c427ed664e7cbacbe0678c Mon Sep 17 00:00:00 2001
+From: Geert Uytterhoeven <geert+renesas@glider.be>
+Date: Fri, 17 Jun 2016 16:45:37 +0200
+Subject: [PATCH 2/7] spi: core: Add support for registering SPI slave
+ controllers
+
+Add support for registering SPI slave controllers using the existing SPI
+master framework:
+ - SPI slave controllers must use spi_alloc_slave() instead of
+ spi_alloc_master(), and should provide an additional callback
+ "slave_abort" to abort an ongoing SPI transfer request,
+ - SPI slave controllers are added to a new "spi_slave" device class,
+ - SPI slave handlers can be bound to the SPI slave device represented
+ by an SPI slave controller using a DT child node named "slave",
+ - Alternatively, (un)binding an SPI slave handler to the SPI slave
+ device represented by an SPI slave controller can be done by
+ (un)registering the slave device through a sysfs virtual file named
+ "slave".
+
+From the point of view of an SPI slave protocol handler, an SPI slave
+controller looks almost like an ordinary SPI master controller. The only
+exception is that a transfer request will block on the remote SPI
+master, and may be cancelled using spi_slave_abort().
+
+Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
+---
+ drivers/spi/Kconfig | 14 +++-
+ drivers/spi/Makefile | 2 +
+ drivers/spi/spi.c | 179 ++++++++++++++++++++++++++++++++++++++++-------
+ include/linux/spi/spi.h | 35 +++++++--
+ 4 files changed, 201 insertions(+), 29 deletions(-)
+
+diff --git a/drivers/spi/Kconfig b/drivers/spi/Kconfig
+index fb418d5..8c97790 100644
+--- a/drivers/spi/Kconfig
++++ b/drivers/spi/Kconfig
+@@ -781,6 +781,18 @@ config SPI_TLE62X0
+
+ endif # SPI_MASTER
+
+-# (slave support would go here)
++#
++# SLAVE side ... listening to other SPI masters
++#
++
++config SPI_SLAVE
++ bool "SPI slave protocol handlers"
++ help
++ If your system has a slave-capable SPI controller, you can enable
++ slave protocol handlers.
++
++if SPI_SLAVE
++
++endif # SPI_SLAVE
+
+ endif # SPI
+diff --git a/drivers/spi/Makefile b/drivers/spi/Makefile
+index aa939d9..2428b0f 100644
+--- a/drivers/spi/Makefile
++++ b/drivers/spi/Makefile
+@@ -102,3 +102,5 @@ obj-$(CONFIG_SPI_XILINX) += spi-xilinx.o
+ obj-$(CONFIG_SPI_XLP) += spi-xlp.o
+ obj-$(CONFIG_SPI_XTENSA_XTFPGA) += spi-xtensa-xtfpga.o
+ obj-$(CONFIG_SPI_ZYNQMP_GQSPI) += spi-zynqmp-gqspi.o
++
++# SPI slave protocol handlers
+diff --git a/drivers/spi/spi.c b/drivers/spi/spi.c
+index 838783c..a403e3a 100644
+--- a/drivers/spi/spi.c
++++ b/drivers/spi/spi.c
+@@ -1513,15 +1513,6 @@ static int spi_master_initialize_queue(struct spi_master *master)
+ goto err_out;
+ }
+
+- /* Device address */
+- rc = of_property_read_u32(nc, "reg", &value);
+- if (rc) {
+- dev_err(&master->dev, "%s has no valid 'reg' property (%d)\n",
+- nc->full_name, rc);
+- goto err_out;
+- }
+- spi->chip_select = value;
+-
+ /* Mode (clock phase/polarity/etc.) */
+ if (of_find_property(nc, "spi-cpha", NULL))
+ spi->mode |= SPI_CPHA;
+@@ -1571,6 +1562,24 @@ static int spi_master_initialize_queue(struct spi_master *master)
+ }
+ }
+
++ if (spi_controller_is_slave(master)) {
++ if (strcmp(nc->name, "slave")) {
++ dev_err(&master->dev, "%s is not called 'slave'\n",
++ nc->full_name);
++ return -EINVAL;
++ }
++ return 0;
++ }
++
++ /* Device address */
++ rc = of_property_read_u32(nc, "reg", &value);
++ if (rc) {
++ dev_err(&master->dev, "%s has no valid 'reg' property (%d)\n",
++ nc->full_name, rc);
++ return rc;
++ }
++ spi->chip_select = value;
++
+ /* Device speed */
+ rc = of_property_read_u32(nc, "spi-max-frequency", &value);
+ if (rc) {
+@@ -1603,8 +1612,8 @@ static int spi_master_initialize_queue(struct spi_master *master)
+ * of_register_spi_devices() - Register child devices onto the SPI bus
+ * @master: Pointer to spi_master device
+ *
+- * Registers an spi_device for each child node of master node which has a 'reg'
+- * property.
++ * Registers an spi_device for each child node of controller node which
++ * represents a valid SPI slave.
+ */
+ static void of_register_spi_devices(struct spi_master *master)
+ {
+@@ -1771,28 +1780,129 @@ static void spi_master_release(struct device *dev)
+ .dev_groups = spi_master_groups,
+ };
+
++#ifdef CONFIG_SPI_SLAVE
++/**
++ * spi_slave_abort - abort the ongoing transfer request on an SPI slave
++ * controller
++ * @spi: device used for the current transfer
++ */
++int spi_slave_abort(struct spi_device *spi)
++{
++ struct spi_master *master = spi->master;
++
++ if (spi_controller_is_slave(master) && master->slave_abort)
++ return master->slave_abort(master);
++
++ return -ENOTSUPP;
++}
++EXPORT_SYMBOL_GPL(spi_slave_abort);
++
++static int match_true(struct device *dev, void *data)
++{
++ return 1;
++}
++
++static ssize_t spi_slave_show(struct device *dev,
++ struct device_attribute *attr, char *buf)
++{
++ struct spi_master *ctlr = container_of(dev, struct spi_master, dev);
++ struct device *child;
++
++ child = device_find_child(&ctlr->dev, NULL, match_true);
++ return sprintf(buf, "%s\n",
++ child ? to_spi_device(child)->modalias : NULL);
++}
++
++static ssize_t spi_slave_store(struct device *dev,
++ struct device_attribute *attr, const char *buf,
++ size_t count)
++{
++ struct spi_master *ctlr = container_of(dev, struct spi_master, dev);
++ struct spi_device *spi;
++ struct device *child;
++ char name[32];
++ int rc;
++
++ rc = sscanf(buf, "%31s", name);
++ if (rc != 1 || !name[0])
++ return -EINVAL;
++
++ child = device_find_child(&ctlr->dev, NULL, match_true);
++ if (child) {
++ /* Remove registered slave */
++ device_unregister(child);
++ put_device(child);
++ }
++
++ if (strcmp(name, "(null)")) {
++ /* Register new slave */
++ spi = spi_alloc_device(ctlr);
++ if (!spi)
++ return -ENOMEM;
++
++ strlcpy(spi->modalias, name, sizeof(spi->modalias));
++
++ rc = spi_add_device(spi);
++ if (rc) {
++ spi_dev_put(spi);
++ return rc;
++ }
++ }
++
++ return count;
++}
++
++static DEVICE_ATTR(slave, 0644, spi_slave_show, spi_slave_store);
++
++static struct attribute *spi_slave_attrs[] = {
++ &dev_attr_slave.attr,
++ NULL,
++};
++
++static const struct attribute_group spi_slave_group = {
++ .attrs = spi_slave_attrs,
++};
++
++static const struct attribute_group *spi_slave_groups[] = {
++ &spi_master_statistics_group,
++ &spi_slave_group,
++ NULL,
++};
++
++static struct class spi_slave_class = {
++ .name = "spi_slave",
++ .owner = THIS_MODULE,
++ .dev_release = spi_master_release,
++ .dev_groups = spi_slave_groups,
++};
++#else
++extern struct class spi_slave_class; /* dummy */
++#endif
+
+ /**
+- * spi_alloc_master - allocate SPI master controller
++ * __spi_alloc_controller - allocate an SPI master or slave controller
+ * @dev: the controller, possibly using the platform_bus
+ * @size: how much zeroed driver-private data to allocate; the pointer to this
+ * memory is in the driver_data field of the returned device,
+ * accessible with spi_master_get_devdata().
++ * @slave: flag indicating whether to allocate an SPI master (false) or SPI
++ * slave (true) controller
+ * Context: can sleep
+ *
+- * This call is used only by SPI master controller drivers, which are the
++ * This call is used only by SPI controller drivers, which are the
+ * only ones directly touching chip registers. It's how they allocate
+ * an spi_master structure, prior to calling spi_register_master().
+ *
+ * This must be called from context that can sleep.
+ *
+- * The caller is responsible for assigning the bus number and initializing
+- * the master's methods before calling spi_register_master(); and (after errors
++ * The caller is responsible for assigning the bus number and initializing the
++ * controller's methods before calling spi_register_master(); and (after errors
+ * adding the device) calling spi_master_put() to prevent a memory leak.
+ *
+- * Return: the SPI master structure on success, else NULL.
++ * Return: the SPI controller structure on success, else NULL.
+ */
+-struct spi_master *spi_alloc_master(struct device *dev, unsigned size)
++struct spi_master *__spi_alloc_controller(struct device *dev,
++ unsigned int size, bool slave)
+ {
+ struct spi_master *master;
+
+@@ -1806,14 +1916,18 @@ struct spi_master *spi_alloc_master(struct device *dev, unsigned size)
+ device_initialize(&master->dev);
+ master->bus_num = -1;
+ master->num_chipselect = 1;
+- master->dev.class = &spi_master_class;
++ master->slave = slave;
++ if (IS_ENABLED(CONFIG_SPI_SLAVE) && slave)
++ master->dev.class = &spi_slave_class;
++ else
++ master->dev.class = &spi_master_class;
+ master->dev.parent = dev;
+ pm_suspend_ignore_children(&master->dev, true);
+ spi_master_set_devdata(master, &master[1]);
+
+ return master;
+ }
+-EXPORT_SYMBOL_GPL(spi_alloc_master);
++EXPORT_SYMBOL_GPL(__spi_alloc_controller);
+
+ #ifdef CONFIG_OF
+ static int of_spi_register_master(struct spi_master *master)
+@@ -1889,9 +2003,11 @@ int spi_register_master(struct spi_master *master)
+ if (!dev)
+ return -ENODEV;
+
+- status = of_spi_register_master(master);
+- if (status)
+- return status;
++ if (!spi_controller_is_slave(master)) {
++ status = of_spi_register_master(master);
++ if (status)
++ return status;
++ }
+
+ /* even if it's just one always-selected device, there must
+ * be at least one chipselect
+@@ -1928,8 +2044,9 @@ int spi_register_master(struct spi_master *master)
+ status = device_add(&master->dev);
+ if (status < 0)
+ goto done;
+- dev_dbg(dev, "registered master %s%s\n", dev_name(&master->dev),
+- dynamic ? " (dynamic)" : "");
++ dev_dbg(dev, "registered %s %s%s\n",
++ spi_controller_is_slave(master) ? "slave" : "master",
++ dev_name(&master->dev), dynamic ? " (dynamic)" : "");
+
+ /* If we're using a queued driver, start the queue */
+ if (master->transfer)
+@@ -3102,6 +3219,9 @@ static struct spi_master *of_find_spi_master_by_node(struct device_node *node)
+
+ dev = class_find_device(&spi_master_class, NULL, node,
+ __spi_of_master_match);
++ if (!dev && IS_ENABLED(CONFIG_SPI_SLAVE))
++ dev = class_find_device(&spi_slave_class, NULL, node,
++ __spi_of_master_match);
+ if (!dev)
+ return NULL;
+
+@@ -3183,6 +3303,9 @@ static struct spi_master *acpi_spi_find_master_by_adev(struct acpi_device *adev)
+
+ dev = class_find_device(&spi_master_class, NULL, adev,
+ spi_acpi_master_match);
++ if (!dev && IS_ENABLED(CONFIG_SPI_SLAVE))
++ dev = class_find_device(&spi_slave_class, NULL, adev,
++ spi_acpi_master_match);
+ if (!dev)
+ return NULL;
+
+@@ -3255,6 +3378,12 @@ static int __init spi_init(void)
+ if (status < 0)
+ goto err2;
+
++ if (IS_ENABLED(CONFIG_SPI_SLAVE)) {
++ status = class_register(&spi_slave_class);
++ if (status < 0)
++ goto err3;
++ }
++
+ if (IS_ENABLED(CONFIG_OF_DYNAMIC))
+ WARN_ON(of_reconfig_notifier_register(&spi_of_notifier));
+ if (IS_ENABLED(CONFIG_ACPI))
+@@ -3262,6 +3391,8 @@ static int __init spi_init(void)
+
+ return 0;
+
++err3:
++ class_unregister(&spi_master_class);
+ err2:
+ bus_unregister(&spi_bus_type);
+ err1:
+diff --git a/include/linux/spi/spi.h b/include/linux/spi/spi.h
+index 4b743ac..f9bbd33 100644
+--- a/include/linux/spi/spi.h
++++ b/include/linux/spi/spi.h
+@@ -28,8 +28,8 @@
+ 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;
+
+@@ -310,6 +310,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
+@@ -373,6 +374,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.
+ * @flash_read_supported: spi device supports flash read
+@@ -443,6 +445,9 @@ struct spi_master {
+ #define SPI_MASTER_MUST_RX BIT(3) /* requires rx */
+ #define SPI_MASTER_MUST_TX BIT(4) /* requires tx */
+
++ /* flag indicating this is an SPI slave controller */
++ bool slave;
++
+ /*
+ * on some hardware transfer / message size may be constrained
+ * the limit may depend on device transfer settings
+@@ -535,6 +540,7 @@ struct spi_master {
+ struct spi_message *message);
+ int (*unprepare_message)(struct spi_master *master,
+ struct spi_message *message);
++ int (*slave_abort)(struct spi_master *spi);
+ int (*spi_flash_read)(struct spi_device *spi,
+ struct spi_flash_read_message *msg);
+ bool (*flash_read_supported)(struct spi_device *spi);
+@@ -589,6 +595,11 @@ static inline void spi_master_put(struct spi_master *master)
+ put_device(&master->dev);
+ }
+
++static inline bool spi_controller_is_slave(struct spi_master *ctlr)
++{
++ 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);
+@@ -599,8 +610,23 @@ static inline void spi_master_put(struct spi_master *master)
+ extern void spi_finalize_current_transfer(struct spi_master *master);
+
+ /* the spi driver core manages memory for the spi_master classdev */
+-extern struct spi_master *
+-spi_alloc_master(struct device *host, unsigned size);
++extern struct spi_master *__spi_alloc_controller(struct device *host,
++ unsigned int size, bool slave);
++
++static inline struct spi_master *spi_alloc_master(struct device *host,
++ unsigned int size)
++{
++ return __spi_alloc_controller(host, size, false);
++}
++
++static inline struct spi_master *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_master(struct spi_master *master);
+ extern int devm_spi_register_master(struct device *dev,
+@@ -906,6 +932,7 @@ static inline void spi_message_free(struct spi_message *m)
+ 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)
+--
+1.7.10.4
diff --git a/meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas/0085-spi-Document-SPI-slave-controller-support.patch b/meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas/0085-spi-Document-SPI-slave-controller-support.patch
new file mode 100644
index 0000000..57436d2
--- /dev/null
+++ b/meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas/0085-spi-Document-SPI-slave-controller-support.patch
@@ -0,0 +1,66 @@
+From 0be2c71f293e8c8423e5378cc73f71e10205ad54 Mon Sep 17 00:00:00 2001
+From: Geert Uytterhoeven <geert+renesas@glider.be>
+Date: Thu, 8 Sep 2016 15:01:48 +0200
+Subject: [PATCH 3/7] spi: Document SPI slave controller support
+
+Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
+---
+ Documentation/spi/spi-summary | 27 ++++++++++++++++++++-------
+ 1 file changed, 20 insertions(+), 7 deletions(-)
+
+diff --git a/Documentation/spi/spi-summary b/Documentation/spi/spi-summary
+index d1824b3..1721c1b 100644
+--- a/Documentation/spi/spi-summary
++++ b/Documentation/spi/spi-summary
+@@ -62,8 +62,8 @@ chips described as using "three wire" signaling: SCK, data, nCSx.
+ (That data line is sometimes called MOMI or SISO.)
+
+ Microcontrollers often support both master and slave sides of the SPI
+-protocol. This document (and Linux) currently only supports the master
+-side of SPI interactions.
++protocol. This document (and Linux) supports both the master and slave
++sides of SPI interactions.
+
+
+ Who uses it? On what kinds of systems?
+@@ -154,9 +154,8 @@ control audio interfaces, present touchscreen sensors as input interfaces,
+ or monitor temperature and voltage levels during industrial processing.
+ And those might all be sharing the same controller driver.
+
+-A "struct spi_device" encapsulates the master-side interface between
+-those two types of driver. At this writing, Linux has no slave side
+-programming interface.
++A "struct spi_device" encapsulates the controller-side interface between
++those two types of drivers.
+
+ There is a minimal core of SPI programming interfaces, focussing on
+ using the driver model to connect controller and protocol drivers using
+@@ -177,10 +176,24 @@ shows up in sysfs in several locations:
+ /sys/bus/spi/drivers/D ... driver for one or more spi*.* devices
+
+ /sys/class/spi_master/spiB ... symlink (or actual device node) to
+- a logical node which could hold class related state for the
+- controller managing bus "B". All spiB.* devices share one
++ a logical node which could hold class related state for the SPI
++ master controller managing bus "B". All spiB.* devices share one
+ physical SPI bus segment, with SCLK, MOSI, and MISO.
+
++ /sys/devices/.../CTLR/slave ... virtual file for (un)registering the
++ slave device for an SPI slave controller.
++ Writing the driver name of an SPI slave handler to this file
++ registers the slave device; writing "(null)" unregisters the slave
++ device.
++ Reading from this file shows the name of the slave device ("(null)"
++ if not registered).
++
++ /sys/class/spi_slave/spiB ... symlink (or actual device node) to
++ a logical node which could hold class related state for the SPI
++ slave controller on bus "B". When registered, a single spiB.*
++ device is present here, possible sharing the physical SPI bus
++ segment with other SPI slave devices.
++
+ Note that the actual location of the controller's class state depends
+ on whether you enabled CONFIG_SYSFS_DEPRECATED or not. At this time,
+ the only class-specific state is the bus number ("B" in "spiB"), so
+--
+1.7.10.4
diff --git a/meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas/0086-spi-sh-msiof-Add-slave-mode-support.patch b/meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas/0086-spi-sh-msiof-Add-slave-mode-support.patch
new file mode 100644
index 0000000..af15bae
--- /dev/null
+++ b/meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas/0086-spi-sh-msiof-Add-slave-mode-support.patch
@@ -0,0 +1,209 @@
+From 383d0d23b9292dab56a2fdf5f6fecf898be6d142 Mon Sep 17 00:00:00 2001
+From: Hisashi Nakamura <hisashi.nakamura.ak@renesas.com>
+Date: Mon, 28 Jul 2014 14:47:56 +0900
+Subject: [PATCH 4/7] spi: sh-msiof: Add slave mode support
+
+Add slave mode support to the MSIOF driver, in both PIO and DMA mode.
+
+For now this only supports the transmission of messages with a size
+that is known in advance.
+
+Signed-off-by: Hisashi Nakamura <hisashi.nakamura.ak@renesas.com>
+Signed-off-by: Hiromitsu Yamasaki <hiromitsu.yamasaki.ym@renesas.com>
+[geert: Timeout handling cleanup, spi core integration, cancellation,
+ rewording]
+Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
+Acked-by: Rob Herring <robh@kernel.org>
+---
+ Documentation/devicetree/bindings/spi/sh-msiof.txt | 2 +
+ drivers/spi/spi-sh-msiof.c | 79 ++++++++++++++------
+ 2 files changed, 60 insertions(+), 21 deletions(-)
+
+diff --git a/Documentation/devicetree/bindings/spi/sh-msiof.txt b/Documentation/devicetree/bindings/spi/sh-msiof.txt
+index c2b6251..74ee3cd 100644
+--- a/Documentation/devicetree/bindings/spi/sh-msiof.txt
++++ b/Documentation/devicetree/bindings/spi/sh-msiof.txt
+@@ -33,6 +33,8 @@ Optional properties:
+ specifiers, one for transmission, and one for
+ reception.
+ - dma-names : Must contain a list of two DMA names, "tx" and "rx".
++- spi-slave : Empty property indicating the SPI controller is used
++ in slave mode.
+ - renesas,dtdl : delay sync signal (setup) in transmit mode.
+ Must contain one of the following values:
+ 0 (no bit delay)
+diff --git a/drivers/spi/spi-sh-msiof.c b/drivers/spi/spi-sh-msiof.c
+index 3281dc7..3b87024 100644
+--- a/drivers/spi/spi-sh-msiof.c
++++ b/drivers/spi/spi-sh-msiof.c
+@@ -3,7 +3,7 @@
+ *
+ * Copyright (C) 2016-2017 Renesas Electronics Corporation
+ * Copyright (c) 2009 Magnus Damm
+- * Copyright (C) 2014 Glider bvba
++ * Copyright (C) 2014-2017 Glider bvba
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+@@ -35,7 +35,6 @@
+
+ #include <asm/unaligned.h>
+
+-
+ struct sh_msiof_chipdata {
+ u16 tx_fifo_size;
+ u16 rx_fifo_size;
+@@ -62,6 +61,7 @@ struct sh_msiof_spi_priv {
+ void *rx_dma_page;
+ dma_addr_t tx_dma_addr;
+ dma_addr_t rx_dma_addr;
++ bool slave_aborted;
+ unsigned int quirks;
+ };
+
+@@ -712,6 +712,33 @@ static int sh_msiof_spi_stop(struct sh_msiof_spi_priv *p, void *rx_buf)
+ return ret;
+ }
+
++static int sh_msiof_slave_abort(struct spi_master *master)
++{
++ struct sh_msiof_spi_priv *p = spi_master_get_devdata(master);
++
++ p->slave_aborted = true;
++ complete(&p->done);
++ return 0;
++}
++
++static int sh_msiof_wait_for_completion(struct sh_msiof_spi_priv *p)
++{
++ if (spi_controller_is_slave(p->master)) {
++ if (wait_for_completion_interruptible(&p->done) ||
++ p->slave_aborted) {
++ dev_dbg(&p->pdev->dev, "interrupted\n");
++ return -EINTR;
++ }
++ } else {
++ if (!wait_for_completion_timeout(&p->done, HZ)) {
++ dev_err(&p->pdev->dev, "timeout\n");
++ return -ETIMEDOUT;
++ }
++ }
++
++ return 0;
++}
++
+ static int sh_msiof_spi_txrx_once(struct sh_msiof_spi_priv *p,
+ void (*tx_fifo)(struct sh_msiof_spi_priv *,
+ const void *, int, int),
+@@ -747,6 +774,7 @@ static int sh_msiof_spi_txrx_once(struct sh_msiof_spi_priv *p,
+ tx_fifo(p, tx_buf, words, fifo_shift);
+
+ reinit_completion(&p->done);
++ p->slave_aborted = false;
+
+ ret = sh_msiof_spi_start(p, rx_buf);
+ if (ret) {
+@@ -867,6 +895,7 @@ static int sh_msiof_dma_once(struct sh_msiof_spi_priv *p, const void *tx,
+ reinit_completion(&p->done);
+ reinit_completion(&p->done_dma_tx);
+ reinit_completion(&p->done_dma_rx);
++ p->slave_aborted = false;
+
+ /* Now start DMA */
+ if (rx)
+@@ -1205,8 +1234,14 @@ static struct sh_msiof_spi_info *sh_msiof_spi_parse_dt(struct device *dev)
+ if (!info)
+ return NULL;
+
++ if (of_property_read_bool(np, "slave"))
++ info->mode = SPI_MSIOF_SLAVE;
++ else
++ info->mode = SPI_MSIOF_MASTER;
++
+ /* Parse the MSIOF properties */
+- of_property_read_u32(np, "num-cs", &num_cs);
++ if (info->mode == SPI_MSIOF_MASTER)
++ of_property_read_u32(np, "num-cs", &num_cs);
+ of_property_read_u32(np, "renesas,tx-fifo-size",
+ &info->tx_fifo_override);
+ of_property_read_u32(np, "renesas,rx-fifo-size",
+@@ -1214,10 +1249,6 @@ static struct sh_msiof_spi_info *sh_msiof_spi_parse_dt(struct device *dev)
+ of_property_read_u32(np, "renesas,dtdl", &info->dtdl);
+ of_property_read_u32(np, "renesas,syncdl", &info->syncdl);
+
+- if (of_property_read_bool(np, "slave"))
+- info->mode = SPI_MSIOF_SLAVE;
+- else
+- info->mode = SPI_MSIOF_MASTER;
+
+ info->num_chipselect = num_cs;
+
+@@ -1368,6 +1399,7 @@ static int sh_msiof_spi_probe(struct platform_device *pdev)
+ struct spi_master *master;
+ const struct sh_msiof_chipdata *chipdata;
+ const struct of_device_id *of_id;
++ struct sh_msiof_spi_info *info;
+ struct sh_msiof_spi_priv *p;
+ struct clk *ref_clk;
+ u32 clk_rate = 0;
+@@ -1375,32 +1407,36 @@ static int sh_msiof_spi_probe(struct platform_device *pdev)
+ int ret;
+ const struct soc_device_attribute *attr;
+
+- master = spi_alloc_master(&pdev->dev, sizeof(struct sh_msiof_spi_priv));
+- if (master == NULL) {
+- dev_err(&pdev->dev, "failed to allocate spi master\n");
+- return -ENOMEM;
+- }
+-
+- p = spi_master_get_devdata(master);
+-
+- platform_set_drvdata(pdev, p);
+- p->master = master;
+-
+ of_id = of_match_device(sh_msiof_match, &pdev->dev);
+ if (of_id) {
+ chipdata = of_id->data;
+- p->info = sh_msiof_spi_parse_dt(&pdev->dev);
++ info = sh_msiof_spi_parse_dt(&pdev->dev);
+ } else {
+ chipdata = (const void *)pdev->id_entry->driver_data;
+- p->info = dev_get_platdata(&pdev->dev);
++ info = dev_get_platdata(&pdev->dev);
+ }
+
+- if (!p->info) {
++ if (!info) {
+ dev_err(&pdev->dev, "failed to obtain device info\n");
+ ret = -ENXIO;
+ goto err1;
+ }
+
++ if (info->mode == SPI_MSIOF_SLAVE)
++ master = spi_alloc_slave(&pdev->dev,
++ sizeof(struct sh_msiof_spi_priv));
++ else
++ master = spi_alloc_master(&pdev->dev,
++ sizeof(struct sh_msiof_spi_priv));
++ if (master == NULL)
++ return -ENOMEM;
++
++ p = spi_master_get_devdata(master);
++
++ platform_set_drvdata(pdev, p);
++ p->master = master;
++ p->info = info;
++
+ attr = soc_device_match(rcar_quirks_match);
+ if (attr)
+ p->quirks = (uintptr_t)attr->data;
+@@ -1458,6 +1494,7 @@ static int sh_msiof_spi_probe(struct platform_device *pdev)
+ master->num_chipselect = p->info->num_chipselect;
+ master->setup = sh_msiof_spi_setup;
+ master->prepare_message = sh_msiof_prepare_message;
++ master->slave_abort = sh_msiof_slave_abort;
+ master->bits_per_word_mask = SPI_BPW_RANGE_MASK(8, 32);
+ master->auto_runtime_pm = true;
+ master->transfer_one = sh_msiof_transfer_one;
+--
+1.7.10.4
diff --git a/meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas/0087-spi-slave-Add-SPI-slave-handler-reporting-uptime-at-.patch b/meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas/0087-spi-slave-Add-SPI-slave-handler-reporting-uptime-at-.patch
new file mode 100644
index 0000000..1c9be85
--- /dev/null
+++ b/meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas/0087-spi-slave-Add-SPI-slave-handler-reporting-uptime-at-.patch
@@ -0,0 +1,182 @@
+From 8b3a09269db92be56455d98bc8cb01f779733f0a Mon Sep 17 00:00:00 2001
+From: Geert Uytterhoeven <geert+renesas@glider.be>
+Date: Fri, 17 Jun 2016 17:00:25 +0200
+Subject: [PATCH 5/7] spi: slave: Add SPI slave handler reporting uptime at
+ previous message
+
+Add an example SPI slave handler responding with the uptime at the time
+of reception of the last SPI message.
+
+This can be used by an external microcontroller as a dead man's switch.
+
+Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
+---
+ drivers/spi/Kconfig | 6 ++
+ drivers/spi/Makefile | 1 +
+ drivers/spi/spi-slave-time.c | 129 ++++++++++++++++++++++++++++++++++++++++++
+ 3 files changed, 136 insertions(+)
+ create mode 100644 drivers/spi/spi-slave-time.c
+
+diff --git a/drivers/spi/Kconfig b/drivers/spi/Kconfig
+index 8c97790..267bedf 100644
+--- a/drivers/spi/Kconfig
++++ b/drivers/spi/Kconfig
+@@ -793,6 +793,12 @@ config SPI_SLAVE
+
+ if SPI_SLAVE
+
++config SPI_SLAVE_TIME
++ tristate "SPI slave handler reporting boot up time"
++ help
++ SPI slave handler responding with the time of reception of the last
++ SPI message.
++
+ endif # SPI_SLAVE
+
+ endif # SPI
+diff --git a/drivers/spi/Makefile b/drivers/spi/Makefile
+index 2428b0f..5e2e537 100644
+--- a/drivers/spi/Makefile
++++ b/drivers/spi/Makefile
+@@ -104,3 +104,4 @@ obj-$(CONFIG_SPI_XTENSA_XTFPGA) += spi-xtensa-xtfpga.o
+ obj-$(CONFIG_SPI_ZYNQMP_GQSPI) += spi-zynqmp-gqspi.o
+
+ # SPI slave protocol handlers
++obj-$(CONFIG_SPI_SLAVE_TIME) += spi-slave-time.o
+diff --git a/drivers/spi/spi-slave-time.c b/drivers/spi/spi-slave-time.c
+new file mode 100644
+index 0000000..fbeaa5b
+--- /dev/null
++++ b/drivers/spi/spi-slave-time.c
+@@ -0,0 +1,129 @@
++/*
++ * SPI slave handler reporting uptime at reception of previous SPI message
++ *
++ * This SPI slave handler sends the time of reception of the last SPI message
++ * as two 32-bit unsigned integers in binary format and in network byte order,
++ * representing the number of seconds and fractional seconds (in microseconds)
++ * since boot up.
++ *
++ * Copyright (C) 2016-2017 Glider bvba
++ *
++ * This file is subject to the terms and conditions of the GNU General Public
++ * License. See the file "COPYING" in the main directory of this archive
++ * for more details.
++ *
++ * Usage (assuming /dev/spidev2.0 corresponds to the SPI master on the remote
++ * system):
++ *
++ * # spidev_test -D /dev/spidev2.0 -p dummy-8B
++ * spi mode: 0x0
++ * bits per word: 8
++ * max speed: 500000 Hz (500 KHz)
++ * RX | 00 00 04 6D 00 09 5B BB ...
++ * ^^^^^ ^^^^^^^^
++ * seconds microseconds
++ */
++
++#include <linux/completion.h>
++#include <linux/module.h>
++#include <linux/sched.h>
++#include <linux/spi/spi.h>
++
++
++struct spi_slave_time_priv {
++ struct spi_device *spi;
++ struct completion finished;
++ struct spi_transfer xfer;
++ struct spi_message msg;
++ __be32 buf[2];
++};
++
++static int spi_slave_time_submit(struct spi_slave_time_priv *priv);
++
++static void spi_slave_time_complete(void *arg)
++{
++ struct spi_slave_time_priv *priv = arg;
++ int ret;
++
++ ret = priv->msg.status;
++ if (ret)
++ goto terminate;
++
++ ret = spi_slave_time_submit(priv);
++ if (ret)
++ goto terminate;
++
++ return;
++
++terminate:
++ dev_info(&priv->spi->dev, "Terminating\n");
++ complete(&priv->finished);
++}
++
++static int spi_slave_time_submit(struct spi_slave_time_priv *priv)
++{
++ u32 rem_us;
++ int ret;
++ u64 ts;
++
++ ts = local_clock();
++ rem_us = do_div(ts, 1000000000) / 1000;
++
++ priv->buf[0] = cpu_to_be32(ts);
++ priv->buf[1] = cpu_to_be32(rem_us);
++
++ spi_message_init_with_transfers(&priv->msg, &priv->xfer, 1);
++
++ priv->msg.complete = spi_slave_time_complete;
++ priv->msg.context = priv;
++
++ ret = spi_async(priv->spi, &priv->msg);
++ if (ret)
++ dev_err(&priv->spi->dev, "spi_async() failed %d\n", ret);
++
++ return ret;
++}
++
++static int spi_slave_time_probe(struct spi_device *spi)
++{
++ struct spi_slave_time_priv *priv;
++ int ret;
++
++ priv = devm_kzalloc(&spi->dev, sizeof(*priv), GFP_KERNEL);
++ if (!priv)
++ return -ENOMEM;
++
++ priv->spi = spi;
++ init_completion(&priv->finished);
++ priv->xfer.tx_buf = priv->buf;
++ priv->xfer.len = sizeof(priv->buf);
++
++ ret = spi_slave_time_submit(priv);
++ if (ret)
++ return ret;
++
++ spi_set_drvdata(spi, priv);
++ return 0;
++}
++
++static int spi_slave_time_remove(struct spi_device *spi)
++{
++ struct spi_slave_time_priv *priv = spi_get_drvdata(spi);
++
++ spi_slave_abort(spi);
++ wait_for_completion(&priv->finished);
++ return 0;
++}
++
++static struct spi_driver spi_slave_time_driver = {
++ .driver = {
++ .name = "spi-slave-time",
++ },
++ .probe = spi_slave_time_probe,
++ .remove = spi_slave_time_remove,
++};
++module_spi_driver(spi_slave_time_driver);
++
++MODULE_AUTHOR("Geert Uytterhoeven <geert+renesas@glider.be>");
++MODULE_DESCRIPTION("SPI slave reporting uptime at previous SPI message");
++MODULE_LICENSE("GPL v2");
+--
+1.7.10.4
diff --git a/meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas/0088-spi-slave-Add-SPI-slave-handler-controlling-system-s.patch b/meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas/0088-spi-slave-Add-SPI-slave-handler-controlling-system-s.patch
new file mode 100644
index 0000000..3752e98
--- /dev/null
+++ b/meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas/0088-spi-slave-Add-SPI-slave-handler-controlling-system-s.patch
@@ -0,0 +1,205 @@
+From 6acf67e94cbd406b57315f03937a8d4d37a2952c Mon Sep 17 00:00:00 2001
+From: Geert Uytterhoeven <geert+renesas@glider.be>
+Date: Fri, 17 Jun 2016 17:05:45 +0200
+Subject: [PATCH 6/7] spi: slave: Add SPI slave handler controlling system
+ state
+
+Add an example SPI slave handler to allow remote control of system
+reboot, power off, halt, and suspend.
+
+Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
+---
+ drivers/spi/Kconfig | 6 ++
+ drivers/spi/Makefile | 1 +
+ drivers/spi/spi-slave-system-control.c | 154 ++++++++++++++++++++++++++++++++
+ 3 files changed, 161 insertions(+)
+ create mode 100644 drivers/spi/spi-slave-system-control.c
+
+diff --git a/drivers/spi/Kconfig b/drivers/spi/Kconfig
+index 267bedf..45208ec 100644
+--- a/drivers/spi/Kconfig
++++ b/drivers/spi/Kconfig
+@@ -799,6 +799,12 @@ config SPI_SLAVE_TIME
+ SPI slave handler responding with the time of reception of the last
+ SPI message.
+
++config SPI_SLAVE_SYSTEM_CONTROL
++ tristate "SPI slave handler controlling system state"
++ help
++ SPI slave handler to allow remote control of system reboot, power
++ off, halt, and suspend.
++
+ endif # SPI_SLAVE
+
+ endif # SPI
+diff --git a/drivers/spi/Makefile b/drivers/spi/Makefile
+index 5e2e537..d4d5050 100644
+--- a/drivers/spi/Makefile
++++ b/drivers/spi/Makefile
+@@ -105,3 +105,4 @@ obj-$(CONFIG_SPI_ZYNQMP_GQSPI) += spi-zynqmp-gqspi.o
+
+ # SPI slave protocol handlers
+ obj-$(CONFIG_SPI_SLAVE_TIME) += spi-slave-time.o
++obj-$(CONFIG_SPI_SLAVE_SYSTEM_CONTROL) += spi-slave-system-control.o
+diff --git a/drivers/spi/spi-slave-system-control.c b/drivers/spi/spi-slave-system-control.c
+new file mode 100644
+index 0000000..c0257e9
+--- /dev/null
++++ b/drivers/spi/spi-slave-system-control.c
+@@ -0,0 +1,154 @@
++/*
++ * SPI slave handler controlling system state
++ *
++ * This SPI slave handler allows remote control of system reboot, power off,
++ * halt, and suspend.
++ *
++ * Copyright (C) 2016-2017 Glider bvba
++ *
++ * This file is subject to the terms and conditions of the GNU General Public
++ * License. See the file "COPYING" in the main directory of this archive
++ * for more details.
++ *
++ * Usage (assuming /dev/spidev2.0 corresponds to the SPI master on the remote
++ * system):
++ *
++ * # reboot='\x7c\x50'
++ * # poweroff='\x71\x3f'
++ * # halt='\x38\x76'
++ * # suspend='\x1b\x1b'
++ * # spidev_test -D /dev/spidev2.0 -p $suspend # or $reboot, $poweroff, $halt
++ */
++
++#include <linux/completion.h>
++#include <linux/module.h>
++#include <linux/reboot.h>
++#include <linux/suspend.h>
++#include <linux/spi/spi.h>
++
++/*
++ * The numbers are chosen to display something human-readable on two 7-segment
++ * displays connected to two 74HC595 shift registers
++ */
++#define CMD_REBOOT 0x7c50 /* rb */
++#define CMD_POWEROFF 0x713f /* OF */
++#define CMD_HALT 0x3876 /* HL */
++#define CMD_SUSPEND 0x1b1b /* ZZ */
++
++struct spi_slave_system_control_priv {
++ struct spi_device *spi;
++ struct completion finished;
++ struct spi_transfer xfer;
++ struct spi_message msg;
++ __be16 cmd;
++};
++
++static
++int spi_slave_system_control_submit(struct spi_slave_system_control_priv *priv);
++
++static void spi_slave_system_control_complete(void *arg)
++{
++ struct spi_slave_system_control_priv *priv = arg;
++ u16 cmd;
++ int ret;
++
++ if (priv->msg.status)
++ goto terminate;
++
++ cmd = be16_to_cpu(priv->cmd);
++ switch (cmd) {
++ case CMD_REBOOT:
++ dev_info(&priv->spi->dev, "Rebooting system...\n");
++ kernel_restart(NULL);
++
++ case CMD_POWEROFF:
++ dev_info(&priv->spi->dev, "Powering off system...\n");
++ kernel_power_off();
++ break;
++
++ case CMD_HALT:
++ dev_info(&priv->spi->dev, "Halting system...\n");
++ kernel_halt();
++ break;
++
++ case CMD_SUSPEND:
++ dev_info(&priv->spi->dev, "Suspending system...\n");
++ pm_suspend(PM_SUSPEND_MEM);
++ break;
++
++ default:
++ dev_warn(&priv->spi->dev, "Unknown command 0x%x\n", cmd);
++ break;
++ }
++
++ ret = spi_slave_system_control_submit(priv);
++ if (ret)
++ goto terminate;
++
++ return;
++
++terminate:
++ dev_info(&priv->spi->dev, "Terminating\n");
++ complete(&priv->finished);
++}
++
++static
++int spi_slave_system_control_submit(struct spi_slave_system_control_priv *priv)
++{
++ int ret;
++
++ spi_message_init_with_transfers(&priv->msg, &priv->xfer, 1);
++
++ priv->msg.complete = spi_slave_system_control_complete;
++ priv->msg.context = priv;
++
++ ret = spi_async(priv->spi, &priv->msg);
++ if (ret)
++ dev_err(&priv->spi->dev, "spi_async() failed %d\n", ret);
++
++ return ret;
++}
++
++static int spi_slave_system_control_probe(struct spi_device *spi)
++{
++ struct spi_slave_system_control_priv *priv;
++ int ret;
++
++ priv = devm_kzalloc(&spi->dev, sizeof(*priv), GFP_KERNEL);
++ if (!priv)
++ return -ENOMEM;
++
++ priv->spi = spi;
++ init_completion(&priv->finished);
++ priv->xfer.rx_buf = &priv->cmd;
++ priv->xfer.len = sizeof(priv->cmd);
++
++ ret = spi_slave_system_control_submit(priv);
++ if (ret)
++ return ret;
++
++ spi_set_drvdata(spi, priv);
++ return 0;
++}
++
++static int spi_slave_system_control_remove(struct spi_device *spi)
++{
++ struct spi_slave_system_control_priv *priv = spi_get_drvdata(spi);
++
++ spi_slave_abort(spi);
++ wait_for_completion(&priv->finished);
++ return 0;
++}
++
++static struct spi_driver spi_slave_system_control_driver = {
++ .driver = {
++ .name = "spi-slave-system-control",
++ },
++ .probe = spi_slave_system_control_probe,
++ .remove = spi_slave_system_control_remove,
++};
++module_spi_driver(spi_slave_system_control_driver);
++
++MODULE_AUTHOR("Geert Uytterhoeven <geert+renesas@glider.be>");
++MODULE_DESCRIPTION("SPI slave handler controlling system state");
++MODULE_LICENSE("GPL v2");
+--
+1.7.10.4
diff --git a/meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas/0089-spi-Generalize-SPI-master-to-controller.patch b/meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas/0089-spi-Generalize-SPI-master-to-controller.patch
new file mode 100644
index 0000000..2c1e0eb
--- /dev/null
+++ b/meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas/0089-spi-Generalize-SPI-master-to-controller.patch
@@ -0,0 +1,3048 @@
+From 5767a2cd113534b904593d143175e1ba71ea6555 Mon Sep 17 00:00:00 2001
+From: Geert Uytterhoeven <geert+renesas@glider.be>
+Date: Wed, 3 May 2017 17:28:39 +0200
+Subject: [PATCH 7/7] spi: Generalize SPI "master" to "controller"
+
+Now struct spi_master is used for both SPI master and slave controllers,
+it makes sense to rename it to struct spi_controller, and replace
+"master" by "controller" where appropriate.
+
+For now this conversion is done for SPI core infrastructure only.
+Wrappers are provided for backwards compatibility, until all SPI drivers
+have been converted.
+
+Noteworthy details:
+ - SPI_MASTER_GPIO_SS is retained, as it only makes sense for SPI
+ master controllers,
+ - spi_busnum_to_master() is kept, as it looks up masters only,
+ - A new field spi_device.controller is added, but spi_device.master is
+ retained for compatibility (both are always initialized by
+ spi_alloc_device()),
+ - spi_flash_read() is used by SPI masters only.
+
+Signed-off-by: Geert Uytterhoeven <geert+renesas@glider.be>
+---
+ drivers/spi/spi.c | 1073 ++++++++++++++++++++++----------------------
+ include/linux/spi/spi.h | 197 ++++----
+ include/trace/events/spi.h | 26 +-
+ 3 files changed, 664 insertions(+), 632 deletions(-)
+
+diff --git a/drivers/spi/spi.c b/drivers/spi/spi.c
+index a403e3a..cd2e271 100644
+--- a/drivers/spi/spi.c
++++ b/drivers/spi/spi.c
+@@ -46,11 +46,11 @@ static void spidev_release(struct device *dev)
+ {
+ struct spi_device *spi = to_spi_device(dev);
+
+- /* spi masters may cleanup for released devices */
+- if (spi->master->cleanup)
+- spi->master->cleanup(spi);
++ /* spi controllers may cleanup for released devices */
++ if (spi->controller->cleanup)
++ spi->controller->cleanup(spi);
+
+- spi_master_put(spi->master);
++ spi_controller_put(spi->controller);
+ kfree(spi);
+ }
+
+@@ -69,17 +69,17 @@ static void spidev_release(struct device *dev)
+ static DEVICE_ATTR_RO(modalias);
+
+ #define SPI_STATISTICS_ATTRS(field, file) \
+-static ssize_t spi_master_##field##_show(struct device *dev, \
+- struct device_attribute *attr, \
+- char *buf) \
++static ssize_t spi_controller_##field##_show(struct device *dev, \
++ struct device_attribute *attr, \
++ char *buf) \
+ { \
+- struct spi_master *master = container_of(dev, \
+- struct spi_master, dev); \
+- return spi_statistics_##field##_show(&master->statistics, buf); \
++ struct spi_controller *ctlr = container_of(dev, \
++ struct spi_controller, dev); \
++ return spi_statistics_##field##_show(&ctlr->statistics, buf); \
+ } \
+-static struct device_attribute dev_attr_spi_master_##field = { \
++static struct device_attribute dev_attr_spi_controller_##field = { \
+ .attr = { .name = file, .mode = S_IRUGO }, \
+- .show = spi_master_##field##_show, \
++ .show = spi_controller_##field##_show, \
+ }; \
+ static ssize_t spi_device_##field##_show(struct device *dev, \
+ struct device_attribute *attr, \
+@@ -199,51 +199,51 @@ static void spidev_release(struct device *dev)
+ NULL,
+ };
+
+-static struct attribute *spi_master_statistics_attrs[] = {
+- &dev_attr_spi_master_messages.attr,
+- &dev_attr_spi_master_transfers.attr,
+- &dev_attr_spi_master_errors.attr,
+- &dev_attr_spi_master_timedout.attr,
+- &dev_attr_spi_master_spi_sync.attr,
+- &dev_attr_spi_master_spi_sync_immediate.attr,
+- &dev_attr_spi_master_spi_async.attr,
+- &dev_attr_spi_master_bytes.attr,
+- &dev_attr_spi_master_bytes_rx.attr,
+- &dev_attr_spi_master_bytes_tx.attr,
+- &dev_attr_spi_master_transfer_bytes_histo0.attr,
+- &dev_attr_spi_master_transfer_bytes_histo1.attr,
+- &dev_attr_spi_master_transfer_bytes_histo2.attr,
+- &dev_attr_spi_master_transfer_bytes_histo3.attr,
+- &dev_attr_spi_master_transfer_bytes_histo4.attr,
+- &dev_attr_spi_master_transfer_bytes_histo5.attr,
+- &dev_attr_spi_master_transfer_bytes_histo6.attr,
+- &dev_attr_spi_master_transfer_bytes_histo7.attr,
+- &dev_attr_spi_master_transfer_bytes_histo8.attr,
+- &dev_attr_spi_master_transfer_bytes_histo9.attr,
+- &dev_attr_spi_master_transfer_bytes_histo10.attr,
+- &dev_attr_spi_master_transfer_bytes_histo11.attr,
+- &dev_attr_spi_master_transfer_bytes_histo12.attr,
+- &dev_attr_spi_master_transfer_bytes_histo13.attr,
+- &dev_attr_spi_master_transfer_bytes_histo14.attr,
+- &dev_attr_spi_master_transfer_bytes_histo15.attr,
+- &dev_attr_spi_master_transfer_bytes_histo16.attr,
+- &dev_attr_spi_master_transfers_split_maxsize.attr,
++static struct attribute *spi_controller_statistics_attrs[] = {
++ &dev_attr_spi_controller_messages.attr,
++ &dev_attr_spi_controller_transfers.attr,
++ &dev_attr_spi_controller_errors.attr,
++ &dev_attr_spi_controller_timedout.attr,
++ &dev_attr_spi_controller_spi_sync.attr,
++ &dev_attr_spi_controller_spi_sync_immediate.attr,
++ &dev_attr_spi_controller_spi_async.attr,
++ &dev_attr_spi_controller_bytes.attr,
++ &dev_attr_spi_controller_bytes_rx.attr,
++ &dev_attr_spi_controller_bytes_tx.attr,
++ &dev_attr_spi_controller_transfer_bytes_histo0.attr,
++ &dev_attr_spi_controller_transfer_bytes_histo1.attr,
++ &dev_attr_spi_controller_transfer_bytes_histo2.attr,
++ &dev_attr_spi_controller_transfer_bytes_histo3.attr,
++ &dev_attr_spi_controller_transfer_bytes_histo4.attr,
++ &dev_attr_spi_controller_transfer_bytes_histo5.attr,
++ &dev_attr_spi_controller_transfer_bytes_histo6.attr,
++ &dev_attr_spi_controller_transfer_bytes_histo7.attr,
++ &dev_attr_spi_controller_transfer_bytes_histo8.attr,
++ &dev_attr_spi_controller_transfer_bytes_histo9.attr,
++ &dev_attr_spi_controller_transfer_bytes_histo10.attr,
++ &dev_attr_spi_controller_transfer_bytes_histo11.attr,
++ &dev_attr_spi_controller_transfer_bytes_histo12.attr,
++ &dev_attr_spi_controller_transfer_bytes_histo13.attr,
++ &dev_attr_spi_controller_transfer_bytes_histo14.attr,
++ &dev_attr_spi_controller_transfer_bytes_histo15.attr,
++ &dev_attr_spi_controller_transfer_bytes_histo16.attr,
++ &dev_attr_spi_controller_transfers_split_maxsize.attr,
+ NULL,
+ };
+
+-static const struct attribute_group spi_master_statistics_group = {
++static const struct attribute_group spi_controller_statistics_group = {
+ .name = "statistics",
+- .attrs = spi_master_statistics_attrs,
++ .attrs = spi_controller_statistics_attrs,
+ };
+
+ static const struct attribute_group *spi_master_groups[] = {
+- &spi_master_statistics_group,
++ &spi_controller_statistics_group,
+ NULL,
+ };
+
+ void spi_statistics_add_transfer_stats(struct spi_statistics *stats,
+ struct spi_transfer *xfer,
+- struct spi_master *master)
++ struct spi_controller *ctlr)
+ {
+ unsigned long flags;
+ int l2len = min(fls(xfer->len), SPI_STATISTICS_HISTO_SIZE) - 1;
+@@ -258,10 +258,10 @@ void spi_statistics_add_transfer_stats(struct spi_statistics *stats,
+
+ stats->bytes += xfer->len;
+ if ((xfer->tx_buf) &&
+- (xfer->tx_buf != master->dummy_tx))
++ (xfer->tx_buf != ctlr->dummy_tx))
+ stats->bytes_tx += xfer->len;
+ if ((xfer->rx_buf) &&
+- (xfer->rx_buf != master->dummy_rx))
++ (xfer->rx_buf != ctlr->dummy_rx))
+ stats->bytes_rx += xfer->len;
+
+ spin_unlock_irqrestore(&stats->lock, flags);
+@@ -403,7 +403,7 @@ int __spi_register_driver(struct module *owner, struct spi_driver *sdrv)
+ /*-------------------------------------------------------------------------*/
+
+ /* SPI devices should normally not be created by SPI device drivers; that
+- * would make them board-specific. Similarly with SPI master drivers.
++ * would make them board-specific. Similarly with SPI controller drivers.
+ * Device registration normally goes into like arch/.../mach.../board-YYY.c
+ * with other readonly (flashable) information about mainboard devices.
+ */
+@@ -414,17 +414,17 @@ struct boardinfo {
+ };
+
+ static LIST_HEAD(board_list);
+-static LIST_HEAD(spi_master_list);
++static LIST_HEAD(spi_controller_list);
+
+ /*
+ * Used to protect add/del opertion for board_info list and
+- * spi_master list, and their matching process
++ * spi_controller list, and their matching process
+ */
+ static DEFINE_MUTEX(board_lock);
+
+ /**
+ * spi_alloc_device - Allocate a new SPI device
+- * @master: Controller to which device is connected
++ * @ctlr: Controller to which device is connected
+ * Context: can sleep
+ *
+ * Allows a driver to allocate and initialize a spi_device without
+@@ -433,27 +433,27 @@ struct boardinfo {
+ * spi_add_device() on it.
+ *
+ * Caller is responsible to call spi_add_device() on the returned
+- * spi_device structure to add it to the SPI master. If the caller
++ * spi_device structure to add it to the SPI controller. If the caller
+ * needs to discard the spi_device without adding it, then it should
+ * call spi_dev_put() on it.
+ *
+ * Return: a pointer to the new device, or NULL.
+ */
+-struct spi_device *spi_alloc_device(struct spi_master *master)
++struct spi_device *spi_alloc_device(struct spi_controller *ctlr)
+ {
+ struct spi_device *spi;
+
+- if (!spi_master_get(master))
++ if (!spi_controller_get(ctlr))
+ return NULL;
+
+ spi = kzalloc(sizeof(*spi), GFP_KERNEL);
+ if (!spi) {
+- spi_master_put(master);
++ spi_controller_put(ctlr);
+ return NULL;
+ }
+
+- spi->master = master;
+- spi->dev.parent = &master->dev;
++ spi->master = spi->controller = ctlr;
++ spi->dev.parent = &ctlr->dev;
+ spi->dev.bus = &spi_bus_type;
+ spi->dev.release = spidev_release;
+ spi->cs_gpio = -ENOENT;
+@@ -474,7 +474,7 @@ static void spi_dev_set_name(struct spi_device *spi)
+ return;
+ }
+
+- dev_set_name(&spi->dev, "%s.%u", dev_name(&spi->master->dev),
++ dev_set_name(&spi->dev, "%s.%u", dev_name(&spi->controller->dev),
+ spi->chip_select);
+ }
+
+@@ -483,7 +483,7 @@ static int spi_dev_check(struct device *dev, void *data)
+ struct spi_device *spi = to_spi_device(dev);
+ struct spi_device *new_spi = data;
+
+- if (spi->master == new_spi->master &&
++ if (spi->controller == new_spi->controller &&
+ spi->chip_select == new_spi->chip_select)
+ return -EBUSY;
+ return 0;
+@@ -501,15 +501,14 @@ static int spi_dev_check(struct device *dev, void *data)
+ int spi_add_device(struct spi_device *spi)
+ {
+ static DEFINE_MUTEX(spi_add_lock);
+- struct spi_master *master = spi->master;
+- struct device *dev = master->dev.parent;
++ struct spi_controller *ctlr = spi->controller;
++ struct device *dev = ctlr->dev.parent;
+ int status;
+
+ /* Chipselects are numbered 0..max; validate. */
+- if (spi->chip_select >= master->num_chipselect) {
+- dev_err(dev, "cs%d >= max %d\n",
+- spi->chip_select,
+- master->num_chipselect);
++ if (spi->chip_select >= ctlr->num_chipselect) {
++ dev_err(dev, "cs%d >= max %d\n", spi->chip_select,
++ ctlr->num_chipselect);
+ return -EINVAL;
+ }
+
+@@ -529,8 +528,8 @@ int spi_add_device(struct spi_device *spi)
+ goto done;
+ }
+
+- if (master->cs_gpios)
+- spi->cs_gpio = master->cs_gpios[spi->chip_select];
++ if (ctlr->cs_gpios)
++ spi->cs_gpio = ctlr->cs_gpios[spi->chip_select];
+
+ /* Drivers may modify this initial i/o setup, but will
+ * normally rely on the device being setup. Devices
+@@ -559,7 +558,7 @@ int spi_add_device(struct spi_device *spi)
+
+ /**
+ * spi_new_device - instantiate one new SPI device
+- * @master: Controller to which device is connected
++ * @ctlr: Controller to which device is connected
+ * @chip: Describes the SPI device
+ * Context: can sleep
+ *
+@@ -571,7 +570,7 @@ int spi_add_device(struct spi_device *spi)
+ *
+ * Return: the new device, or NULL.
+ */
+-struct spi_device *spi_new_device(struct spi_master *master,
++struct spi_device *spi_new_device(struct spi_controller *ctlr,
+ struct spi_board_info *chip)
+ {
+ struct spi_device *proxy;
+@@ -584,7 +583,7 @@ struct spi_device *spi_new_device(struct spi_master *master,
+ * suggests syslogged diagnostics are best here (ugh).
+ */
+
+- proxy = spi_alloc_device(master);
++ proxy = spi_alloc_device(ctlr);
+ if (!proxy)
+ return NULL;
+
+@@ -614,7 +613,7 @@ struct spi_device *spi_new_device(struct spi_master *master,
+ * @spi: spi_device to unregister
+ *
+ * Start making the passed SPI device vanish. Normally this would be handled
+- * by spi_unregister_master().
++ * by spi_unregister_controller().
+ */
+ void spi_unregister_device(struct spi_device *spi)
+ {
+@@ -629,17 +628,17 @@ void spi_unregister_device(struct spi_device *spi)
+ }
+ EXPORT_SYMBOL_GPL(spi_unregister_device);
+
+-static void spi_match_master_to_boardinfo(struct spi_master *master,
+- struct spi_board_info *bi)
++static void spi_match_controller_to_boardinfo(struct spi_controller *ctlr,
++ struct spi_board_info *bi)
+ {
+ struct spi_device *dev;
+
+- if (master->bus_num != bi->bus_num)
++ if (ctlr->bus_num != bi->bus_num)
+ return;
+
+- dev = spi_new_device(master, bi);
++ dev = spi_new_device(ctlr, bi);
+ if (!dev)
+- dev_err(master->dev.parent, "can't create new device for %s\n",
++ dev_err(ctlr->dev.parent, "can't create new device for %s\n",
+ bi->modalias);
+ }
+
+@@ -677,13 +676,14 @@ int spi_register_board_info(struct spi_board_info const *info, unsigned n)
+ return -ENOMEM;
+
+ for (i = 0; i < n; i++, bi++, info++) {
+- struct spi_master *master;
++ struct spi_controller *ctlr;
+
+ memcpy(&bi->board_info, info, sizeof(*info));
+ mutex_lock(&board_lock);
+ list_add_tail(&bi->list, &board_list);
+- list_for_each_entry(master, &spi_master_list, list)
+- spi_match_master_to_boardinfo(master, &bi->board_info);
++ list_for_each_entry(ctlr, &spi_controller_list, list)
++ spi_match_controller_to_boardinfo(ctlr,
++ &bi->board_info);
+ mutex_unlock(&board_lock);
+ }
+
+@@ -699,12 +699,12 @@ static void spi_set_cs(struct spi_device *spi, bool enable)
+
+ if (gpio_is_valid(spi->cs_gpio))
+ gpio_set_value(spi->cs_gpio, !enable);
+- else if (spi->master->set_cs)
+- spi->master->set_cs(spi, !enable);
++ else if (spi->controller->set_cs)
++ spi->controller->set_cs(spi, !enable);
+ }
+
+ #ifdef CONFIG_HAS_DMA
+-static int spi_map_buf(struct spi_master *master, struct device *dev,
++static int spi_map_buf(struct spi_controller *ctlr, struct device *dev,
+ struct sg_table *sgt, void *buf, size_t len,
+ enum dma_data_direction dir)
+ {
+@@ -728,7 +728,7 @@ static int spi_map_buf(struct spi_master *master, struct device *dev,
+ desc_len = min_t(int, max_seg_size, PAGE_SIZE);
+ sgs = DIV_ROUND_UP(len + offset_in_page(buf), desc_len);
+ } else if (virt_addr_valid(buf)) {
+- desc_len = min_t(int, max_seg_size, master->max_dma_len);
++ desc_len = min_t(int, max_seg_size, ctlr->max_dma_len);
+ sgs = DIV_ROUND_UP(len, desc_len);
+ } else {
+ return -EINVAL;
+@@ -776,7 +776,7 @@ static int spi_map_buf(struct spi_master *master, struct device *dev,
+ return 0;
+ }
+
+-static void spi_unmap_buf(struct spi_master *master, struct device *dev,
++static void spi_unmap_buf(struct spi_controller *ctlr, struct device *dev,
+ struct sg_table *sgt, enum dma_data_direction dir)
+ {
+ if (sgt->orig_nents) {
+@@ -785,31 +785,31 @@ static void spi_unmap_buf(struct spi_master *master, struct device *dev,
+ }
+ }
+
+-static int __spi_map_msg(struct spi_master *master, struct spi_message *msg)
++static int __spi_map_msg(struct spi_controller *ctlr, struct spi_message *msg)
+ {
+ struct device *tx_dev, *rx_dev;
+ struct spi_transfer *xfer;
+ int ret;
+
+- if (!master->can_dma)
++ if (!ctlr->can_dma)
+ return 0;
+
+- if (master->dma_tx)
+- tx_dev = master->dma_tx->device->dev;
++ if (ctlr->dma_tx)
++ tx_dev = ctlr->dma_tx->device->dev;
+ else
+- tx_dev = &master->dev;
++ tx_dev = &ctlr->dev;
+
+- if (master->dma_rx)
+- rx_dev = master->dma_rx->device->dev;
++ if (ctlr->dma_rx)
++ rx_dev = ctlr->dma_rx->device->dev;
+ else
+- rx_dev = &master->dev;
++ rx_dev = &ctlr->dev;
+
+ list_for_each_entry(xfer, &msg->transfers, transfer_list) {
+- if (!master->can_dma(master, msg->spi, xfer))
++ if (!ctlr->can_dma(ctlr, msg->spi, xfer))
+ continue;
+
+ if (xfer->tx_buf != NULL) {
+- ret = spi_map_buf(master, tx_dev, &xfer->tx_sg,
++ ret = spi_map_buf(ctlr, tx_dev, &xfer->tx_sg,
+ (void *)xfer->tx_buf, xfer->len,
+ DMA_TO_DEVICE);
+ if (ret != 0)
+@@ -817,79 +817,78 @@ static int __spi_map_msg(struct spi_master *master, struct spi_message *msg)
+ }
+
+ if (xfer->rx_buf != NULL) {
+- ret = spi_map_buf(master, rx_dev, &xfer->rx_sg,
++ ret = spi_map_buf(ctlr, rx_dev, &xfer->rx_sg,
+ xfer->rx_buf, xfer->len,
+ DMA_FROM_DEVICE);
+ if (ret != 0) {
+- spi_unmap_buf(master, tx_dev, &xfer->tx_sg,
++ spi_unmap_buf(ctlr, tx_dev, &xfer->tx_sg,
+ DMA_TO_DEVICE);
+ return ret;
+ }
+ }
+ }
+
+- master->cur_msg_mapped = true;
++ ctlr->cur_msg_mapped = true;
+
+ return 0;
+ }
+
+-static int __spi_unmap_msg(struct spi_master *master, struct spi_message *msg)
++static int __spi_unmap_msg(struct spi_controller *ctlr, struct spi_message *msg)
+ {
+ struct spi_transfer *xfer;
+ struct device *tx_dev, *rx_dev;
+
+- if (!master->cur_msg_mapped || !master->can_dma)
++ if (!ctlr->cur_msg_mapped || !ctlr->can_dma)
+ return 0;
+
+- if (master->dma_tx)
+- tx_dev = master->dma_tx->device->dev;
++ if (ctlr->dma_tx)
++ tx_dev = ctlr->dma_tx->device->dev;
+ else
+- tx_dev = &master->dev;
++ tx_dev = &ctlr->dev;
+
+- if (master->dma_rx)
+- rx_dev = master->dma_rx->device->dev;
++ if (ctlr->dma_rx)
++ rx_dev = ctlr->dma_rx->device->dev;
+ else
+- rx_dev = &master->dev;
++ rx_dev = &ctlr->dev;
+
+ list_for_each_entry(xfer, &msg->transfers, transfer_list) {
+- if (!master->can_dma(master, msg->spi, xfer))
++ if (!ctlr->can_dma(ctlr, msg->spi, xfer))
+ continue;
+
+- spi_unmap_buf(master, rx_dev, &xfer->rx_sg, DMA_FROM_DEVICE);
+- spi_unmap_buf(master, tx_dev, &xfer->tx_sg, DMA_TO_DEVICE);
++ spi_unmap_buf(ctlr, rx_dev, &xfer->rx_sg, DMA_FROM_DEVICE);
++ spi_unmap_buf(ctlr, tx_dev, &xfer->tx_sg, DMA_TO_DEVICE);
+ }
+
+ return 0;
+ }
+ #else /* !CONFIG_HAS_DMA */
+-static inline int spi_map_buf(struct spi_master *master,
+- struct device *dev, struct sg_table *sgt,
+- void *buf, size_t len,
++static inline int spi_map_buf(struct spi_controller *ctlr, struct device *dev,
++ struct sg_table *sgt, void *buf, size_t len,
+ enum dma_data_direction dir)
+ {
+ return -EINVAL;
+ }
+
+-static inline void spi_unmap_buf(struct spi_master *master,
++static inline void spi_unmap_buf(struct spi_controller *ctlr,
+ struct device *dev, struct sg_table *sgt,
+ enum dma_data_direction dir)
+ {
+ }
+
+-static inline int __spi_map_msg(struct spi_master *master,
++static inline int __spi_map_msg(struct spi_controller *ctlr,
+ struct spi_message *msg)
+ {
+ return 0;
+ }
+
+-static inline int __spi_unmap_msg(struct spi_master *master,
++static inline int __spi_unmap_msg(struct spi_controller *ctlr,
+ struct spi_message *msg)
+ {
+ return 0;
+ }
+ #endif /* !CONFIG_HAS_DMA */
+
+-static inline int spi_unmap_msg(struct spi_master *master,
++static inline int spi_unmap_msg(struct spi_controller *ctlr,
+ struct spi_message *msg)
+ {
+ struct spi_transfer *xfer;
+@@ -899,63 +898,63 @@ static inline int spi_unmap_msg(struct spi_master *master,
+ * Restore the original value of tx_buf or rx_buf if they are
+ * NULL.
+ */
+- if (xfer->tx_buf == master->dummy_tx)
++ if (xfer->tx_buf == ctlr->dummy_tx)
+ xfer->tx_buf = NULL;
+- if (xfer->rx_buf == master->dummy_rx)
++ if (xfer->rx_buf == ctlr->dummy_rx)
+ xfer->rx_buf = NULL;
+ }
+
+- return __spi_unmap_msg(master, msg);
++ return __spi_unmap_msg(ctlr, msg);
+ }
+
+-static int spi_map_msg(struct spi_master *master, struct spi_message *msg)
++static int spi_map_msg(struct spi_controller *ctlr, struct spi_message *msg)
+ {
+ struct spi_transfer *xfer;
+ void *tmp;
+ unsigned int max_tx, max_rx;
+
+- if (master->flags & (SPI_MASTER_MUST_RX | SPI_MASTER_MUST_TX)) {
++ if (ctlr->flags & (SPI_CONTROLLER_MUST_RX | SPI_CONTROLLER_MUST_TX)) {
+ max_tx = 0;
+ max_rx = 0;
+
+ list_for_each_entry(xfer, &msg->transfers, transfer_list) {
+- if ((master->flags & SPI_MASTER_MUST_TX) &&
++ if ((ctlr->flags & SPI_CONTROLLER_MUST_TX) &&
+ !xfer->tx_buf)
+ max_tx = max(xfer->len, max_tx);
+- if ((master->flags & SPI_MASTER_MUST_RX) &&
++ if ((ctlr->flags & SPI_CONTROLLER_MUST_RX) &&
+ !xfer->rx_buf)
+ max_rx = max(xfer->len, max_rx);
+ }
+
+ if (max_tx) {
+- tmp = krealloc(master->dummy_tx, max_tx,
++ tmp = krealloc(ctlr->dummy_tx, max_tx,
+ GFP_KERNEL | GFP_DMA);
+ if (!tmp)
+ return -ENOMEM;
+- master->dummy_tx = tmp;
++ ctlr->dummy_tx = tmp;
+ memset(tmp, 0, max_tx);
+ }
+
+ if (max_rx) {
+- tmp = krealloc(master->dummy_rx, max_rx,
++ tmp = krealloc(ctlr->dummy_rx, max_rx,
+ GFP_KERNEL | GFP_DMA);
+ if (!tmp)
+ return -ENOMEM;
+- master->dummy_rx = tmp;
++ ctlr->dummy_rx = tmp;
+ }
+
+ if (max_tx || max_rx) {
+ list_for_each_entry(xfer, &msg->transfers,
+ transfer_list) {
+ if (!xfer->tx_buf)
+- xfer->tx_buf = master->dummy_tx;
++ xfer->tx_buf = ctlr->dummy_tx;
+ if (!xfer->rx_buf)
+- xfer->rx_buf = master->dummy_rx;
++ xfer->rx_buf = ctlr->dummy_rx;
+ }
+ }
+ }
+
+- return __spi_map_msg(master, msg);
++ return __spi_map_msg(ctlr, msg);
+ }
+
+ /*
+@@ -965,14 +964,14 @@ static int spi_map_msg(struct spi_master *master, struct spi_message *msg)
+ * drivers which implement a transfer_one() operation. It provides
+ * standard handling of delays and chip select management.
+ */
+-static int spi_transfer_one_message(struct spi_master *master,
++static int spi_transfer_one_message(struct spi_controller *ctlr,
+ struct spi_message *msg)
+ {
+ struct spi_transfer *xfer;
+ bool keep_cs = false;
+ int ret = 0;
+ unsigned long long ms = 1;
+- struct spi_statistics *statm = &master->statistics;
++ struct spi_statistics *statm = &ctlr->statistics;
+ struct spi_statistics *stats = &msg->spi->statistics;
+
+ spi_set_cs(msg->spi, true);
+@@ -983,13 +982,13 @@ static int spi_transfer_one_message(struct spi_master *master,
+ list_for_each_entry(xfer, &msg->transfers, transfer_list) {
+ trace_spi_transfer_start(msg, xfer);
+
+- spi_statistics_add_transfer_stats(statm, xfer, master);
+- spi_statistics_add_transfer_stats(stats, xfer, master);
++ spi_statistics_add_transfer_stats(statm, xfer, ctlr);
++ spi_statistics_add_transfer_stats(stats, xfer, ctlr);
+
+ if (xfer->tx_buf || xfer->rx_buf) {
+- reinit_completion(&master->xfer_completion);
++ reinit_completion(&ctlr->xfer_completion);
+
+- ret = master->transfer_one(master, msg->spi, xfer);
++ ret = ctlr->transfer_one(ctlr, msg->spi, xfer);
+ if (ret < 0) {
+ SPI_STATISTICS_INCREMENT_FIELD(statm,
+ errors);
+@@ -1009,7 +1008,7 @@ static int spi_transfer_one_message(struct spi_master *master,
+ if (ms > UINT_MAX)
+ ms = UINT_MAX;
+
+- ms = wait_for_completion_timeout(&master->xfer_completion,
++ ms = wait_for_completion_timeout(&ctlr->xfer_completion,
+ msecs_to_jiffies(ms));
+ }
+
+@@ -1058,33 +1057,33 @@ static int spi_transfer_one_message(struct spi_master *master,
+ if (msg->status == -EINPROGRESS)
+ msg->status = ret;
+
+- if (msg->status && master->handle_err)
+- master->handle_err(master, msg);
++ if (msg->status && ctlr->handle_err)
++ ctlr->handle_err(ctlr, msg);
+
+- spi_res_release(master, msg);
++ spi_res_release(ctlr, msg);
+
+- spi_finalize_current_message(master);
++ spi_finalize_current_message(ctlr);
+
+ return ret;
+ }
+
+ /**
+ * spi_finalize_current_transfer - report completion of a transfer
+- * @master: the master reporting completion
++ * @ctlr: the controller reporting completion
+ *
+ * Called by SPI drivers using the core transfer_one_message()
+ * implementation to notify it that the current interrupt driven
+ * transfer has finished and the next one may be scheduled.
+ */
+-void spi_finalize_current_transfer(struct spi_master *master)
++void spi_finalize_current_transfer(struct spi_controller *ctlr)
+ {
+- complete(&master->xfer_completion);
++ complete(&ctlr->xfer_completion);
+ }
+ EXPORT_SYMBOL_GPL(spi_finalize_current_transfer);
+
+ /**
+ * __spi_pump_messages - function which processes spi message queue
+- * @master: master to process queue for
++ * @ctlr: controller to process queue for
+ * @in_kthread: true if we are in the context of the message pump thread
+ *
+ * This function checks if there is any spi message in the queue that
+@@ -1095,136 +1094,136 @@ void spi_finalize_current_transfer(struct spi_master *master)
+ * inside spi_sync(); the queue extraction handling at the top of the
+ * function should deal with this safely.
+ */
+-static void __spi_pump_messages(struct spi_master *master, bool in_kthread)
++static void __spi_pump_messages(struct spi_controller *ctlr, bool in_kthread)
+ {
+ unsigned long flags;
+ bool was_busy = false;
+ int ret;
+
+ /* Lock queue */
+- spin_lock_irqsave(&master->queue_lock, flags);
++ spin_lock_irqsave(&ctlr->queue_lock, flags);
+
+ /* Make sure we are not already running a message */
+- if (master->cur_msg) {
+- spin_unlock_irqrestore(&master->queue_lock, flags);
++ if (ctlr->cur_msg) {
++ spin_unlock_irqrestore(&ctlr->queue_lock, flags);
+ return;
+ }
+
+ /* If another context is idling the device then defer */
+- if (master->idling) {
+- kthread_queue_work(&master->kworker, &master->pump_messages);
+- spin_unlock_irqrestore(&master->queue_lock, flags);
++ if (ctlr->idling) {
++ kthread_queue_work(&ctlr->kworker, &ctlr->pump_messages);
++ spin_unlock_irqrestore(&ctlr->queue_lock, flags);
+ return;
+ }
+
+ /* Check if the queue is idle */
+- if (list_empty(&master->queue) || !master->running) {
+- if (!master->busy) {
+- spin_unlock_irqrestore(&master->queue_lock, flags);
++ if (list_empty(&ctlr->queue) || !ctlr->running) {
++ if (!ctlr->busy) {
++ spin_unlock_irqrestore(&ctlr->queue_lock, flags);
+ return;
+ }
+
+ /* Only do teardown in the thread */
+ if (!in_kthread) {
+- kthread_queue_work(&master->kworker,
+- &master->pump_messages);
+- spin_unlock_irqrestore(&master->queue_lock, flags);
++ kthread_queue_work(&ctlr->kworker,
++ &ctlr->pump_messages);
++ spin_unlock_irqrestore(&ctlr->queue_lock, flags);
+ return;
+ }
+
+- master->busy = false;
+- master->idling = true;
+- spin_unlock_irqrestore(&master->queue_lock, flags);
+-
+- kfree(master->dummy_rx);
+- master->dummy_rx = NULL;
+- kfree(master->dummy_tx);
+- master->dummy_tx = NULL;
+- if (master->unprepare_transfer_hardware &&
+- master->unprepare_transfer_hardware(master))
+- dev_err(&master->dev,
++ ctlr->busy = false;
++ ctlr->idling = true;
++ spin_unlock_irqrestore(&ctlr->queue_lock, flags);
++
++ kfree(ctlr->dummy_rx);
++ ctlr->dummy_rx = NULL;
++ kfree(ctlr->dummy_tx);
++ ctlr->dummy_tx = NULL;
++ if (ctlr->unprepare_transfer_hardware &&
++ ctlr->unprepare_transfer_hardware(ctlr))
++ dev_err(&ctlr->dev,
+ "failed to unprepare transfer hardware\n");
+- if (master->auto_runtime_pm) {
+- pm_runtime_mark_last_busy(master->dev.parent);
+- pm_runtime_put_autosuspend(master->dev.parent);
++ if (ctlr->auto_runtime_pm) {
++ pm_runtime_mark_last_busy(ctlr->dev.parent);
++ pm_runtime_put_autosuspend(ctlr->dev.parent);
+ }
+- trace_spi_master_idle(master);
++ trace_spi_controller_idle(ctlr);
+
+- spin_lock_irqsave(&master->queue_lock, flags);
+- master->idling = false;
+- spin_unlock_irqrestore(&master->queue_lock, flags);
++ spin_lock_irqsave(&ctlr->queue_lock, flags);
++ ctlr->idling = false;
++ spin_unlock_irqrestore(&ctlr->queue_lock, flags);
+ return;
+ }
+
+ /* Extract head of queue */
+- master->cur_msg =
+- list_first_entry(&master->queue, struct spi_message, queue);
++ ctlr->cur_msg =
++ list_first_entry(&ctlr->queue, struct spi_message, queue);
+
+- list_del_init(&master->cur_msg->queue);
+- if (master->busy)
++ list_del_init(&ctlr->cur_msg->queue);
++ if (ctlr->busy)
+ was_busy = true;
+ else
+- master->busy = true;
+- spin_unlock_irqrestore(&master->queue_lock, flags);
++ ctlr->busy = true;
++ spin_unlock_irqrestore(&ctlr->queue_lock, flags);
+
+- mutex_lock(&master->io_mutex);
++ mutex_lock(&ctlr->io_mutex);
+
+- if (!was_busy && master->auto_runtime_pm) {
+- ret = pm_runtime_get_sync(master->dev.parent);
++ if (!was_busy && ctlr->auto_runtime_pm) {
++ ret = pm_runtime_get_sync(ctlr->dev.parent);
+ if (ret < 0) {
+- dev_err(&master->dev, "Failed to power device: %d\n",
++ dev_err(&ctlr->dev, "Failed to power device: %d\n",
+ ret);
+- mutex_unlock(&master->io_mutex);
++ mutex_unlock(&ctlr->io_mutex);
+ return;
+ }
+ }
+
+ if (!was_busy)
+- trace_spi_master_busy(master);
++ trace_spi_controller_busy(ctlr);
+
+- if (!was_busy && master->prepare_transfer_hardware) {
+- ret = master->prepare_transfer_hardware(master);
++ if (!was_busy && ctlr->prepare_transfer_hardware) {
++ ret = ctlr->prepare_transfer_hardware(ctlr);
+ if (ret) {
+- dev_err(&master->dev,
++ dev_err(&ctlr->dev,
+ "failed to prepare transfer hardware\n");
+
+- if (master->auto_runtime_pm)
+- pm_runtime_put(master->dev.parent);
+- mutex_unlock(&master->io_mutex);
++ if (ctlr->auto_runtime_pm)
++ pm_runtime_put(ctlr->dev.parent);
++ mutex_unlock(&ctlr->io_mutex);
+ return;
+ }
+ }
+
+- trace_spi_message_start(master->cur_msg);
++ trace_spi_message_start(ctlr->cur_msg);
+
+- if (master->prepare_message) {
+- ret = master->prepare_message(master, master->cur_msg);
++ if (ctlr->prepare_message) {
++ ret = ctlr->prepare_message(ctlr, ctlr->cur_msg);
+ if (ret) {
+- dev_err(&master->dev,
+- "failed to prepare message: %d\n", ret);
+- master->cur_msg->status = ret;
+- spi_finalize_current_message(master);
++ dev_err(&ctlr->dev, "failed to prepare message: %d\n",
++ ret);
++ ctlr->cur_msg->status = ret;
++ spi_finalize_current_message(ctlr);
+ goto out;
+ }
+- master->cur_msg_prepared = true;
++ ctlr->cur_msg_prepared = true;
+ }
+
+- ret = spi_map_msg(master, master->cur_msg);
++ ret = spi_map_msg(ctlr, ctlr->cur_msg);
+ if (ret) {
+- master->cur_msg->status = ret;
+- spi_finalize_current_message(master);
++ ctlr->cur_msg->status = ret;
++ spi_finalize_current_message(ctlr);
+ goto out;
+ }
+
+- ret = master->transfer_one_message(master, master->cur_msg);
++ ret = ctlr->transfer_one_message(ctlr, ctlr->cur_msg);
+ if (ret) {
+- dev_err(&master->dev,
++ dev_err(&ctlr->dev,
+ "failed to transfer one message from queue\n");
+ goto out;
+ }
+
+ out:
+- mutex_unlock(&master->io_mutex);
++ mutex_unlock(&ctlr->io_mutex);
+
+ /* Prod the scheduler in case transfer_one() was busy waiting */
+ if (!ret)
+@@ -1233,44 +1232,43 @@ static void __spi_pump_messages(struct spi_master *master, bool in_kthread)
+
+ /**
+ * spi_pump_messages - kthread work function which processes spi message queue
+- * @work: pointer to kthread work struct contained in the master struct
++ * @work: pointer to kthread work struct contained in the controller struct
+ */
+ static void spi_pump_messages(struct kthread_work *work)
+ {
+- struct spi_master *master =
+- container_of(work, struct spi_master, pump_messages);
++ struct spi_controller *ctlr =
++ container_of(work, struct spi_controller, pump_messages);
+
+- __spi_pump_messages(master, true);
++ __spi_pump_messages(ctlr, true);
+ }
+
+-static int spi_init_queue(struct spi_master *master)
++static int spi_init_queue(struct spi_controller *ctlr)
+ {
+ struct sched_param param = { .sched_priority = MAX_RT_PRIO - 1 };
+
+- master->running = false;
+- master->busy = false;
++ ctlr->running = false;
++ ctlr->busy = false;
+
+- kthread_init_worker(&master->kworker);
+- master->kworker_task = kthread_run(kthread_worker_fn,
+- &master->kworker, "%s",
+- dev_name(&master->dev));
+- if (IS_ERR(master->kworker_task)) {
+- dev_err(&master->dev, "failed to create message pump task\n");
+- return PTR_ERR(master->kworker_task);
++ kthread_init_worker(&ctlr->kworker);
++ ctlr->kworker_task = kthread_run(kthread_worker_fn, &ctlr->kworker,
++ "%s", dev_name(&ctlr->dev));
++ if (IS_ERR(ctlr->kworker_task)) {
++ dev_err(&ctlr->dev, "failed to create message pump task\n");
++ return PTR_ERR(ctlr->kworker_task);
+ }
+- kthread_init_work(&master->pump_messages, spi_pump_messages);
++ kthread_init_work(&ctlr->pump_messages, spi_pump_messages);
+
+ /*
+- * Master config will indicate if this controller should run the
++ * Controller config will indicate if this controller should run the
+ * message pump with high (realtime) priority to reduce the transfer
+ * latency on the bus by minimising the delay between a transfer
+ * request and the scheduling of the message pump thread. Without this
+ * setting the message pump thread will remain at default priority.
+ */
+- if (master->rt) {
+- dev_info(&master->dev,
++ if (ctlr->rt) {
++ dev_info(&ctlr->dev,
+ "will run message pump with realtime priority\n");
+- sched_setscheduler(master->kworker_task, SCHED_FIFO, &param);
++ sched_setscheduler(ctlr->kworker_task, SCHED_FIFO, &param);
+ }
+
+ return 0;
+@@ -1279,23 +1277,23 @@ static int spi_init_queue(struct spi_master *master)
+ /**
+ * spi_get_next_queued_message() - called by driver to check for queued
+ * messages
+- * @master: the master to check for queued messages
++ * @ctlr: the controller to check for queued messages
+ *
+ * If there are more messages in the queue, the next message is returned from
+ * this call.
+ *
+ * Return: the next message in the queue, else NULL if the queue is empty.
+ */
+-struct spi_message *spi_get_next_queued_message(struct spi_master *master)
++struct spi_message *spi_get_next_queued_message(struct spi_controller *ctlr)
+ {
+ struct spi_message *next;
+ unsigned long flags;
+
+ /* get a pointer to the next message, if any */
+- spin_lock_irqsave(&master->queue_lock, flags);
+- next = list_first_entry_or_null(&master->queue, struct spi_message,
++ spin_lock_irqsave(&ctlr->queue_lock, flags);
++ next = list_first_entry_or_null(&ctlr->queue, struct spi_message,
+ queue);
+- spin_unlock_irqrestore(&master->queue_lock, flags);
++ spin_unlock_irqrestore(&ctlr->queue_lock, flags);
+
+ return next;
+ }
+@@ -1303,36 +1301,36 @@ struct spi_message *spi_get_next_queued_message(struct spi_master *master)
+
+ /**
+ * spi_finalize_current_message() - the current message is complete
+- * @master: the master to return the message to
++ * @ctlr: the controller to return the message to
+ *
+ * Called by the driver to notify the core that the message in the front of the
+ * queue is complete and can be removed from the queue.
+ */
+-void spi_finalize_current_message(struct spi_master *master)
++void spi_finalize_current_message(struct spi_controller *ctlr)
+ {
+ struct spi_message *mesg;
+ unsigned long flags;
+ int ret;
+
+- spin_lock_irqsave(&master->queue_lock, flags);
+- mesg = master->cur_msg;
+- spin_unlock_irqrestore(&master->queue_lock, flags);
++ spin_lock_irqsave(&ctlr->queue_lock, flags);
++ mesg = ctlr->cur_msg;
++ spin_unlock_irqrestore(&ctlr->queue_lock, flags);
+
+- spi_unmap_msg(master, mesg);
++ spi_unmap_msg(ctlr, mesg);
+
+- if (master->cur_msg_prepared && master->unprepare_message) {
+- ret = master->unprepare_message(master, mesg);
++ if (ctlr->cur_msg_prepared && ctlr->unprepare_message) {
++ ret = ctlr->unprepare_message(ctlr, mesg);
+ if (ret) {
+- dev_err(&master->dev,
+- "failed to unprepare message: %d\n", ret);
++ dev_err(&ctlr->dev, "failed to unprepare message: %d\n",
++ ret);
+ }
+ }
+
+- spin_lock_irqsave(&master->queue_lock, flags);
+- master->cur_msg = NULL;
+- master->cur_msg_prepared = false;
+- kthread_queue_work(&master->kworker, &master->pump_messages);
+- spin_unlock_irqrestore(&master->queue_lock, flags);
++ spin_lock_irqsave(&ctlr->queue_lock, flags);
++ ctlr->cur_msg = NULL;
++ ctlr->cur_msg_prepared = false;
++ kthread_queue_work(&ctlr->kworker, &ctlr->pump_messages);
++ spin_unlock_irqrestore(&ctlr->queue_lock, flags);
+
+ trace_spi_message_done(mesg);
+
+@@ -1342,66 +1340,65 @@ void spi_finalize_current_message(struct spi_master *master)
+ }
+ EXPORT_SYMBOL_GPL(spi_finalize_current_message);
+
+-static int spi_start_queue(struct spi_master *master)
++static int spi_start_queue(struct spi_controller *ctlr)
+ {
+ unsigned long flags;
+
+- spin_lock_irqsave(&master->queue_lock, flags);
++ spin_lock_irqsave(&ctlr->queue_lock, flags);
+
+- if (master->running || master->busy) {
+- spin_unlock_irqrestore(&master->queue_lock, flags);
++ if (ctlr->running || ctlr->busy) {
++ spin_unlock_irqrestore(&ctlr->queue_lock, flags);
+ return -EBUSY;
+ }
+
+- master->running = true;
+- master->cur_msg = NULL;
+- spin_unlock_irqrestore(&master->queue_lock, flags);
++ ctlr->running = true;
++ ctlr->cur_msg = NULL;
++ spin_unlock_irqrestore(&ctlr->queue_lock, flags);
+
+- kthread_queue_work(&master->kworker, &master->pump_messages);
++ kthread_queue_work(&ctlr->kworker, &ctlr->pump_messages);
+
+ return 0;
+ }
+
+-static int spi_stop_queue(struct spi_master *master)
++static int spi_stop_queue(struct spi_controller *ctlr)
+ {
+ unsigned long flags;
+ unsigned limit = 500;
+ int ret = 0;
+
+- spin_lock_irqsave(&master->queue_lock, flags);
++ spin_lock_irqsave(&ctlr->queue_lock, flags);
+
+ /*
+ * This is a bit lame, but is optimized for the common execution path.
+- * A wait_queue on the master->busy could be used, but then the common
++ * A wait_queue on the ctlr->busy could be used, but then the common
+ * execution path (pump_messages) would be required to call wake_up or
+ * friends on every SPI message. Do this instead.
+ */
+- while ((!list_empty(&master->queue) || master->busy) && limit--) {
+- spin_unlock_irqrestore(&master->queue_lock, flags);
++ while ((!list_empty(&ctlr->queue) || ctlr->busy) && limit--) {
++ spin_unlock_irqrestore(&ctlr->queue_lock, flags);
+ usleep_range(10000, 11000);
+- spin_lock_irqsave(&master->queue_lock, flags);
++ spin_lock_irqsave(&ctlr->queue_lock, flags);
+ }
+
+- if (!list_empty(&master->queue) || master->busy)
++ if (!list_empty(&ctlr->queue) || ctlr->busy)
+ ret = -EBUSY;
+ else
+- master->running = false;
++ ctlr->running = false;
+
+- spin_unlock_irqrestore(&master->queue_lock, flags);
++ spin_unlock_irqrestore(&ctlr->queue_lock, flags);
+
+ if (ret) {
+- dev_warn(&master->dev,
+- "could not stop message queue\n");
++ dev_warn(&ctlr->dev, "could not stop message queue\n");
+ return ret;
+ }
+ return ret;
+ }
+
+-static int spi_destroy_queue(struct spi_master *master)
++static int spi_destroy_queue(struct spi_controller *ctlr)
+ {
+ int ret;
+
+- ret = spi_stop_queue(master);
++ ret = spi_stop_queue(ctlr);
+
+ /*
+ * kthread_flush_worker will block until all work is done.
+@@ -1410,12 +1407,12 @@ static int spi_destroy_queue(struct spi_master *master)
+ * return anyway.
+ */
+ if (ret) {
+- dev_err(&master->dev, "problem destroying queue\n");
++ dev_err(&ctlr->dev, "problem destroying queue\n");
+ return ret;
+ }
+
+- kthread_flush_worker(&master->kworker);
+- kthread_stop(master->kworker_task);
++ kthread_flush_worker(&ctlr->kworker);
++ kthread_stop(ctlr->kworker_task);
+
+ return 0;
+ }
+@@ -1424,23 +1421,23 @@ static int __spi_queued_transfer(struct spi_device *spi,
+ struct spi_message *msg,
+ bool need_pump)
+ {
+- struct spi_master *master = spi->master;
++ struct spi_controller *ctlr = spi->controller;
+ unsigned long flags;
+
+- spin_lock_irqsave(&master->queue_lock, flags);
++ spin_lock_irqsave(&ctlr->queue_lock, flags);
+
+- if (!master->running) {
+- spin_unlock_irqrestore(&master->queue_lock, flags);
++ if (!ctlr->running) {
++ spin_unlock_irqrestore(&ctlr->queue_lock, flags);
+ return -ESHUTDOWN;
+ }
+ msg->actual_length = 0;
+ msg->status = -EINPROGRESS;
+
+- list_add_tail(&msg->queue, &master->queue);
+- if (!master->busy && need_pump)
+- kthread_queue_work(&master->kworker, &master->pump_messages);
++ list_add_tail(&msg->queue, &ctlr->queue);
++ if (!ctlr->busy && need_pump)
++ kthread_queue_work(&ctlr->kworker, &ctlr->pump_messages);
+
+- spin_unlock_irqrestore(&master->queue_lock, flags);
++ spin_unlock_irqrestore(&ctlr->queue_lock, flags);
+ return 0;
+ }
+
+@@ -1456,31 +1453,31 @@ static int spi_queued_transfer(struct spi_device *spi, struct spi_message *msg)
+ return __spi_queued_transfer(spi, msg, true);
+ }
+
+-static int spi_master_initialize_queue(struct spi_master *master)
++static int spi_controller_initialize_queue(struct spi_controller *ctlr)
+ {
+ int ret;
+
+- master->transfer = spi_queued_transfer;
+- if (!master->transfer_one_message)
+- master->transfer_one_message = spi_transfer_one_message;
++ ctlr->transfer = spi_queued_transfer;
++ if (!ctlr->transfer_one_message)
++ ctlr->transfer_one_message = spi_transfer_one_message;
+
+ /* Initialize and start queue */
+- ret = spi_init_queue(master);
++ ret = spi_init_queue(ctlr);
+ if (ret) {
+- dev_err(&master->dev, "problem initializing queue\n");
++ dev_err(&ctlr->dev, "problem initializing queue\n");
+ goto err_init_queue;
+ }
+- master->queued = true;
+- ret = spi_start_queue(master);
++ ctlr->queued = true;
++ ret = spi_start_queue(ctlr);
+ if (ret) {
+- dev_err(&master->dev, "problem starting queue\n");
++ dev_err(&ctlr->dev, "problem starting queue\n");
+ goto err_start_queue;
+ }
+
+ return 0;
+
+ err_start_queue:
+- spi_destroy_queue(master);
++ spi_destroy_queue(ctlr);
+ err_init_queue:
+ return ret;
+ }
+@@ -1489,16 +1486,16 @@ static int spi_master_initialize_queue(struct spi_master *master)
+
+ #if defined(CONFIG_OF)
+ static struct spi_device *
+-of_register_spi_device(struct spi_master *master, struct device_node *nc)
++of_register_spi_device(struct spi_controller *ctlr, struct device_node *nc)
+ {
+ struct spi_device *spi;
+ int rc;
+ u32 value;
+
+ /* Alloc an spi_device */
+- spi = spi_alloc_device(master);
++ spi = spi_alloc_device(ctlr);
+ if (!spi) {
+- dev_err(&master->dev, "spi_device alloc error for %s\n",
++ dev_err(&ctlr->dev, "spi_device alloc error for %s\n",
+ nc->full_name);
+ rc = -ENOMEM;
+ goto err_out;
+@@ -1508,7 +1505,7 @@ static int spi_master_initialize_queue(struct spi_master *master)
+ rc = of_modalias_node(nc, spi->modalias,
+ sizeof(spi->modalias));
+ if (rc < 0) {
+- dev_err(&master->dev, "cannot find modalias for %s\n",
++ dev_err(&ctlr->dev, "cannot find modalias for %s\n",
+ nc->full_name);
+ goto err_out;
+ }
+@@ -1537,7 +1534,7 @@ static int spi_master_initialize_queue(struct spi_master *master)
+ spi->mode |= SPI_TX_QUAD;
+ break;
+ default:
+- dev_warn(&master->dev,
++ dev_warn(&ctlr->dev,
+ "spi-tx-bus-width %d not supported\n",
+ value);
+ break;
+@@ -1555,35 +1552,36 @@ static int spi_master_initialize_queue(struct spi_master *master)
+ spi->mode |= SPI_RX_QUAD;
+ break;
+ default:
+- dev_warn(&master->dev,
++ dev_warn(&ctlr->dev,
+ "spi-rx-bus-width %d not supported\n",
+ value);
+ break;
+ }
+ }
+
+- if (spi_controller_is_slave(master)) {
++ if (spi_controller_is_slave(ctlr)) {
+ if (strcmp(nc->name, "slave")) {
+- dev_err(&master->dev, "%s is not called 'slave'\n",
++ dev_err(&ctlr->dev, "%s is not called 'slave'\n",
+ nc->full_name);
+- return -EINVAL;
++ rc = -EINVAL;
++ goto err_out;
+ }
+- return 0;
+ }
+
+ /* Device address */
+ rc = of_property_read_u32(nc, "reg", &value);
+ if (rc) {
+- dev_err(&master->dev, "%s has no valid 'reg' property (%d)\n",
++ dev_err(&ctlr->dev, "%s has no valid 'reg' property (%d)\n",
+ nc->full_name, rc);
+- return rc;
++ goto err_out;
+ }
+ spi->chip_select = value;
+
+ /* Device speed */
+ rc = of_property_read_u32(nc, "spi-max-frequency", &value);
+ if (rc) {
+- dev_err(&master->dev, "%s has no valid 'spi-max-frequency' property (%d)\n",
++ dev_err(&ctlr->dev,
++ "%s has no valid 'spi-max-frequency' property (%d)\n",
+ nc->full_name, rc);
+ goto err_out;
+ }
+@@ -1596,7 +1594,7 @@ static int spi_master_initialize_queue(struct spi_master *master)
+ /* Register the new device */
+ rc = spi_add_device(spi);
+ if (rc) {
+- dev_err(&master->dev, "spi_device register error %s\n",
++ dev_err(&ctlr->dev, "spi_device register error %s\n",
+ nc->full_name);
+ goto err_out;
+ }
+@@ -1610,39 +1608,40 @@ static int spi_master_initialize_queue(struct spi_master *master)
+
+ /**
+ * of_register_spi_devices() - Register child devices onto the SPI bus
+- * @master: Pointer to spi_master device
++ * @ctlr: Pointer to spi_controller device
+ *
+ * Registers an spi_device for each child node of controller node which
+ * represents a valid SPI slave.
+ */
+-static void of_register_spi_devices(struct spi_master *master)
++static void of_register_spi_devices(struct spi_controller *ctlr)
+ {
+ struct spi_device *spi;
+ struct device_node *nc;
+
+- if (!master->dev.of_node)
++ if (!ctlr->dev.of_node)
+ return;
+
+- for_each_available_child_of_node(master->dev.of_node, nc) {
++ for_each_available_child_of_node(ctlr->dev.of_node, nc) {
+ if (of_node_test_and_set_flag(nc, OF_POPULATED))
+ continue;
+- spi = of_register_spi_device(master, nc);
++ spi = of_register_spi_device(ctlr, nc);
+ if (IS_ERR(spi)) {
+- dev_warn(&master->dev, "Failed to create SPI device for %s\n",
+- nc->full_name);
++ dev_warn(&ctlr->dev,
++ "Failed to create SPI device for %s\n",
++ nc->full_name);
+ of_node_clear_flag(nc, OF_POPULATED);
+ }
+ }
+ }
+ #else
+-static void of_register_spi_devices(struct spi_master *master) { }
++static void of_register_spi_devices(struct spi_controller *ctlr) { }
+ #endif
+
+ #ifdef CONFIG_ACPI
+ static int acpi_spi_add_resource(struct acpi_resource *ares, void *data)
+ {
+ struct spi_device *spi = data;
+- struct spi_master *master = spi->master;
++ struct spi_controller *ctlr = spi->controller;
+
+ if (ares->type == ACPI_RESOURCE_TYPE_SERIAL_BUS) {
+ struct acpi_resource_spi_serialbus *sb;
+@@ -1656,8 +1655,8 @@ static int acpi_spi_add_resource(struct acpi_resource *ares, void *data)
+ * 0 .. max - 1 so we need to ask the driver to
+ * translate between the two schemes.
+ */
+- if (master->fw_translate_cs) {
+- int cs = master->fw_translate_cs(master,
++ if (ctlr->fw_translate_cs) {
++ int cs = ctlr->fw_translate_cs(ctlr,
+ sb->device_selection);
+ if (cs < 0)
+ return cs;
+@@ -1686,7 +1685,7 @@ static int acpi_spi_add_resource(struct acpi_resource *ares, void *data)
+ return 1;
+ }
+
+-static acpi_status acpi_register_spi_device(struct spi_master *master,
++static acpi_status acpi_register_spi_device(struct spi_controller *ctlr,
+ struct acpi_device *adev)
+ {
+ struct list_head resource_list;
+@@ -1697,9 +1696,9 @@ static acpi_status acpi_register_spi_device(struct spi_master *master,
+ acpi_device_enumerated(adev))
+ return AE_OK;
+
+- spi = spi_alloc_device(master);
++ spi = spi_alloc_device(ctlr);
+ if (!spi) {
+- dev_err(&master->dev, "failed to allocate SPI device for %s\n",
++ dev_err(&ctlr->dev, "failed to allocate SPI device for %s\n",
+ dev_name(&adev->dev));
+ return AE_NO_MEMORY;
+ }
+@@ -1726,7 +1725,7 @@ static acpi_status acpi_register_spi_device(struct spi_master *master,
+ strlcpy(spi->modalias, acpi_device_hid(adev), sizeof(spi->modalias));
+ if (spi_add_device(spi)) {
+ adev->power.flags.ignore_parent = false;
+- dev_err(&master->dev, "failed to add SPI device %s from ACPI\n",
++ dev_err(&ctlr->dev, "failed to add SPI device %s from ACPI\n",
+ dev_name(&adev->dev));
+ spi_dev_put(spi);
+ }
+@@ -1737,46 +1736,45 @@ static acpi_status acpi_register_spi_device(struct spi_master *master,
+ static acpi_status acpi_spi_add_device(acpi_handle handle, u32 level,
+ void *data, void **return_value)
+ {
+- struct spi_master *master = data;
++ struct spi_controller *ctlr = data;
+ struct acpi_device *adev;
+
+ if (acpi_bus_get_device(handle, &adev))
+ return AE_OK;
+
+- return acpi_register_spi_device(master, adev);
++ return acpi_register_spi_device(ctlr, adev);
+ }
+
+-static void acpi_register_spi_devices(struct spi_master *master)
++static void acpi_register_spi_devices(struct spi_controller *ctlr)
+ {
+ acpi_status status;
+ acpi_handle handle;
+
+- handle = ACPI_HANDLE(master->dev.parent);
++ handle = ACPI_HANDLE(ctlr->dev.parent);
+ if (!handle)
+ return;
+
+ status = acpi_walk_namespace(ACPI_TYPE_DEVICE, handle, 1,
+- acpi_spi_add_device, NULL,
+- master, NULL);
++ acpi_spi_add_device, NULL, ctlr, NULL);
+ if (ACPI_FAILURE(status))
+- dev_warn(&master->dev, "failed to enumerate SPI slaves\n");
++ dev_warn(&ctlr->dev, "failed to enumerate SPI slaves\n");
+ }
+ #else
+-static inline void acpi_register_spi_devices(struct spi_master *master) {}
++static inline void acpi_register_spi_devices(struct spi_controller *ctlr) {}
+ #endif /* CONFIG_ACPI */
+
+-static void spi_master_release(struct device *dev)
++static void spi_controller_release(struct device *dev)
+ {
+- struct spi_master *master;
++ struct spi_controller *ctlr;
+
+- master = container_of(dev, struct spi_master, dev);
+- kfree(master);
++ ctlr = container_of(dev, struct spi_controller, dev);
++ kfree(ctlr);
+ }
+
+ static struct class spi_master_class = {
+ .name = "spi_master",
+ .owner = THIS_MODULE,
+- .dev_release = spi_master_release,
++ .dev_release = spi_controller_release,
+ .dev_groups = spi_master_groups,
+ };
+
+@@ -1788,10 +1786,10 @@ static void spi_master_release(struct device *dev)
+ */
+ int spi_slave_abort(struct spi_device *spi)
+ {
+- struct spi_master *master = spi->master;
++ struct spi_controller *ctlr = spi->controller;
+
+- if (spi_controller_is_slave(master) && master->slave_abort)
+- return master->slave_abort(master);
++ if (spi_controller_is_slave(ctlr) && ctlr->slave_abort)
++ return ctlr->slave_abort(ctlr);
+
+ return -ENOTSUPP;
+ }
+@@ -1805,7 +1803,8 @@ static int match_true(struct device *dev, void *data)
+ static ssize_t spi_slave_show(struct device *dev,
+ struct device_attribute *attr, char *buf)
+ {
+- struct spi_master *ctlr = container_of(dev, struct spi_master, dev);
++ struct spi_controller *ctlr = container_of(dev, struct spi_controller,
++ dev);
+ struct device *child;
+
+ child = device_find_child(&ctlr->dev, NULL, match_true);
+@@ -1817,7 +1816,8 @@ static ssize_t spi_slave_store(struct device *dev,
+ struct device_attribute *attr, const char *buf,
+ size_t count)
+ {
+- struct spi_master *ctlr = container_of(dev, struct spi_master, dev);
++ struct spi_controller *ctlr = container_of(dev, struct spi_controller,
++ dev);
+ struct spi_device *spi;
+ struct device *child;
+ char name[32];
+@@ -1864,7 +1864,7 @@ static ssize_t spi_slave_store(struct device *dev,
+ };
+
+ static const struct attribute_group *spi_slave_groups[] = {
+- &spi_master_statistics_group,
++ &spi_controller_statistics_group,
+ &spi_slave_group,
+ NULL,
+ };
+@@ -1872,7 +1872,7 @@ static ssize_t spi_slave_store(struct device *dev,
+ static struct class spi_slave_class = {
+ .name = "spi_slave",
+ .owner = THIS_MODULE,
+- .dev_release = spi_master_release,
++ .dev_release = spi_controller_release,
+ .dev_groups = spi_slave_groups,
+ };
+ #else
+@@ -1884,62 +1884,63 @@ static ssize_t spi_slave_store(struct device *dev,
+ * @dev: the controller, possibly using the platform_bus
+ * @size: how much zeroed driver-private data to allocate; the pointer to this
+ * memory is in the driver_data field of the returned device,
+- * accessible with spi_master_get_devdata().
++ * accessible with spi_controller_get_devdata().
+ * @slave: flag indicating whether to allocate an SPI master (false) or SPI
+ * slave (true) controller
+ * Context: can sleep
+ *
+ * This call is used only by SPI controller drivers, which are the
+ * only ones directly touching chip registers. It's how they allocate
+- * an spi_master structure, prior to calling spi_register_master().
++ * an spi_controller structure, prior to calling spi_register_controller().
+ *
+ * This must be called from context that can sleep.
+ *
+ * The caller is responsible for assigning the bus number and initializing the
+- * controller's methods before calling spi_register_master(); and (after errors
+- * adding the device) calling spi_master_put() to prevent a memory leak.
++ * controller's methods before calling spi_register_controller(); and (after
++ * errors adding the device) calling spi_controller_put() to prevent a memory
++ * leak.
+ *
+ * Return: the SPI controller structure on success, else NULL.
+ */
+-struct spi_master *__spi_alloc_controller(struct device *dev,
+- unsigned int size, bool slave)
++struct spi_controller *__spi_alloc_controller(struct device *dev,
++ unsigned int size, bool slave)
+ {
+- struct spi_master *master;
++ struct spi_controller *ctlr;
+
+ if (!dev)
+ return NULL;
+
+- master = kzalloc(size + sizeof(*master), GFP_KERNEL);
+- if (!master)
++ ctlr = kzalloc(size + sizeof(*ctlr), GFP_KERNEL);
++ if (!ctlr)
+ return NULL;
+
+- device_initialize(&master->dev);
+- master->bus_num = -1;
+- master->num_chipselect = 1;
+- master->slave = slave;
++ device_initialize(&ctlr->dev);
++ ctlr->bus_num = -1;
++ ctlr->num_chipselect = 1;
++ ctlr->slave = slave;
+ if (IS_ENABLED(CONFIG_SPI_SLAVE) && slave)
+- master->dev.class = &spi_slave_class;
++ ctlr->dev.class = &spi_slave_class;
+ else
+- master->dev.class = &spi_master_class;
+- master->dev.parent = dev;
+- pm_suspend_ignore_children(&master->dev, true);
+- spi_master_set_devdata(master, &master[1]);
++ ctlr->dev.class = &spi_master_class;
++ ctlr->dev.parent = dev;
++ pm_suspend_ignore_children(&ctlr->dev, true);
++ spi_controller_set_devdata(ctlr, &ctlr[1]);
+
+- return master;
++ return ctlr;
+ }
+ EXPORT_SYMBOL_GPL(__spi_alloc_controller);
+
+ #ifdef CONFIG_OF
+-static int of_spi_register_master(struct spi_master *master)
++static int of_spi_register_master(struct spi_controller *ctlr)
+ {
+ int nb, i, *cs;
+- struct device_node *np = master->dev.of_node;
++ struct device_node *np = ctlr->dev.of_node;
+
+ if (!np)
+ return 0;
+
+ nb = of_gpio_named_count(np, "cs-gpios");
+- master->num_chipselect = max_t(int, nb, master->num_chipselect);
++ ctlr->num_chipselect = max_t(int, nb, ctlr->num_chipselect);
+
+ /* Return error only for an incorrectly formed cs-gpios property */
+ if (nb == 0 || nb == -ENOENT)
+@@ -1947,15 +1948,14 @@ static int of_spi_register_master(struct spi_master *master)
+ else if (nb < 0)
+ return nb;
+
+- cs = devm_kzalloc(&master->dev,
+- sizeof(int) * master->num_chipselect,
++ cs = devm_kzalloc(&ctlr->dev, sizeof(int) * ctlr->num_chipselect,
+ GFP_KERNEL);
+- master->cs_gpios = cs;
++ ctlr->cs_gpios = cs;
+
+- if (!master->cs_gpios)
++ if (!ctlr->cs_gpios)
+ return -ENOMEM;
+
+- for (i = 0; i < master->num_chipselect; i++)
++ for (i = 0; i < ctlr->num_chipselect; i++)
+ cs[i] = -ENOENT;
+
+ for (i = 0; i < nb; i++)
+@@ -1964,20 +1964,21 @@ static int of_spi_register_master(struct spi_master *master)
+ return 0;
+ }
+ #else
+-static int of_spi_register_master(struct spi_master *master)
++static int of_spi_register_master(struct spi_controller *ctlr)
+ {
+ return 0;
+ }
+ #endif
+
+ /**
+- * spi_register_master - register SPI master controller
+- * @master: initialized master, originally from spi_alloc_master()
++ * spi_register_controller - register SPI master or slave controller
++ * @ctlr: initialized master, originally from spi_alloc_master() or
++ * spi_alloc_slave()
+ * Context: can sleep
+ *
+- * SPI master controllers connect to their drivers using some non-SPI bus,
++ * SPI controllers connect to their drivers using some non-SPI bus,
+ * such as the platform bus. The final stage of probe() in that code
+- * includes calling spi_register_master() to hook up to this SPI bus glue.
++ * includes calling spi_register_controller() to hook up to this SPI bus glue.
+ *
+ * SPI controllers use board specific (often SOC specific) bus numbers,
+ * and board-specific addressing for SPI devices combines those numbers
+@@ -1986,16 +1987,16 @@ static int of_spi_register_master(struct spi_master *master)
+ * chip is at which address.
+ *
+ * This must be called from context that can sleep. It returns zero on
+- * success, else a negative error code (dropping the master's refcount).
++ * success, else a negative error code (dropping the controller's refcount).
+ * After a successful return, the caller is responsible for calling
+- * spi_unregister_master().
++ * spi_unregister_controller().
+ *
+ * Return: zero on success, else a negative error code.
+ */
+-int spi_register_master(struct spi_master *master)
++int spi_register_controller(struct spi_controller *ctlr)
+ {
+ static atomic_t dyn_bus_id = ATOMIC_INIT((1<<15) - 1);
+- struct device *dev = master->dev.parent;
++ struct device *dev = ctlr->dev.parent;
+ struct boardinfo *bi;
+ int status = -ENODEV;
+ int dynamic = 0;
+@@ -2003,8 +2004,8 @@ int spi_register_master(struct spi_master *master)
+ if (!dev)
+ return -ENODEV;
+
+- if (!spi_controller_is_slave(master)) {
+- status = of_spi_register_master(master);
++ if (!spi_controller_is_slave(ctlr)) {
++ status = of_spi_register_master(ctlr);
+ if (status)
+ return status;
+ }
+@@ -2012,97 +2013,100 @@ int spi_register_master(struct spi_master *master)
+ /* even if it's just one always-selected device, there must
+ * be at least one chipselect
+ */
+- if (master->num_chipselect == 0)
++ if (ctlr->num_chipselect == 0)
+ return -EINVAL;
+
+- if ((master->bus_num < 0) && master->dev.of_node)
+- master->bus_num = of_alias_get_id(master->dev.of_node, "spi");
++ if ((ctlr->bus_num < 0) && ctlr->dev.of_node)
++ ctlr->bus_num = of_alias_get_id(ctlr->dev.of_node, "spi");
+
+ /* convention: dynamically assigned bus IDs count down from the max */
+- if (master->bus_num < 0) {
++ if (ctlr->bus_num < 0) {
+ /* FIXME switch to an IDR based scheme, something like
+ * I2C now uses, so we can't run out of "dynamic" IDs
+ */
+- master->bus_num = atomic_dec_return(&dyn_bus_id);
++ ctlr->bus_num = atomic_dec_return(&dyn_bus_id);
+ dynamic = 1;
+ }
+
+- INIT_LIST_HEAD(&master->queue);
+- spin_lock_init(&master->queue_lock);
+- spin_lock_init(&master->bus_lock_spinlock);
+- mutex_init(&master->bus_lock_mutex);
+- mutex_init(&master->io_mutex);
+- master->bus_lock_flag = 0;
+- init_completion(&master->xfer_completion);
+- if (!master->max_dma_len)
+- master->max_dma_len = INT_MAX;
++ INIT_LIST_HEAD(&ctlr->queue);
++ spin_lock_init(&ctlr->queue_lock);
++ spin_lock_init(&ctlr->bus_lock_spinlock);
++ mutex_init(&ctlr->bus_lock_mutex);
++ mutex_init(&ctlr->io_mutex);
++ ctlr->bus_lock_flag = 0;
++ init_completion(&ctlr->xfer_completion);
++ if (!ctlr->max_dma_len)
++ ctlr->max_dma_len = INT_MAX;
+
+ /* register the device, then userspace will see it.
+ * registration fails if the bus ID is in use.
+ */
+- dev_set_name(&master->dev, "spi%u", master->bus_num);
+- status = device_add(&master->dev);
++ dev_set_name(&ctlr->dev, "spi%u", ctlr->bus_num);
++ status = device_add(&ctlr->dev);
+ if (status < 0)
+ goto done;
+ dev_dbg(dev, "registered %s %s%s\n",
+- spi_controller_is_slave(master) ? "slave" : "master",
+- dev_name(&master->dev), dynamic ? " (dynamic)" : "");
++ spi_controller_is_slave(ctlr) ? "slave" : "master",
++ dev_name(&ctlr->dev), dynamic ? " (dynamic)" : "");
+
+ /* If we're using a queued driver, start the queue */
+- if (master->transfer)
++ if (ctlr->transfer)
+ dev_info(dev, "master is unqueued, this is deprecated\n");
+ else {
+- status = spi_master_initialize_queue(master);
++ status = spi_controller_initialize_queue(ctlr);
+ if (status) {
+- device_del(&master->dev);
++ device_del(&ctlr->dev);
+ goto done;
+ }
+ }
+ /* add statistics */
+- spin_lock_init(&master->statistics.lock);
++ spin_lock_init(&ctlr->statistics.lock);
+
+ mutex_lock(&board_lock);
+- list_add_tail(&master->list, &spi_master_list);
++ list_add_tail(&ctlr->list, &spi_controller_list);
+ list_for_each_entry(bi, &board_list, list)
+- spi_match_master_to_boardinfo(master, &bi->board_info);
++ spi_match_controller_to_boardinfo(ctlr, &bi->board_info);
+ mutex_unlock(&board_lock);
+
+ /* Register devices from the device tree and ACPI */
+- of_register_spi_devices(master);
+- acpi_register_spi_devices(master);
++ of_register_spi_devices(ctlr);
++ acpi_register_spi_devices(ctlr);
+ done:
+ return status;
+ }
+-EXPORT_SYMBOL_GPL(spi_register_master);
++EXPORT_SYMBOL_GPL(spi_register_controller);
+
+ static void devm_spi_unregister(struct device *dev, void *res)
+ {
+- spi_unregister_master(*(struct spi_master **)res);
++ spi_unregister_controller(*(struct spi_master **)res);
+ }
+
+ /**
+- * dev_spi_register_master - register managed SPI master controller
+- * @dev: device managing SPI master
+- * @master: initialized master, originally from spi_alloc_master()
++ * devm_spi_register_controller - register managed SPI master or slave
++ * controller
++ * @dev: device managing SPI controller
++ * @ctlr: initialized controller, originally from spi_alloc_master() or
++ * spi_alloc_slave()
+ * Context: can sleep
+ *
+- * Register a SPI device as with spi_register_master() which will
++ * Register a SPI device as with spi_register_controller() which will
+ * automatically be unregister
+ *
+ * Return: zero on success, else a negative error code.
+ */
+-int devm_spi_register_master(struct device *dev, struct spi_master *master)
++int devm_spi_register_controller(struct device *dev,
++ struct spi_controller *ctlr)
+ {
+- struct spi_master **ptr;
++ struct spi_controller **ptr;
+ int ret;
+
+ ptr = devres_alloc(devm_spi_unregister, sizeof(*ptr), GFP_KERNEL);
+ if (!ptr)
+ return -ENOMEM;
+
+- ret = spi_register_master(master);
++ ret = spi_register_controller(ctlr);
+ if (!ret) {
+- *ptr = master;
++ *ptr = ctlr;
+ devres_add(dev, ptr);
+ } else {
+ devres_free(ptr);
+@@ -2110,7 +2114,7 @@ int devm_spi_register_master(struct device *dev, struct spi_master *master)
+
+ return ret;
+ }
+-EXPORT_SYMBOL_GPL(devm_spi_register_master);
++EXPORT_SYMBOL_GPL(devm_spi_register_controller);
+
+ static int __unregister(struct device *dev, void *null)
+ {
+@@ -2119,71 +2123,71 @@ static int __unregister(struct device *dev, void *null)
+ }
+
+ /**
+- * spi_unregister_master - unregister SPI master controller
+- * @master: the master being unregistered
++ * spi_unregister_controller - unregister SPI master or slave controller
++ * @ctlr: the controller being unregistered
+ * Context: can sleep
+ *
+- * This call is used only by SPI master controller drivers, which are the
++ * This call is used only by SPI controller drivers, which are the
+ * only ones directly touching chip registers.
+ *
+ * This must be called from context that can sleep.
+ */
+-void spi_unregister_master(struct spi_master *master)
++void spi_unregister_controller(struct spi_controller *ctlr)
+ {
+ int dummy;
+
+- if (master->queued) {
+- if (spi_destroy_queue(master))
+- dev_err(&master->dev, "queue remove failed\n");
++ if (ctlr->queued) {
++ if (spi_destroy_queue(ctlr))
++ dev_err(&ctlr->dev, "queue remove failed\n");
+ }
+
+ mutex_lock(&board_lock);
+- list_del(&master->list);
++ list_del(&ctlr->list);
+ mutex_unlock(&board_lock);
+
+- dummy = device_for_each_child(&master->dev, NULL, __unregister);
+- device_unregister(&master->dev);
++ dummy = device_for_each_child(&ctlr->dev, NULL, __unregister);
++ device_unregister(&ctlr->dev);
+ }
+-EXPORT_SYMBOL_GPL(spi_unregister_master);
++EXPORT_SYMBOL_GPL(spi_unregister_controller);
+
+-int spi_master_suspend(struct spi_master *master)
++int spi_controller_suspend(struct spi_controller *ctlr)
+ {
+ int ret;
+
+- /* Basically no-ops for non-queued masters */
+- if (!master->queued)
++ /* Basically no-ops for non-queued controllers */
++ if (!ctlr->queued)
+ return 0;
+
+- ret = spi_stop_queue(master);
++ ret = spi_stop_queue(ctlr);
+ if (ret)
+- dev_err(&master->dev, "queue stop failed\n");
++ dev_err(&ctlr->dev, "queue stop failed\n");
+
+ return ret;
+ }
+-EXPORT_SYMBOL_GPL(spi_master_suspend);
++EXPORT_SYMBOL_GPL(spi_controller_suspend);
+
+-int spi_master_resume(struct spi_master *master)
++int spi_controller_resume(struct spi_controller *ctlr)
+ {
+ int ret;
+
+- if (!master->queued)
++ if (!ctlr->queued)
+ return 0;
+
+- ret = spi_start_queue(master);
++ ret = spi_start_queue(ctlr);
+ if (ret)
+- dev_err(&master->dev, "queue restart failed\n");
++ dev_err(&ctlr->dev, "queue restart failed\n");
+
+ return ret;
+ }
+-EXPORT_SYMBOL_GPL(spi_master_resume);
++EXPORT_SYMBOL_GPL(spi_controller_resume);
+
+-static int __spi_master_match(struct device *dev, const void *data)
++static int __spi_controller_match(struct device *dev, const void *data)
+ {
+- struct spi_master *m;
++ struct spi_controller *ctlr;
+ const u16 *bus_num = data;
+
+- m = container_of(dev, struct spi_master, dev);
+- return m->bus_num == *bus_num;
++ ctlr = container_of(dev, struct spi_controller, dev);
++ return ctlr->bus_num == *bus_num;
+ }
+
+ /**
+@@ -2193,22 +2197,22 @@ static int __spi_master_match(struct device *dev, const void *data)
+ *
+ * This call may be used with devices that are registered after
+ * arch init time. It returns a refcounted pointer to the relevant
+- * spi_master (which the caller must release), or NULL if there is
++ * spi_controller (which the caller must release), or NULL if there is
+ * no such master registered.
+ *
+ * Return: the SPI master structure on success, else NULL.
+ */
+-struct spi_master *spi_busnum_to_master(u16 bus_num)
++struct spi_controller *spi_busnum_to_master(u16 bus_num)
+ {
+ struct device *dev;
+- struct spi_master *master = NULL;
++ struct spi_controller *ctlr = NULL;
+
+ dev = class_find_device(&spi_master_class, NULL, &bus_num,
+- __spi_master_match);
++ __spi_controller_match);
+ if (dev)
+- master = container_of(dev, struct spi_master, dev);
++ ctlr = container_of(dev, struct spi_controller, dev);
+ /* reference got in class_find_device */
+- return master;
++ return ctlr;
+ }
+ EXPORT_SYMBOL_GPL(spi_busnum_to_master);
+
+@@ -2228,7 +2232,7 @@ struct spi_master *spi_busnum_to_master(u16 bus_num)
+ * Return: the pointer to the allocated data
+ *
+ * This may get enhanced in the future to allocate from a memory pool
+- * of the @spi_device or @spi_master to avoid repeated allocations.
++ * of the @spi_device or @spi_controller to avoid repeated allocations.
+ */
+ void *spi_res_alloc(struct spi_device *spi,
+ spi_res_release_t release,
+@@ -2280,11 +2284,10 @@ void spi_res_add(struct spi_message *message, void *res)
+
+ /**
+ * spi_res_release - release all spi resources for this message
+- * @master: the @spi_master
++ * @ctlr: the @spi_controller
+ * @message: the @spi_message
+ */
+-void spi_res_release(struct spi_master *master,
+- struct spi_message *message)
++void spi_res_release(struct spi_controller *ctlr, struct spi_message *message)
+ {
+ struct spi_res *res;
+
+@@ -2293,7 +2296,7 @@ void spi_res_release(struct spi_master *master,
+ struct spi_res, entry);
+
+ if (res->release)
+- res->release(master, message, res->data);
++ res->release(ctlr, message, res->data);
+
+ list_del(&res->entry);
+
+@@ -2306,7 +2309,7 @@ void spi_res_release(struct spi_master *master,
+
+ /* Core methods for spi_message alterations */
+
+-static void __spi_replace_transfers_release(struct spi_master *master,
++static void __spi_replace_transfers_release(struct spi_controller *ctlr,
+ struct spi_message *msg,
+ void *res)
+ {
+@@ -2315,7 +2318,7 @@ static void __spi_replace_transfers_release(struct spi_master *master,
+
+ /* call extra callback if requested */
+ if (rxfer->release)
+- rxfer->release(master, msg, res);
++ rxfer->release(ctlr, msg, res);
+
+ /* insert replaced transfers back into the message */
+ list_splice(&rxfer->replaced_transfers, rxfer->replaced_after);
+@@ -2435,7 +2438,7 @@ struct spi_replaced_transfers *spi_replace_transfers(
+ }
+ EXPORT_SYMBOL_GPL(spi_replace_transfers);
+
+-static int __spi_split_transfer_maxsize(struct spi_master *master,
++static int __spi_split_transfer_maxsize(struct spi_controller *ctlr,
+ struct spi_message *msg,
+ struct spi_transfer **xferp,
+ size_t maxsize,
+@@ -2497,7 +2500,7 @@ static int __spi_split_transfer_maxsize(struct spi_master *master,
+ *xferp = &xfers[count - 1];
+
+ /* increment statistics counters */
+- SPI_STATISTICS_INCREMENT_FIELD(&master->statistics,
++ SPI_STATISTICS_INCREMENT_FIELD(&ctlr->statistics,
+ transfers_split_maxsize);
+ SPI_STATISTICS_INCREMENT_FIELD(&msg->spi->statistics,
+ transfers_split_maxsize);
+@@ -2509,14 +2512,14 @@ static int __spi_split_transfer_maxsize(struct spi_master *master,
+ * spi_split_tranfers_maxsize - split spi transfers into multiple transfers
+ * when an individual transfer exceeds a
+ * certain size
+- * @master: the @spi_master for this transfer
++ * @ctlr: the @spi_controller for this transfer
+ * @msg: the @spi_message to transform
+ * @maxsize: the maximum when to apply this
+ * @gfp: GFP allocation flags
+ *
+ * Return: status of transformation
+ */
+-int spi_split_transfers_maxsize(struct spi_master *master,
++int spi_split_transfers_maxsize(struct spi_controller *ctlr,
+ struct spi_message *msg,
+ size_t maxsize,
+ gfp_t gfp)
+@@ -2532,8 +2535,8 @@ int spi_split_transfers_maxsize(struct spi_master *master,
+ */
+ list_for_each_entry(xfer, &msg->transfers, transfer_list) {
+ if (xfer->len > maxsize) {
+- ret = __spi_split_transfer_maxsize(
+- master, msg, &xfer, maxsize, gfp);
++ ret = __spi_split_transfer_maxsize(ctlr, msg, &xfer,
++ maxsize, gfp);
+ if (ret)
+ return ret;
+ }
+@@ -2545,18 +2548,18 @@ int spi_split_transfers_maxsize(struct spi_master *master,
+
+ /*-------------------------------------------------------------------------*/
+
+-/* Core methods for SPI master protocol drivers. Some of the
++/* Core methods for SPI controller protocol drivers. Some of the
+ * other core methods are currently defined as inline functions.
+ */
+
+-static int __spi_validate_bits_per_word(struct spi_master *master, u8 bits_per_word)
++static int __spi_validate_bits_per_word(struct spi_controller *ctlr,
++ u8 bits_per_word)
+ {
+- if (master->bits_per_word_mask) {
++ if (ctlr->bits_per_word_mask) {
+ /* Only 32 bits fit in the mask */
+ if (bits_per_word > 32)
+ return -EINVAL;
+- if (!(master->bits_per_word_mask &
+- SPI_BPW_MASK(bits_per_word)))
++ if (!(ctlr->bits_per_word_mask & SPI_BPW_MASK(bits_per_word)))
+ return -EINVAL;
+ }
+
+@@ -2602,9 +2605,9 @@ int spi_setup(struct spi_device *spi)
+ (SPI_TX_DUAL | SPI_TX_QUAD | SPI_RX_DUAL | SPI_RX_QUAD)))
+ return -EINVAL;
+ /* help drivers fail *cleanly* when they need options
+- * that aren't supported with their current master
++ * that aren't supported with their current controller
+ */
+- bad_bits = spi->mode & ~spi->master->mode_bits;
++ bad_bits = spi->mode & ~spi->controller->mode_bits;
+ ugly_bits = bad_bits &
+ (SPI_TX_DUAL | SPI_TX_QUAD | SPI_RX_DUAL | SPI_RX_QUAD);
+ if (ugly_bits) {
+@@ -2623,15 +2626,16 @@ int spi_setup(struct spi_device *spi)
+ if (!spi->bits_per_word)
+ spi->bits_per_word = 8;
+
+- status = __spi_validate_bits_per_word(spi->master, spi->bits_per_word);
++ status = __spi_validate_bits_per_word(spi->controller,
++ spi->bits_per_word);
+ if (status)
+ return status;
+
+ if (!spi->max_speed_hz)
+- spi->max_speed_hz = spi->master->max_speed_hz;
++ spi->max_speed_hz = spi->controller->max_speed_hz;
+
+- if (spi->master->setup)
+- status = spi->master->setup(spi);
++ if (spi->controller->setup)
++ status = spi->controller->setup(spi);
+
+ spi_set_cs(spi, false);
+
+@@ -2650,7 +2654,7 @@ int spi_setup(struct spi_device *spi)
+
+ static int __spi_validate(struct spi_device *spi, struct spi_message *message)
+ {
+- struct spi_master *master = spi->master;
++ struct spi_controller *ctlr = spi->controller;
+ struct spi_transfer *xfer;
+ int w_size;
+
+@@ -2662,16 +2666,16 @@ static int __spi_validate(struct spi_device *spi, struct spi_message *message)
+ * either MOSI or MISO is missing. They can also be caused by
+ * software limitations.
+ */
+- if ((master->flags & SPI_MASTER_HALF_DUPLEX)
+- || (spi->mode & SPI_3WIRE)) {
+- unsigned flags = master->flags;
++ if ((ctlr->flags & SPI_CONTROLLER_HALF_DUPLEX) ||
++ (spi->mode & SPI_3WIRE)) {
++ unsigned flags = ctlr->flags;
+
+ list_for_each_entry(xfer, &message->transfers, transfer_list) {
+ if (xfer->rx_buf && xfer->tx_buf)
+ return -EINVAL;
+- if ((flags & SPI_MASTER_NO_TX) && xfer->tx_buf)
++ if ((flags & SPI_CONTROLLER_NO_TX) && xfer->tx_buf)
+ return -EINVAL;
+- if ((flags & SPI_MASTER_NO_RX) && xfer->rx_buf)
++ if ((flags & SPI_CONTROLLER_NO_RX) && xfer->rx_buf)
+ return -EINVAL;
+ }
+ }
+@@ -2691,13 +2695,12 @@ static int __spi_validate(struct spi_device *spi, struct spi_message *message)
+ if (!xfer->speed_hz)
+ xfer->speed_hz = spi->max_speed_hz;
+ if (!xfer->speed_hz)
+- xfer->speed_hz = master->max_speed_hz;
++ xfer->speed_hz = ctlr->max_speed_hz;
+
+- if (master->max_speed_hz &&
+- xfer->speed_hz > master->max_speed_hz)
+- xfer->speed_hz = master->max_speed_hz;
++ if (ctlr->max_speed_hz && xfer->speed_hz > ctlr->max_speed_hz)
++ xfer->speed_hz = ctlr->max_speed_hz;
+
+- if (__spi_validate_bits_per_word(master, xfer->bits_per_word))
++ if (__spi_validate_bits_per_word(ctlr, xfer->bits_per_word))
+ return -EINVAL;
+
+ /*
+@@ -2715,8 +2718,8 @@ static int __spi_validate(struct spi_device *spi, struct spi_message *message)
+ if (xfer->len % w_size)
+ return -EINVAL;
+
+- if (xfer->speed_hz && master->min_speed_hz &&
+- xfer->speed_hz < master->min_speed_hz)
++ if (xfer->speed_hz && ctlr->min_speed_hz &&
++ xfer->speed_hz < ctlr->min_speed_hz)
+ return -EINVAL;
+
+ if (xfer->tx_buf && !xfer->tx_nbits)
+@@ -2761,16 +2764,16 @@ static int __spi_validate(struct spi_device *spi, struct spi_message *message)
+
+ static int __spi_async(struct spi_device *spi, struct spi_message *message)
+ {
+- struct spi_master *master = spi->master;
++ struct spi_controller *ctlr = spi->controller;
+
+ message->spi = spi;
+
+- SPI_STATISTICS_INCREMENT_FIELD(&master->statistics, spi_async);
++ SPI_STATISTICS_INCREMENT_FIELD(&ctlr->statistics, spi_async);
+ SPI_STATISTICS_INCREMENT_FIELD(&spi->statistics, spi_async);
+
+ trace_spi_message_submit(message);
+
+- return master->transfer(spi, message);
++ return ctlr->transfer(spi, message);
+ }
+
+ /**
+@@ -2806,7 +2809,7 @@ static int __spi_async(struct spi_device *spi, struct spi_message *message)
+ */
+ int spi_async(struct spi_device *spi, struct spi_message *message)
+ {
+- struct spi_master *master = spi->master;
++ struct spi_controller *ctlr = spi->controller;
+ int ret;
+ unsigned long flags;
+
+@@ -2814,14 +2817,14 @@ int spi_async(struct spi_device *spi, struct spi_message *message)
+ if (ret != 0)
+ return ret;
+
+- spin_lock_irqsave(&master->bus_lock_spinlock, flags);
++ spin_lock_irqsave(&ctlr->bus_lock_spinlock, flags);
+
+- if (master->bus_lock_flag)
++ if (ctlr->bus_lock_flag)
+ ret = -EBUSY;
+ else
+ ret = __spi_async(spi, message);
+
+- spin_unlock_irqrestore(&master->bus_lock_spinlock, flags);
++ spin_unlock_irqrestore(&ctlr->bus_lock_spinlock, flags);
+
+ return ret;
+ }
+@@ -2860,7 +2863,7 @@ int spi_async(struct spi_device *spi, struct spi_message *message)
+ */
+ int spi_async_locked(struct spi_device *spi, struct spi_message *message)
+ {
+- struct spi_master *master = spi->master;
++ struct spi_controller *ctlr = spi->controller;
+ int ret;
+ unsigned long flags;
+
+@@ -2868,11 +2871,11 @@ int spi_async_locked(struct spi_device *spi, struct spi_message *message)
+ if (ret != 0)
+ return ret;
+
+- spin_lock_irqsave(&master->bus_lock_spinlock, flags);
++ spin_lock_irqsave(&ctlr->bus_lock_spinlock, flags);
+
+ ret = __spi_async(spi, message);
+
+- spin_unlock_irqrestore(&master->bus_lock_spinlock, flags);
++ spin_unlock_irqrestore(&ctlr->bus_lock_spinlock, flags);
+
+ return ret;
+
+@@ -2884,7 +2887,7 @@ int spi_flash_read(struct spi_device *spi,
+ struct spi_flash_read_message *msg)
+
+ {
+- struct spi_master *master = spi->master;
++ struct spi_controller *master = spi->controller;
+ struct device *rx_dev = NULL;
+ int ret;
+
+@@ -2938,7 +2941,7 @@ int spi_flash_read(struct spi_device *spi,
+
+ /*-------------------------------------------------------------------------*/
+
+-/* Utility methods for SPI master protocol drivers, layered on
++/* Utility methods for SPI protocol drivers, layered on
+ * top of the core. Some other utility methods are defined as
+ * inline functions.
+ */
+@@ -2952,7 +2955,7 @@ static int __spi_sync(struct spi_device *spi, struct spi_message *message)
+ {
+ DECLARE_COMPLETION_ONSTACK(done);
+ int status;
+- struct spi_master *master = spi->master;
++ struct spi_controller *ctlr = spi->controller;
+ unsigned long flags;
+
+ status = __spi_validate(spi, message);
+@@ -2963,7 +2966,7 @@ static int __spi_sync(struct spi_device *spi, struct spi_message *message)
+ message->context = &done;
+ message->spi = spi;
+
+- SPI_STATISTICS_INCREMENT_FIELD(&master->statistics, spi_sync);
++ SPI_STATISTICS_INCREMENT_FIELD(&ctlr->statistics, spi_sync);
+ SPI_STATISTICS_INCREMENT_FIELD(&spi->statistics, spi_sync);
+
+ /* If we're not using the legacy transfer method then we will
+@@ -2971,14 +2974,14 @@ static int __spi_sync(struct spi_device *spi, struct spi_message *message)
+ * This code would be less tricky if we could remove the
+ * support for driver implemented message queues.
+ */
+- if (master->transfer == spi_queued_transfer) {
+- spin_lock_irqsave(&master->bus_lock_spinlock, flags);
++ if (ctlr->transfer == spi_queued_transfer) {
++ spin_lock_irqsave(&ctlr->bus_lock_spinlock, flags);
+
+ trace_spi_message_submit(message);
+
+ status = __spi_queued_transfer(spi, message, false);
+
+- spin_unlock_irqrestore(&master->bus_lock_spinlock, flags);
++ spin_unlock_irqrestore(&ctlr->bus_lock_spinlock, flags);
+ } else {
+ status = spi_async_locked(spi, message);
+ }
+@@ -2987,12 +2990,12 @@ static int __spi_sync(struct spi_device *spi, struct spi_message *message)
+ /* Push out the messages in the calling context if we
+ * can.
+ */
+- if (master->transfer == spi_queued_transfer) {
+- SPI_STATISTICS_INCREMENT_FIELD(&master->statistics,
++ if (ctlr->transfer == spi_queued_transfer) {
++ SPI_STATISTICS_INCREMENT_FIELD(&ctlr->statistics,
+ spi_sync_immediate);
+ SPI_STATISTICS_INCREMENT_FIELD(&spi->statistics,
+ spi_sync_immediate);
+- __spi_pump_messages(master, false);
++ __spi_pump_messages(ctlr, false);
+ }
+
+ wait_for_completion(&done);
+@@ -3027,9 +3030,9 @@ int spi_sync(struct spi_device *spi, struct spi_message *message)
+ {
+ int ret;
+
+- mutex_lock(&spi->master->bus_lock_mutex);
++ mutex_lock(&spi->controller->bus_lock_mutex);
+ ret = __spi_sync(spi, message);
+- mutex_unlock(&spi->master->bus_lock_mutex);
++ mutex_unlock(&spi->controller->bus_lock_mutex);
+
+ return ret;
+ }
+@@ -3059,7 +3062,7 @@ int spi_sync_locked(struct spi_device *spi, struct spi_message *message)
+
+ /**
+ * spi_bus_lock - obtain a lock for exclusive SPI bus usage
+- * @master: SPI bus master that should be locked for exclusive bus access
++ * @ctlr: SPI bus master that should be locked for exclusive bus access
+ * Context: can sleep
+ *
+ * This call may only be used from a context that may sleep. The sleep
+@@ -3072,15 +3075,15 @@ int spi_sync_locked(struct spi_device *spi, struct spi_message *message)
+ *
+ * Return: always zero.
+ */
+-int spi_bus_lock(struct spi_master *master)
++int spi_bus_lock(struct spi_controller *ctlr)
+ {
+ unsigned long flags;
+
+- mutex_lock(&master->bus_lock_mutex);
++ mutex_lock(&ctlr->bus_lock_mutex);
+
+- spin_lock_irqsave(&master->bus_lock_spinlock, flags);
+- master->bus_lock_flag = 1;
+- spin_unlock_irqrestore(&master->bus_lock_spinlock, flags);
++ spin_lock_irqsave(&ctlr->bus_lock_spinlock, flags);
++ ctlr->bus_lock_flag = 1;
++ spin_unlock_irqrestore(&ctlr->bus_lock_spinlock, flags);
+
+ /* mutex remains locked until spi_bus_unlock is called */
+
+@@ -3090,7 +3093,7 @@ int spi_bus_lock(struct spi_master *master)
+
+ /**
+ * spi_bus_unlock - release the lock for exclusive SPI bus usage
+- * @master: SPI bus master that was locked for exclusive bus access
++ * @ctlr: SPI bus master that was locked for exclusive bus access
+ * Context: can sleep
+ *
+ * This call may only be used from a context that may sleep. The sleep
+@@ -3101,11 +3104,11 @@ int spi_bus_lock(struct spi_master *master)
+ *
+ * Return: always zero.
+ */
+-int spi_bus_unlock(struct spi_master *master)
++int spi_bus_unlock(struct spi_controller *ctlr)
+ {
+- master->bus_lock_flag = 0;
++ ctlr->bus_lock_flag = 0;
+
+- mutex_unlock(&master->bus_lock_mutex);
++ mutex_unlock(&ctlr->bus_lock_mutex);
+
+ return 0;
+ }
+@@ -3207,48 +3210,48 @@ static struct spi_device *of_find_spi_device_by_node(struct device_node *node)
+ return dev ? to_spi_device(dev) : NULL;
+ }
+
+-static int __spi_of_master_match(struct device *dev, const void *data)
++static int __spi_of_controller_match(struct device *dev, const void *data)
+ {
+ return dev->of_node == data;
+ }
+
+-/* the spi masters are not using spi_bus, so we find it with another way */
+-static struct spi_master *of_find_spi_master_by_node(struct device_node *node)
++/* the spi controllers are not using spi_bus, so we find it with another way */
++static struct spi_controller *of_find_spi_controller_by_node(struct device_node *node)
+ {
+ struct device *dev;
+
+ dev = class_find_device(&spi_master_class, NULL, node,
+- __spi_of_master_match);
++ __spi_of_controller_match);
+ if (!dev && IS_ENABLED(CONFIG_SPI_SLAVE))
+ dev = class_find_device(&spi_slave_class, NULL, node,
+- __spi_of_master_match);
++ __spi_of_controller_match);
+ if (!dev)
+ return NULL;
+
+ /* reference got in class_find_device */
+- return container_of(dev, struct spi_master, dev);
++ return container_of(dev, struct spi_controller, dev);
+ }
+
+ static int of_spi_notify(struct notifier_block *nb, unsigned long action,
+ void *arg)
+ {
+ struct of_reconfig_data *rd = arg;
+- struct spi_master *master;
++ struct spi_controller *ctlr;
+ struct spi_device *spi;
+
+ switch (of_reconfig_get_state_change(action, arg)) {
+ case OF_RECONFIG_CHANGE_ADD:
+- master = of_find_spi_master_by_node(rd->dn->parent);
+- if (master == NULL)
++ ctlr = of_find_spi_controller_by_node(rd->dn->parent);
++ if (ctlr == NULL)
+ return NOTIFY_OK; /* not for us */
+
+ if (of_node_test_and_set_flag(rd->dn, OF_POPULATED)) {
+- put_device(&master->dev);
++ put_device(&ctlr->dev);
+ return NOTIFY_OK;
+ }
+
+- spi = of_register_spi_device(master, rd->dn);
+- put_device(&master->dev);
++ spi = of_register_spi_device(ctlr, rd->dn);
++ put_device(&ctlr->dev);
+
+ if (IS_ERR(spi)) {
+ pr_err("%s: failed to create for '%s'\n",
+@@ -3287,7 +3290,7 @@ static int of_spi_notify(struct notifier_block *nb, unsigned long action,
+ #endif /* IS_ENABLED(CONFIG_OF_DYNAMIC) */
+
+ #if IS_ENABLED(CONFIG_ACPI)
+-static int spi_acpi_master_match(struct device *dev, const void *data)
++static int spi_acpi_controller_match(struct device *dev, const void *data)
+ {
+ return ACPI_COMPANION(dev->parent) == data;
+ }
+@@ -3297,19 +3300,19 @@ static int spi_acpi_device_match(struct device *dev, void *data)
+ return ACPI_COMPANION(dev) == data;
+ }
+
+-static struct spi_master *acpi_spi_find_master_by_adev(struct acpi_device *adev)
++static struct spi_controller *acpi_spi_find_controller_by_adev(struct acpi_device *adev)
+ {
+ struct device *dev;
+
+ dev = class_find_device(&spi_master_class, NULL, adev,
+- spi_acpi_master_match);
++ spi_acpi_controller_match);
+ if (!dev && IS_ENABLED(CONFIG_SPI_SLAVE))
+ dev = class_find_device(&spi_slave_class, NULL, adev,
+- spi_acpi_master_match);
++ spi_acpi_controller_match);
+ if (!dev)
+ return NULL;
+
+- return container_of(dev, struct spi_master, dev);
++ return container_of(dev, struct spi_controller, dev);
+ }
+
+ static struct spi_device *acpi_spi_find_device_by_adev(struct acpi_device *adev)
+@@ -3325,17 +3328,17 @@ static int acpi_spi_notify(struct notifier_block *nb, unsigned long value,
+ void *arg)
+ {
+ struct acpi_device *adev = arg;
+- struct spi_master *master;
++ struct spi_controller *ctlr;
+ struct spi_device *spi;
+
+ switch (value) {
+ case ACPI_RECONFIG_DEVICE_ADD:
+- master = acpi_spi_find_master_by_adev(adev->parent);
+- if (!master)
++ ctlr = acpi_spi_find_controller_by_adev(adev->parent);
++ if (!ctlr)
+ break;
+
+- acpi_register_spi_device(master, adev);
+- put_device(&master->dev);
++ acpi_register_spi_device(ctlr, adev);
++ put_device(&ctlr->dev);
+ break;
+ case ACPI_RECONFIG_DEVICE_REMOVE:
+ if (!acpi_device_enumerated(adev))
+diff --git a/include/linux/spi/spi.h b/include/linux/spi/spi.h
+index f9bbd33..920cdb7 100644
+--- a/include/linux/spi/spi.h
++++ b/include/linux/spi/spi.h
+@@ -23,7 +23,7 @@
+ #include <linux/scatterlist.h>
+
+ struct dma_chan;
+-struct spi_master;
++struct spi_controller;
+ struct spi_transfer;
+ struct spi_flash_read_message;
+
+@@ -83,7 +83,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 { \
+@@ -97,13 +97,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
+@@ -139,7 +140,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;
+@@ -197,7 +199,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;
+@@ -291,9 +293,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
+@@ -326,8 +328,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
+@@ -381,7 +383,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
+@@ -390,7 +392,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
+@@ -401,7 +403,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;
+@@ -439,11 +441,13 @@ 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_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;
+@@ -481,8 +485,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)
+@@ -495,7 +499,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);
+
+ /*
+@@ -505,13 +509,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.
+ */
+@@ -532,15 +536,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_master *spi);
++ int (*slave_abort)(struct spi_controller *ctlr);
+ int (*spi_flash_read)(struct spi_device *spi,
+ struct spi_flash_read_message *msg);
+ bool (*flash_read_supported)(struct spi_device *spi);
+@@ -550,9 +554,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,58 +573,59 @@ 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_master_put(struct spi_master *master)
++static inline void spi_controller_put(struct spi_controller *ctlr)
+ {
+- if (master)
+- put_device(&master->dev);
++ if (ctlr)
++ put_device(&ctlr->dev);
+ }
+
+-static inline bool spi_controller_is_slave(struct spi_master *ctlr)
++static inline bool spi_controller_is_slave(struct spi_controller *ctlr)
+ {
+ 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_controller(struct device *host,
+- unsigned int size, bool slave);
++/* 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);
+
+-static inline struct spi_master *spi_alloc_master(struct device *host,
+- unsigned int size)
++static inline struct spi_controller *spi_alloc_master(struct device *host,
++ unsigned int size)
+ {
+ return __spi_alloc_controller(host, size, false);
+ }
+
+-static inline struct spi_master *spi_alloc_slave(struct device *host,
+- unsigned int size)
++static inline struct spi_controller *spi_alloc_slave(struct device *host,
++ unsigned int size)
+ {
+ if (!IS_ENABLED(CONFIG_SPI_SLAVE))
+ return NULL;
+@@ -628,18 +633,18 @@ static inline struct spi_master *spi_alloc_slave(struct device *host,
+ return __spi_alloc_controller(host, size, true);
+ }
+
+-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);
++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_master *spi_busnum_to_master(u16 busnum);
++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);
+
+@@ -664,7 +669,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);
+
+ /*---------------------------------------------------------------------------*/
+@@ -848,7 +853,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;
+@@ -937,21 +942,22 @@ extern int spi_async_locked(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);
+@@ -962,7 +968,7 @@ extern int spi_async_locked(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);
+ /**
+@@ -1006,7 +1012,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);
+@@ -1020,8 +1026,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
+@@ -1206,9 +1212,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,
+@@ -1240,7 +1246,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.
+@@ -1279,7 +1285,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.
+@@ -1313,7 +1319,7 @@ struct spi_board_info {
+ /* 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
+@@ -1322,13 +1328,13 @@ struct spi_board_info {
+ * 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);
+
+@@ -1336,9 +1342,32 @@ struct spi_board_info {
+ 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 */
+diff --git a/include/trace/events/spi.h b/include/trace/events/spi.h
+index 7e02c98..f9f702b 100644
+--- a/include/trace/events/spi.h
++++ b/include/trace/events/spi.h
+@@ -7,37 +7,37 @@
+ #include <linux/ktime.h>
+ #include <linux/tracepoint.h>
+
+-DECLARE_EVENT_CLASS(spi_master,
++DECLARE_EVENT_CLASS(spi_controller,
+
+- TP_PROTO(struct spi_master *master),
++ TP_PROTO(struct spi_controller *controller),
+
+- TP_ARGS(master),
++ TP_ARGS(controller),
+
+ TP_STRUCT__entry(
+ __field( int, bus_num )
+ ),
+
+ TP_fast_assign(
+- __entry->bus_num = master->bus_num;
++ __entry->bus_num = controller->bus_num;
+ ),
+
+ TP_printk("spi%d", (int)__entry->bus_num)
+
+ );
+
+-DEFINE_EVENT(spi_master, spi_master_idle,
++DEFINE_EVENT(spi_controller, spi_controller_idle,
+
+- TP_PROTO(struct spi_master *master),
++ TP_PROTO(struct spi_controller *controller),
+
+- TP_ARGS(master)
++ TP_ARGS(controller)
+
+ );
+
+-DEFINE_EVENT(spi_master, spi_master_busy,
++DEFINE_EVENT(spi_controller, spi_controller_busy,
+
+- TP_PROTO(struct spi_master *master),
++ TP_PROTO(struct spi_controller *controller),
+
+- TP_ARGS(master)
++ TP_ARGS(controller)
+
+ );
+
+@@ -54,7 +54,7 @@
+ ),
+
+ TP_fast_assign(
+- __entry->bus_num = msg->spi->master->bus_num;
++ __entry->bus_num = msg->spi->controller->bus_num;
+ __entry->chip_select = msg->spi->chip_select;
+ __entry->msg = msg;
+ ),
+@@ -95,7 +95,7 @@
+ ),
+
+ TP_fast_assign(
+- __entry->bus_num = msg->spi->master->bus_num;
++ __entry->bus_num = msg->spi->controller->bus_num;
+ __entry->chip_select = msg->spi->chip_select;
+ __entry->msg = msg;
+ __entry->frame = msg->frame_length;
+@@ -122,7 +122,7 @@
+ ),
+
+ TP_fast_assign(
+- __entry->bus_num = msg->spi->master->bus_num;
++ __entry->bus_num = msg->spi->controller->bus_num;
+ __entry->chip_select = msg->spi->chip_select;
+ __entry->xfer = xfer;
+ __entry->len = xfer->len;
+--
+1.7.10.4
diff --git a/meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas/0090-spidev-Do-not-automatically-bind-to-MSIOF-spi-may-be.patch b/meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas/0090-spidev-Do-not-automatically-bind-to-MSIOF-spi-may-be.patch
new file mode 100644
index 0000000..de7cc2b
--- /dev/null
+++ b/meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas/0090-spidev-Do-not-automatically-bind-to-MSIOF-spi-may-be.patch
@@ -0,0 +1,26 @@
+From e2fe50b628f660ef35c82b778c5d0c56b5c4487b Mon Sep 17 00:00:00 2001
+From: Andrey Dolnikov <andrey.dolnikov@cogentembedded.com>
+Date: Fri, 12 Jan 2018 18:25:33 +0300
+Subject: [PATCH] spidev: Do not automatically bind to MSIOF spi (may be used
+ as slave).
+
+Signed-off-by: Andrey Dolnikov <andrey.dolnikov@cogentembedded.com>
+---
+ drivers/spi/spidev.c | 1 -
+ 1 file changed, 1 deletion(-)
+
+diff --git a/drivers/spi/spidev.c b/drivers/spi/spidev.c
+index 203d68c..cbd0b93 100644
+--- a/drivers/spi/spidev.c
++++ b/drivers/spi/spidev.c
+@@ -697,7 +697,6 @@ static struct class *spidev_class;
+ static const struct of_device_id spidev_dt_ids[] = {
+ { .compatible = "rohm,dh2228fv" },
+ { .compatible = "lineartechnology,ltc2488" },
+- { .compatible = "renesas,sh-msiof" },
+ { .compatible = "spi-gpio" },
+ {},
+ };
+--
+2.7.4
+
diff --git a/meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas/v3msk.cfg b/meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas/v3msk.cfg
index 34a385b..7dea6e2 100644
--- a/meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas/v3msk.cfg
+++ b/meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas/v3msk.cfg
@@ -32,3 +32,6 @@ CONFIG_TOUCHSCREEN_PROPERTIES=y
CONFIG_HID_MULTITOUCH=y
CONFIG_SERIAL_SH_SCI_DMA=y
CONFIG_UIO=y
+CONFIG_SPI_SLAVE=y
+CONFIG_SPI_SLAVE_TIME=y
+CONFIG_SPI_SLAVE_SYSTEM_CONTROL=y
diff --git a/meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas_4.9.bbappend b/meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas_4.9.bbappend
index f21ad58..f855641 100644
--- a/meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas_4.9.bbappend
+++ b/meta-rcar-gen3-adas/recipes-kernel/linux/linux-renesas_4.9.bbappend
@@ -73,6 +73,14 @@ SRC_URI_append = " \
file://0078-MOST-aim-fix-null-pointer-crash.patch \
file://0079-Revert-dmaengine-rcar-dmac-use-TCRB-instead-of-TCR-f.patch \
file://0082-gpio-pca953x-fix-interrupt-trigger.patch \
+ file://0083-spi-Document-DT-bindings-for-SPI-controllers-in-slav.patch \
+ file://0084-spi-core-Add-support-for-registering-SPI-slave-contr.patch \
+ file://0085-spi-Document-SPI-slave-controller-support.patch \
+ file://0086-spi-sh-msiof-Add-slave-mode-support.patch \
+ file://0087-spi-slave-Add-SPI-slave-handler-reporting-uptime-at-.patch \
+ file://0088-spi-slave-Add-SPI-slave-handler-controlling-system-s.patch \
+ file://0089-spi-Generalize-SPI-master-to-controller.patch \
+ file://0090-spidev-Do-not-automatically-bind-to-MSIOF-spi-may-be.patch \
file://0103-gpu-drm-rcar-du-Extend-VSP1-DRM-interface.patch \
file://0104-media-vsp1-extend-DRM-VSP1-interface.patch \
file://0105-media-rcar-imr-IMR-driver-updates-for-raw-DL.patch \