超硬干货：I2C最全教程，绝对不负期望！（万字长文，建议收藏）

static int   s3c24xx_i2c_probe(struct platform_device *pdev)

{

       struct s3c24xx_i2c *i2c;//最重要的结构体

       //保存设备树信息

       struct s3c2410_platform_i2c *pdata =   NULL;

       struct resource *res;

       int ret;

       if (!pdev->dev.of_node) {

              pdata =   dev_get_platdata(&pdev->dev);

              if (!pdata) {

                     dev_err(&pdev->dev,   "no platform data\n");

                     return -EINVAL;

              }

       }

       /*为结构体变量i2c分配内存*/

       i2c = devm_kzalloc(&pdev->dev,   sizeof(struct s3c24xx_i2c), GFP_KERNEL);

       if (!i2c) {

              dev_err(&pdev->dev,   "no memory for state\n");

              return -ENOMEM;

       }

       i2c->pdata =   devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);

       if (!i2c->pdata) {

              dev_err(&pdev->dev,   "no memory for platform data\n");

              return -ENOMEM;

       }

       /*i2c控制器的一些特殊行为

              #define QUIRK_S3C2440              (1 << 0)

              #define QUIRK_HDMIPHY            (1 << 1)

              #define QUIRK_NO_GPIO             (1 << 2)

              #define QUIRK_POLL            (1 << 3)

              其中bite：3如果采用轮训方式与底层硬件通信值为1，中断方式值为0*/

       i2c->quirks =   s3c24xx_get_device_quirks(pdev);

       if (pdata)

              memcpy(i2c->pdata, pdata,   sizeof(*pdata));

       else

              s3c24xx_i2c_parse_dt(pdev->dev.of_node,   i2c);

       strlcpy(i2c->adap.name,   "s3c2410-i2c", sizeof(i2c->adap.name));

       i2c->adap.owner   = THIS_MODULE;

       /*为i2c_msg传输方法赋值，*/

       i2c->adap.algo    = &s3c24xx_i2c_algorithm;

       i2c->adap.retries = 2;

       i2c->adap.class   = I2C_CLASS_HWMON | I2C_CLASS_SPD;

       i2c->tx_setup     = 50;

       //初始化等待队列，该等待队列用于唤醒读写数据的进程

       init_waitqueue_head(&i2c->wait);

       /* find the clock and enable it */

       i2c->dev = &pdev->dev;

       //获取时钟

       i2c->clk =   devm_clk_get(&pdev->dev, "i2c");

       if (IS_ERR(i2c->clk)) {

              dev_err(&pdev->dev,   "cannot get clock\n");

              return -ENOENT;

       }

       dev_dbg(&pdev->dev, "clock   source %p\n", i2c->clk);

       /* map the registers */

       //通过pdev得到i2c控制器的寄存器地址资源

       res = platform_get_resource(pdev,   IORESOURCE_MEM, 0);

       //映射i2c控制器的物理基地址为虚拟基地址

       i2c->regs =   devm_ioremap_resource(&pdev->dev, res);

       if (IS_ERR(i2c->regs))

              return PTR_ERR(i2c->regs);

       dev_dbg(&pdev->dev,   "registers %p (%p)\n",

              i2c->regs, res);

       /* setup info block for the i2c core */

       /*将结构体变量i2c保存到i2c_adapter的私有变量指针algo_data，

       编写i2c设备驱动可以通过adapter指针找到结构体i2c*/

       i2c->adap.algo_data = i2c;

       i2c->adap.dev.parent =   &pdev->dev;

       i2c->pctrl =   devm_pinctrl_get_select_default(i2c->dev);

       /* inititalise the i2c gpio lines */

       //得到i2c复用的gpio引脚并初始化

       if (i2c->pdata->cfg_gpio) {

              i2c->pdata->cfg_gpio(to_platform_device(i2c->dev));

       } else if (IS_ERR(i2c->pctrl)   && s3c24xx_i2c_parse_dt_gpio(i2c)) {

              return -EINVAL;

       }

       /* initialise the i2c controller */

       clk_prepare_enable(i2c->clk);

       /*将从设备地址写入寄存器S3C2410_IICADD，同时初始化时钟频率*/

       ret = s3c24xx_i2c_init(i2c);

       clk_disable_unprepare(i2c->clk);

       if (ret != 0) {

              dev_err(&pdev->dev,   "I2C controller init failed\n");

              return ret;

       }

       /* find the IRQ for this unit (note,   this relies on the init call to

        * ensure no current IRQs pending

        */

       if (!(i2c->quirks & QUIRK_POLL))   {

              /*获得中断号*/

              i2c->irq = ret =   platform_get_irq(pdev, 0);

              if (ret <= 0) {

                     dev_err(&pdev->dev,   "cannot find IRQ\n");

                     return ret;

              }

       /*注册中断处理函数s3c24xx_i2c_irq()*/

       ret =   devm_request_irq(&pdev->dev, i2c->irq, s3c24xx_i2c_irq, 0,

                            dev_name(&pdev->dev),   i2c);

              if (ret != 0) {

                     dev_err(&pdev->dev,   "cannot claim IRQ %d\n", i2c->irq);

                     return ret;

              }

       }

       ret =   s3c24xx_i2c_register_cpufreq(i2c);

       if (ret < 0) {

              dev_err(&pdev->dev,   "failed to register cpufreq notifier\n");

              return   ret;

       }

       /* Note, previous versions of the   driver used i2c_add_adapter()

        * to add the bus at any number. We now pass   the bus number via

        * the platform data, so if unset it will now   default to always

        * being bus 0.

        */

       /*保存i2c控制器的通道号，本例是bus 5*/

       i2c->adap.nr =   i2c->pdata->bus_num;

       i2c->adap.dev.of_node =   pdev->dev.of_node;

       //注册adapter

       ret =   i2c_add_numbered_adapter(&i2c->adap);

       if (ret < 0) {

              dev_err(&pdev->dev,   "failed to add bus to i2c core\n");

              s3c24xx_i2c_deregister_cpufreq(i2c);

              return ret;

       }

       /*保存私有变量i2c到pdev->dev->p->driver_data*/

       platform_set_drvdata(pdev, i2c);

       pm_runtime_enable(&pdev->dev);

       pm_runtime_enable(&i2c->adap.dev);

       dev_info(&pdev->dev, "%s:   S3C I2C adapter\n", dev_name(&i2c->adap.dev));

       return 0;

}

