Chinaunix首页 | 论坛 | 博客
  • 博客访问: 386836
  • 博文数量: 380
  • 博客积分: 75
  • 博客等级: 民兵
  • 技术积分: 1925
  • 用 户 组: 普通用户
  • 注册时间: 2011-09-05 15:35
文章分类

全部博文(380)

文章存档

2014年(1)

2013年(2)

2012年(19)

2011年(358)

我的朋友

分类:

2011-12-30 22:11:01

原文地址:Linux下SPI驱动分析 作者:protheschildren

Linux下SPI总线驱动有通用接口,一般的SPI设备驱动使用这个驱动接口实现设备驱动。分析驱动最好是先了解核心代码,然后从具体设备分析入手,然后从下至上,了解整个框架,再从上到下分析,理解透彻。
以下分析内核根目录均以"src"代替。内核代码,版本2.6.37.2。
SPI的核心代码即
"src/drivers/spi/spi.c"——SPI 初始化和核心代码

"src/drivers/spi/spi_gpio.c"——IO模拟SPI接口代码
头文件:
"src/include/linux/spi/spi.h"
"src/include/linux/spi/spi_gpio.h"
"src/include/linux/spi/spi_bitbang.h"
 首先,先看核心代码。
 一步步来,先分析代码,然后看了具体驱动再回过头来看这个核心代码。
 spi.c

--------------------------------------------------------------------------------
       /* 这个函数是驱动模块卸载时使用 */
  32static void spidev_release(struct device *dev)
  33{
            /* 标准设备结构体转换成SPI设备结构体
             * 调用container_of函数获取dev设备所在的SPI设备结构体指针
             */
  34        struct spi_device       *spi = to_spi_device(dev);
  35
  36        /* spi masters may cleanup for released devices */
            /* 清空SPI主机申请的内存 */
  37        if (spi->master->cleanup)
  38                spi->master->cleanup(spi);
  39
            /* 减调用次数 */
  40        spi_master_put(spi->master);
            /* 释放SPI设备节点内存 */
  41        kfree(spi);
  42}
  43
      /* 打印模块别名 */
  44static ssize_t
  45modalias_show(struct device *dev, struct device_attribute *a, char *buf)
  46{
  47        const struct spi_device *spi = to_spi_device(dev);
  48
  49        return sprintf(buf, "%s\n", spi->modalias);
  50}
  51

/* 设置SPI总线属性——名称/显示 */
  52static struct device_attribute spi_dev_attrs[] = {
  53        __ATTR_RO(modalias),
  54        __ATTR_NULL,
  55};
56
      /* 获取设备ID */
  57/* modalias support makes "modprobe $MODALIAS" new-style hotplug work,
  58 * and the sysfs version makes coldplug work too.
  59 */
  60
  61static const struct spi_device_id *spi_match_id(const struct spi_device_id *id,
  62                                                const struct spi_device *sdev)
  63{
            /* 判断设备中名称与模块别名相同,则返回该设备ID */
  64        while (id->name[0]) {
  65                if (!strcmp(sdev->modalias, id->name))
  66                        return id;
  67                id++;
  68        }
  69        return NULL;
  70}
  71
    /* 返回设备ID */
  72const struct spi_device_id *spi_get_device_id(const struct spi_device *sdev)
  73{
  74        const struct spi_driver *sdrv = to_spi_driver(sdev->dev.driver);
  75
  76        return spi_match_id(sdrv->id_table, sdev);
  77}
  78EXPORT_SYMBOL_GPL(spi_get_device_id);

接上一个继续看spi.c。
-------------------------------
匹配设备    /* 名词解释of: OpenFirmware
     * 调用层次spi_match_device-->of_driver_match_device-->of_match_device-->
     * of_match_node
     * 用于驱动程序检查platform_device是否在其支持列表里
     */
  80static int spi_match_device(struct device *dev, struct device_driver *drv)
  81{
  82        const struct spi_device *spi = to_spi_device(dev);
  83        const struct spi_driver *sdrv = to_spi_driver(drv);
  84
  85        /* Attempt an OF style match */
            /* 不匹配返回0;匹配返回非0,指向struct of_device_id类型的指针
             * dev:需要查找的设备; drv:驱动程序结构体
             */
  86        if (of_driver_match_device(dev, drv))
  87                return 1;
  88
            /* 在驱动查找设备ID,找到返回真,否则假  */
  89        if (sdrv->id_table)
  90                return !!spi_match_id(sdrv->id_table, spi);
  91
            /* 比较设备别名和驱动名称,匹配返回真 */
  92        return strcmp(spi->modalias, drv->name) == 0;
  93}
  94
-------------------------------
uevent    /* struct kobj_uevent_env 是内核用户空间的一个环境参数
     * uevent是sysfs向用户空间发出的消息,这里实际上添加的是一串字符串消息。
     * 关于uevent参考:http://blog.csdn.net/walkingman321/archive/2010/10/01/5917737.aspx
     */
  95static int spi_uevent(struct device *dev, struct kobj_uevent_env *env)
  96{
  97        const struct spi_device         *spi = to_spi_device(dev);
  98
  99        add_uevent_var(env, "MODALIAS=%s%s", SPI_MODULE_PREFIX, spi->modalias);
 100        return 0;
 101}
-------------------------------
电源管理   /* 配置了电源管理
    * 现在不清楚suspend和resume函数哪里实现,等找到了再说
    */
103#ifdef  CONFIG_PM
 104
    /* 挂起
     */
 105static int spi_suspend(struct device *dev, pm_message_t message)
 106{
 107        int                     value = 0;
 108        struct spi_driver       *drv = to_spi_driver(dev->driver);
 109
 110        /* suspend will stop irqs and dma; no more i/o */
            /* 挂起将定制终端和DMA,没有输入输出 */
 111        if (drv) {
                    /* 驱动实现了挂起操作函数 */
 112                if (drv->suspend)
 113                        value = drv->suspend(to_spi_device(dev), message);
 114                else
 115                        dev_dbg(dev, "... can't suspend\n");
 116        }
 117        return value;
 118}
 119
    /* 恢复
     */
 120static int spi_resume(struct device *dev)
 121{
 122        int                     value = 0;
 123        struct spi_driver       *drv = to_spi_driver(dev->driver);
 124
 125        /* resume may restart the i/o queue */
            /* 重新开始输入输出队列 */
 126        if (drv) {
 127                if (drv->resume)
 128                        value = drv->resume(to_spi_device(dev));
 129                else
 130                        dev_dbg(dev, "... can't resume\n");
 131        }
 132        return value;
 133}
 134
 135#else /* 没有电源管理 */
 136#define spi_suspend     NULL
 137#define spi_resume      NULL
 138#endif
