Android下led控制(下)--Linux驱动部分--platform机制

前面写了两个博文，一个是Android下，一个是Linux下led控制，但是Linux下那个写的有很多漏洞和不清楚的地方。这里写一篇作为补充，也是我在学习中理解的深入。当然这个可能也会有很多漏洞，如果我有更深入的了解，继续进行补充。我的开发板是全志科技的CQA83T，成都启划公司出的扩展板。

先贴出来驱动源程序的代码，此代码的位置在 lichee\linux-3.4\drivers\char\led.c：

#include <linux/types.h>
#include <linux/delay.h>
#include <linux/platform_device.h>
#include <linux/init.h>
#include <linux/input.h>
#include <linux/irq.h>
#include <linux/interrupt.h>
#include <linux/jiffies.h>
#include <linux/module.h>
#include <linux/gpio.h>
#include <linux/input/matrix_keypad.h>
#include <linux/slab.h>
#include <asm/io.h>
#include <mach/irqs.h>
#include <mach/hardware.h>
#include <mach/sys_config.h>
#include <linux/miscdevice.h>
#include <linux/printk.h>
#include <linux/kernel.h>

#define LED_IOCTL_SET_ON		1
#define LED_IOCTL_SET_OFF			0
static script_item_u			led_val[5];
static script_item_value_type_e		led_type;
static struct semaphore lock;

//led_open
static int led_open(struct inode *inode, struct file *file)
{
if (!down_trylock(&lock))
return 0;
else
return -EBUSY;
}

//led_close
static int  led_close(struct inode *inode, struct file *file)
{
up(&lock);
return 0;
}

//led_ioctl
static long  led_ioctl(struct file *filep, unsigned int cmd,
unsigned long arg)
{
unsigned int n;
n = (unsigned int)arg;
switch (cmd) {
case LED_IOCTL_SET_ON:
if (n < 1)
return -EINVAL;
if(led_val[n-1].gpio.gpio != -1) {
__gpio_set_value(led_val[n-1].gpio.gpio, 1);
printk("led%d on !\n", n);
}
break;

case LED_IOCTL_SET_OFF:
default:
if (n < 1)
return -EINVAL;
if(led_val[n-1].gpio.gpio != -1) {
__gpio_set_value(led_val[n-1].gpio.gpio, 0);
printk("led%d off !\n", n);
}
break;
}

return 0;
}

//led_gpio
static int __devinit led_gpio(void)
{
int i = 0;
char gpio_num[10];

for(i =1 ; i < 6; i++)
{
sprintf(gpio_num, "led_gpio%d", i);

led_type= script_get_item("led_para", gpio_num, &led_val[i-1]);
if(SCIRPT_ITEM_VALUE_TYPE_PIO != led_type) {
printk("led_gpio type fail !");
//			gpio_free(led_val[i-1].gpio.gpio);
led_val[i-1].gpio.gpio	= -1;
continue;
}

if(0 != gpio_request(led_val[i-1].gpio.gpio, NULL)) {
printk("led_gpio gpio_request fail !");
led_val[i-1].gpio.gpio = -1;
continue;
}

if (0 != gpio_direction_output(led_val[i-1].gpio.gpio, 0)) {
printk("led_gpio gpio_direction_output fail !");
//			gpio_free(led_val[i-1].gpio.gpio);
led_val[i-1].gpio.gpio = -1;
continue;
}
}

return 0;
}

//file_operations
static struct file_operations leds_ops = {
.owner			= THIS_MODULE,
.open			= led_open,
.release		= led_close,
.unlocked_ioctl		= led_ioctl,
};

//miscdevice
static struct miscdevice leds_dev = {
.minor = MISC_DYNAMIC_MINOR,
.name = "led",
.fops = &leds_ops,
};

//led_remove
static int __devexit led_remove(struct platform_device *pdev)
{
return 0;
}

//led_probe
static int __devinit led_probe(struct platform_device *pdev)
{
int led_used;
script_item_u	val;
script_item_value_type_e  type;

int err;

printk("led_para!\n");
type = script_get_item("led_para", "led_used", &val);
if (SCIRPT_ITEM_VALUE_TYPE_INT != type) {
printk("%s script_get_item \"led_para\" led_used = %d\n",
__FUNCTION__, val.val);
return -1;
}
led_used = val.val;
printk("%s script_get_item \"led_para\" led_used = %d\n",
__FUNCTION__, val.val);

if(!led_used) {
printk("%s led_used is not used in config,  led_used=%d\n", __FUNCTION__,led_used);
return -1;
}

err = led_gpio();
if (err)
return -1;

sema_init(&lock, 1);
err = misc_register(&leds_dev);
printk("======= cqa83 led initialized ================\n");

return err;
}

//platform_device
struct platform_device led_device = {
.name		= "led",
};

//platform_driver
static struct platform_driver led_driver = {
.probe		= led_probe,
.remove		= __devexit_p(led_remove),
.driver		= {
.name	= "led",
.owner	= THIS_MODULE,
},
};

//led_init
static int __init led_init(void)
{

if (platform_device_register(&led_device)) {
printk("%s: register gpio device failed\n", __func__);
}
if (platform_driver_register(&led_driver)) {
printk("%s: register gpio driver failed\n", __func__);
}

return 0;
}