int   i2c_add_numbered_adapter(struct i2c_adapter *adap)

{

       if (adap->nr == -1) /* -1 means   dynamically assign bus id */

              return i2c_add_adapter(adap);

       return __i2c_add_numbered_adapter(adap);

}

static int   i2c_register_adapter(struct i2c_adapter *adap)

{

       int res = 0;

       /* Can't register until after driver   model init */

       if (unlikely(WARN_ON(!i2c_bus_type.p)))   {

              res = -EAGAIN;

              goto out_list;

       }

       /* Sanity checks */

       if (unlikely(adap->name[0] == '\0'))   {

              pr_err("i2c-core: Attempt   to register an adapter with "

                     "no name!\n");

              return -EINVAL;

       }

       if (unlikely(!adap->algo)) {

              pr_err("i2c-core: Attempt   to register adapter '%s' with "

                     "no algo!\n",   adap->name);

              return -EINVAL;

       }

       rt_mutex_init(&adap->bus_lock);

       mutex_init(&adap->userspace_clients_lock);

       INIT_LIST_HEAD(&adap->userspace_clients);

       /* Set default timeout to 1 second if   not already set */

       if (adap->timeout == 0)

              adap->timeout = HZ;

       //设置adapter名字,本例注册后会生成以下节点/dev/i2c-5

       dev_set_name(&adap->dev,   "i2c-%d", adap->nr);

       adap->dev.bus = &i2c_bus_type;

       adap->dev.type = &i2c_adapter_type;

       res =   device_register(&adap->dev);

       if (res)

              goto out_list;

       dev_dbg(&adap->dev,   "adapter [%s] registered\n", adap->name);

#ifdef   CONFIG_I2C_COMPAT

       res =   class_compat_create_link(i2c_adapter_compat_class, &adap->dev,

                                   adap->dev.parent);

       if (res)

              dev_warn(&adap->dev,

                      "Failed to create compatibility class   link\n");

#endif

       /* bus recovery specific initialization   */

       /*初始化sda、scl，通常这两个引脚会复用gpio引脚*/

       if (adap->bus_recovery_info) {

              struct i2c_bus_recovery_info   *bri = adap->bus_recovery_info;

              if (!bri->recover_bus) {

                     dev_err(&adap->dev,   "No recover_bus() found, not using recovery\n");

                     adap->bus_recovery_info   = NULL;

                     goto exit_recovery;

              }

              /* Generic GPIO recovery */

              if (bri->recover_bus ==   i2c_generic_gpio_recovery) {

                     if   (!gpio_is_valid(bri->scl_gpio)) {

                            dev_err(&adap->dev,   "Invalid SCL gpio, not using recovery\n");

                            adap->bus_recovery_info   = NULL;

                            goto   exit_recovery;

                     }

                     if   (gpio_is_valid(bri->sda_gpio))

                            bri->get_sda =   get_sda_gpio_value;

                     else

                            bri->get_sda =   NULL;

                     bri->get_scl =   get_scl_gpio_value;

                     bri->set_scl =   set_scl_gpio_value;

              } else if (!bri->set_scl ||   !bri->get_scl) {

                     /* Generic SCL recovery   */

                     dev_err(&adap->dev,   "No {get|set}_gpio() found, not using recovery\n");

                     adap->bus_recovery_info   = NULL;

              }

       }

exit_recovery:

       /* create pre-declared device nodes */

       /*通过设备树节点注册所有该控制器下的所有从设备*/

       of_i2c_register_devices(adap);

       acpi_i2c_register_devices(adap);

       /*与动态分配的总线号相关，动态分配的总线号应该是从已经现有最大总线号基础上+1的，

       这样能够保证动态分配出的总线号与板级总线号不会产生冲突

       在没有设备树情况下，会基于队列__i2c_board_list, 创建i2c_client

       其中节点struct i2c_board_info手动填写*/

       if (adap->nr <   __i2c_first_dynamic_bus_num)

              i2c_scan_static_board_info(adap);

       /* Notify drivers */

       mutex_lock(&core_lock);

       bus_for_each_drv(&i2c_bus_type,   NULL, adap, __process_new_adapter);

       mutex_unlock(&core_lock);

       return 0;

out_list:

       mutex_lock(&core_lock);

       idr_remove(&i2c_adapter_idr,   adap->nr);

       mutex_unlock(&core_lock);

       return res;

}