-------------------------------
总线    /* 总线 参考:http://hi.baidu.com/xingzuzi/blog/item/d12c03f473b3c2a0a50f5260.html
     */
 140struct bus_type spi_bus_type = {
 141        .name           = "spi",
 142        .dev_attrs      = spi_dev_attrs,
 143        .match          = spi_match_device,
 144        .uevent         = spi_uevent,
 145        .suspend        = spi_suspend,
 146        .resume         = spi_resume,
 147};
 148EXPORT_SYMBOL_GPL(spi_bus_type);
-------------------------------
驱动注册、删除    /* 驱动注册
     */
 151static int spi_drv_probe(struct device *dev)
 152{
 153        const struct spi_driver         *sdrv = to_spi_driver(dev->driver);
 154
 155        return sdrv->probe(to_spi_device(dev));
 156}
 157
    /* 驱动删除
     */
 158static int spi_drv_remove(struct device *dev)
 159{
 160        const struct spi_driver         *sdrv = to_spi_driver(dev->driver);
 161
 162        return sdrv->remove(to_spi_device(dev));
 163}
 164
    /* 关闭
     */
 165static void spi_drv_shutdown(struct device *dev)
 166{
 167        const struct spi_driver         *sdrv = to_spi_driver(dev->driver);
 168
 169        sdrv->shutdown(to_spi_device(dev));
 170}
-------------------------------
注册SPI总线驱动    /* 注册SPI驱动
     */
 172/**
 173 * spi_register_driver - register a SPI driver
 174 * @sdrv: the driver to register
 175 * Context: can sleep
 176 */
 177int spi_register_driver(struct spi_driver *sdrv)
 178{
            /* 初始化总线结构体 */
 179        sdrv->driver.bus = &spi_bus_type;
            /* 初始化驱动相关函数 */
 180        if (sdrv->probe)
 181                sdrv->driver.probe = spi_drv_probe;
 182        if (sdrv->remove)
 183                sdrv->driver.remove = spi_drv_remove;
 184        if (sdrv->shutdown)
 185                sdrv->driver.shutdown = spi_drv_shutdown;
            /* 驱动注册
             * 添加驱动到总线
             * sysfs、uevent等创建、初始化
             */
 186        return driver_register(&sdrv->driver);
 187}
 188EXPORT_SYMBOL_GPL(spi_register_driver);
 
