從DTS到驅動加載的過程分析

最新推荐文章于 2023-08-29 17:58:25 发布

linxi_hnh

最新推荐文章于 2023-08-29 17:58:25 发布

阅读量1k

点赞数

一、驅動中的probe函數如何被調用？

首先，我們知道驅動執行的起始函數是init函數。以I2C驅動爲例。

(cm36283.c)

[cpp]view plaincopy 
   
 static int __init cm36283_init(void)  
 {  
     int err = 0;  
     err = i2c_add_driver(&cm36283_driver);
     return err;  
 }  
   
 module_init(cm36283_init);  

(i2c.h)

[cpp]view plaincopy 
   
 #define i2c_add_driver(driver) \  
     i2c_register_driver(THIS_MODULE, driver)  

(i2c-core.c)

[cpp]view plaincopy 
   
 int i2c_register_driver(struct module *owner, struct i2c_driver *driver)  
 {  
     int res;  
   
     /* Can't register until after driver model init */  
     if (unlikely(WARN_ON(!i2c_bus_type.p)))  
         return -EAGAIN;  
   
     /* add the driver to the list of i2c drivers in the driver core */  
     driver->driver.owner = owner;  
     driver->driver.bus = &i2c_bus_type;  
   
     /* When registration returns, the driver core 
      * will have called probe() for all matching-but-unbound devices. 
      */  
     res = driver_register(&driver->driver);</span>  
     if (res)  
         return res;  
   
     /* Drivers should switch to dev_pm_ops instead. */  
     if (driver->suspend)  
         pr_warn("i2c-core: driver [%s] using legacy suspend method\n",  
             driver->driver.name);  
     if (driver->resume)  
         pr_warn("i2c-core: driver [%s] using legacy resume method\n",  
             driver->driver.name);  
   
     pr_debug("i2c-core: driver [%s] registered\n", driver->driver.name);  
   
     INIT_LIST_HEAD(&driver->clients);  
     /* Walk the adapters that are already present */  
     i2c_for_each_dev(driver, __process_new_driver);  
   
     return 0;  
 }  
 EXPORT_SYMBOL(i2c_register_driver);  

(driver.c)

[cpp]view plaincopy 
   
 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\n", drv->name);  
   
     other = driver_find(drv->name, drv->bus);  
     if (other) {  
         printk(KERN_ERR "Error: Driver '%s' is already registered, "  
             "aborting...\n", drv->name);  
         return -EBUSY;  
     }  
   
     ret = bus_add_driver(drv);</span>  
     if (ret)  
         return ret;  
     ret = driver_add_groups(drv, drv->groups);  
     if (ret)  
         bus_remove_driver(drv);  
     return ret;  
 }  

(bus.c)

[cpp]view plaincopy 
   
 int bus_add_driver(struct device_driver *drv)  
 {  
     struct bus_type *bus;  
     struct driver_private *priv;  
     int error = 0;  
   
     bus = bus_get(drv->bus);  
     if (!bus)  
         return -EINVAL;  
   
     pr_debug("bus: '%s': add driver %s\n", bus->name, drv->name);  
   
     priv = kzalloc(sizeof(*priv), GFP_KERNEL);  
     if (!priv) {  
         error = -ENOMEM;  
         goto out_put_bus;  
     }  
     klist_init(&priv->klist_devices, NULL, NULL);  
     priv->driver = drv;  
     drv->p = priv;  
     priv->kobj.kset = bus->p->drivers_kset;  
     error = kobject_init_and_add(&priv->kobj, &driver_ktype, NULL,  
                      "%s", drv->name);  
     if (error)  
         goto out_unregister;  
   
     klist_add_tail(&priv->knode_bus, &bus->p->klist_drivers);  
     if (drv->bus->p->drivers_autoprobe) {  
         <span style="color:#FF6666;">error = driver_attach(drv);</span>  
         if (error)  
             goto out_unregister;  
     }  
     module_add_driver(drv->owner, drv);  
   
     error = driver_create_file(drv, &driver_attr_uevent);  
     if (error) {  
         printk(KERN_ERR "%s: uevent attr (%s) failed\n",  
             __func__, drv->name);  
     }  
     error = driver_add_attrs(bus, drv);  
     if (error) {  
         /* How the hell do we get out of this pickle? Give up */  
         printk(KERN_ERR "%s: driver_add_attrs(%s) failed\n",  
             __func__, drv->name);  
     }  
   
     if (!drv->suppress_bind_attrs) {  
         error = add_bind_files(drv);  
         if (error) {  
             /* Ditto */  
             printk(KERN_ERR "%s: add_bind_files(%s) failed\n",  
                 __func__, drv->name);  
         }  
     }  
   
     kobject_uevent(&priv->kobj, KOBJ_ADD);  
     return 0;  
   
 out_unregister:  
     kobject_put(&priv->kobj);  
     kfree(drv->p);  
     drv->p = NULL;  
 out_put_bus:  
     bus_put(bus);  
     return error;  
 }  

driver註冊到bus上時，同時會建立uevent屬性文件及bus->attr數組中的屬性文件（如果 bus->attr 有的話）。

(dd.c)

[cpp]view plaincopy 
   
 int driver_attach(struct device_driver *drv)  
 {  
     return bus_for_each_dev(drv->bus, NULL, drv, __driver_attach);  
 }  
 EXPORT_SYMBOL_GPL(driver_attach);  

(bus.c)

[cpp]view plaincopy 
   
 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 = <span style="color:#FF6666;">fn(dev, data);</span>  
     klist_iter_exit(&i);  
     return error;  
 }  
 EXPORT_SYMBOL_GPL(bus_for_each_dev);  

(dd.c)

