linux SPI驱动——spidev之driver（六）

一： spidev_init注册spidev

static int __init spidev_init(void)
{
    int status;

    /* Claim our 256 reserved device numbers.  Then register a class
     * that will key udev/mdev to add/remove /dev nodes.  Last, register
     * the driver which manages those device numbers.
     */
    BUILD_BUG_ON(N_SPI_MINORS > 256);
    /* 注册spi字符设备 */
    status = register_chrdev(SPIDEV_MAJOR, "spi", &spidev_fops);
    if (status < 0) {
        return status;
    }
    /* 为该设备创建一个class spidev */
    spidev_class = class_create(THIS_MODULE, "spidev");
    if (IS_ERR(spidev_class)) {
        unregister_chrdev(SPIDEV_MAJOR, spidev_spi_driver.driver.name);
        return PTR_ERR(spidev_class);
    }
    /* register匹配到device ,最终调用prob函数 */
    status = spi_register_driver(&spidev_spi_driver);
    if (status < 0) {
        class_destroy(spidev_class);
        unregister_chrdev(SPIDEV_MAJOR, spidev_spi_driver.driver.name);
    }
    return status;
}
module_init(spidev_init);

static void __exit spidev_exit(void)
{
    spi_unregister_driver(&spidev_spi_driver);
    class_destroy(spidev_class);
    unregister_chrdev(SPIDEV_MAJOR, spidev_spi_driver.driver.name);
}
module_exit(spidev_exit);

MODULE_AUTHOR("Andrea Paterniani, <a.paterniani@swapp-eng.it>");
MODULE_DESCRIPTION("User mode SPI device interface");
MODULE_LICENSE("GPL");
MODULE_ALIAS("spi:spidev");

总结：

       1)注册一个字符设备，cat /proc/device 会查看到“153 spi”主设备号位153的设备

       2) 创建一个class spidev ，”/sys/class/spidev/”

       3) spi_register_driver 注册spi driver。

二：spidev_probe 函数