接下去看spi.c
特殊的板级相关设备添加方法    /* 神奇的分割线 */
 190/*-------------------------------------------------------------------------*/
 191
 192/* SPI devices should normally not be created by SPI device drivers; that
 193 * would make them board-specific.  Similarly with SPI master drivers.
 194 * Device registration normally goes into like arch/.../mach.../board-YYY.c
 195 * with other readonly (flashable) information about mainboard devices.
 196 */
 197
    /* 板级相关信息链表 */
 198struct boardinfo {
 199        struct list_head        list;
 200        struct spi_board_info   board_info;
 201};
 202
 203static LIST_HEAD(board_list);
 204static LIST_HEAD(spi_master_list);
 206/*
 207 * Used to protect add/del opertion for board_info list and
 208 * spi_master list, and their matching process
 209 */
    /* 链表操作锁 */
 210static DEFINE_MUTEX(board_lock);
 211
 212/**
 213 * spi_alloc_device - Allocate a new SPI device
 214 * @master: Controller to which device is connected
 215 * Context: can sleep
 216 *
 217 * Allows a driver to allocate and initialize a spi_device without
 218 * registering it immediately.  This allows a driver to directly
 219 * fill the spi_device with device parameters before calling
 220 * spi_add_device() on it.
 221 *
 222 * Caller is responsible to call spi_add_device() on the returned
 223 * spi_device structure to add it to the SPI master.  If the caller
 224 * needs to discard the spi_device without adding it, then it should
 225 * call spi_dev_put() on it.
 226 *
 227 * Returns a pointer to the new device, or NULL.
 228 */
    /* 为申请SPI设备结构体空间而不注册设备,必须调用spi_add_device,如要丢弃这个设备
     * 则必须调用spi_dev_put
     */
 229struct spi_device *spi_alloc_device(struct spi_master *master)
 230{
 231        struct spi_device       *spi;
 232        struct device           *dev = master->dev.parent;
 233
            /* 增加设备引用次数,相反操作spi_master_put */
 234        if (!spi_master_get(master))
 235                return NULL;
 236
            /* 申请内核空间内存 */
 237        spi = kzalloc(sizeof *spi, GFP_KERNEL);
 238        if (!spi) {
 239                dev_err(dev, "cannot alloc spi_device\n");
 240                spi_master_put(master);
 241                return NULL;
 242        }
 243
            /* SPI主机控制结构体 */
 244        spi->master = master;
            /* 设备 */
 245        spi->dev.parent = dev;
            /* 总线 */
 246        spi->dev.bus = &spi_bus_type;
            /* 删除方法 */
 247        spi->dev.release = spidev_release;
            /* 设备初始化
             * 初始化kobject,dma池链表,设备互斥锁,自旋锁,设备对象的电源相关部分
             * src/drivers/base/core.c
             */
 248        device_initialize(&spi->dev);
            /* 返回spi设备结构体指针 */
 249        return spi;
 250}
 251EXPORT_SYMBOL_GPL(spi_alloc_device);
 252
 253/**
 254 * spi_add_device - Add spi_device allocated with spi_alloc_device
 255 * @spi: spi_device to register
 256 *
 257 * Companion function to spi_alloc_device.  Devices allocated with
 258 * spi_alloc_device can be added onto the spi bus with this function.
 259 *
 260 * Returns 0 on success; negative errno on failure
 261 */
    /* 与spi_alloc_device配合使用,将设备结构体添加到SPI总线 */
 262int spi_add_device(struct spi_device *spi)
 263{
 264        static DEFINE_MUTEX(spi_add_lock);
 265        struct device *dev = spi->master->dev.parent;
 266        struct device *d;
 267        int status;
 268
 269        /* Chipselects are numbered 0..max; validate. */
            /* 设备片选编号比SPI主控制器的片选大,出错 */
 270        if (spi->chip_select >= spi->master->num_chipselect) {
 271                dev_err(dev, "cs%d >= max %d\n",
 272                        spi->chip_select,
 273                        spi->master->num_chipselect);
 274                return -EINVAL;
 275        }
 276
 277        /* Set the bus ID string */
            /* 设置设备名称,调用kobject的设置设备名称参数方法 */
 278        dev_set_name(&spi->dev, "%s.%u", dev_name(&spi->master->dev),
 279                        spi->chip_select);
 280
 281
 282        /* We need to make sure there's no other device with this
 283         * chipselect **BEFORE** we call setup(), else we'll trash
 284         * its configuration.  Lock against concurrent add() calls.
 285         */
            /* 互斥锁,保证设置时,没有其他设备用这个片选,防止并发添加add() */
 286        mutex_lock(&spi_add_lock);
 287
            /* 按照名称字符查找设备结构体,设备名称由dev_name查找kobject返回
             * 能够找到说明设备已经在用
             */
 288        d = bus_find_device_by_name(&spi_bus_type, NULL, dev_name(&spi->dev));
 289        if (d != NULL) {
 290                dev_err(dev, "chipselect %d already in use\n",
 291                                spi->chip_select);
 292                put_device(d);
 293                status = -EBUSY;
 294                goto done;
 295        }
 296
 297        /* Drivers may modify this initial i/o setup, but will
 298         * normally rely on the device being setup.  Devices
 299         * using SPI_CS_HIGH can't coexist well otherwise...
 300         */
            /*
            /* 设置SPI模式和时钟频率
             * 驱动可以初始化IO,当设备被设置的时候
             * 取消片选没有用
             * 详细见后面驱动核心方法spi_setup解析
             */
 301        status = spi_setup(spi);
 302        if (status < 0) {
 303                dev_err(dev, "can't setup %s, status %d\n",
 304                                dev_name(&spi->dev), status);
 305                goto done;
 306        }
 307
 308        /* Device may be bound to an active driver when this returns */
            /* 将设备添加到驱动层次结构,添加到kobject层次结构,添加到其他子系统 */
 309        status = device_add(&spi->dev);
 310        if (status < 0)
 311                dev_err(dev, "can't add %s, status %d\n",
 312                                dev_name(&spi->dev), status);
 313        else
 314                dev_dbg(dev, "registered child %s\n", dev_name(&spi->dev));
 315
 316done:
 317        mutex_unlock(&spi_add_lock);
 318        return status;
 319}
 320EXPORT_SYMBOL_GPL(spi_add_device);
 321
 322/**
 323 * spi_new_device - instantiate one new SPI device
 324 * @master: Controller to which device is connected
 325 * @chip: Describes the SPI device
 326 * Context: can sleep
 327 *
 328 * On typical mainboards, this is purely internal; and it's not needed
 329 * after board init creates the hard-wired devices.  Some development
 330 * platforms may not be able to use spi_register_board_info though, and
 331 * this is exported so that for example a USB or parport based adapter
 332 * driver could add devices (which it would learn about out-of-band).
 333 *
 334 * Returns the new device, or NULL.
 335 */
    /* 有些开发平台可能不能通过spi_register_board_info添加设备
     * 这个用来让一些比如基于USB适配的驱动添加设备
     */
 336struct spi_device *spi_new_device(struct spi_master *master,
 337                                  struct spi_board_info *chip)
 338{
 339        struct spi_device       *proxy;
 340        int                     status;
 341
 342        /* NOTE:  caller did any chip->bus_num checks necessary.
 343         *
 344         * Also, unless we change the return value convention to use
 345         * error-or-pointer (not NULL-or-pointer), troubleshootability
 346         * suggests syslogged diagnostics are best here (ugh).
 347         */
 348
            /* 分配设备结构体内存空间,并初始化 */
 349        proxy = spi_alloc_device(master);
 350        if (!proxy)
 351                return NULL;
 352
 353        WARN_ON(strlen(chip->modalias) >= sizeof(proxy->modalias));
 354
 355        proxy->chip_select = chip->chip_select;
 356        proxy->max_speed_hz = chip->max_speed_hz;
 357        proxy->mode = chip->mode;
 358        proxy->irq = chip->irq;
 359        strlcpy(proxy->modalias, chip->modalias, sizeof(proxy->modalias));
 360        proxy->dev.platform_data = (void *) chip->platform_data;
 361        proxy->controller_data = chip->controller_data;
 362        proxy->controller_state = NULL;
 363
            /* 添加设备 */
 364        status = spi_add_device(proxy);
 365        if (status < 0) {
 366                spi_dev_put(proxy);
 367                return NULL;
 368        }
 369
 370        return proxy;
 371}
 372EXPORT_SYMBOL_GPL(spi_new_device);
 373
    /* 使用主控制类和板级信息匹配则添加一个新设备 */
 374static void spi_match_master_to_boardinfo(struct spi_master *master,
 375                                struct spi_board_info *bi)
 376{
 377        struct spi_device *dev;
 378
 379        if (master->bus_num != bi->bus_num)
 380                return;
 381
 382        dev = spi_new_device(master, bi);
 383        if (!dev)
 384                dev_err(master->dev.parent, "can't create new device for %s\n",
 385                        bi->modalias);
 386}
 387
 388/**
 389 * spi_register_board_info - register SPI devices for a given board
 390 * @info: array of chip descriptors
 391 * @n: how many descriptors are provided
 392 * Context: can sleep
 393 *
 394 * Board-specific early init code calls this (probably during arch_initcall)
 395 * with segments of the SPI device table.  Any device nodes are created later,
 396 * after the relevant parent SPI controller (bus_num) is defined.  We keep
 397 * this table of devices forever, so that reloading a controller driver will
 398 * not make Linux forget about these hard-wired devices.
 399 *
 400 * Other code can also call this, e.g. a particular add-on board might provide
 401 * SPI devices through its expansion connector, so code initializing that board
 402 * would naturally declare its SPI devices.
 403 *
 404 * The board info passed can safely be __initdata ... but be careful of
 405 * any embedded pointers (platform_data, etc), they're copied as-is.
 406 */
    /* 使用一系列板级描述信息初始化设备 */
 407int __init
 408spi_register_board_info(struct spi_board_info const *info, unsigned n)
 409{
 410        struct boardinfo *bi;
 411        int i;
 412
 413        bi = kzalloc(n * sizeof(*bi), GFP_KERNEL);
 414        if (!bi)
 415                return -ENOMEM;
 416
 417        for (i = 0; i < n; i++, bi++, info++) {
 418                struct spi_master *master;
 419
 420                memcpy(&bi->board_info, info, sizeof(*info));
 421                mutex_lock(&board_lock);
                    /* 添加到板级描述符链表 */
 422                list_add_tail(&bi->list, &board_list);
                    /* 将主机控制类链表所有的节点匹配板级信息的设备初始化 */
 423                list_for_each_entry(master, &spi_master_list, list)
 424                        spi_match_master_to_boardinfo(master, &bi->board_info);
 425                mutex_unlock(&board_lock);
 426        }
 427
 428        return 0;
 429}
 430
 431/*-------------------------------------------------------------------------*/
 