[cpp]view plaincopy 
   
 static int __driver_attach(struct device *dev, void *data)  
 {  
     struct device_driver *drv = data;  
   
     /* 
      * Lock device and try to bind to it. We drop the error 
      * here and always return 0, because we need to keep trying 
      * to bind to devices and some drivers will return an error 
      * simply if it didn't support the device. 
      * 
      * driver_probe_device() will spit a warning if there 
      * is an error. 
      */  
   
     if (!driver_match_device(drv, dev))</strong>  
         return 0;  
   
     if (dev->parent) /* Needed for USB */  
         device_lock(dev->parent);  
     device_lock(dev);  
     if (!dev->driver)  
         <strong><span style="color:#FF6666;">driver_probe_device(drv, dev);</span></strong>  
     device_unlock(dev);  
     if (dev->parent)  
         device_unlock(dev->parent);  
   
     return 0;  
 }  

driver_match_device调用bus上的match函数进行匹配。具体可以参照各种总线match匹配函数

匹配成功后，会调用driver的probe函数。

[cpp]view plaincopy 
   
 int driver_probe_device(struct device_driver *drv, struct device *dev)  
 {  
     int ret = 0;  
   
     if (!device_is_registered(dev))  
         return -ENODEV;  
   
     pr_debug("bus: '%s': %s: matched device %s with driver %s\n",  
          drv->bus->name, __func__, dev_name(dev), drv->name);  
   
     pm_runtime_get_noresume(dev);  
     pm_runtime_barrier(dev);  
     <span style="color:#FF6666;">ret = really_probe(dev, drv);</span>  
     pm_runtime_put_sync(dev);  
   
     return ret;  
 }  

[cpp]view plaincopy 
   
 static int really_probe(struct device *dev, struct device_driver *drv)  
 {  
     int ret = 0;  
   
     atomic_inc(&probe_count);  
     pr_debug("bus: '%s': %s: probing driver %s with device %s\n",  
          drv->bus->name, __func__, drv->name, dev_name(dev));  
     WARN_ON(!list_empty(&dev->devres_head));  
   
     dev->driver = drv;  
   
     /* If using pinctrl, bind pins now before probing */  
     ret = pinctrl_bind_pins(dev);  
     if (ret)  
         goto probe_failed;  
   
     if (driver_sysfs_add(dev)) {  
         printk(KERN_ERR "%s: driver_sysfs_add(%s) failed\n",  
             __func__, dev_name(dev));  
         goto probe_failed;  
     }  
   
     if (dev->bus->probe) {  
         ret = dev->bus->probe(dev);  
         if (ret)  
             goto probe_failed;  
     } else if (drv->probe) {  
         <span style="color:#FF6666;">ret = drv->probe(dev);</span>  
         if (ret)  
             goto probe_failed;  
     }
   
     driver_bound(dev);  
     ret = 1;  
     pr_debug("bus: '%s': %s: bound device %s to driver %s\n",  
          drv->bus->name, __func__, dev_name(dev), drv->name);  
     goto done;  
   
 probe_failed:  
     devres_release_all(dev);  
     driver_sysfs_remove(dev);  
     dev->driver = NULL;  
   
     if (ret == -EPROBE_DEFER) {  
         /* Driver requested deferred probing */  
         dev_info(dev, "Driver %s requests probe deferral\n", drv->name);  
         driver_deferred_probe_add(dev);  
     } else if (ret != -ENODEV && ret != -ENXIO) {  
         /* driver matched but the probe failed */  
         printk(KERN_WARNING  
                "%s: probe of %s failed with error %d\n",  
                drv->name, dev_name(dev), ret);  
     } else {  
         pr_debug("%s: probe of %s rejects match %d\n",  
                drv->name, dev_name(dev), ret);  
     }  
     /* 
      * Ignore errors returned by ->probe so that the next driver can try 
      * its luck. 
      */  
     ret = 0;  
 done:  
     atomic_dec(&probe_count);  
     wake_up(&probe_waitqueue);  
     return ret;  
 }  

如果bus->probe爲空，就執行drv->probe

二、驅動中的probe函數參數如何產生的？

根據函數參數傳遞可以跟蹤到，是從bus_for_each_dev中獲得參數的。

[cpp]view plaincopy 
   
 int driver_attach(struct device_driver *drv)  
 {  
     return bus_for_each_dev(<span style="color:#FF0000;"><strong>drv->bus, NULL, drv, __driver_attach</strong></span>);  
 }  
 EXPORT_SYMBOL_GPL(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 ((<strong><span style="color:#FF0000;">dev = next_device(&i)</span></strong>) && !error)  
         error = fn(dev, data);  
     klist_iter_exit(&i);  
     return error;  
 }  

這樣可以看到klist_iter_init_node實際調用klist_iter_init_node（&bus->p->klist_devices, &i,NULL），所以，跟蹤klist_iter_init_node函數，發現並沒做什麼相關重要的東西。

[cpp]view plaincopy 
   
 void klist_iter_init_node(struct klist *k, struct klist_iter *i,  
               struct klist_node *n)  
 {  
     i->i_klist = k;  
     i->i_cur = n;  
     if (n)  
         kref_get(&n->n_ref);  
 }  
 EXPORT_SYMBOL_GPL(klist_iter_init_node);  

[cpp]view plaincopy 
   
 static struct device *next_device(struct klist_iter *i)  
 {  
     struct klist_node *n = klist_next(i);  
     struct device *dev = NULL;  
     struct device_private *dev_prv;  
   
     if (n) {  
         dev_prv =<span style="color:#FF0000;"> to_device_private_bus(n);</span>  
         <span style="color:#FF0000;">dev = dev_prv->device;</span>  
     }  
     return dev;  
 }  