static int __devinit spidev_probe(struct spi_device *spi)
{
    struct spidev_data    *spidev;
    int            status;
    unsigned long        minor;

    /* Allocate driver data */
    spidev = kzalloc(sizeof(*spidev), GFP_KERNEL);
    if (!spidev)
        return -ENOMEM;

    /* Initialize the driver data */
    spidev->spi = spi;
    spin_lock_init(&spidev->spi_lock);
    mutex_init(&spidev->buf_lock);

    INIT_LIST_HEAD(&spidev->device_entry);

    /* If we can allocate a minor number, hook up this device.
     * Reusing minors is fine so long as udev or mdev is working.
     */
    mutex_lock(&device_list_lock);

    minor = find_first_zero_bit(minors, N_SPI_MINORS);
    if (minor < N_SPI_MINORS) {
        struct device *dev;

        spidev->devt = MKDEV(SPIDEV_MAJOR, minor);
        dev = device_create(spidev_class, &spi->dev, spidev->devt,
                    spidev, "spidev%d.%d",
                    spi->master->bus_num, spi->chip_select);
        status = IS_ERR(dev) ? PTR_ERR(dev) : 0;
    } else {
        dev_dbg(&spi->dev, "no minor number available!
");
        status = -ENODEV;
    }
    if (status == 0) {
        set_bit(minor, minors);
        list_add(&spidev->device_entry, &device_list);
    }

    mutex_unlock(&device_list_lock);

    if (status == 0)
        spi_set_drvdata(spi, spidev);
    else
        kfree(spidev);

    return status;
}

总结： 1. spidev_prob函数很简单，调用device_create创界字符设备的结点名为"spidev%d.%d" 2. 将spidev作为spi->dev->p->driver_data 的data

三：spidev_probe 函数是如何被调用的，以及什么时候被调用的追踪 status = spi_register_driver(&spidev_spi_driver)调用

int spi_register_driver(struct spi_driver *sdrv)
{
    sdrv->driver.bus = &spi_bus_type;
    if (sdrv->probe)
        sdrv->driver.probe = spi_drv_probe;
    if (sdrv->remove)
        sdrv->driver.remove = spi_drv_remove;
    if (sdrv->shutdown)
        sdrv->driver.shutdown = spi_drv_shutdown;
    return driver_register(&sdrv->driver);
}

//sdrv->driver.probe = spi_drv_probe; 函数

static int spi_drv_probe(struct device *dev)
{
    const struct spi_driver        *sdrv = to_spi_driver(dev->driver);

    return sdrv->probe(to_spi_device(dev));
}

可以看出调用spi_drv_prob就是调用sdrv->probe，即spidev_probe 函数

2）追踪driver_register(&sdrv->driver);

int driver_register(struct device_driver *drv)
{
    int ret;
    struct device_driver *other;

    BUG_ON(!drv->bus->p);

    if ((drv->bus->probe && drv->probe) ||
        (drv->bus->remove && drv->remove) ||
        (drv->bus->shutdown && drv->shutdown))
        printk(KERN_WARNING "Driver '%s' needs updating - please use "
            "bus_type methods
", drv->name);

    other = driver_find(drv->name, drv->bus);
    if (other) {
        put_driver(other);
        printk(KERN_ERR "Error: Driver '%s' is already registered, "
            "aborting...
", drv->name);
        return -EBUSY;
    }

    ret = bus_add_driver(drv);
    if (ret)
        return ret;
    ret = driver_add_groups(drv, drv->groups);
    if (ret)
        bus_remove_driver(drv);
    return ret;
}

查看bus_add_driver(drv)函数调用，有一段代码

1: if (drv->bus->p->drivers_autoprobe) {

2:       error = driver_attach(drv);

3:       if (error) 4: goto out_unregister;

5: }

再看一下driver_attach函数

int driver_attach(struct device_driver *drv)
{
    return bus_for_each_dev(drv->bus, NULL, drv, __driver_attach);
}

 

int bus_for_each_dev(struct bus_type *bus, struct device *start,
             void *data, int (*fn)(struct device *, void *))
{
    struct klist_iter i;
    struct device *dev;
    int error = 0;

    if (!bus)
        return -EINVAL;

    klist_iter_init_node(&bus->p->klist_devices, &i,
                 (start ? &start->p->knode_bus : NULL));
    while ((dev = next_device(&i)) && !error)
        error = fn(dev, data);
    klist_iter_exit(&i);
    return error;
}

从上面两段代码可以看出bus_for_each_dev会遍历总线上所有设备并设用__driver_attach。我们再看一下__driver_attach所做的工作：

1.driver_match_device(drv, dev)；device与driver name时候strncmp

2.driver_probe_device(drv, dev); 函数调用prob

static int __driver_attach(struct device *dev, void *data)
{
    struct device_driver *drv = data;


    if (!driver_match_device(drv, dev))
        return 0;

    if (dev->parent)    /* Needed for USB */
        device_lock(dev->parent);
    device_lock(dev);
    if (!dev->driver)
        driver_probe_device(drv, dev);
    device_unlock(dev);
    if (dev->parent)
        device_unlock(dev->parent);

    return 0;
}

我们再继续查看一下driver_probe_device函数的调用：

   1:  int driver_probe_device(struct device_driver *drv, struct device *dev)

   2:  {

   3:      int ret = 0;

   4:   

   5:      if (!device_is_registered(dev))

   6:          return -ENODEV;

   7:   

   8:      pr_debug("bus: '%s': %s: matched device %s with driver %s
",

   9:           drv->bus->name, __func__, dev_name(dev), drv->name);

  10:   

  11:      pm_runtime_get_noresume(dev);

  12:      pm_runtime_barrier(dev);

  13:      

ret = really_probe(dev, drv);

  14:      pm_runtime_put_sync(dev);

  15:   

  16:      return ret;

  17:  }

 

总结 : 通过代码最终我们最终看到了spidev_prob函数是怎样被调用的