接下来继续看SPI主机注册、删除方法。
---------------------------------------------
主机设备删除、添加方法    /* 又见神奇的分割线 */
 431/*-------------------------------------------------------------------------*/
 432
    /* SPI主机驱动删除方法
     * 这里是由设备驱动找到主机控制结构体,并释放内存
     */
 433static void spi_master_release(struct device *dev)
 434{
 435        struct spi_master *master;
 436
 437        master = container_of(dev, struct spi_master, dev);
 438        kfree(master);
 439}
 440
    /* SPI主机设备类 */
 441static struct class spi_master_class = {
 442        .name           = "spi_master",
 443        .owner          = THIS_MODULE,
 444        .dev_release    = spi_master_release,
 445};
 446
 447
 448/**
 449 * spi_alloc_master - allocate SPI master controller
 450 * @dev: the controller, possibly using the platform_bus
 451 * @size: how much zeroed driver-private data to allocate; the pointer to this
 452 *      memory is in the driver_data field of the returned device,
 453 *      accessible with spi_master_get_devdata().
 454 * Context: can sleep
 455 *
 456 * This call is used only by SPI master controller drivers, which are the
 457 * only ones directly touching chip registers.  It's how they allocate
 458 * an spi_master structure, prior to calling spi_register_master().
 459 *
 460 * This must be called from context that can sleep.  It returns the SPI
 461 * master structure on success, else NULL.
 462 *
 463 * The caller is responsible for assigning the bus number and initializing
 464 * the master's methods before calling spi_register_master(); and (after errors
 465 * adding the device) calling spi_master_put() to prevent a memory leak.
 466 */
    /* 只用在直接操作芯片寄存器的SPI主机控制器驱动
     */
 467struct spi_master *spi_alloc_master(struct device *dev, unsigned size)
 468{
 469        struct spi_master       *master;
 470
 471        if (!dev)
 472                return NULL;
 473
            /* 多申请size用于存放设备私有数据 */
 474        master = kzalloc(size + sizeof *master, GFP_KERNEL);
 475        if (!master)
 476                return NULL;
 477
            /* 初始化设备,kobject、电源相关方法... */
 478        device_initialize(&master->dev);
            /* 设备类 */
 479        master->dev.class = &spi_master_class;
            /* 增加引用次数,并返回设备结构体 */
 480        master->dev.parent = get_device(dev);
            /* 设置设备私有数据 */
 481        spi_master_set_devdata(master, &master[1]);
 482
 483        return master;
 484}
 485EXPORT_SYMBOL_GPL(spi_alloc_master);
 486
 487/**
 488 * spi_register_master - register SPI master controller
 489 * @master: initialized master, originally from spi_alloc_master()
 490 * Context: can sleep
 491 *
 492 * SPI master controllers connect to their drivers using some non-SPI bus,
 493 * such as the platform bus.  The final stage of probe() in that code
 494 * includes calling spi_register_master() to hook up to this SPI bus glue.
 495 *
 496 * SPI controllers use board specific (often SOC specific) bus numbers,
 497 * and board-specific addressing for SPI devices combines those numbers
 498 * with chip select numbers.  Since SPI does not directly support dynamic
 499 * device identification, boards need configuration tables telling which
 500 * chip is at which address.
 501 *
 502 * This must be called from context that can sleep.  It returns zero on
 503 * success, else a negative error code (dropping the master's refcount).
 504 * After a successful return, the caller is responsible for calling
 505 * spi_unregister_master().
 506 */
 507int spi_register_master(struct spi_master *master)
 508{
 509        static atomic_t         dyn_bus_id = ATOMIC_INIT((1<<15) - 1);
 510        struct device           *dev = master->dev.parent;
 511        struct boardinfo        *bi;
 512        int                     status = -ENODEV;
 513        int                     dynamic = 0;
 514
 515        if (!dev)
 516                return -ENODEV;
 517
 518        /* even if it's just one always-selected device, there must
 519         * be at least one chipselect
 520         */
            /* 至少要有一个片选 */
 521        if (master->num_chipselect == 0)
 522                return -EINVAL;
 523
 524        /* convention:  dynamically assigned bus IDs count down from the max */
            /* 总线号从最大开始减 */
 525        if (master->bus_num < 0) {
 526                /* FIXME switch to an IDR based scheme, something like
 527                 * I2C now uses, so we can't run out of "dynamic" IDs
 528                 */
 529                master->bus_num = atomic_dec_return(&dyn_bus_id);
 530                dynamic = 1;
 531        }
 532
 533        spin_lock_init(&master->bus_lock_spinlock);
 534        mutex_init(&master->bus_lock_mutex);
            /* 指示SPI总线是否被锁 */
 535        master->bus_lock_flag = 0;
 536
 537        /* register the device, then userspace will see it.
 538         * registration fails if the bus ID is in use.
 539         */
            /* 注册设备,用户空间就可以看到了
             * 失败,当总线ID正在使用
             * 下面的设备添加与上一篇文章一样
             */
 540        dev_set_name(&master->dev, "spi%u", master->bus_num);
 541        status = device_add(&master->dev);
 542        if (status < 0)
 543                goto done;
 544        dev_dbg(dev, "registered master %s%s\n", dev_name(&master->dev),
 545                        dynamic ? " (dynamic)" : "");
 546
 547        mutex_lock(&board_lock);
            /* 添加主机设备链表 */
 548        list_add_tail(&master->list, &spi_master_list);
            /* 在主机链表中查找匹配板设备信息的添加设备 */
 549        list_for_each_entry(bi, &board_list, list)
 550                spi_match_master_to_boardinfo(master, &bi->board_info);
 551        mutex_unlock(&board_lock);
 552
 553        status = 0;
 554
 555        /* Register devices from the device tree */
            /* OF注册SPI设备
             * 为主节点的子节点中含有reg属性的子节点注册一个SPI设备
             */
 556        of_register_spi_devices(master);
 557done:
 558        return status;
 559}
 560EXPORT_SYMBOL_GPL(spi_register_master);
 561
 562
    /* 删除设备驱动 */
 563static int __unregister(struct device *dev, void *null)
 564{
            /* 内联函数,调用device_unregister
             * 从系统中删除设备相关的电源方法、sysfs……释放内存、删除文件等
             * 减引用次数
             */
 565        spi_unregister_device(to_spi_device(dev));
 566        return 0;
 567}
 568
 569/**
 570 * spi_unregister_master - unregister SPI master controller
 571 * @master: the master being unregistered
 572 * Context: can sleep
 573 *
 574 * This call is used only by SPI master controller drivers, which are the
 575 * only ones directly touching chip registers.
 576 *
 577 * This must be called from context that can sleep.
 578 */
    /* 仅用在SPI主机控制驱动删除 */
 579void spi_unregister_master(struct spi_master *master)
 580{
 581        int dummy;
 582
 583        mutex_lock(&board_lock);
            /* 删除设备链表 */
 584        list_del(&master->list);
 585        mutex_unlock(&board_lock);
 586
            /* 删除所有子设备 */
 587        dummy = device_for_each_child(&master->dev, NULL, __unregister);
            /* 删除设备 */
 588        device_unregister(&master->dev);
 589}
 590EXPORT_SYMBOL_GPL(spi_unregister_master);
 591
 592static int __spi_master_match(struct device *dev, void *data)
 593{
 594        struct spi_master *m;
 595        u16 *bus_num = data;
 596
            /* 比较设备的总线数,一样返回TRUE */
 597        m = container_of(dev, struct spi_master, dev);
 598        return m->bus_num == *bus_num;
 599}
 600
 601/**
 602 * spi_busnum_to_master - look up master associated with bus_num
 603 * @bus_num: the master's bus number
 604 * Context: can sleep
 605 *
 606 * This call may be used with devices that are registered after
 607 * arch init time.  It returns a refcounted pointer to the relevant
 608 * spi_master (which the caller must release), or NULL if there is
 609 * no such master registered.
 610 */
 611struct spi_master *spi_busnum_to_master(u16 bus_num)
 612{
 613        struct device           *dev;
 614        struct spi_master       *master = NULL;
 615
            /* 在主机设备类中查找与bus_num匹配的设备
             * 找到则返回主机设备结构体指针
             */
 616        dev = class_find_device(&spi_master_class, NULL, &bus_num,
 617                                __spi_master_match);
 618        if (dev)
 619                master = container_of(dev, struct spi_master, dev);
 620        /* reference got in class_find_device */
 621        return master;
 622}
 623EXPORT_SYMBOL_GPL(spi_busnum_to_master);