可以看出，只要得到dev_prv就可以得到dev。下面的問題就是dev_prv中的dev如何被添加進去的呢？

[cpp]view plaincopy 
   
 #define to_device_private_bus(obj)  \  
     container_of(obj, struct device_private, knode_bus)  

這裏引用其他一些文章解釋：

先上几个struct：

struct klist_iter {

struct klist *i_klist;

struct klist_node *i_cur;

};

struct klist {

spinlock_t k_lock;

struct list_head k_list;

void (*get)(struct klist_node *);

void (*put)(struct klist_node *);

} __attribute__ ((aligned (sizeof(void*))));

struct klist_node {

void *n_klist; /* never access directly */

struct list_head n_node;

struct kref n_ref;

};

struct kref {

atomic_t refcount;

};

其中的klist_iter_init_node(&bus->p->klist_devices, &i,(start ?&start->p->knode_bus :NULL))作用是定义个klist_iter指向此klist，以便以后直接使用，如图：

[cpp]view plaincopy 
   
 static struct device *next_device(struct klist_iter *i)  
 {  
     struct klist_node *n =<span style="color:#FF0000;"> <strong>klist_next(i);</strong></span>  
     struct device *dev = NULL;  
     struct device_private *dev_prv;  
   
     if (n) {  
         dev_prv = to_device_private_bus(n);  
         dev = dev_prv->device;  
     }  
     return dev;  
 }  

（klist.c）

[cpp]view plaincopy 
   
 struct klist_node *klist_next(struct klist_iter *i)  
 {  
     void (*put)(struct klist_node *) = i->i_klist->put;  
     struct klist_node *last = i->i_cur;  <span style="color:#FFCCCC;"> <span style="color:#009900;">// NULL</span></span>  
     struct klist_node *next;  
   
     spin_lock(&i->i_klist->k_lock);  
   
     if (last) {  
         next = to_klist_node(last->n_node.next);  
         if (!klist_dec_and_del(last))  
             put = NULL;  
     } else  
         <span style="color:#FF0000;">next = to_klist_node(i->i_klist->k_list.next);</span>  
   
     i->i_cur = NULL;  
     while (next != to_klist_node(&i->i_klist->k_list)) {  
         if (likely(!knode_dead(next))) {  
             kref_get(&next->n_ref);  
             i->i_cur = next;  
             break;  
         }  
         next = to_klist_node(next->n_node.next);  
     }  
   
     spin_unlock(&i->i_klist->k_lock);  
   
     if (put && last)  
         put(last);  
     return i->i_cur;  
 }  
 EXPORT_SYMBOL_GPL(klist_next);  

這裏可以知道i->i_cur=NULL，i->i_klist=&bus->p->klist_devices。 to_klist_node 從klist中取得下一個node賦值給next，然後執行一次while循環裏的內容，將next賦值給i->i_cur。這樣就得到了klist_node. to_device_private_bus通過container_of 得到struct device_private。下圖說明其中的關係。

由此，可以知道DTS解析後的設備都是通過klist和klist_node掛載到bus上的。

三、 DTS的解析掛載

dts文件編譯時通過dtc被編譯成了dtb文件。然後在內核啓動時該文件被解析。DTS节点信息保存到allnodes鏈表中。

start_kernel() --> setup_arch() --> unflatten_device_tree()

随后，当系统启动到board文件时，会调用.init_machine，高通8974平台对应的是msm8974_init()。接着调用of_platform_populate(....)接口，加载平台总线和平台设备。

(kernel/arch/arm/mach-msm/board-8226.c)

[cpp]view plaincopy 
   
 void __init msm8226_init(void)  
 {  
     board_dt_populate(adata);</span>  
     msm8226_add_drivers();  
 }  

(kernel/arch/arm/mach-msm/board-dt.c)

[cpp]view plaincopy 
   
 void __init board_dt_populate(struct of_dev_auxdata *adata)  
 {  
     of_platform_populate(NULL, of_default_bus_match_table, NULL, NULL);
   
     /* Explicitly parent the /soc devices to the root node to preserve 
      * the kernel ABI (sysfs structure, etc) until userspace is updated 
      */  
     of_platform_populate(of_find_node_by_path("/soc"),  
                  of_default_bus_match_table, adata, NULL);
 }  

上面兩句話，一個是以“/”爲根進行遍歷;一個是遍歷allnodes鏈找到“/soc”，並以這一節點爲根節點進行遍歷。

（kernel/driver/of/platform.c）

[cpp]view plaincopy 
   
 int of_platform_populate(struct device_node *root,  
             const struct of_device_id *matches,  
             const struct of_dev_auxdata *lookup,  
             struct device *parent)  
 {  
     struct device_node *child;  
     int rc = 0;  
   
     root = root ? of_node_get(root) : of_find_node_by_path("/");  
     if (!root)  
         return -EINVAL;  
   
     for_each_child_of_node(root, child) {  
         rc = of_platform_bus_create(child, matches, lookup, parent, true);  
         if (rc)  
             break;  
     }  
   
     of_node_put(root);  
     return rc;  
 }  
 #endif /* CONFIG_OF_ADDRESS */  

of_platform_populate遍歷根節點下的所有節點，分配建立platform device。for_each_child_of_node實現遍歷父節點下的所有兄弟節點及孩子節點。

[cpp]view plaincopy 
   
 #define for_each_child_of_node(parent, child) \  
     for (child = of_get_next_child(parent, NULL); child != NULL; \  
          child = of_get_next_child(parent, child))  

