linux spi 驱动

linux 5.15 armv8-a64

本文主要讲述spi 驱动的master和slave的初始化过程，linux中抽象spi master为spi_controler，spi slave 为spi_device，其中spi_controler实质是platform device，理解spi需要先从platform开始。

platform bus的由来

linux最基本的驱动的模型是设备device，驱动driver，bus总线。device是对物理设备的抽象，总线会枚举设备，并连接设备与驱动。CPU一般通过特定的总线访问设备，比如usb总线，这些总线会发现并通知system 该bus所连接的设备，但有一类设备不是特殊的总线连接到system也没有办法让system知道自己的存在，例如spi controler cpu可以直接访问它的寄存器，但是他不会枚举自己，这种设备就满足不了linux标准驱动模型。为了用标准驱动模型来抽象这类设备，linux引入了platform bus(virtual bus)利用这个软件虚拟bus实现这类设备的枚举和驱动的连接，linux Document解释如下。

Platform devices are devices that typically appear as autonomous entities
in the system. This includes legacy port-based devices and host bridges
to peripheral buses, and most controllers integrated into system-on-chip
platforms. What they usually have in common is direct addressing from
a CPU bus. Rarely, a platform_device will be connected through a segment
of some other kind of bus; but its registers will still be directly addressable.

spi controler的初始化过程

platform bus 初始化在start_kernel的最后kernel_init线程中

start_kernel --> rest_init --> kernel_init --> kernel_init_freeable --> do_basic_setup --> driver_init --> platform_bus_init

int __init platform_bus_init(void)
{
        int error;

        early_platform_cleanup();

        error = device_register(&platform_bus);
        if (error) {
                put_device(&platform_bus);
                return error;
        }
        error =  bus_register(&platform_bus_type);
        if (error)
                device_unregister(&platform_bus);
        of_platform_register_reconfig_notifier();
        return error;
}
"platform.c" 1524 lines --99%--

do_basic_setup --> do_initcalls（driver_init之后）

arch_initcall_sync(of_platform_default_populate_init);

/**
 * of_platform_populate() - Populate platform_devices from device tree data
 * @root: parent of the first level to probe or NULL for the root of the tree
 * @matches: match table, NULL to use the default
 * @lookup: auxdata table for matching id and platform_data with device nodes
 * @parent: parent to hook devices from, NULL for toplevel
 *
 * Similar to of_platform_bus_probe(), this function walks the device tree
 * and creates devices from nodes.  It differs in that it follows the modern
 * convention of requiring all device nodes to have a 'compatible' property,
 * and it is suitable for creating devices which are children of the root
 * node (of_platform_bus_probe will only create children of the root which
 * are selected by the @matches argument).
 *
 * New board support should be using this function instead of
 * of_platform_bus_probe().
 *
 * Return: 0 on success, < 0 on failure.
 */
int of_platform_populate(struct device_node *root,
            const struct of_device_id *matches,
            const struct of_dev_auxdata *lookup,
            struct device *parent)

matches参数of_default_bus_match_table

of_platform_populate(root, of_default_bus_match_table, lookup, parent);
const struct of_device_id of_default_bus_match_table[] = {
    { .compatible = "simple-bus", },
    { .compatible = "simple-mfd", },
    { .compatible = "isa", },
#ifdef CONFIG_ARM_AMBA
    { .compatible = "arm,amba-bus", },
#endif /* CONFIG_ARM_AMBA */
    {} /* Empty terminated list */
};

/** 
* of_platform_bus_create() - Create a device for a node and its children. 
* @bus: device node of the bus to instantiate 
* @matches: match table for bus nodes 
* @lookup: auxdata table for matching id and platform_data with device nodes 
* @parent: parent for new device, or NULL for top level. 
* @strict: require compatible property 
*
* Creates a platform_device for the provided device_node, and optionally 
* recursively create devices for all the child nodes. */

static int of_platform_bus_create(structdevice_node*bus,
                  conststructof_device_id*matches,
                  conststructof_dev_auxdata*lookup,
                  structdevice*parent,boolstrict);

/**
 * of_platform_device_create_pdata - Alloc, initialize and register an of_device
 * @np: pointer to node to create device for
 * @bus_id: name to assign device
 * @platform_data: pointer to populate platform_data pointer with
 * @parent: Linux device model parent device.
 *
 * Return: Pointer to created platform device, or NULL if a device was not
 * registered.  Unavailable devices will not get registered.
 */
static struct platform_device *of_platform_device_create_pdata(
                    struct device_node *np,
                    const char *bus_id,
                    void *platform_data,
                    struct device *parent)
{
    struct platform_device *dev;