---------------------------------------------
接下来,看SPI的核心方法。
---------------------------------------------

SPI主机驱动的核心方法
-------------------------------------------------
SPI主机协议驱动核心方法    /* 神奇的分割线 */
 626/*-------------------------------------------------------------------------*/
 627
 628/* Core methods for SPI master protocol drivers.  Some of the
 629 * other core methods are currently defined as inline functions.
 630 */
 631
 632/**
 633 * spi_setup - setup SPI mode and clock rate
 634 * @spi: the device whose settings are being modified
 635 * Context: can sleep, and no requests are queued to the device
 636 *
 637 * SPI protocol drivers may need to update the transfer mode if the
 638 * device doesn't work with its default.  They may likewise need
 639 * to update clock rates or word sizes from initial values.  This function
 640 * changes those settings, and must be called from a context that can sleep.
 641 * Except for SPI_CS_HIGH, which takes effect immediately, the changes take
 642 * effect the next time the device is selected and data is transferred to
 643 * or from it.  When this function returns, the spi device is deselected.
 644 *
 645 * Note that this call will fail if the protocol driver specifies an option
 646 * that the underlying controller or its driver does not support.  For
 647 * example, not all hardware supports wire transfers using nine bit words,
 648 * LSB-first wire encoding, or active-high chipselects.
 649 */
 650int spi_setup(struct spi_device *spi)
 651{
 652        unsigned        bad_bits;
 653        int             status;
 654
 655        /* help drivers fail *cleanly* when they need options
 656         * that aren't supported with their current master
 657         */
            /* 显示驱动不支持的模式 */
 658        bad_bits = spi->mode & ~spi->master->mode_bits;
 659        if (bad_bits) {
 660                dev_err(&spi->dev, "setup: unsupported mode bits %x\n",
 661                        bad_bits);
 662                return -EINVAL;
 663        }
 664
            /* 设置传输位数 */
 665        if (!spi->bits_per_word)
 666                spi->bits_per_word = 8;
 667
            /* 调用主机驱动的设置方法设置驱动 */
 668        status = spi->master->setup(spi);
 669
 670        dev_dbg(&spi->dev, "setup mode %d, %s%s%s%s"
 671                                "%u bits/w, %u Hz max --> %d\n",
 672                        (int) (spi->mode & (SPI_CPOL | SPI_CPHA)),
 673                        (spi->mode & SPI_CS_HIGH) ? "cs_high, " : "",
 674                        (spi->mode & SPI_LSB_FIRST) ? "lsb, " : "",
 675                        (spi->mode & SPI_3WIRE) ? "3wire, " : "",
 676                        (spi->mode & SPI_LOOP) ? "loopback, " : "",
 677                        spi->bits_per_word, spi->max_speed_hz,
 678                        status);
 679
 680        return status;
 681}
 682EXPORT_SYMBOL_GPL(spi_setup);
 683
 684static int __spi_async(struct spi_device *spi, struct spi_message *message)
 685{
 686        struct spi_master *master = spi->master;
 687
 688        /* Half-duplex links include original MicroWire, and ones with
 689         * only one data pin like SPI_3WIRE (switches direction) or where
 690         * either MOSI or MISO is missing.  They can also be caused by
 691         * software limitations.
 692         */
            /* 半双工模式 或者 3线SPI */
 693        if ((master->flags & SPI_MASTER_HALF_DUPLEX)
 694                        || (spi->mode & SPI_3WIRE)) {
                    /* struct spi_transfer 读写缓存 */
 695                struct spi_transfer *xfer;
 696                unsigned flags = master->flags;
 697
                    /* 遍历message->transfers链表判断缓存 */
 698                list_for_each_entry(xfer, &message->transfers, transfer_list) {
                            /* 半双工 */
 699                        if (xfer->rx_buf && xfer->tx_buf)
 700                                return -EINVAL;
                            /* 当前模式没有发送,而有发送缓存 */
 701                        if ((flags & SPI_MASTER_NO_TX) && xfer->tx_buf)
 702                                return -EINVAL;
                            /* 当前模式没有接收,而有接收缓存 */
 703                        if ((flags & SPI_MASTER_NO_RX) && xfer->rx_buf)
 704                                return -EINVAL;
 705                }
 706        }
 707
            /* 该消息使用的设备为SPI */
 708        message->spi = spi;
            /* 消息正在处理 */
 709        message->status = -EINPROGRESS;
            /* 调用主机驱动的传输方法 */
 710        return master->transfer(spi, message);
 711}
 712
 713/**
 714 * spi_async - asynchronous SPI transfer
 715 * @spi: device with which data will be exchanged
 716 * @message: describes the data transfers, including completion callback
 717 * Context: any (irqs may be blocked, etc)
 718 *
 719 * This call may be used in_irq and other contexts which can't sleep,
 720 * as well as from task contexts which can sleep.
 721 *
 722 * The completion callback is invoked in a context which can't sleep.
 723 * Before that invocation, the value of message->status is undefined.
 724 * When the callback is issued, message->status holds either zero (to
 725 * indicate complete success) or a negative error code.  After that
 726 * callback returns, the driver which issued the transfer request may
 727 * deallocate the associated memory; it's no longer in use by any SPI
 728 * core or controller driver code.
 729 *
 730 * Note that although all messages to a spi_device are handled in
 731 * FIFO order, messages may go to different devices in other orders.
 732 * Some device might be higher priority, or have various "hard" access
 733 * time requirements, for example.
 734 *
 735 * On detection of any fault during the transfer, processing of
 736 * the entire message is aborted, and the device is deselected.
 737 * Until returning from the associated message completion callback,
 738 * no other spi_message queued to that device will be processed.
 739 * (This rule applies equally to all the synchronous transfer calls,
 740 * which are wrappers around this core asynchronous primitive.)
 741 */
 742int spi_async(struct spi_device *spi, struct spi_message *message)
 743{
 744        struct spi_master *master = spi->master;
 745        int ret;
 746        unsigned long flags;
 747
            /* 禁止终端,同时请求持有自旋锁 */
 748        spin_lock_irqsave(&master->bus_lock_spinlock, flags);
 749
 750        if (master->bus_lock_flag)
 751                ret = -EBUSY;
 752        else
                    /* 异步传输消息 */
 753                ret = __spi_async(spi, message);
 754
            /* 恢复终端,解锁自旋锁 */
 755        spin_unlock_irqrestore(&master->bus_lock_spinlock, flags);
 756
 757        return ret;
 758}
 759EXPORT_SYMBOL_GPL(spi_async);
 760
 761/**
 762 * spi_async_locked - version of spi_async with exclusive bus usage
 763 * @spi: device with which data will be exchanged
 764 * @message: describes the data transfers, including completion callback
 765 * Context: any (irqs may be blocked, etc)
 766 *
 767 * This call may be used in_irq and other contexts which can't sleep,
 768 * as well as from task contexts which can sleep.
 769 *
 770 * The completion callback is invoked in a context which can't sleep.
 771 * Before that invocation, the value of message->status is undefined.
 772 * When the callback is issued, message->status holds either zero (to
 773 * indicate complete success) or a negative error code.  After that
 774 * callback returns, the driver which issued the transfer request may
 775 * deallocate the associated memory; it's no longer in use by any SPI
 776 * core or controller driver code.
 777 *
 778 * Note that although all messages to a spi_device are handled in
 779 * FIFO order, messages may go to different devices in other orders.
 780 * Some device might be higher priority, or have various "hard" access
 781 * time requirements, for example.
 782 *
 783 * On detection of any fault during the transfer, processing of
 784 * the entire message is aborted, and the device is deselected.
 785 * Until returning from the associated message completion callback,
 786 * no other spi_message queued to that device will be processed.
 787 * (This rule applies equally to all the synchronous transfer calls,
 788 * which are wrappers around this core asynchronous primitive.)
 789 */
    /* 另一个版本的spi_async,不包括使用总线 */
 790int spi_async_locked(struct spi_device *spi, struct spi_message *message)
 791{
 792        struct spi_master *master = spi->master;
 793        int ret;
 794        unsigned long flags;
 795
 796        spin_lock_irqsave(&master->bus_lock_spinlock, flags);
 797
 798        ret = __spi_async(spi, message);
 799
 800        spin_unlock_irqrestore(&master->bus_lock_spinlock, flags);
 801
 802        return ret;
 803
 804}
 805EXPORT_SYMBOL_GPL(spi_async_locked);
 806
 807
 808/*-------------------------------------------------------------------------*/