[cpp]view plaincopy 
   
 struct device_node *of_get_next_child(const struct device_node *node,  
     struct device_node *prev)  
 {  
     struct device_node *next;  
   
     read_lock(&devtree_lock);  
     next = prev ? prev->sibling : node->child;  
     for (; next; next = next->sibling)  
         if (of_node_get(next))  
             break;  
     of_node_put(prev);  
     read_unlock(&devtree_lock);  
     return next;  
 }  
 EXPORT_SYMBOL(of_get_next_child);  

[cpp]view plaincopy 
   
 （kernel/driver/of/platform.c）  
   
 static int of_platform_bus_create(struct device_node *bus,  
                   const struct of_device_id *matches,  
                   const struct of_dev_auxdata *lookup,  
                   struct device *parent, bool strict)  
 {  
     const struct of_dev_auxdata *auxdata;  
     struct device_node *child;  
     struct platform_device *dev;  
     const char *bus_id = NULL;  
     void *platform_data = NULL;  
     int rc = 0;  
   
     /* Make sure it has a compatible property */  
     if (strict && (!of_get_property(bus, "compatible", NULL))) {  
         pr_debug("%s() - skipping %s, no compatible prop\n",  
              __func__, bus->full_name);  
         return 0;  
     }  
   
     auxdata = of_dev_lookup(lookup, bus);  
     if (auxdata) {  
         bus_id = auxdata->name;  
         platform_data = auxdata->platform_data;  
     }  
   
     if (of_device_is_compatible(bus, "arm,primecell")) {  
         of_amba_device_create(bus, bus_id, platform_data, parent);  
         return 0;  
     }  
   
     dev = of_platform_device_create_pdata(bus, bus_id, platform_data, parent);
     if (!dev || !of_match_node(matches, bus))  
         return 0;  
   
      for_each_child_of_node(bus, child) {  
         pr_debug("   create child: %s\n", child->full_name);  
          rc = of_platform_bus_create(child, matches, lookup, &dev->dev, strict);  
         if (rc) {  
             of_node_put(child);  
             break;  
         }  
     }  
     return rc;  
 }  

[cpp]view plaincopy 
   
 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))  
         return NULL;  
   
     dev = of_device_alloc(np, bus_id, parent);
     if (!dev)  
         return NULL;  
   
 #if defined(CONFIG_MICROBLAZE)  
     dev->archdata.dma_mask = 0xffffffffUL;  
 #endif  
     dev->dev.coherent_dma_mask = DMA_BIT_MASK(sizeof(dma_addr_t) * 8);  
     dev->dev.bus = &platform_bus_type;  
     dev->dev.platform_data = platform_data;  
   
     /* We do not fill the DMA ops for platform devices by default. 
      * This is currently the responsibility of the platform code 
      * to do such, possibly using a device notifier 
      */  
   
     if (of_device_add(dev) != 0) {  
         platform_device_put(dev);  
         return NULL;  
     }  
   
     return dev;  
 }  

of_device_alloc根據allnodes的device node分配platform device空間。然後設置platform device的bus總線。

[cpp]view plaincopy 
   
 struct platform_device *of_device_alloc(struct device_node *np,  
                   const char *bus_id,  
                   struct device *parent)  
 {  
     struct platform_device *dev;  
     int rc, i, num_reg = 0, num_irq;  
     struct resource *res, temp_res;  
   
     dev = platform_device_alloc("", -1);  
     if (!dev)  
         return NULL;  
   
     /* count the io and irq resources */  
     if (of_can_translate_address(np))  
         while (of_address_to_resource(np, num_reg, &temp_res) == 0)  
             num_reg++;  
     num_irq = of_irq_count(np);  
   
     /* Populate the resource table */  
     if (num_irq || num_reg) {  
         res = kzalloc(sizeof(*res) * (num_irq + num_reg), GFP_KERNEL);  
         if (!res) {  
             platform_device_put(dev);  
             return NULL;  
         }  
   
         dev->num_resources = num_reg + num_irq;  
         dev->resource = res;  
         for (i = 0; i < num_reg; i++, res++) {  
             rc = of_address_to_resource(np, i, res);  
             WARN_ON(rc);  
         }  
         WARN_ON(of_irq_to_resource_table(np, res, num_irq) != num_irq);  
     }  
   
     dev->dev.of_node = of_node_get(np);
 #if defined(CONFIG_MICROBLAZE)  
     dev->dev.dma_mask = &dev->archdata.dma_mask;  
 #endif  
     dev->dev.parent = parent;  
   
     if (bus_id)  
         dev_set_name(&dev->dev, "%s", bus_id);  
     else  
         of_device_make_bus_id(&dev->dev);  
   
     return dev;  
 }  
 EXPORT_SYMBOL(of_device_alloc);  

分配platform device空間後，注意將device node賦值給dev->dev.of_node，這也就是爲什麼經常在probe函數中見到通過pdev->dev.of_node得到dts 設備節點，並從該節點中讀取相關信息。

I2C platform device驅動加載在i2c-qup.c文件中。下面是i2c-qup platform device驅動加載及i2c-client的驅動加載。

（i2c-qup.c）

