Linux driver for an emulated SPI device without DT/ACPI info - cross-platform

Question

The vast majority of real SPI devices are platform-specific, and provide some means for automated discovery/enumeration (usually via Device Tree or ACPI). I need to write a kernel module for a dummy SPI device which doesn't have any platform-specific identity, and can be accessed via spidev. I've tried to write the controller driver for it first, but the system won't see it since it doesn't represent any real device (or?).
I've already implemented a dummy I2C device using the i2c-dev driver, but i2c-dev itself provides a discovery mechanism using bus notifier chains, so eventually I was able to add my adapter to the system.
So my question is: what steps should I take to be able to see my dummy SPI device as /dev/spidevB.C?

Answer 1

Here is a skeleton of a driver that creates a dummy SPI controller with some SPIDEV client devices attached to it. It probably needs more work to emulate the transfers properly in the SPI controller, but it seems to be good enough to make the SPIDEV devices appear in the system.
fake-spidev.c
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
#include <linux/version.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/spi/spi.h>
struct fake_spi_controller_platform_data {
u16 num_chipselect;
};
struct fake_spi {
int todo; /* placeholder */
};
static struct platform_device *fake_spi_controller_device;
static int fake_spi_controller_probe_pdata(struct platform_device *pdev,
struct spi_controller *ctlr)
{
struct device *dev = &pdev->dev;
struct fake_spi_controller_platform_data *pdata = dev_get_platdata(dev);
struct fake_spi *fake_spi = spi_controller_get_devdata(ctlr);
ctlr->num_chipselect =
pdata && pdata->num_chipselect ? pdata->num_chipselect : 1;
fake_spi->todo = 42; /* placeholder */
return 0;
}
static int fake_spi_transfer_one(struct spi_controller *ctlr,
struct spi_device *spi,
struct spi_transfer *transfer)
{
spi_finalize_current_transfer(ctlr);
return 0;
}
static int fake_spi_controller_probe(struct platform_device *pdev)
{
int rc;
struct device *dev = &pdev->dev;
struct spi_controller *ctlr;
struct fake_spi *priv;
unsigned int cs;
struct spi_board_info board_info = {
/* Not sure if there is better way to match the spidev driver */
#if LINUX_VERSION_CODE < KERNEL_VERSION(5,15,0)
.modalias = "spidev",
#else
.modalias = "bk4", /* One of the IDs matched by spidev */
#endif
.max_speed_hz = 1000000,
.mode = SPI_MODE_0,
};
ctlr = devm_spi_alloc_master(dev, sizeof(*priv));
if (!ctlr)
return -ENOMEM;
rc = fake_spi_controller_probe_pdata(pdev, ctlr);
if (rc)
return rc;
priv = spi_controller_get_devdata(ctlr);
platform_set_drvdata(pdev, priv);
ctlr->transfer_one = fake_spi_transfer_one;
ctlr->mode_bits = SPI_CPOL | SPI_CPHA;
rc = devm_spi_register_controller(dev, ctlr);
if (rc) {
dev_err(dev, "unable to register SPI controller.\n");
return rc;
}
/* Create SPIDEV devices. */
board_info.bus_num = ctlr->bus_num;
for (cs = 0; cs < ctlr->num_chipselect; cs++) {
struct spi_device *spi;
board_info.chip_select = cs;
spi = spi_new_device(ctlr, &board_info);
if (!spi) {
dev_warn(dev, "failed to create SPI device %u: %s\n",
cs, board_info.modalias);
break;
}
}
return 0;
}
static int fake_spi_controller_remove(struct platform_device *pdev)
{
return 0;
}
static struct platform_driver fake_spi_controller_driver = {
.driver = {
.name = "fake-spi-controller",
},
.remove = fake_spi_controller_remove,
};
static const struct fake_spi_controller_platform_data fake_spi_pdata = {
.num_chipselect = 2,
};
static int __init fake_spidev_init(void)
{
int rc;
fake_spi_controller_device =
platform_create_bundle(&fake_spi_controller_driver,
fake_spi_controller_probe,
NULL, 0,
&fake_spi_pdata, sizeof(fake_spi_pdata));
rc = PTR_ERR_OR_ZERO(fake_spi_controller_device);
if (rc) {
goto fail_create_fake_spi_controller_device;
}
return 0;
fail_create_fake_spi_controller_device:
return rc;
}
static void __exit fake_spidev_exit(void)
{
platform_device_unregister(fake_spi_controller_device);
platform_driver_unregister(&fake_spi_controller_driver);
}
module_init(fake_spidev_init);
module_exit(fake_spidev_exit);
MODULE_LICENSE("GPL");
Makefile
ifneq ($(KERNELRELEASE),)
obj-m += fake-spidev.o
else
# Default to running kernel's build directory if KDIR not set externally
KDIR ?= "/lib/modules/$(shell uname -r)/build"
all:
$(MAKE) -C "$(KDIR)" M="$(CURDIR)" modules
install:
$(MAKE) -C "$(KDIR)" M="$(CURDIR)" modules_install
clean:
$(MAKE) -C "$(KDIR)" M="$(CURDIR)" clean
endif

