mirror of
https://github.com/BobTheBlinker/android_kernel_motorola_sm6375.git
synced 2026-10-30 11:41:38 -04:00
Merge branches 'topic/core', 'topic/slave' and 'fix/doc' of git://git.kernel.org/pub/scm/linux/kernel/git/broonie/spi into spi-master
This commit is contained in:
Mark Brown
commit
c94085f587
8 changed files with 564 additions and 68 deletions
|
|
@ -784,6 +784,30 @@ 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
|
||||
|
||||
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.
|
||||
|
||||
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
|
||||
|
|
|
|||
|
|
@ -105,3 +105,7 @@ 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
|
||||
obj-$(CONFIG_SPI_SLAVE_TIME) += spi-slave-time.o
|
||||
obj-$(CONFIG_SPI_SLAVE_SYSTEM_CONTROL) += spi-slave-system-control.o
|
||||
|
|
|
|||
154
drivers/spi/spi-slave-system-control.c
Normal file
154
drivers/spi/spi-slave-system-control.c
Normal file
|
|
@ -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 <[email protected]>");
|
||||
MODULE_DESCRIPTION("SPI slave handler controlling system state");
|
||||
MODULE_LICENSE("GPL v2");
|
||||
129
drivers/spi/spi-slave-time.c
Normal file
129
drivers/spi/spi-slave-time.c
Normal file
|
|
@ -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/clock.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 <[email protected]>");
|
||||
MODULE_DESCRIPTION("SPI slave reporting uptime at previous SPI message");
|
||||
MODULE_LICENSE("GPL v2");
|
||||
|
|
@ -1535,15 +1535,6 @@ static int of_spi_parse_dt(struct spi_master *master, struct spi_device *spi,
|
|||
u32 value;
|
||||
int rc;
|
||||
|
||||
/* 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;
|
||||
|
||||
/* Mode (clock phase/polarity/etc.) */
|
||||
if (of_find_property(nc, "spi-cpha", NULL))
|
||||
spi->mode |= SPI_CPHA;
|
||||
|
|
@ -1593,6 +1584,24 @@ static int of_spi_parse_dt(struct spi_master *master, struct spi_device *spi,
|
|||
}
|
||||
}
|
||||
|
||||
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) {
|
||||
|
|
@ -1658,8 +1667,8 @@ err_out:
|
|||
* 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)
|
||||
{
|
||||
|
|
@ -1828,28 +1837,129 @@ static struct class spi_master_class = {
|
|||
.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;
|
||||
|
||||
|
|
@ -1863,14 +1973,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)
|
||||
|
|
@ -1946,9 +2060,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
|
||||
|
|
@ -1985,8 +2101,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)
|
||||
|
|
@ -2021,7 +2138,7 @@ static void devm_spi_unregister(struct device *dev, void *res)
|
|||
}
|
||||
|
||||
/**
|
||||
* dev_spi_register_master - register managed SPI master controller
|
||||
* devm_spi_register_master - register managed SPI master controller
|
||||
* @dev: device managing SPI master
|
||||
* @master: initialized master, originally from spi_alloc_master()
|
||||
* Context: can sleep
|
||||
|
|
@ -3159,6 +3276,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;
|
||||
|
||||
|
|
@ -3240,6 +3360,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;
|
||||
|
||||
|
|
@ -3312,6 +3435,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))
|
||||
|
|
@ -3319,6 +3448,8 @@ static int __init spi_init(void)
|
|||
|
||||
return 0;
|
||||
|
||||
err3:
|
||||
class_unregister(&spi_master_class);
|
||||
err2:
|
||||
bus_unregister(&spi_bus_type);
|
||||
err1:
|
||||
|
|
|
|||
Loading…
Reference in a new issue