[cpp]view plaincopy 
   
 static int __devinit  
 qup_i2c_probe(struct platform_device *pdev)  
 {  
     struct qup_i2c_dev  *dev;  
     struct resource         *qup_mem, *gsbi_mem, *qup_io, *gsbi_io, *res;  
     struct resource     *in_irq, *out_irq, *err_irq;  
     struct clk         *clk, *pclk;  
     int  ret = 0;  
     int  i;  
     int  dt_gpios[I2C_GPIOS_DT_CNT];  
     bool use_device_tree = pdev->dev.of_node;  
     struct msm_i2c_platform_data *pdata;  
   
     gsbi_mem = NULL;  
     dev_dbg(&pdev->dev, "qup_i2c_probe\n");  
   
     if (use_device_tree) {  
         pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);  
         if (!pdata)  
             return -ENOMEM;  
   
         ret = msm_i2c_rsrcs_dt_to_pdata_map(pdev, pdata, dt_gpios);  
         if (ret)  
             goto get_res_failed;  
     } else  
         pdata = pdev->dev.platform_data;  
   
     if (!pdata) {  
         dev_err(&pdev->dev, "platform data not initialized\n");  
         return -ENOSYS;  
     }  
     qup_mem = platform_get_resource_byname(pdev, IORESOURCE_MEM,  
                         "qup_phys_addr");  
     if (!qup_mem) {  
         dev_err(&pdev->dev,  
             "platform_get_resource_byname(qup_phys_addr) failed\n");  
         ret = -ENODEV;  
         goto get_res_failed;  
     }  
   
     /* 
      * We only have 1 interrupt for new hardware targets and in_irq, 
      * out_irq will be NULL for those platforms 
      */  
     in_irq = platform_get_resource_byname(pdev, IORESOURCE_IRQ,  
                         "qup_in_intr");  
   
     out_irq = platform_get_resource_byname(pdev, IORESOURCE_IRQ,  
                         "qup_out_intr");  
   
     err_irq = platform_get_resource_byname(pdev, IORESOURCE_IRQ,  
                         "qup_err_intr");  
     if (!err_irq) {  
         dev_err(&pdev->dev, "no error irq resource?\n");  
         ret = -ENODEV;  
         goto get_res_failed;  
     }  
   
     qup_io = request_mem_region(qup_mem->start, resource_size(qup_mem),  
                     pdev->name);  
     if (!qup_io) {  
         dev_err(&pdev->dev, "QUP region already claimed\n");  
         ret = -EBUSY;  
         goto get_res_failed;  
     }  
     if (!pdata->use_gsbi_shared_mode) {  
         gsbi_mem = platform_get_resource_byname(pdev, IORESOURCE_MEM,  
                             "gsbi_qup_i2c_addr");  
         if (!gsbi_mem) {  
             dev_dbg(&pdev->dev, "Assume BLSP\n");  
             /* 
              * BLSP core does not need protocol programming so this 
              * resource is not expected 
              */  
             goto blsp_core_init;  
         }  
         gsbi_io = request_mem_region(gsbi_mem->start,  
                         resource_size(gsbi_mem),  
                         pdev->name);  
         if (!gsbi_io) {  
             dev_err(&pdev->dev, "GSBI region already claimed\n");  
             ret = -EBUSY;  
             goto err_res_failed;  
         }  
     }  
   
 blsp_core_init:  
     clk = clk_get(&pdev->dev, "core_clk");  
     if (IS_ERR(clk)) {  
         dev_err(&pdev->dev, "Could not get core_clk\n");  
         ret = PTR_ERR(clk);  
         goto err_clk_get_failed;  
     }  
   
     pclk = clk_get(&pdev->dev, "iface_clk");  
     if (IS_ERR(pclk)) {  
         dev_err(&pdev->dev, "Could not get iface_clk\n");  
         ret = PTR_ERR(pclk);  
         clk_put(clk);  
         goto err_clk_get_failed;  
     }  
   
     /* We support frequencies upto FAST Mode(400KHz) */  
     if (pdata->clk_freq <= 0 ||  
             pdata->clk_freq > 400000) {  
         dev_err(&pdev->dev, "clock frequency not supported\n");  
         ret = -EIO;  
         goto err_config_failed;  
     }  
   
     dev = kzalloc(sizeof(struct qup_i2c_dev), GFP_KERNEL);  
     if (!dev) {  
         ret = -ENOMEM;  
         goto err_alloc_dev_failed;  
     }  
   
     dev->dev = &pdev->dev;  
     if (in_irq)  
         dev->in_irq = in_irq->start;  
     if (out_irq)  
         dev->out_irq = out_irq->start;  
     dev->err_irq = err_irq->start;  
     if (in_irq && out_irq)  
         dev->num_irqs = 3;  
     else  
         dev->num_irqs = 1;  
     dev->clk = clk;  
     dev->pclk = pclk;  
     dev->base = ioremap(qup_mem->start, resource_size(qup_mem));  
     if (!dev->base) {  
         ret = -ENOMEM;  
         goto err_ioremap_failed;  
     }  
   
     /* Configure GSBI block to use I2C functionality */  
     if (gsbi_mem) {  
         dev->gsbi = ioremap(gsbi_mem->start, resource_size(gsbi_mem));  
         if (!dev->gsbi) {  
             ret = -ENOMEM;  
             goto err_gsbi_failed;  
         }  
     }  
   
     for (i = 0; i < ARRAY_SIZE(i2c_rsrcs); ++i) {  
         if (use_device_tree && i < I2C_GPIOS_DT_CNT) {  
             dev->i2c_gpios[i] = dt_gpios[i];  
         } else {  
             res = platform_get_resource_byname(pdev, IORESOURCE_IO,  
                                i2c_rsrcs[i]);  
             dev->i2c_gpios[i] = res ? res->start : -1;  
         }  
     }  
   
     platform_set_drvdata(pdev, dev);  
   
     dev->one_bit_t = (USEC_PER_SEC/pdata->clk_freq) + 1;  
     dev->pdata = pdata;  
     dev->clk_ctl = 0;  
     dev->pos = 0;  
   
     ret = i2c_qup_clk_path_init(pdev, dev);  
     if (ret) {  
         dev_err(&pdev->dev,  
         "Failed to init clock path-voting data structs. err:%d", ret);  
         /* disable i2c_qup_clk_path_xxx() functionality */  
         dev->pdata->master_id = 0;  
     }  
   
     if (dev->pdata->src_clk_rate <= 0) {  
         dev_info(&pdev->dev,  
             "No src_clk_rate specified in platfrom data\n");  
         dev_info(&pdev->dev, "Using default clock rate %dHz\n",  
                             DEFAULT_CLK_RATE);  
         dev->pdata->src_clk_rate = DEFAULT_CLK_RATE;  
     }  
   
     ret = clk_set_rate(dev->clk, dev->pdata->src_clk_rate);  
     if (ret)  
         dev_info(&pdev->dev, "clk_set_rate(core_clk, %dHz):%d\n",  
                     dev->pdata->src_clk_rate, ret);  
   
     clk_prepare_enable(dev->clk);  
     clk_prepare_enable(dev->pclk);  
     /* 
      * If bootloaders leave a pending interrupt on certain GSBI's, 
      * then we reset the core before registering for interrupts. 
      */  
     writel_relaxed(1, dev->base + QUP_SW_RESET);  
     if (qup_i2c_poll_state(dev, 0, true) != 0)  
         goto err_reset_failed;  
     clk_disable_unprepare(dev->clk);  
     clk_disable_unprepare(dev->pclk);  
   
     /* 
      * We use num_irqs to also indicate if we got 3 interrupts or just 1. 
      * If we have just 1, we use err_irq as the general purpose irq 
      * and handle the changes in ISR accordingly 
      * Per Hardware guidelines, if we have 3 interrupts, they are always 
      * edge triggering, and if we have 1, it's always level-triggering 
      */  
     if (dev->num_irqs == 3) {  
         ret = request_irq(dev->in_irq, qup_i2c_interrupt,  
                 IRQF_TRIGGER_RISING, "qup_in_intr", dev);  
         if (ret) {  
             dev_err(&pdev->dev, "request_in_irq failed\n");  
             goto err_request_irq_failed;  
         }  
         /* 
          * We assume out_irq exists if in_irq does since platform 
          * configuration either has 3 interrupts assigned to QUP or 1 
          */  
         ret = request_irq(dev->out_irq, qup_i2c_interrupt,  
                 IRQF_TRIGGER_RISING, "qup_out_intr", dev);  
         if (ret) {  
             dev_err(&pdev->dev, "request_out_irq failed\n");  
             free_irq(dev->in_irq, dev);  
             goto err_request_irq_failed;  
         }  
         ret = request_irq(dev->err_irq, qup_i2c_interrupt,  
                 IRQF_TRIGGER_RISING, "qup_err_intr", dev);  
         if (ret) {  
             dev_err(&pdev->dev, "request_err_irq failed\n");  
             free_irq(dev->out_irq, dev);  
             free_irq(dev->in_irq, dev);  
             goto err_request_irq_failed;  
         }  
     } else {  
         ret = request_irq(dev->err_irq, qup_i2c_interrupt,  
                 IRQF_TRIGGER_HIGH, "qup_err_intr", dev);  
         if (ret) {  
             dev_err(&pdev->dev, "request_err_irq failed\n");  
             goto err_request_irq_failed;  
         }  
     }  
     disable_irq(dev->err_irq);  
     if (dev->num_irqs == 3) {  
         disable_irq(dev->in_irq);  
         disable_irq(dev->out_irq);  
     }  
     i2c_set_adapdata(&dev->adapter, dev);  
     dev->adapter.algo = &qup_i2c_algo;  
     strlcpy(dev->adapter.name,  
         "QUP I2C adapter",  
         sizeof(dev->adapter.name));  
     dev->adapter.nr = pdev->id;  
     dev->adapter.dev.parent = &pdev->dev;  
     if (pdata->msm_i2c_config_gpio)  
         pdata->msm_i2c_config_gpio(dev->adapter.nr, 1);  
   
     mutex_init(&dev->mlock);  
     dev->pwr_state = MSM_I2C_PM_SUSPENDED;  
     /* If the same AHB clock is used on Modem side 
      * switch it on here itself and don't switch it 
      * on and off during suspend and resume. 
      */  
     if (dev->pdata->keep_ahb_clk_on)  
         clk_prepare_enable(dev->pclk);  
   
     ret = i2c_add_numbered_adapter(&dev->adapter);  
     if (ret) {  
         dev_err(&pdev->dev, "i2c_add_adapter failed\n");  
         if (dev->num_irqs == 3) {  
             free_irq(dev->out_irq, dev);  
             free_irq(dev->in_irq, dev);  
         }  
         free_irq(dev->err_irq, dev);  
     } else {  
         if (dev->dev->of_node) {  
             dev->adapter.dev.of_node = pdev->dev.of_node;  
             of_i2c_register_devices(&dev->adapter);
         }  
   
         pm_runtime_set_autosuspend_delay(&pdev->dev, MSEC_PER_SEC);  
         pm_runtime_use_autosuspend(&pdev->dev);  
         pm_runtime_enable(&pdev->dev);  
         return 0;  
     }  
   
   
 err_request_irq_failed:  
     if (dev->gsbi)  
         iounmap(dev->gsbi);  
 err_reset_failed:  
     clk_disable_unprepare(dev->clk);  
     clk_disable_unprepare(dev->pclk);  
     i2c_qup_clk_path_teardown(dev);  
 err_gsbi_failed:  
     iounmap(dev->base);  
 err_ioremap_failed:  
     kfree(dev);  
 err_alloc_dev_failed:  
 err_config_failed:  
     clk_put(clk);  
     clk_put(pclk);  
 err_clk_get_failed:  
     if (gsbi_mem)  
         release_mem_region(gsbi_mem->start, resource_size(gsbi_mem));  
 err_res_failed:  
     release_mem_region(qup_mem->start, resource_size(qup_mem));  
 get_res_failed:  
     if (pdev->dev.of_node)  
         kfree(pdata);  
     return ret;  
 }  