//led_exit
static void __exit led_exit(void)
{
platform_driver_unregister(&led_driver);
}

module_init(led_init);
module_exit(led_exit);

MODULE_DESCRIPTION("Led Driver");
MODULE_LICENSE("GPL v2");

首先，在这里我们应该获取这样几个信息，

1、这是一个Linux驱动程序，一个字符驱动，一个杂项字符驱动。从err = misc_register(&leds_dev);可以知道是杂项字符驱动。

2、这里使用到了Linux的GPIO驱动模型。

3、这个驱动是基于platform机制的。

第一，我们先说一说platform机制。

platform机制是Linux2.6引入的一套新的驱动管理和注册机制，Linux大部分设备驱动中都能使用这套机制。platform是一种虚拟总线，主要用来管理CPU的片上资源具有很好的移植性。platform机制本身的使用并不复杂，由platform_device(总是设备)和platform_driver(总线驱动)两部分组成，设备用platform_device表示，驱动用platform_driver注册。系统首先会初始化platform总线，当platform设备想要挂载到总线上时，定义platform_device和platform_driver，然后使用函数platform_device_register注册platform_device，再使用platform_driver_register函数注册platform_driver驱动，这里要记住，platform_device_register它一定要在platform_driver_register之前。也就是一定要先注册设备再注册驱动，因为在驱动注册是，要先查找与之对应的设备，如果能够找到并匹配成功才能注册驱动。具体细节下面会分析。

下面，我们来说一下platform总线，platform总线相关的代码都在内核 linux-3.4\drivers\base\platform.c里面。既然platform总线是在内核启动时初始化，那么先列出初始化函数的调用过程，asmlinkagevoid __init start_kernel(void)[linux-3.4\init\main.c]
--> static noinline void __init_refok rest_init(void)[linux-3.4\init\main.c] --> static
int __init kernel_init(void * unused)[linux-3.4\init\main.c] --> static void __init do_basic_setup(void)
[linux-3.4\init\main.c] --> void __init driver_init(void) [linux-3.4\drivers\base\init.c] --> int
__init platform_bus_init(void) [linux-3.4\drivers\base\platform.c] ，中括号里是文件位置，函数platform_bus_init就是platform的总线初始化函数。

来看platform总线初始化函数platform_bus_init，位于linux-3.4\drivers\base\platform.c中：

int __init platform_bus_init(void)
{
int error;

early_platform_cleanup();

error = device_register(&platform_bus);
if (error)
return error;
error =  bus_register(&platform_bus_type);
if (error)
device_unregister(&platform_bus);
return error;
}

按图索骥，继续深入platform总线初始化函数来看early_platform_cleanup函数，这个函数从名字上就可以看出是一个清理函数。我们来看一下这个函数的源码，位于linux-3.4\drivers\base\platform.c中：

/**
* early_platform_cleanup - clean up early platform code
*/
void __init early_platform_cleanup(void)
{
struct platform_device *pd, *pd2;

/* clean up the devres list used to chain devices */
list_for_each_entry_safe(pd, pd2, &early_platform_device_list,
dev.devres_head) {
list_del(&pd->dev.devres_head);
memset(&pd->dev.devres_head, 0, sizeof(pd->dev.devres_head));
}
}

从注释可以看出，这个函数是清除早期的platform设备链表，list_for_each_entry_safe的作用是遍历先前的platform设备链表early_platform_device_list

，并清零每一个链表节点。

下面继续platform总线初始化函数中的device_register(&platform_bus)的函数，该函数是将platform总线作为设备进行注册。我们先看参数plat_bus，位于linux-3.4\drivers\base\platform.c中：

struct device platform_bus = {
.init_name	= "platform",
};
EXPORT_SYMBOL_GPL(platform_bus);

参数platform_bus是一个device类型的结构体，下面EXPORT_SYMBOL_GPL是宏，这个宏说明其参数所指向的函数只给有GPL认证的模块使用。下面来看一下device结构体，位于linux-3.4\include\linux\device.h中：

struct device {
struct device		*parent;

struct device_private	*p;

struct kobject kobj;
const char		*init_name; /* initial name of the device */
const struct device_type *type;

struct mutex		mutex;	/* mutex to synchronize calls to
* its driver.
*/

struct bus_type	*bus;		/* type of bus device is on */
struct device_driver *driver;	/* which driver has allocated this
device */
void		*platform_data;	/* Platform specific data, device
core doesn't touch it */
struct dev_pm_info	power;
struct dev_pm_domain	*pm_domain;

#ifdef CONFIG_NUMA
int		numa_node;	/* NUMA node this device is close to */
#endif
u64		*dma_mask;	/* dma mask (if dma'able device) */
u64		coherent_dma_mask;/* Like dma_mask, but for
alloc_coherent mappings as
not all hardware supports
64 bit addresses for consistent
allocations such descriptors. */

struct device_dma_parameters *dma_parms;

struct list_head	dma_pools;	/* dma pools (if dma'ble) */

struct dma_coherent_mem	*dma_mem; /* internal for coherent mem
override */
#ifdef CONFIG_CMA
struct cma *cma_area;		/* contiguous memory area for dma
allocations */
#endif
/* arch specific additions */
struct dev_archdata	archdata;

struct device_node	*of_node; /* associated device tree node */

dev_t			devt;	/* dev_t, creates the sysfs "dev" */
u32			id;	/* device instance */

spinlock_t		devres_lock;
struct list_head	devres_head;

struct klist_node	knode_class;
struct class		*class;
const struct attribute_group **groups;	/* optional groups */

void	(*release)(struct device *dev);
};

