1 開發環境

    Host：Ubuntu14.04

    Target：s3c64xx

    Kernel：linux-3.18.2

2 平臺裝置

        關於裝置樹是如果被載入並解析成裝置節點的，詳見參考資料[1]，本文重點分析如何利用裝置節點建立相依的平臺裝置。

2.1 platform_device建立&註冊

（1）裝置匹配表

const struct of_device_id of_default_bus_match_table[] = {
    { .compatible = "simple-bus", },
#ifdef CONFIG_ARM_AMBA
    { .compatible = "arm,amba-bus", },
#endif /* CONFIG_ARM_AMBA */
    {} /* Empty terminated list */
};
 

（2）入口定義

DT_MACHINE_START(S3C6400_DT, "Samsung S3C64xx (Flattened Device Tree)")
    /* Maintainer: Tomasz Figa <[email protected].com> */
    .dt_compat  = s3c64xx_dt_compat,
    .map_io     = s3c64xx_dt_map_io,
    .init_machine   = s3c64xx_dt_init_machine,
    .restart        = s3c64xx_dt_restart,                                                                                                                                                                    
MACHINE_END  
 

原始檔：arch/arm/mach-s3c64xx/mach-s3c64xx-dt.c

對比分析：與《Linux裝置驅動--LCD平臺裝置與驅動（smdk6410）》不同的是，這裡不再使用MACHINE_START，而是使用DT_MACHINE_START取代之[5]。

（3）s3c64xx入口函式

static void __init s3c64xx_dt_init_machine(void)
{
    samsung_wdt_reset_of_init();
    of_platform_populate(NULL, of_default_bus_match_table, NULL, NULL); /* 建立平臺裝置. */
}
 

    在s3c64xx入口函式中，呼叫of_platform_populate（）函式根據裝置節點建立相應的平臺裝置。那麼of_platform_populate（）具體是如何根據裝置節點建立相應的平臺裝置的呢?下文將對此進行詳細分析。

2.2 of_platform_populate（）呼叫過程

（1）of_platform_populate（）

    該函式主要根據裝置節點（device_node）建立相應的平臺裝置：

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; 
}
EXPORT_SYMBOL_GPL(of_platform_populate);

原始檔：drivers/of/platform.c

（2）of_platform_bus_create（）

    該函式呼叫of_platform_device_create_pdata（）函式建立平臺裝置（platform_device），如下第35行所示：

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")) {
        /*
         * Don't return an error here to keep compatibility with older
         * device tree files.
         */
        of_amba_device_create(bus, bus_id, platform_data, parent);
        return 0;
    }
    /* 建立平臺裝置(platform_device) */
    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;
        }
    }
    of_node_set_flag(bus, OF_POPULATED_BUS);
    return rc;
}

原始檔：drivers/of/platform.c

（3）of_platform_device_create_pdata（）

    該函式呼叫of_device_add（）將平臺設備註冊到系統中，如下第26行所示：

static struct platform_device *of_platform_device_create_pdata(
                    struct device_node *np,
                    const char *bus_id,
                    void *platform_data,
                    struct device *parent)
{
    struct platform_device *dev;

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

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

    of_dma_configure(&dev->dev);
    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);
        goto err_clear_flag;
    }

    return dev;

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

原始檔：drivers/of/platform.c

（4）of_device_add（）

    該函式呼叫device_add（）函式將平臺設備註冊到系統中，如下第16行所示：

int of_device_add(struct platform_device *ofdev)
{
    BUG_ON(ofdev->dev.of_node == NULL);

    /* name and id have to be set so that the platform bus doesn't get
     * confused on matching */
    ofdev->name = dev_name(&ofdev->dev);
    ofdev->id = -1; 

    /* device_add will assume that this device is on the same node as
     * the parent. If there is no parent defined, set the node
     * explicitly */
    if (!ofdev->dev.parent)
        set_dev_node(&ofdev->dev, of_node_to_nid(ofdev->dev.of_node));

    return device_add(&ofdev->dev);
}

原始檔：drivers/of/device.c

（5）device_add（）

    該函式是普通的設備註冊函式，與裝置樹並沒有直接的關係。也即說，裝置樹的機制最後在這裡與傳統機制相結合。

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, &dev_attr_uevent);
	if (error)
		goto attrError;

	if (MAJOR(dev->devt)) {
		error = device_create_file(dev, &dev_attr_dev);
		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, &dev_attr_dev);
 ueventattrError:
	device_remove_file(dev, &dev_attr_uevent);
 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;
}
EXPORT_SYMBOL_GPL(device_add);

原始檔：drivers/base/core.c

3 平臺驅動

參考資料