-------------------------------------------------
SPI主机协议驱动核心方法2 808/*-------------------------------------------------------------------------*/
 809
 810/* Utility methods for SPI master protocol drivers, layered on
 811 * top of the core.  Some other utility methods are defined as
 812 * inline functions.
 813 */
 814
    /* 发送信号给一个线程完成等待,唤醒线程 */
 815static void spi_complete(void *arg)
 816{
 817        complete(arg);
 818}
 819
    /* 驱动同步发送信息
     * bus_locked如果为1,则不使用锁,0则是使用锁
     */
 820static int __spi_sync(struct spi_device *spi, struct spi_message *message,
 821                      int bus_locked)
 822{
            /* 在堆栈中定义并初始化一个完成状态变量 */
 823        DECLARE_COMPLETION_ONSTACK(done);
 824        int status;
 825        struct spi_master *master = spi->master;
 826
 827        message->complete = spi_complete;
 828        message->context = &done;
 829
 830        if (!bus_locked)
 831                mutex_lock(&master->bus_lock_mutex);
 832
            /* 使用不加锁的异步发送消息方法 */
 833        status = spi_async_locked(spi, message);
 834
 835        if (!bus_locked)
 836                mutex_unlock(&master->bus_lock_mutex);
 837
 838        if (status == 0) {
                    /* 等待任务结束 */
 839                wait_for_completion(&done);
 840                status = message->status;
 841        }
 842        message->context = NULL;
 843        return status;
 844}
 845
 846/**
 847 * spi_sync - blocking/synchronous SPI data transfers
 848 * @spi: device with which data will be exchanged
 849 * @message: describes the data transfers
 850 * Context: can sleep
 851 *
 852 * This call may only be used from a context that may sleep.  The sleep
 853 * is non-interruptible, and has no timeout.  Low-overhead controller
 854 * drivers may DMA directly into and out of the message buffers.
 855 *
 856 * Note that the SPI device's chip select is active during the message,
 857 * and then is normally disabled between messages.  Drivers for some
 858 * frequently-used devices may want to minimize costs of selecting a chip,
 859 * by leaving it selected in anticipation that the next message will go
 860 * to the same chip.  (That may increase power usage.)
 861 *
 862 * Also, the caller is guaranteeing that the memory associated with the
 863 * message will not be freed before this call returns.
 864 *
 865 * It returns zero on success, else a negative error code.
 866 */
    /* 同步、阻塞方式传输 */
 867int spi_sync(struct spi_device *spi, struct spi_message *message)
 868{
 869        return __spi_sync(spi, message, 0);
 870}
 871EXPORT_SYMBOL_GPL(spi_sync);
 872
 873/**
 874 * spi_sync_locked - version of spi_sync with exclusive bus usage
 875 * @spi: device with which data will be exchanged
 876 * @message: describes the data transfers
 877 * Context: can sleep
 878 *
 879 * This call may only be used from a context that may sleep.  The sleep
 880 * is non-interruptible, and has no timeout.  Low-overhead controller
 881 * drivers may DMA directly into and out of the message buffers.
 882 *
 883 * This call should be used by drivers that require exclusive access to the
 884 * SPI bus. It has to be preceeded by a spi_bus_lock call. The SPI bus must
 885 * be released by a spi_bus_unlock call when the exclusive access is over.
 886 *
 887 * It returns zero on success, else a negative error code.
 888 */
    /* 同步、阻塞方式传输,不是用总线锁 */
 889int spi_sync_locked(struct spi_device *spi, struct spi_message *message)
 890{
 891        return __spi_sync(spi, message, 1);
 892}
 893EXPORT_SYMBOL_GPL(spi_sync_locked);