i2c、spi等都是platform bus，在msm8974_init()時调用of_platform_populate(....)接口註冊到系統中。這樣在i2c bus驅動中就可以調用of_i2c_register_devices，將i2c設備註冊到i2c bus上。

(of_i2c.c)

[cpp]view plaincopy 
   
 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_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;  
   
         request_module("%s%s", I2C_MODULE_PREFIX, info.type);  
   
         <span style="color:#FF0000;">result = i2c_new_device(adap, &info);</span>  
         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;  
         }  
     }  
 }  
 EXPORT_SYMBOL(of_i2c_register_devices);  

of_i2c_register_devices從解析後的allnodes鏈表信息取出節點，解析具體信息後，放到stuct i2c_board_info中，用於建立i2c-client。

(I2c-core.c)

[cpp]view plaincopy 
   
 struct i2c_client *  
 i2c_new_device(struct i2c_adapter *adap, struct i2c_board_info const *info)  
 {  
     struct i2c_client   *client;  
     int         status;  
   
     client = kzalloc(sizeof *client, GFP_KERNEL);  
     if (!client)  
         return NULL;  
   
     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;  
   
     /* For 10-bit clients, add an arbitrary offset to avoid collisions */  
     dev_set_name(&client->dev, "%d-%04x", i2c_adapter_id(adap),  
              client->addr | ((client->flags & I2C_CLIENT_TEN)  
                      ? 0xa000 : 0));  
     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;  
 }  
 EXPORT_SYMBOL_GPL(i2c_new_device);  