这个是基本的设备结构体，用于描述设备相关信息设备之间的层次关系，以及设备与总线驱动的关系。其实简单说在Linux内核里用这个结构体来表示一个设备，并用于设备在内核中的注册。网上有较多关于这个结构体的解析这里就不多说了。

接下来看设备注册函数device_register，位于linux-3.4\drivers\base\core.c中：

int device_register(struct device *dev)
{
device_initialize(dev);
return device_add(dev);
}

这个函数作用是向系统注册一个设备，它首先使用函数device_initialize对设备进行初始化，然后使用device_add添加设备。下面分别来看一下这俩函数，但这里不做解释，这俩函数都是位于linux-3.4\drivers\base\core.c中：

void device_initialize(struct device *dev)
{
dev->kobj.kset = devices_kset;
kobject_init(&dev->kobj, &device_ktype);
INIT_LIST_HEAD(&dev->dma_pools);
mutex_init(&dev->mutex);
lockdep_set_novalidate_class(&dev->mutex);
spin_lock_init(&dev->devres_lock);
INIT_LIST_HEAD(&dev->devres_head);
device_pm_init(dev);
set_dev_node(dev, -1);
}

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;
}

下面我们继续回到platform总线初始化函数platform_bus_init中，来看总线注册函数bus_register(&platform_bus_type)，先看一下参数platfor_bus_type，位于linux-3.4\drivers\base\platform.c中：

struct bus_type platform_bus_type = {
.name		= "platform",
.dev_attrs	= platform_dev_attrs,
.match		= platform_match,
.uevent		= platform_uevent,
.pm		= &platform_dev_pm_ops,
};
EXPORT_SYMBOL_GPL(platform_bus_type);

从上面可以看出这是一个bus_type类型的结构体，bus_type类型结构体的定义位于linux-3.4\include\linux\device.h中：

struct bus_type {
const char		*name;
const char		*dev_name;
struct device		*dev_root;
struct bus_attribute	*bus_attrs;
struct device_attribute	*dev_attrs;
struct driver_attribute	*drv_attrs;

int (*match)(struct device *dev, struct device_driver *drv);
int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
int (*probe)(struct device *dev);
int (*remove)(struct device *dev);
void (*shutdown)(struct device *dev);

int (*suspend)(struct device *dev, pm_message_t state);
int (*resume)(struct device *dev);

const struct dev_pm_ops *pm;

struct iommu_ops *iommu_ops;

struct subsys_private *p;
};

这是一个设备总线类型结构体，成员变量指出了总线名称，子设备前缀名(像"foo%u", dev->id)，被用作父设备的默认设备，总线属性，设备属性，驱动属性以及一些回调函数。

下面来看一下总线注册函数bus_register，位于linux-3.4\include\linux\device.h中，这是一个宏定义：

/* This is a #define to keep the compiler from merging different
* instances of the __key variable */
#define bus_register(subsys)			\
({						\
static struct lock_class_key __key;	\
__bus_register(subsys, &__key);	\
})

继续看函数_bus_register(subsys, &__key)函数，位于linux-3.4\drivers\base\bus.c中：

int __bus_register(struct bus_type *bus, struct lock_class_key *key)
{
int retval;
struct subsys_private *priv;

priv = kzalloc(sizeof(struct subsys_private), GFP_KERNEL);
if (!priv)
return -ENOMEM;

priv->bus = bus;
bus->p = priv;

BLOCKING_INIT_NOTIFIER_HEAD(&priv->bus_notifier);

retval = kobject_set_name(&priv->subsys.kobj, "%s", bus->name);
if (retval)
goto out;

priv->subsys.kobj.kset = bus_kset;
priv->subsys.kobj.ktype = &bus_ktype;
priv->drivers_autoprobe = 1;

retval = kset_register(&priv->subsys);
if (retval)
goto out;

retval = bus_create_file(bus, &bus_attr_uevent);
if (retval)
goto bus_uevent_fail;

priv->devices_kset = kset_create_and_add("devices", NULL,
&priv->subsys.kobj);
if (!priv->devices_kset) {
retval = -ENOMEM;
goto bus_devices_fail;
}

priv->drivers_kset = kset_create_and_add("drivers", NULL,
&priv->subsys.kobj);
if (!priv->drivers_kset) {
retval = -ENOMEM;
goto bus_drivers_fail;
}

INIT_LIST_HEAD(&priv->interfaces);
__mutex_init(&priv->mutex, "subsys mutex", key);
klist_init(&priv->klist_devices, klist_devices_get, klist_devices_put);
klist_init(&priv->klist_drivers, NULL, NULL);

retval = add_probe_files(bus);
if (retval)
goto bus_probe_files_fail;

retval = bus_add_attrs(bus);
if (retval)
goto bus_attrs_fail;

pr_debug("bus: '%s': registered\n", bus->name);
return 0;

bus_attrs_fail:
remove_probe_files(bus);
bus_probe_files_fail:
kset_unregister(bus->p->drivers_kset);
bus_drivers_fail:
kset_unregister(bus->p->devices_kset);
bus_devices_fail:
bus_remove_file(bus, &bus_attr_uevent);
bus_uevent_fail:
kset_unregister(&bus->p->subsys);
out:
kfree(bus->p);
bus->p = NULL;
return retval;
}
EXPORT_SYMBOL_GPL(__bus_register);