static void   of_i2c_register_devices(struct i2c_adapter *adap)

{

       void *result;

       struct device_node *node;

       /* Only register child devices if the   adapter has a node pointer set */

       if (!adap->dev.of_node)

              return;

       dev_dbg(&adap->dev,   "of_i2c: walking child nodes\n");

       for_each_available_child_of_node(adap->dev.of_node,   node) {

              struct i2c_board_info info = {};

              struct dev_archdata dev_ad = {};

              const __be32 *addr;

              int len;

              dev_dbg(&adap->dev,   "of_i2c: register %s\n", node->full_name);

              if (of_modalias_node(node,   info.type, sizeof(info.type)) < 0) {

                     dev_err(&adap->dev,   "of_i2c: modalias failure on %s\n",

                            node->full_name);

                     continue;

              }

              /*获取从设备的地址*/

              addr = of_get_property(node,   "reg", &len);

              if (!addr || (len <   sizeof(int))) {

                     dev_err(&adap->dev,   "of_i2c: invalid reg on %s\n",

                            node->full_name);

                     continue;

              }

              /*存储从设备地址*/

              info.addr = be32_to_cpup(addr);

              if (info.addr > (1 <<   10) - 1) {

                     dev_err(&adap->dev,   "of_i2c: invalid addr=%x on %s\n",

                            info.addr,   node->full_name);

                     continue;

              }

              /*获取中断号*/

              info.irq =   irq_of_parse_and_map(node, 0);

              info.of_node =   of_node_get(node);

              info.archdata = &dev_ad;

              /*获取设备树节点wakeup-source信息*/

              if (of_get_property(node,   "wakeup-source", NULL))

                     info.flags |=   I2C_CLIENT_WAKE;

              request_module("%s%s",   I2C_MODULE_PREFIX, info.type);

              /*将i2c_board_info转换成i2c_client并注册到i2c总线*/

              result = i2c_new_device(adap,   &info);

              if (result == NULL) {

                     dev_err(&adap->dev,   "of_i2c: Failure registering %s\n",

                            node->full_name);

                     of_node_put(node);

                     irq_dispose_mapping(info.irq);

                     continue;

              }

       }

}

{

       struct i2c_client      *client;

       int                 status;

       /*给i2c_client分配内存*/

       client = kzalloc(sizeof *client, GFP_KERNEL);

       if (!client)

              return NULL;

       /*将adapter的地址保存到i2c_client->adapter，

       在驱动函数中可以通过i2c_client找到adapter*/

       client->adapter = adap;

       client->dev.platform_data =   info->platform_data;

       if (info->archdata)

              client->dev.archdata =   *info->archdata;

       /*保存从设备地址类型*/

       client->flags = info->flags;

       /*保存从设备地址*/

       client->addr = info->addr;

       /*保存从设备中断号*/

       client->irq = info->irq;

       strlcpy(client->name, info->type,   sizeof(client->name));

       /* Check for address validity */

       /*检测从设备地址是否合法*/

       status =   i2c_check_client_addr_validity(client);

       if (status) {

              dev_err(&adap->dev,   "Invalid %d-bit I2C address 0x%02hx\n",

                     client->flags &   I2C_CLIENT_TEN ? 10 : 7, client->addr);

              goto out_err_silent;

       }

       /* Check for address business */

       /*检测从设备地址是否被占用*/

       status = i2c_check_addr_busy(adap,   client->addr);

       if (status)

              goto out_err;

       /*建立从设备与适配器的父子关系*/

       client->dev.parent =   &client->adapter->dev;

       client->dev.bus = &i2c_bus_type;

       client->dev.type =   &i2c_client_type;

       client->dev.of_node = info->of_node;

       ACPI_COMPANION_SET(&client->dev,   info->acpi_node.companion);

       i2c_dev_set_name(adap, client);

       /*注册到Linux核心*/

       status =   device_register(&client->dev);

       if (status)

              goto out_err;

       dev_dbg(&adap->dev, "client   [%s] registered with bus id %s\n",

              client->name,   dev_name(&client->dev));

       return client;

out_err:

       dev_err(&adap->dev, "Failed   to register i2c client %s at 0x%02x "

              "(%d)\n",   client->name, client->addr, status);

out_err_silent:

       kfree(client);

       return NULL;

}