（bus.c）

[cpp]view plaincopy 
   
 int device_register(struct device *dev)  
 {  
     device_initialize(dev);  
     return device_add(dev);
 }  

[cpp]view plaincopy 
   
 int device_add(struct device *dev)  
 {  
     struct device *parent = NULL;  
     struct kobject *kobj;  
     struct class_interface *class_intf;  
     int error = -EINVAL;  
   
     dev = get_device(dev);  
     if (!dev)  
         goto done;  
   
     if (!dev->p) {  
         error = device_private_init(dev);  
         if (error)  
             goto done;  
     }  
   
     /* 
      * for statically allocated devices, which should all be converted 
      * some day, we need to initialize the name. We prevent reading back 
      * the name, and force the use of dev_name() 
      */  
     if (dev->init_name) {  
         dev_set_name(dev, "%s", dev->init_name);  
         dev->init_name = NULL;  
     }  
   
     /* subsystems can specify simple device enumeration */  
     if (!dev_name(dev) && dev->bus && dev->bus->dev_name)  
         dev_set_name(dev, "%s%u", dev->bus->dev_name, dev->id);  
   
     if (!dev_name(dev)) {  
         error = -EINVAL;  
         goto name_error;  
     }  
   
     pr_debug("device: '%s': %s\n", dev_name(dev), __func__);  
   
     parent = get_device(dev->parent);  
     kobj = get_device_parent(dev, parent);  
     if (kobj)  
         dev->kobj.parent = kobj;  
   
     /* use parent numa_node */  
     if (parent)  
         set_dev_node(dev, dev_to_node(parent));  
   
     /* first, register with generic layer. */  
     /* we require the name to be set before, and pass NULL */  
     error = kobject_add(&dev->kobj, dev->kobj.parent, NULL);  
     if (error)  
         goto Error;  
   
     /* notify platform of device entry */  
     if (platform_notify)  
         platform_notify(dev);  
   
     error = device_create_file(dev, &uevent_attr);  
     if (error)  
         goto attrError;  
   
     if (MAJOR(dev->devt)) {  
         error = device_create_file(dev, &devt_attr);  
         if (error)  
             goto ueventattrError;  
   
         error = device_create_sys_dev_entry(dev);  
         if (error)  
             goto devtattrError;  
   
         devtmpfs_create_node(dev);  
     }  
   
     error = device_add_class_symlinks(dev);  
     if (error)  
         goto SymlinkError;  
     error = device_add_attrs(dev);  
     if (error)  
         goto AttrsError;  
    error = bus_add_device(dev);
     if (error)  
         goto BusError;  
     error = dpm_sysfs_add(dev);  
     if (error)  
         goto DPMError;  
     device_pm_add(dev);  
   
     /* Notify clients of device addition.  This call must come 
      * after dpm_sysfs_add() and before kobject_uevent(). 
      */  
     if (dev->bus)  
         blocking_notifier_call_chain(&dev->bus->p->bus_notifier,  
                          BUS_NOTIFY_ADD_DEVICE, dev);  
   
     kobject_uevent(&dev->kobj, KOBJ_ADD);  
     bus_probe_device(dev);  
     if (parent)  
         klist_add_tail(&dev->p->knode_parent,  
                    &parent->p->klist_children);  
   
     if (dev->class) {  
         mutex_lock(&dev->class->p->mutex);  
         /* tie the class to the device */  
         klist_add_tail(&dev->knode_class,  
                    &dev->class->p->klist_devices);  
   
         /* notify any interfaces that the device is here */  
         list_for_each_entry(class_intf,  
                     &dev->class->p->interfaces, node)  
             if (class_intf->add_dev)  
                 class_intf->add_dev(dev, class_intf);  
         mutex_unlock(&dev->class->p->mutex);  
     }  
 done:  
     put_device(dev);  
     return error;  
  DPMError:  
     bus_remove_device(dev);  
  BusError:  
     device_remove_attrs(dev);  
  AttrsError:  
     device_remove_class_symlinks(dev);  
  SymlinkError:  
     if (MAJOR(dev->devt))  
         devtmpfs_delete_node(dev);  
     if (MAJOR(dev->devt))  
         device_remove_sys_dev_entry(dev);  
  devtattrError:  
     if (MAJOR(dev->devt))  
         device_remove_file(dev, &devt_attr);  
  ueventattrError:  
     device_remove_file(dev, &uevent_attr);  
  attrError:  
     kobject_uevent(&dev->kobj, KOBJ_REMOVE);  
     kobject_del(&dev->kobj);  
  Error:  
     cleanup_device_parent(dev);  
     if (parent)  
         put_device(parent);  
 name_error:  
     kfree(dev->p);  
     dev->p = NULL;  
     goto done;  
 }  
   
 <pre name="code" class="cpp">int bus_add_device(struct device *dev)  
 {  
     struct bus_type *bus = bus_get(dev->bus);  
     int error = 0;  
   
     if (bus) {  
         pr_debug("bus: '%s': add device %s\n", bus->name, dev_name(dev));  
         error = device_add_attrs(bus, dev);  
         if (error)  
             goto out_put;  
         error = sysfs_create_link(&bus->p->devices_kset->kobj,  
                         &dev->kobj, dev_name(dev));  
         if (error)  
             goto out_id;  
         error = sysfs_create_link(&dev->kobj,  
                 &dev->bus->p->subsys.kobj, "subsystem");  
         if (error)  
             goto out_subsys;  
         klist_add_tail(&dev->p->knode_bus, &bus->p->klist_devices);
     }  
     return 0;  
   
 out_subsys:  
     sysfs_remove_link(&bus->p->devices_kset->kobj, dev_name(dev));  
 out_id:  
     device_remove_attrs(bus, dev);  
 out_put:  
     bus_put(dev->bus);  
     return error;  
 }  