这个函数进行了返回检测，如果注册识别，则进行与注册相反的操作注销device_unregister。这个函数位于linux-3.4\drivers\base\core.c中：

/**
* device_unregister - unregister device from system.
* @dev: device going away.
*
* We do this in two parts, like we do device_register(). First,
* we remove it from all the subsystems with device_del(), then
* we decrement the reference count via put_device(). If that
* is the final reference count, the device will be cleaned up
* via device_release() above. Otherwise, the structure will
* stick around until the final reference to the device is dropped.
*/
void device_unregister(struct device *dev)
{
pr_debug("device: '%s': %s\n", dev_name(dev), __func__);
device_del(dev);
put_device(dev);
}

附上了英文注释，解释很清楚了。

到这里呢，platform总线初始化就结束了，没有做更多的解释，主要原因是我也在学习，还有就是每个函数的作用无论是见名知意还是查看函数说明，这个函数的功能是很明确的。

现在呢，platform总线已经初始化完成，下面就是把platform设备和驱动挂载到platform总线上了。

现在我们还是回到开始led驱动函数led.c中，了解过驱动的人都知道，驱动被加载到内核第一次被调用的函数就是其初始化函数，在led.c中：

module_init(led_init);

初始化函数led_init的源码再写一遍，如下：

static int __init led_init(void)
{

if (platform_device_register(&led_device)) {
printk("%s: register gpio device failed\n", __func__);
}
if (platform_driver_register(&led_driver)) {
printk("%s: register gpio driver failed\n", __func__);
}

return 0;
}

这里第一步是设备注册函数platform_device_register(&led_device)，我们先看参数led_device：

struct platform_device led_device = {
.name		= "led",
};

led_device是一个platform_device类型的结构体，platform_device结构体的定义在linux-3.4\include\linux\platform_device.h中：

struct platform_device {
const char	* name;//设备名
int		id;//设备id
struct device	dev;//包含设备结构体
u32		num_resources;//资源个数
struct resource	* resource;//资源结构体

const struct platform_device_id	*id_entry;

/* MFD cell pointer */
struct mfd_cell *mfd_cell;

/* arch specific additions */
struct pdev_archdata	archdata;
};

这个结构体里面封装了device结构体，resource结构体，说明platform_device是device结构体派生出的一个结构体，platform_device是一个特殊的device。下面来看platform_device中最重要的结构体resource结构体，该结构体位于linux-3.4\include\linux\ioprt.h中：

struct resource {
resource_size_t start;//资源起始地址
resource_size_t end;//资源结束地址
const char *name;//定义资源名称
unsigned long flags;//定义资源类型
struct resource *parent, *sibling, *child;//资源树
};

这个结构体表明了设备所拥有的资源。

platform_device结构体包含了device结构体，device结构体描述了设备的详细情况，在面向对象编程中device是所有设备的基类。device结构体在platform总线初始化的时候已经说过了，这里就不说了。

然后我们来看一下platform_device_register 函数，其位于linux-3.4\drivers\base\platform.c中：

/**
* platform_device_register - add a platform-level device
* @pdev: platform device we're adding
*/
int platform_device_register(struct platform_device *pdev)
{
device_initialize(&pdev->dev);
arch_setup_pdev_archdata(pdev);
return platform_device_add(pdev);
}
EXPORT_SYMBOL_GPL(platform_device_register);

这里首先对设备使用函数device_initalize进行初始化，这个函数在上面platform总线初始化的时候已经说过，这里不说了。在这是不是可以发散一下，只要设备注册进内核，无论是总线设备也好，其他设备也好，内核都把他们看成设备，使用同样的方式初始化。

然后使用arch_setup_pdev_archdata(pdev)，这个函数位于linux-3.4\drivers\base\platform.c中：

/**
* arch_setup_pdev_archdata - Allow manipulation of archdata before its used
* @pdev: platform device
*
* This is called before platform_device_add() such that any pdev_archdata may
* be setup before the platform_notifier is called.  So if a user needs to
* manipulate any relevant information in the pdev_archdata they can do:
*
* 	platform_devic_alloc()
* 	... manipulate ...
* 	platform_device_add()
*
* And if they don't care they can just call platform_device_register() and
* everything will just work out.
*/
void __weak arch_setup_pdev_archdata(struct platform_device *pdev)
{
}

这个函数目前是一个空函数，根据注释，这是留给使用者在添加设备前来操作设备相关结构体的，也就是留给用户根据需要使用的。

最后使用了platform_device_add(pdev)来添加设备。该函数位于linux-3.4\drivers\base\platform.c中：