    if (!of_device_is_available(np) ||
        of_node_test_and_set_flag(np, OF_POPULATED))
        return NULL;

    dev = of_device_alloc(np, bus_id, parent);
    if (!dev)
        goto err_clear_flag;

    dev->dev.coherent_dma_mask = DMA_BIT_MASK(32);
    if (!dev->dev.dma_mask)
        dev->dev.dma_mask = &dev->dev.coherent_dma_mask;
    dev->dev.bus = &platform_bus_type;
    dev->dev.platform_data = platform_data;
    of_msi_configure(&dev->dev, dev->dev.of_node);

    if (of_device_add(dev) != 0) {
        platform_device_put(dev);
        goto err_clear_flag;
    }

    return dev;

err_clear_flag:
    of_node_clear_flag(np, OF_POPULATED);
    return NULL;
}

of_platform_bus_create --> of_platform_device_create_pdata 创建paltform_device

例如qcom 的sm8250.dtsi 中soc 节点的compatible属性simple-bus，of_platform_bus_create函数递归的将compatible属性为simple-bus的节点以及其一级子节点都创建为platform device，spi controler spi14同理。

        soc: soc@0 {
                #address-cells = <2>;
                #size-cells = <2>;
                ranges = <0 0 0 0 0x10 0>;
                dma-ranges = <0 0 0 0 0x10 0>;
                compatible = "simple-bus";
                 spi14: spi@880000 {
                                compatible = "qcom,geni-spi";
                                reg = <0 0x00880000 0 0x4000>;
                                status = "disabled";
                        };

                        i2c15: i2c@884000 {
                                compatible = "qcom,geni-i2c";
                                reg = <0 0x00884000 0 0x4000>;
                       };
              };
                                                                                
                                                                                

platform bus he platform device ready后，只缺platform driver

module_platform_driver(spi_geni_driver);

do_initcalls --> module_init --> platform_driver_register --> driver_register --> bus_add_driver

--> driver_attatch --> __driver_attatch --> driver_probe_device

spi controler的probe方法在注册platform driver的时候被调用

当然在driver_probe_device之前有一个driver与device match的过程，使用的driver->bus的match 方法

static inline int driver_match_device(struct device_driver *drv,
                      struct device *dev)
{
    return drv->bus->match ? drv->bus->match(dev, drv) : 1;
}

spi slave的初始化过程

postcore_initcall(spi_init);

do_basic_setup --> do_initcalls --> postcore_initcall

spi_init过程会register spi bus

struct bus_type spi_bus_type = {
        .name           = "spi",
        .dev_groups     = spi_dev_groups,
        .match          = spi_match_device,
        .uevent         = spi_uevent,
        .probe          = spi_probe,
        .remove         = spi_remove,
        .shutdown       = spi_shutdown,
};
EXPORT_SYMBOL_GPL(spi_bus_type);

spi slave在dts中需要以spi controler节点的子节点存在如下

&main_spi0 {
        pinctrl-names = "default";
        pinctrl-0 = <&main_spi0_pins_default>;
        ti,pindir-d0-out-d1-in;
        eeprom@0 {
                compatible = "microchip,93lc46b";
                reg = <0>;
                spi-max-frequency = <1000000>;
                spi-cs-high;
                data-size = <16>;
        };
};

spi controler的子节点是怎样被创建成device的呢

spi controler的probe方法中又调用spi_register_master --> of_register_spi_devices --> spi_add_device，of_register_spi_devices会遍历spi controler的子节点然后创建为spi_device

/**
 * of_register_spi_devices() - Register child devices onto the SPI bus
 * @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_controller *ctlr)
{
        struct spi_device *spi;
        struct device_node *nc;

        if (!ctlr->dev.of_node)
                return;

        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(ctlr, nc);
                if (IS_ERR(spi)) {
                        dev_warn(&ctlr->dev,
                                 "Failed to create SPI device for %pOF\n", nc);
                        of_node_clear_flag(nc, OF_POPULATED);
                }
        }
}

spi slave的driver代码如下 module_spi_driver --> module_init --> spi_driver_register --> driver_register

spi_driver_register 设置sdrv->bus = spi_bus_type，后面的driver_register到spi slave probe方法被调用的过程与platform driver的过程类似

static struct spi_driver eeprom_93xx46_driver = {
        .driver = {
                .name   = "93xx46",
                .of_match_table = of_match_ptr(eeprom_93xx46_of_table),
        },
        .probe          = eeprom_93xx46_probe,
        .remove         = eeprom_93xx46_remove,
        .id_table       = eeprom_93xx46_spi_ids,
};

module_spi_driver(eeprom_93xx46_driver);

至此controler slave 与spi bus 都已经准备完成