Android下led控制(下)--Linux驱动部分--platform机制
16lz
2021-01-25
前面写了两个博文，一个是Android下，一个是Linux下led控制，但是Linux下那个写的有很多漏洞和不清楚的地方。这里写一篇作为补充，也是我在学习中理解的深入。当然这个可能也会有很多漏洞，如果我有更深入的了解，继续进行补充。我的开发板是全志科技的CQA83T，成都启划公司出的扩展板。
先贴出来驱动源程序的代码，此代码的位置在 lichee\linux-3.4\drivers\char\led.c：
#include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #define LED_IOCTL_SET_ON1#define LED_IOCTL_SET_OFF0static script_item_uled_val[5];static script_item_value_type_eled_type;static struct semaphore lock;//led_openstatic int led_open(struct inode *inode, struct file *file){if (!down_trylock(&lock))return 0;elsereturn -EBUSY;}//led_closestatic int led_close(struct inode *inode, struct file *file){up(&lock);return 0;}//led_ioctlstatic 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_gpiostatic 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_operationsstatic struct file_operations leds_ops = {.owner= THIS_MODULE,.open= led_open,.release= led_close, .unlocked_ioctl= led_ioctl,};//miscdevicestatic struct miscdevice leds_dev = {.minor = MISC_DYNAMIC_MINOR,.name = "led",.fops = &leds_ops,};//led_removestatic int __devexit led_remove(struct platform_device *pdev){return 0;}//led_probestatic int __devinit led_probe(struct platform_device *pdev){int led_used;script_item_uval;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_devicestruct platform_device led_device = {.name= "led",};//platform_driverstatic struct platform_driver led_driver = {.probe= led_probe,.remove= __devexit_p(led_remove),.driver= {.name= "led",.owner= THIS_MODULE,},};//led_initstatic 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_exitstatic 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;}/** * 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总线初始化函数中的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);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 mutexmutex;/* 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_infopower;struct dev_pm_domain*pm_domain;#ifdef CONFIG_NUMAintnuma_node;/* NUMA node this device is close to */#endifu64*dma_mask;/* dma mask (if dma'able device) */u64coherent_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_headdma_pools;/* dma pools (if dma'ble) */struct dma_coherent_mem*dma_mem; /* internal for coherent mem override */#ifdef CONFIG_CMAstruct cma *cma_area;/* contiguous memory area for dma allocations */#endif/* arch specific additions */struct dev_archdataarchdata;struct device_node*of_node; /* associated device tree node */dev_tdevt;/* dev_t, creates the sysfs "dev" */u32id;/* device instance */spinlock_tdevres_lock;struct list_headdevres_head;struct klist_nodeknode_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);}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;};下面来看一下总线注册函数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 - 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);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;//设备名intid;//设备idstruct devicedev;//包含设备结构体u32num_resources;//资源个数struct resource* resource;//资源结构体const struct platform_device_id*id_entry;/* MFD cell pointer */struct mfd_cell *mfd_cell;/* arch specific additions */struct pdev_archdataarchdata;};这个结构体里面封装了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);然后使用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;pdev->dev.bus = &platform_bus_type;if (pdev->id != -1)dev_set_name(&pdev->dev, "%s.%d", pdev->name, pdev->id);elsedev_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 && insert_resource(p, r)) {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 = device_add(&pdev->dev);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;};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;if (drv->bus->p->drivers_autoprobe) {error = driver_attach(drv);if (error)goto out_unregister;}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)driver_probe_device(drv, dev);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 = really_probe(dev, drv);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) {ret = drv->probe(dev);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_probestatic int __devinit led_probe(struct platform_device *pdev){int led_used;script_item_uval;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_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: * "", where is a short description of the type of * device, like "pci" or "floppy", and is the enumerated * instance of the device, like '0' or '42'. Driver IDs are simply * "". So, extract the 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 */return (strcmp(pdev->name, drv->name) == 0);} 这里的匹配就是通过字符串对比来进行的，这就是开始说的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_operationsstatic struct file_operations leds_ops = {.owner= THIS_MODULE,.open= led_open,.release= led_close, .unlocked_ioctl= led_ioctl,};//led_openstatic int led_open(struct inode *inode, struct file *file){if (!down_trylock(&lock))return 0;elsereturn -EBUSY;}led_open函数是开始时对设备加锁，防止多应用程序访问。
//led_closestatic int led_close(struct inode *inode, struct file *file){up(&lock);return 0;}led_close函数是设备使用完之后对设备进行解锁方便其他程序使用。
//led_ioctlstatic 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 insmod /system/vendor/modules/disp.ko insmod /system/vendor/modules/hdmi.koled的配置并没有使用到insmod名令，并且在Android设备中也找不到其相应的ko文件。所以说这个led驱动应该是静态编译进内核的。一般字符驱动设备静态编译进内核都会在相应的makefile中加入mknod命令来创建节点。那么我们就去led.c对应的makefile中找一下：
然而其关于led的只有：
obj-$(CONFIG_SUNXI_LED)+= led.o并没有mknod命令。那这到底是咋回事呢？
其实我们再回到led.c代码中的led_probe函数：
//led_probestatic int __devinit led_probe(struct platform_device *pdev){int led_used;script_item_uval;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;}来看红色的部分，再看参数leds_dev：
//miscdevicestatic 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
等等。
再次表示感谢！
更多相关文章
- ADB 常用命令
- 36、Android编写应用-为新设备添加模块
- Android(安卓)Handler解析
- Android传感器概述（五）
- 【Android(安卓)UI】如何做一个纯粹的Android(安卓)app UI 设计
- AndroidLinker与SO加壳技术
- Android(安卓)JNI输出LOG
- Android(安卓)5.0特性
- 在非NDK编译条件下使用Android(安卓)Log函数