/**
* platform_device_add - add a platform device to device hierarchy
* @pdev: platform device we're adding
*
* This is part 2 of platform_device_register(), though may be called
* separately _iff_ pdev was allocated by platform_device_alloc().
*/
int platform_device_add(struct platform_device *pdev)
{
int i, ret = 0;

if (!pdev)
return -EINVAL;

if (!pdev->dev.parent)
pdev->dev.parent = &platform_bus;

<span style="color:#ff0000;">pdev->dev.bus = &platform_bus_type;</span>

if (pdev->id != -1)
dev_set_name(&pdev->dev, "%s.%d", pdev->name,  pdev->id);
else
dev_set_name(&pdev->dev, "%s", pdev->name);

for (i = 0; i < pdev->num_resources; i++) {
struct resource *p, *r = &pdev->resource[i];

if (r->name == NULL)
r->name = dev_name(&pdev->dev);

p = r->parent;
if (!p) {
if (resource_type(r) == IORESOURCE_MEM)
p = &iomem_resource;
else if (resource_type(r) == IORESOURCE_IO)
p = &ioport_resource;
}

if (p && <span style="color:#ff0000;">insert_resource(p, r)</span>) {
printk(KERN_ERR
"%s: failed to claim resource %d\n",
dev_name(&pdev->dev), i);
ret = -EBUSY;
goto failed;
}
}

pr_debug("Registering platform device '%s'. Parent at %s\n",
dev_name(&pdev->dev), dev_name(pdev->dev.parent));

ret = <span style="color:#ff0000;">device_add(&pdev->dev);</span>
if (ret == 0)
return ret;

failed:
while (--i >= 0) {
struct resource *r = &pdev->resource[i];
unsigned long type = resource_type(r);

if (type == IORESOURCE_MEM || type == IORESOURCE_IO)
release_resource(r);
}

return ret;
}
EXPORT_SYMBOL_GPL(platform_device_add);

该函数有三个重点，一个是设备如果没有父设备，则把platform_bus设置为其父设备，一个是插入资源，还有一个是调用了device_add来添加设备。这里说明device_register和platform_device_register有很多相似之处。

下面我们回到led_init函数继续往下看驱动注册函数platform_driver_register(&led_driver)，还是先看参数led_driver：

static struct platform_driver led_driver = {
.probe		= led_probe,
.remove		= __devexit_p(led_remove),
.driver		= {
.name	= "led",
.owner	= THIS_MODULE,
},
};

led_driver是一个platform_driver类型的结构体，里面主要是指向了一些操作函数。我们来看一下platform_driver结构体，其位于linux-3.4\include\linux\platform_device.h中：

struct platform_driver {
int (*probe)(struct platform_device *);
int (*remove)(struct platform_device *);
void (*shutdown)(struct platform_device *);
int (*suspend)(struct platform_device *, pm_message_t state);
int (*resume)(struct platform_device *);
struct device_driver driver;
const struct platform_device_id *id_table;
};

该结构体主要包含了设备操作的一些函数，并且包含了device_driver结构体，用面向对象的思想说明platform_driver继承了device_driver结构体。也即是device_driver结构体派生了platform_driver结构体，device_driver是platform_driver的基类。结构体device_driver位于linux-3.4\include\linux中：

struct device_driver {
const char		*name;
struct bus_type		*bus;

struct module		*owner;
const char		*mod_name;	/* used for built-in modules */

bool suppress_bind_attrs;	/* disables bind/unbind via sysfs */

const struct of_device_id	*of_match_table;

int (*probe) (struct device *dev);
int (*remove) (struct device *dev);
void (*shutdown) (struct device *dev);
int (*suspend) (struct device *dev, pm_message_t state);
int (*resume) (struct device *dev);
const struct attribute_group **groups;

const struct dev_pm_ops *pm;

struct driver_private *p;
};

该结构体包含了设备驱动的相关数据，比如设备驱动名称，总线类型，拥有者，操作函数等等。

这里最重要的俩变量name和owner，name的主要作用是把platform驱动和对应的platform设备连接起来，在platform_device结构体里也存在name成员。只有这两个name的名称一样才能成功注册设备的驱动。owner的作用是说明驱动的所有者，通常初始化为THIS_MODULE。

我们接下来看platform设备驱动注册函数platform_driver_register，该函数位于linux-3.4\drivers\base\platform.c中：

/**
* platform_driver_register - register a driver for platform-level devices
* @drv: platform driver structure
*/
int platform_driver_register(struct platform_driver *drv)
{
drv->driver.bus = &platform_bus_type;
if (drv->probe)
drv->driver.probe = platform_drv_probe;
if (drv->remove)
drv->driver.remove = platform_drv_remove;
if (drv->shutdown)
drv->driver.shutdown = platform_drv_shutdown;

return driver_register(&drv->driver);
}
EXPORT_SYMBOL_GPL(platform_driver_register);

该函数首先声明定义自己所挂载的总线类型，这一点很重要，因为platform_driver和platform_device都是挂载到platform_bus中，platform_driver和platform_device是通过platform_bus_type中注册的回调函数platform_match来完成的，所以一定要先注册设备再注册驱动，否则无法匹配成功，驱动也就无法使用；然后给探测(probe)，移除(remove)，关闭(shutdown)函数指针赋值，最后使用driver_register函数进行设备的驱动注册。我们来看一下driver_register函数，其在linux-3.4\drivers\base\driver.c中：