-------------------------------------------------
总线加解锁    /* 用于上述无使用锁得方法 */
 895/**
 896 * spi_bus_lock - obtain a lock for exclusive SPI bus usage
 897 * @master: SPI bus master that should be locked for exclusive bus access
 898 * Context: can sleep
 899 *
 900 * This call may only be used from a context that may sleep.  The sleep
 901 * is non-interruptible, and has no timeout.
 902 *
 903 * This call should be used by drivers that require exclusive access to the
 904 * SPI bus. The SPI bus must be released by a spi_bus_unlock call when the
 905 * exclusive access is over. Data transfer must be done by spi_sync_locked
 906 * and spi_async_locked calls when the SPI bus lock is held.
 907 *
 908 * It returns zero on success, else a negative error code.
 909 */
    /* 用于不使用总线锁的一些方法来加锁 */
 910int spi_bus_lock(struct spi_master *master)
 911{
 912        unsigned long flags;
 913
 914        mutex_lock(&master->bus_lock_mutex);
 915
 916        spin_lock_irqsave(&master->bus_lock_spinlock, flags);
 917        master->bus_lock_flag = 1;
 918        spin_unlock_irqrestore(&master->bus_lock_spinlock, flags);
 919
 920        /* mutex remains locked until spi_bus_unlock is called */
 921
 922        return 0;
 923}
 924EXPORT_SYMBOL_GPL(spi_bus_lock);
 925
 926/**
 927 * spi_bus_unlock - release the lock for exclusive SPI bus usage
 928 * @master: SPI bus master that was locked for exclusive bus access
 929 * Context: can sleep
 930 *
 931 * This call may only be used from a context that may sleep.  The sleep
 932 * is non-interruptible, and has no timeout.
 933 *
 934 * This call releases an SPI bus lock previously obtained by an spi_bus_lock
 935 * call.
 936 *
 937 * It returns zero on success, else a negative error code.
 938 */
    /* 用于不使用总线锁的一些方法来解锁 */
 939int spi_bus_unlock(struct spi_master *master)
 940{
 941        master->bus_lock_flag = 0;
 942
 943        mutex_unlock(&master->bus_lock_mutex);
 944
 945        return 0;
 946}
 947EXPORT_SYMBOL_GPL(spi_bus_unlock);