Answer 2

Here's my own solution :) Unlike Ian's, my driver doesn't pretend to be spidev, but binds to it.
my_spi.c
#include <linux/init.h>
#include <linux/printk.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/errno.h>
#include <linux/uaccess.h>
#include <linux/spi/spi.h>
#include <linux/platform_device.h>
static struct spi_master *master;
static struct spi_device *spi_dev;
static int myspi_transfer_one(struct spi_controller *ctlr, struct spi_device *spi,
struct spi_transfer *transfer)
{
pr_info("%s()\n", __func__);
pr_info(" transfer->len == %u\n", transfer->len);
if (transfer->rx_buf) {
unsigned char * rx_buf = transfer->rx_buf;
const unsigned char * tx_buf = transfer->tx_buf;
int i;
for (i = 0; i < transfer->len; i++)
rx_buf[i] = ~tx_buf[i];
}
spi_finalize_current_transfer(ctlr);
return 0;
}
struct spi_board_info chip = {
.modalias = "my_spi",
};
static int plat_probe(struct platform_device *pdev)
{
int err = 0;
pr_info("%s()\n", __func__);
master = spi_alloc_master(&pdev->dev, 0);
if (master == NULL) {
pr_err("spi_alloc_master failed\n");
return -ENOMEM;
}
master->num_chipselect = 1;
master->transfer_one = myspi_transfer_one;
err = spi_register_master(master);
if (err) {
pr_err("spi_register_master failed\n");
spi_master_put(master);
return err;
}
spi_dev = spi_new_device(master, &chip);
if (!spi_dev)
/* TODO do we need to do anything else? */
err = -ENOMEM;
if (err)
pr_err("spi driver error\n");
else
pr_info("spi driver ok\n");
return err;
}
static int plat_remove(struct platform_device *pdev)
{
pr_info("%s()\n", __func__);
spi_unregister_master(master);
return 0;
}
static struct platform_device * plat_device;
static struct platform_driver plat_driver = {
.driver = {
.name = "my_platform",
.owner = THIS_MODULE,
},
.probe = plat_probe,
.remove = plat_remove,
};
static int __init myspi_init(void)
{
int err = -ENODEV;
plat_device = platform_device_register_simple("my_platform",
PLATFORM_DEVID_NONE, NULL, 0);
if (IS_ERR(plat_device))
return PTR_ERR(plat_device);
err = platform_driver_register(&plat_driver);
if (err)
return err;
if (!err)
pr_info("spi driver loaded\n");
return err;
}
static void __exit myspi_exit(void) {
platform_driver_unregister(&plat_driver);
platform_device_unregister(plat_device);
pr_info("spi driver unloaded\n");
}
module_init(myspi_init);
module_exit(myspi_exit);
MODULE_LICENSE("GPL");
Makefile
obj-m += my_spi.o
all:
make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules
clean:
make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean
Usage:
# modprobe spidev
# insmod my_spi.ko
# echo spidev > /sys/bus/spi/devices/spi0.0/driver_override
# echo spi0.0 > /sys/bus/spi/drivers/spidev/bind
# ls /dev/spi*
/dev/spidev0.0
Testing with spidev_test:
# ./spidev_test -D /dev/spidev0.0 -v -p "12345"
spi mode: 0x0
bits per word: 8
max speed: 500000 Hz (500 kHz)
TX | 31 32 33 34 35 __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ |12345|
RX | CE CD CC CB CA __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ __ |.....|