/**
* driver_register - register driver with bus
* @drv: driver to register
*
* We pass off most of the work to the bus_add_driver() call,
* since most of the things we have to do deal with the bus
* structures.
*/
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);
if (ret)
return ret;
ret = driver_add_groups(drv, drv->groups);
if (ret)
bus_remove_driver(drv);
return ret;
}
EXPORT_SYMBOL_GPL(driver_register);

首先如果总线的方法和设备自己的方法同时存在，则打印警告信息。如果设备驱动已经注册，则返回-EBUSY，否则使用bus_add_driver(drv)向总线添加驱动。

下面来看一下bus_add_driver函数，这个函数位于linux-3.4\drivers\base\bus.c中：

/**
* bus_add_driver - Add a driver to the bus.
* @drv: driver.
*/
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;

<span style="color:#ff0000;">if (drv->bus->p->drivers_autoprobe) {
error = driver_attach(drv);
if (error)
goto out_unregister;
}</span>
klist_add_tail(&priv->knode_bus, &bus->p->klist_drivers);
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;
}

从上面的红线部分，如果驱动是自动probe的话，将调用driver_attach来绑定设备和驱动。函数driver_attach位于linux-3.4\drivers\base\dd.c中：

/**
* driver_attach - try to bind driver to devices.
* @drv: driver.
*
* Walk the list of devices that the bus has on it and try to
* match the driver with each one.  If driver_probe_device()
* returns 0 and the @dev->driver is set, we've found a
* compatible pair.
*/
int driver_attach(struct device_driver *drv)
{
return bus_for_each_dev(drv->bus, NULL, drv, __driver_attach);
}
EXPORT_SYMBOL_GPL(driver_attach);

这里可以看到，调用了bus_for_each_dev函数，该函数位于linux-3.4\drivers\based\bus.c中：

/**
* bus_for_each_dev - device iterator.
* @bus: bus type.
* @start: device to start iterating from.
* @data: data for the callback.
* @fn: function to be called for each device.
*
* Iterate over @bus's list of devices, and call @fn for each,
* passing it @data. If @start is not NULL, we use that device to
* begin iterating from.
*
* We check the return of @fn each time. If it returns anything
* other than 0, we break out and return that value.
*
* NOTE: The device that returns a non-zero value is not retained
* in any way, nor is its refcount incremented. If the caller needs
* to retain this data, it should do so, and increment the reference
* count in the supplied callback.
*/
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 || !bus->p)
return -EINVAL;

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

这里可以发现该函数是遍历总线上的每一个设备，并调用了函数fn，，这里的fn函数就是__driver__attach函数。我们来看一下__driver__attach函数，该函数位于linux-3.4\drivers\base\dd.c中：

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))
return 0;

if (dev->parent)	/* Needed for USB */
device_lock(dev->parent);
device_lock(dev);
if (!dev->driver)
<span style="color:#ff0000;">driver_probe_device(drv, dev);</span>
device_unlock(dev);
if (dev->parent)
device_unlock(dev->parent);

return 0;
}

这里首先是driver 匹配device，然后调用了driver_probe_device函数，该函数位于linux-3.4\drivers\base\dd.c中：

/**
* driver_probe_device - attempt to bind device & driver together
* @drv: driver to bind a device to
* @dev: device to try to bind to the driver
*
* This function returns -ENODEV if the device is not registered,
* 1 if the device is bound successfully and 0 otherwise.
*
* This function must be called with @dev lock held.  When called for a
* USB interface, @dev->parent lock must be held as well.
*/
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);
ret =<span style="color:#ff0000;"> really_probe(dev, drv);</span>
pm_runtime_put_sync(dev);

return ret;
}

这里首先检测了设备是否被注册，然后调用了really_probe函数，这个函数位于linux-3.4\drivers\base\dd.c中：

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 (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:#ff0000;">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;
}

这里调用了drv->probe(dev)，而这个就是我们定义platform_driver结构体里声明的probe函数，在驱动led.c中就是函数led_probe函数：

//led_probe
static int __devinit led_probe(struct platform_device *pdev)
{
int led_used;
script_item_u	val;
script_item_value_type_e  type;

int err;

printk("led_para!\n");
type = script_get_item("led_para", "led_used", &val);
if (SCIRPT_ITEM_VALUE_TYPE_INT != type) {
printk("%s script_get_item \"led_para\" led_used = %d\n",
__FUNCTION__, val.val);
return -1;
}
led_used = val.val;
printk("%s script_get_item \"led_para\" led_used = %d\n",
__FUNCTION__, val.val);

if(!led_used) {
printk("%s led_used is not used in config,  led_used=%d\n", __FUNCTION__,led_used);
return -1;
}

err = led_gpio();
if (err)
return -1;

sema_init(&lock, 1);
err = misc_register(&leds_dev);
printk("======= cqa83 led initialized ================\n");

return err;
}

到这里，platform设备的设备和驱动初始化和绑定，探测就结束了，其实也意味着驱动已经设备和注册成功了。

我觉得有一点还是要说一下，那就是设备和驱动的匹配，在驱动注册是会回调总线注册的匹配函数platform_match，该函数位于linux-3.4\drivers\base\platform.c中：