這樣，i2c-client device掛載到了i2c bus上。當i2c 設備驅動添加到系統時，就出現了在前幾部分的東西了。從bus上取下i2c-client與i2c-driver進行匹配。

雖然i2-client怎麼掛載到i2c-bus上知道了（由qup_i2c_probe調用of_i2c_register_device掛載）。新的問題又來了：qup_i2c_probe參數是platform_device，i2c-bus又是如何建立platform_device的。

（kernel/include/linux/init.h）

[cpp]view plaincopy 
   
 #define arch_initcall(fn)       <span style="color:#FF0000;">__define_initcall("3",fn,3)</span>  

[cpp]view plaincopy 
   
 #define __define_initcall(level,fn,id) \  
     static initcall_t __initcall_##fn##id __used \  
     __attribute__((__section__(".initcall" level ".init"))) = fn  

將i2c-bus的driver init函數放到.initcall3.init 代碼段中。

之所以，i2c-bus的driver和i2c 設備的驅動init函數使用的不同的函數放到.initcall代碼段，主要原因是後面調用.initcall中的函數執行順序是按.initcall段的函數順序進行的（按照initcall的level從0到7依次存放的）。

（kernel/include/linux/vmlinux.lds.h）

[cpp]view plaincopy 
   
 #define INIT_CALLS_LEVEL(level)                        \  
         VMLINUX_SYMBOL(__initcall##level##_start) = .;        \  
         *(.initcall##level##.init)                \  
         *(.initcall##level##s.init)      
   
 #define INIT_CALLS                          \  
         VMLINUX_SYMBOL(__initcall_start) = .;           \  
         *(.initcallearly.init)                  \  
         INIT_CALLS_LEVEL(0)                 \  
         INIT_CALLS_LEVEL(1)                 \  
         INIT_CALLS_LEVEL(2)                 \  
         INIT_CALLS_LEVEL(3)                 \  
         INIT_CALLS_LEVEL(4)                 \  
         INIT_CALLS_LEVEL(5)                 \  
         INIT_CALLS_LEVEL(rootfs)                \  
         INIT_CALLS_LEVEL(6)                 \  
         INIT_CALLS_LEVEL(7)                 \  
         VMLINUX_SYMBOL(__initcall_end) = .;  

那麼現在根據前面部分內容，知道driver_register將platform bus上的platform device取下來，與driver進行匹配。到此終於理順了從dts節點信息到驅動註冊的完整過程。

四、module_init()中的驅動初始化後函數何時被調用

（kernel/include/linux/init.h）

#define module_init(x) __initcall(x);

#define __initcall(fn)                               device_initcall(fn)
#define device_initcall(fn)                __define_initcall("6",fn,6)
#define __define_initcall(level,fn,id) /
        static initcall_t __initcall_##fn##id __used /
        __attribute__((__section__(".initcall" level ".init"))) = fn

initcall_t（typedef int (*initcall_t)(void)）

這樣就將module_init傳遞的fn函數放到了制定的.initcall6.init 代碼段中。

在linux /init/main.c 中，
static void __init do_initcalls(void)
{
　　initcall_t *call;

　　call = &__initcall_start;
　　do {
　　　(*call)();
　　　call++;
　　} while (call < &__initcall_end);

　　/* Make sure there is no pending stuff from the initcall sequence */
　　flush_scheduled_tasks();
}

通過do_initcalls就可以吧__initcall section段的函數調用起來。

參考文章： http://blog.csdn.net/MarsWG/archive/2004/11/05/168552.aspx

linxi_hnh

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
從DTS到驅動加載的過程分析

一、驅動中的probe函數如何被調用？首先，我們知道驅動執行的起始函數是init函數。以I2C驅動爲例。(cm36283.c)[cpp] view plaincopystatic int __init cm36283_init(void) { int err = 0;
复制链接

扫一扫