-------------------------------------------------
半双工式的传输,先写后读    /* SPI缓存大小 */
 949/* portable code must never pass more than 32 bytes */
 950#define SPI_BUFSIZ      max(32,SMP_CACHE_BYTES)
 951
    /* 缓存指针 */
 952static u8       *buf;
 953
 954/**
 955 * spi_write_then_read - SPI synchronous write followed by read
 956 * @spi: device with which data will be exchanged
 957 * @txbuf: data to be written (need not be dma-safe)
 958 * @n_tx: size of txbuf, in bytes
 959 * @rxbuf: buffer into which data will be read (need not be dma-safe)
 960 * @n_rx: size of rxbuf, in bytes
 961 * Context: can sleep
 962 *
 963 * This performs a half duplex MicroWire style transaction with the
 964 * device, sending txbuf and then reading rxbuf.  The return value
 965 * is zero for success, else a negative errno status code.
 966 * This call may only be used from a context that may sleep.
 967 *
 968 * Parameters to this routine are always copied using a small buffer;
 969 * portable code should never use this for more than 32 bytes.
 970 * Performance-sensitive or bulk transfer code should instead use
 971 * spi_{async,sync}() calls with dma-safe buffers.
 972 */
    /* 半双工式的传输,先写后读
     */
 973int spi_write_then_read(struct spi_device *spi,
 974                const u8 *txbuf, unsigned n_tx,
 975                u8 *rxbuf, unsigned n_rx)
 976{
            /* 定义、初始化缓存互斥锁 */
 977        static DEFINE_MUTEX(lock);
 978
 979        int                     status;
 980        struct spi_message      message;
 981        struct spi_transfer     x[2];
 982        u8                      *local_buf;
 983
 984        /* Use preallocated DMA-safe buffer.  We can't avoid copying here,
 985         * (as a pure convenience thing), but we can keep heap costs
 986         * out of the hot path ...
 987         */
            /* 要发送和接收数据总量不能超过缓存大小 */
 988        if ((n_tx + n_rx) > SPI_BUFSIZ)
 989                return -EINVAL;
 990
            /* 初始化message->transfer缓存链表 */
 991        spi_message_init(&message);
 992        memset(x, 0, sizeof x);
            /* 需要发送,将x[0]加入消息链表尾 */
 993        if (n_tx) {
 994                x[0].len = n_tx;
 995                spi_message_add_tail(&x[0], &message);
 996        }
            /* 需要接收,将x[1]加入消息链表尾 */
 997        if (n_rx) {
 998                x[1].len = n_rx;
 999                spi_message_add_tail(&x[1], &message);
1000        }
1001
1002        /* ... unless someone else is using the pre-allocated buffer */
            /* 有在用,则重新申请一块内存,第一次锁操作必返回1
             * 这里有个地方,buf没有申请内存空间,如何使用?
             */
1003        if (!mutex_trylock(&lock)) {
1004                local_buf = kmalloc(SPI_BUFSIZ, GFP_KERNEL);
1005                if (!local_buf)
1006                        return -ENOMEM;
1007        } else
1008                local_buf = buf;
1009
1010        memcpy(local_buf, txbuf, n_tx);
1011        x[0].tx_buf = local_buf;
1012        x[1].rx_buf = local_buf + n_tx;
1013
1014        /* do the i/o */
            /* IO操作,传输消息 */
1015        status = spi_sync(spi, &message);
            /* 成功,拷贝接收数据 */
1016        if (status == 0)
1017                memcpy(rxbuf, x[1].rx_buf, n_rx);
1018
            /* 释放缓存空间,解锁 */
1019        if (x[0].tx_buf == buf)
1020                mutex_unlock(&lock);
1021        else
1022                kfree(local_buf);
1023
1024        return status;
1025}
1026EXPORT_SYMBOL_GPL(spi_write_then_read);
1027
1028/*-------------------------------------------------------------------------*/
 
-------------------------------------------------
SPI初始化    /* SPI初始化
     * 初始化缓存
     * 注册总线驱动
     * 注册主机驱动类
     */
1030static int __init spi_init(void)
1031{
1032        int     status;
1033
            /* 初始化缓存 */
1034        buf = kmalloc(SPI_BUFSIZ, GFP_KERNEL);
1035        if (!buf) {
1036                status = -ENOMEM;
1037                goto err0;
1038        }
1039
            /* 注册总线驱动 */
1040        status = bus_register(&spi_bus_type);
1041        if (status < 0)
1042                goto err1;
1043
            /* 注册主机驱动类 */
1044        status = class_register(&spi_master_class);
1045        if (status < 0)
1046                goto err2;
1047        return 0;
1048
1049err2:
1050        bus_unregister(&spi_bus_type);
1051err1:
1052        kfree(buf);
1053        buf = NULL;
1054err0:
1055        return status;
1056}
1057
1058/* board_info is normally registered in arch_initcall(),
1059 * but even essential drivers wait till later
1060 *
1061 * REVISIT only boardinfo really needs static linking. the rest (device and
1062 * driver registration) _could_ be dynamically linked (modular) ... costs
1063 * include needing to have boardinfo data structures be much more public.
1064 */
    /* 定义初始化函数,不能再模块中调用,需要静态链接 */
1065postcore_initcall(spi_init);
-------------------------------------------------
结束。初步了解了代码…
-------------------------------------------------

本篇文章来源于 Linux公社网站()  原文链接:
 
 
 
阅读(922) | 评论(0) | 转发(0) |
给主人留下些什么吧!~~