/**
* platform_match - bind platform device to platform driver.
* @dev: device.
* @drv: driver.
*
* Platform device IDs are assumed to be encoded like this:
* "<name><instance>", where <name> is a short description of the type of
* device, like "pci" or "floppy", and <instance> is the enumerated
* instance of the device, like '0' or '42'.  Driver IDs are simply
* "<name>".  So, extract the <name> from the platform_device structure,
* and compare it against the name of the driver. Return whether they match
* or not.
*/
static int platform_match(struct device *dev, struct device_driver *drv)
{
struct platform_device *pdev = to_platform_device(dev);
struct platform_driver *pdrv = to_platform_driver(drv);

/* Attempt an OF style match first */
if (of_driver_match_device(dev, drv))
return 1;

/* Then try to match against the id table */
if (pdrv->id_table)
return platform_match_id(pdrv->id_table, pdev) != NULL;

/* fall-back to driver name match */
<span style="color:#ff0000;">return (strcmp(pdev->name, drv->name) == 0);</span>
}

这里的匹配就是通过字符串对比来进行的，这就是开始说的platform_device的name成员和platform_driver的name成员要一样。

在这里简单总结一下，platform设备加载驱动的过程。首先有一个platform总线，这个总线呢会在系统初始化的时候对其进行初始化。在总线初始化完成之后，如果你想要往总线上挂载platform设备，那么这个要分为两部分，一是设备，二是驱动，也即是片platform_device和platform_driver，这两个都是要挂载到platform总线上。但是挂载有一个顺序，一定要先挂载设备，再挂载驱动，因为驱动是遍历总线上所有的设备节点来匹配的。那么这俩东西靠什么来匹配呢？他们靠的是其结构体下的name成员变量，如果名字一样才能匹配成功，这也就是为什么要求platform_device和platform_driver的名字要一样的原因了。

platform_device结构体提供的是资源，而platform_driver结构体提供的是操作，也就是驱动操作设备。platform_driver主要完成了设备的注册和初始化，还有移除是的资源释放等。在驱动led.c中很容易可以看出来，led_probe调用了led_gpio函数。到platform设备驱动加载完成，其实是在目录/dev/platform下会出现你的设备。然而这并不能做什么，但是Linux里有一句话“一切皆文件”，设备也是文件。那么这些完成之后，下面就是文件操作了。

一个问题是，我们的应用程序如何去使用驱动程序中的函数？比如打开设备，关闭设备，使用设备等等。这里就是说对应用程序来说需要一个入口，一个可以通过驱动程序控制设备的入口。这里就引入了一个重要的数据结构file_operrations，这个结构体包含了一组函数指针，这些指针所指向的函数就是用来操作设备的。

这个结构体位于linux-3.4\include\linux\fs.h中：

struct file_operations {
struct module *owner;
loff_t (*llseek) (struct file *, loff_t, int);
ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
ssize_t (*aio_read) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
int (*readdir) (struct file *, void *, filldir_t);
unsigned int (*poll) (struct file *, struct poll_table_struct *);
long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
int (*mmap) (struct file *, struct vm_area_struct *);
int (*open) (struct inode *, struct file *);
int (*flush) (struct file *, fl_owner_t id);
int (*release) (struct inode *, struct file *);
int (*fsync) (struct file *, loff_t, loff_t, int datasync);
int (*aio_fsync) (struct kiocb *, int datasync);
int (*fasync) (int, struct file *, int);
int (*lock) (struct file *, int, struct file_lock *);
ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
int (*check_flags)(int);
int (*flock) (struct file *, int, struct file_lock *);
ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
int (*setlease)(struct file *, long, struct file_lock **);
long (*fallocate)(struct file *file, int mode, loff_t offset,
loff_t len);
};

那么我们来对比一下驱动代码led.c中的file_operations结构体：

//file_operations
static struct file_operations leds_ops = {
.owner			= THIS_MODULE,
.open			= led_open,
.release		= led_close,
.unlocked_ioctl		= led_ioctl,
};

这里只定义了open函数，release函数，unlocked_ioctl函数，并且定义了其拥有者是THIS_MODULE。这几个函数的源代码分别是：

//led_open
static int led_open(struct inode *inode, struct file *file)
{
if (!down_trylock(&lock))
return 0;
else
return -EBUSY;
}

led_open函数是开始时对设备加锁，防止多应用程序访问。

//led_close
static int  led_close(struct inode *inode, struct file *file)
{
up(&lock);
return 0;
}

led_close函数是设备使用完之后对设备进行解锁方便其他程序使用。

//led_ioctl
static long  led_ioctl(struct file *filep, unsigned int cmd,
unsigned long arg)
{
unsigned int n;
n = (unsigned int)arg;
switch (cmd) {
case LED_IOCTL_SET_ON:
if (n < 1)
return -EINVAL;
if(led_val[n-1].gpio.gpio != -1) {
__gpio_set_value(led_val[n-1].gpio.gpio, 1);
printk("led%d on !\n", n);
}
break;

case LED_IOCTL_SET_OFF:
default:
if (n < 1)
return -EINVAL;
if(led_val[n-1].gpio.gpio != -1) {
__gpio_set_value(led_val[n-1].gpio.gpio, 0);
printk("led%d off !\n", n);
}
break;
}

return 0;
}

led_ioctl里面主要是对设备的控制，这个在前面已经分析过了，这里不再进行分析。

到此呢，驱动也加载了，应用程序也有了入口，但是还有一个重要问题没有说，那就是它是何时加载到驱动的呢？

我们知道Linux系统驱动加载一般是两种方式，一个是编译成ko模块加载，一个是编译进内核，系统启动时自动加载。模块加载有两种方式，一个是手动加载，一个是使用脚本在系统启动时加载，但是这两种方式都会使用到mknod，insmod命令等。

那么这里是怎么加载的呢？我们先查看其系统启动的配置文件init.sun8i.rc，里面关于led的启动设置是这样的

# led
chmod 777 /dev/led

而不像lcd，lcd是这样的：

# lcd
insmod /system/vendor/modules/disp.ko
insmod /system/vendor/modules/hdmi.ko

led的配置并没有使用到insmod名令，并且在Android设备中也找不到其相应的ko文件。所以说这个led驱动应该是静态编译进内核的。一般字符驱动设备静态编译进内核都会在相应的makefile中加入mknod命令来创建节点。那么我们就去led.c对应的makefile中找一下：

然而其关于led的只有：

obj-$(CONFIG_SUNXI_LED)		+= led.o

并没有mknod命令。那这到底是咋回事呢？

其实我们再回到led.c代码中的led_probe函数：

//led_probe
static int __devinit led_probe(struct platform_device *pdev)
{
int led_used;
script_item_u	val;
script_item_value_type_e  type;

int err;

printk("led_para!\n");
type = script_get_item("led_para", "led_used", &val);
if (SCIRPT_ITEM_VALUE_TYPE_INT != type) {
printk("%s script_get_item \"led_para\" led_used = %d\n",
__FUNCTION__, val.val);
return -1;
}
led_used = val.val;
printk("%s script_get_item \"led_para\" led_used = %d\n",
__FUNCTION__, val.val);

if(!led_used) {
printk("%s led_used is not used in config,  led_used=%d\n", __FUNCTION__,led_used);
return -1;
}

err = led_gpio();
if (err)
return -1;

sema_init(&lock, 1);
<span style="background-color: rgb(255, 0, 0);">err = misc_register(&leds_dev);</span>
printk("======= cqa83 led initialized ================\n");

return err;
}

来看红色的部分，再看参数leds_dev：

//miscdevice
static struct miscdevice leds_dev = {
.minor = MISC_DYNAMIC_MINOR,
.name = "led",
.fops = &leds_ops,
};

到这里是否明白了呢？

这个led设备驱动呢是一个杂项字符驱动，这就是我开始说的那三点中的一点。那这个有什么关系呢？

misc_device是特殊字符设备。注册驱动程序时采用misc_register函数注册，此函数中会自动创建设备节点，即设备文件。无需mknod指令创建设备文件。

因为misc_register()会调用class_device_creat或者device_creat().

关于杂项字符设备网上有很多资料，大家可以查一下。我会在后面的博文中写一篇来说杂项字符设备。

到这里我们解决了没有mknod的疑问，但是我们是如何配置才能把驱动编译进内核呢？

可以这样做，在内核源代码目录下执行make menuconfig命令，这会弹出一个对话界面。找到对应的驱动，然后用空格把前面的尖括号里变为*号，然后保存退出。编译系统就可以了。由于我的电脑不能截屏，就不能给大家上图了，抱歉。不过网上有很多资料。我下面会给出连接。

到这里这个驱动的分析基本上就完成了。但是还有俩问题需要另外来写一下，一个是LinuxGPIO驱动模型，一个是杂项字符设备。

我参考了很多网上朋友的作品，但是由于这个文章写了好多天，可能有的连接没有及时保存，在这里表示抱歉，也在此表示真心的感谢，感谢大家的分享：
http://blog.csdn.net/chocolate001/article/details/7572203 http://blog.csdn.net/zjg555543/article/details/7420650 http://blog.sina.com.cn/s/blog_966f8e8501010xhw.html http://www.cnblogs.com/geneil/archive/2011/12/03/2272869.html http://www.cnblogs.com/myblesh/articles/2367520.html http://www.embedu.org/Column/Column425.htm http://blog.csdn.net/weiqing1981127/article/details/8245665 http://blog.csdn.net/liuhaoyutz/article/details/15504127 http://blog.csdn.net/qingfengtsing/article/details/19211021 http://blog.chinaunix.net/uid-26285146-id-3307147.html http://blog.csdn.net/chocolate001/article/details/7572203 http://blog.csdn.net/gdt_a20/article/details/6429451 http://blog.chinaunix.net/uid-20729605-id-1884305.html http://www.51hei.com/bbs/dpj-30117-1.html http://blog.chinaunix.net/uid-20729605-id-1884305.html http://blog.csdn.net/abo8888882006/article/details/5424363 http://blog.csdn.net/engerled/article/details/6237884 http://blog.csdn.net/cppgp/article/details/6333359 http://blog.csdn.net/engerled/article/details/6243891 http://blog.csdn.net/cug_fish_2009/article/details/6518856 http://blog.sina.com.cn/s/blog_7943319e01018m3w.html http://blog.chinaunix.net/uid-26694208-id-3128890.html http://www.cnblogs.com/Daniel-G/archive/2013/08/27/3284791.html http://blog.chinaunix.net/uid-20769502-id-147170.html
等等。

再次表示感谢！