Linux Platform设备驱动学习与小结

Platform设备驱动匹配基本流程：Platform 设备先被注册然后platfrom驱动加载时会调用驱动程序中的probe（）入口函数，扫描系统中已注册的设备，通过。Name域找到匹配设备后将驱动和设备绑定。一个驱动可以对应多个设备，但是一个设备只对一个驱动。

Linux下的虚拟总线platform对应设备platform_device，对应的驱动为platform_driver。我想到一个比较牵强的例子：设备好比男人，驱动好比女人，platform作为媒人，将两个对上眼的（name域相同）的相匹配到一起。然后男人（device）到她（driver）的门口（driver的probe入口函数）主动去找女人约会巴拉巴拉啪啪啪。。。哎呀好羞射，这就进入正题：

所有的头文件均在include“s3c_driver.h”下

/*********************************************************************************
 *      Copyright:  (C) 2011 Guo Wenxue<[email protected]>  
 *                  All rights reserved.
 *
 *       Filename:  s3c_led.c
 *    Description:  This is the common LED driver runs on S3C24XX.
 *                 
 *        Version:  1.0.0(10/27/2011~)
 *         Author:  Guo Wenxue <[email protected]>
 *      ChangeLog:  1, Release initial version on "10/27/2011 11:39:10 AM"
 *                 
 ********************************************************************************/
#include "s3c_driver.h"

#define DRV_AUTHOR                "Guo Wenxue <[email protected]>"
#define DRV_DESC                  "S3C24XX LED driver"

/* Driver version*/
#define DRV_MAJOR_VER             1
#define DRV_MINOR_VER             0
#define DRV_REVER_VER             0

#define DEV_NAME                  DEV_LED_NAME

//#define DEV_MAJOR                 DEV_LED_MAJOR
#ifndef DEV_MAJOR
#define DEV_MAJOR                 0 /*  dynamic major by default */ 
#endif

#define TIMER_TIMEOUT             40

static int debug = DISABLE;
static int dev_major = DEV_MAJOR;
static int dev_minor = 0;


/* ============================ Platform Device part ===============================*/
/*  LED hardware informtation structure*/
struct s3c_led_info
{
    unsigned char           num;              /* The LED number  */
    unsigned int            gpio;             /* Which GPIO the LED used */  
    unsigned char           active_level;     /* The GPIO pin level(HIGHLEVEL or LOWLEVEL) to turn on or off  */
    unsigned char           status;           /* Current LED status: OFF/ON */
    unsigned char           blink;            /* Blink or not */           
};

/*  The LED platform device private data structure */
struct s3c_led_platform_data
{
    struct s3c_led_info    *leds;
    int                     nleds;
};


/*  LED hardware informtation data*/ 
static struct s3c_led_info  s3c_leds[] = {
    [0] = {
        .num = 1,
        .gpio = S3C2410_GPB(5),
        .active_level = LOWLEVEL,
        .status = OFF,
        .blink = ENABLE,
    },
    [1] = {
        .num = 2,
        .gpio = S3C2410_GPB(6),
        .active_level = LOWLEVEL,
        .status = OFF,
        .blink = DISABLE,
    },
    [2] = {
        .num = 3,
        .gpio = S3C2410_GPB(8),
        .active_level = LOWLEVEL,
        .status = OFF,
        .blink = DISABLE,
    },
    [3] = { 
        .num = 4,
        .gpio = S3C2410_GPB(10),
        .active_level = LOWLEVEL,
        .status = OFF,
        .blink = DISABLE,
    }, 
};

/*  The LED platform device private data */
static struct s3c_led_platform_data s3c_led_data = {
    .leds = s3c_leds,
    .nleds = ARRAY_SIZE(s3c_leds),
};

struct led_device
{
    struct s3c_led_platform_data    *data;
    struct cdev                     cdev;
    struct class                    *dev_class;
    struct timer_list               blink_timer;
} led_device;

static void platform_led_release(struct device * dev)
{
    int i;
    struct s3c_led_platform_data *pdata = dev->platform_data; 

    dbg_print("%s():%d\n", __FUNCTION__,__LINE__);

    /* Turn all LED off */
    for(i=0; i<pdata->nleds; i++)
    {
         s3c2410_gpio_setpin(pdata->leds[i].gpio, ~pdata->leds[i].active_level); 
    }
}

static struct platform_device s3c_led_device = {
    .name    = "s3c_led",
    .id      = 1,
    .dev     = 
    {
        .platform_data = &s3c_led_data, 
        .release = platform_led_release,
    },
};



/* ===================== led device driver part ===========================*/

void led_timer_handler(unsigned long data)
{ 
    int  i; 
    struct s3c_led_platform_data *pdata = (struct s3c_led_platform_data *)data;

    for(i=0; i<pdata->nleds; i++) 
    { 
        if(ON == pdata->leds[i].status)
        {
              s3c2410_gpio_setpin(pdata->leds[i].gpio, pdata->leds[i].active_level); 
        }
        else
        {
              s3c2410_gpio_setpin(pdata->leds[i].gpio, ~pdata->leds[i].active_level); 
        }

        if(ENABLE == pdata->leds[i].blink )  /* LED should blink */
        {
            /* Switch status between 0 and 1 to turn LED ON or off */
            pdata->leds[i].status = pdata->leds[i].status ^ 0x01;  
        }

        mod_timer(&(led_device.blink_timer), jiffies + TIMER_TIMEOUT);
    }
}


static int led_open(struct inode *inode, struct file *file)
{ 
    struct led_device *pdev ;
    struct s3c_led_platform_data *pdata;

    pdev = container_of(inode->i_cdev,struct led_device, cdev);//container_of是linux内核中常用的一个神奇的宏，这个宏的功能是，通过一个结构变体量中一个成员的地址找到这个结构体变量的首地址。
    pdata = pdev->data;

    file->private_data = pdata;

    return 0;
}


static int led_release(struct inode *inode, struct file *file)
{ 
    return 0;
}

static void print_led_help(void)
{
    printk("Follow is the ioctl() command for LED driver:\n");
    printk("Enable Driver debug command: %u\n", SET_DRV_DEBUG);
    printk("Get Driver verion  command : %u\n", GET_DRV_VER);
    printk("Turn LED on command        : %u\n", LED_ON);
    printk("Turn LED off command       : %u\n", LED_OFF);
    printk("Turn LED blink command     : %u\n", LED_BLINK);
}

/* compatible with kernel version >=2.6.38*/
static long led_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{ 
    struct s3c_led_platform_data *pdata = file->private_data;

    switch (cmd)
    {
        case SET_DRV_DEBUG:
            dbg_print("%s driver debug now.\n", DISABLE == arg ? "Disable" : "Enable");
            debug = (0==arg) ? DISABLE : ENABLE;
            break;
        case GET_DRV_VER:
            print_version(DRV_VERSION);
            return DRV_VERSION;

        case LED_OFF:
            if(pdata->nleds <= arg)
            {
               printk("LED%ld doesn't exist\n", arg);  
               return -ENOTTY;
            }
            pdata->leds[arg].status = OFF;
            pdata->leds[arg].blink = DISABLE;
            break;

        case LED_ON:
            if(pdata->nleds <= arg)
            {
               printk("LED%ld doesn't exist\n", arg);  
               return -ENOTTY;
            }
            pdata->leds[arg].status = ON;
            pdata->leds[arg].blink = DISABLE;
            break;

        case LED_BLINK:
            if(pdata->nleds <= arg)
            {
               printk("LED%ld doesn't exist\n", arg);  
               return -ENOTTY;
            }
            pdata->leds[arg].blink = ENABLE;
            pdata->leds[arg].status = ON;
            break;

        default: 
            dbg_print("%s driver don't support ioctl command=%d\n", DEV_NAME, cmd); 
            print_led_help();
            return -EINVAL;

    }
    return 0;
}


static struct file_operations led_fops = { 
    .owner = THIS_MODULE, 
    .open = led_open, 
    .release = led_release, 
    .unlocked_ioctl = led_ioctl, /* compatible with kernel version >=2.6.38*/
};


static int s3c_led_probe(struct platform_device *dev)
{
    struct s3c_led_platform_data *pdata = dev->dev.platform_data; 
    int result = 0;
    int i;
    dev_t devno;

    /* Initialize the LED status */
    for(i=0; i<pdata->nleds; i++)
    {
         s3c2410_gpio_cfgpin(pdata->leds[i].gpio, S3C2410_GPIO_OUTPUT);
         if(ON == pdata->leds[i].status)
         {
            s3c2410_gpio_setpin(pdata->leds[i].gpio, pdata->leds[i].active_level); 
         }
         else
         {
            s3c2410_gpio_setpin(pdata->leds[i].gpio, ~pdata->leds[i].active_level); 
         }
    }

    /*  Alloc the device for driver */
    if (0 != dev_major) 
    { 
        devno = MKDEV(dev_major, dev_minor); 
        result = register_chrdev_region(devno, 1, DEV_NAME); 
    } 
    else 
    { 
        result = alloc_chrdev_region(&devno, dev_minor, 1, DEV_NAME); 
        dev_major = MAJOR(devno); 
    }

    /* Alloc for device major failure */ 
    if (result < 0) 
    { 
        printk("%s driver can't get major %d\n", DEV_NAME, dev_major); 
        return result; 
    }

    /* Initialize button structure and register cdev*/
    memset(&led_device, 0, sizeof(led_device));
    led_device.data = dev->dev.platform_data;
    cdev_init (&(led_device.cdev), &led_fops);
    led_device.cdev.owner  = THIS_MODULE;

    result = cdev_add (&(led_device.cdev), devno , 1); 
    if (result) 
    { 
        printk (KERN_NOTICE "error %d add %s device", result, DEV_NAME); 
        goto ERROR; 
    } 
    
    led_device.dev_class = class_create(THIS_MODULE, DEV_NAME); 
    if(IS_ERR(led_device.dev_class)) 
    { 
        printk("%s driver create class failture\n",DEV_NAME); 
        result =  -ENOMEM; 
        goto ERROR; 
    }

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,24)     
    device_create(led_device.dev_class, NULL, devno, NULL, DEV_NAME);
#else
    device_create (led_device.dev_class, NULL, devno, DEV_NAME);
#endif

    /*  Initial the LED blink timer */
    init_timer(&(led_device.blink_timer));
    led_device.blink_timer.function = led_timer_handler;
    led_device.blink_timer.data = (unsigned long)pdata;
    led_device.blink_timer.expires  = jiffies + TIMER_TIMEOUT;
    add_timer(&(led_device.blink_timer)); 

    printk("S3C %s driver version %d.%d.%d initiliazed.\n", DEV_NAME, DRV_MAJOR_VER, DRV_MINOR_VER, DRV_REVER_VER); 

    return 0;
               

ERROR: 
    printk("S3C %s driver version %d.%d.%d install failure.\n", DEV_NAME, DRV_MAJOR_VER, DRV_MINOR_VER, DRV_REVER_VER); 
    cdev_del(&(led_device.cdev)); 

    unregister_chrdev_region(devno, 1); 
    return result;

}

static int s3c_led_remove(struct platform_device *dev)
{
    dev_t devno = MKDEV(dev_major, dev_minor);

    del_timer(&(led_device.blink_timer));

    cdev_del(&(led_device.cdev)); 
    device_destroy(led_device.dev_class, devno); 
    class_destroy(led_device.dev_class); 
    
    unregister_chrdev_region(devno, 1); 
    printk("S3C %s driver removed\n", DEV_NAME);

    return 0;
}


static struct platform_driver s3c_led_driver = { 
    .probe      = s3c_led_probe, 
    .remove     = s3c_led_remove, 
    .driver     = { 
        .name       = "s3c_led", 
        .owner      = THIS_MODULE, 
    },
};


static int __init s3c_led_init(void)
{
   int       ret = 0;

   ret = platform_device_register(&s3c_led_device);
   if(ret)
   {
        printk(KERN_ERR "%s:%d: Can't register platform device %d\n", __FUNCTION__,__LINE__, ret); 
        goto fail_reg_plat_dev;
   }
   dbg_print("Regist S3C LED Platform Device successfully.\n");

   ret = platform_driver_register(&s3c_led_driver);
   if(ret)
   {
        printk(KERN_ERR "%s:%d: Can't register platform driver %d\n", __FUNCTION__,__LINE__, ret); 
        goto fail_reg_plat_drv;
   }
   dbg_print("Regist S3C LED Platform Driver successfully.\n");

   return 0;

fail_reg_plat_drv:
   platform_driver_unregister(&s3c_led_driver);
fail_reg_plat_dev:
   return ret;
}


static void s3c_led_exit(void)
{
    dbg_print("%s():%d remove LED platform drvier\n", __FUNCTION__,__LINE__);
    platform_driver_unregister(&s3c_led_driver);
    dbg_print("%s():%d remove LED platform device\n", __FUNCTION__,__LINE__);
    platform_device_unregister(&s3c_led_device);
}

module_init(s3c_led_init);
module_exit(s3c_led_exit);

module_param(debug, int, S_IRUGO);
module_param(dev_major, int, S_IRUGO);
module_param(dev_minor, int, S_IRUGO);

MODULE_AUTHOR(DRV_AUTHOR);
MODULE_DESCRIPTION(DRV_DESC);
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:S3C24XX_led");

学习驱动后的小结：

（一）前面几篇所讲的LED驱动都是将驱动和设备绑定在一块。这里要把设备和驱动分成platform_device和platform_driver是因为我们知道linux内核中常见的的总线有I2C总线，PCI总线，串口总线，SPI总线等，所以有些设备和驱动就可以挂在这些总线上，然后通过总线上的match进行设备和驱动的匹配。但是有的设备并不属于这些常见总线，所以我们引入了一种虚拟总线，也就是platform总线的概念，对应的设备叫做platform设备，对应的驱动叫做platform驱动。

（二）前篇的LED驱动生成设备节点文件是利用mknod手动创建的方法；实际上Linux内核为我们提供了一组函数，可以用来在模块加载的时候自动在/dev目录下创建相应设备节点，并在卸载模块时删除该节点。即在这篇里看到的device_creat这个函数来为我们自动创建设备节点。这是利用在驱动中加入了对mdev的支持所完成的。而要支持mdev：在驱动初始化的代码里调用class_create()为该设备创建一个class，再为每个设备调用device_create()创建对应的设备( 在2.6较早的内核中用class_device_create)。内核中定义的struct class结构体，顾名思义，一个struct class结构体类型变量对应一个类，内核同时提供了class_create(…)函数，可以用它来创建一个类，这个类存放于sysfs下面，一旦创建好了这个类，再调用 device_create(…)函数来在/dev目录下创建相应的设备节点。这样，加载模块的时候，用户空间中的mdev会自动响应 device_create(…)函数，去/sysfs下寻找对应的类从而创建设备节点。

注：struct class和class_create(…) 以及device_create(…)都包含在在/include/linux/device.h中，使用的时候一定要包含这个头文件，否则编译器会报错。

（三）static struct platform_device s3c_led_device = {

    .name    = "s3c_led",

    .id      = 1,

    .dev     =

    {

        .platform_data = &s3c_led_data,

        .release = platform_led_release,

    },

};

 static struct platform_driver s3c_led_driver = {

    .probe      = s3c_led_probe,  

    .remove     = s3c_led_remove,

    .driver     = {

        .name       = "s3c_led",

        .owner      = THIS_MODULE,

    },

};

驱动和设备的结构体成员有差别，但是用来匹配识别的name域必须是相同的。只有这样才能实现互相匹配，实现驱动找设备，设备找驱动。（系统为platform总线定义了一个bus_type(总线类型)的实例platform_bus_type,在此结构体中有一个成员函数: .match,系统通过这个函数完成相关匹配）

使用platform虚拟总线的目的就是为了将驱动和设备分离，增强其可移植性。

（四）加载驱动时首先调用s3c_led_init（）函数分别注册platfrom设备和platfrom驱动。

 而对于platfrom_devices设备链来说:

Platfrom_device_register -> 调用（platform_device）结构体类型的结构体s3c_led_device，结构体中定义name域和id以及设备dev信息的函数指针 -> 其中设备数据又存放在结构体类型为（s3c_led_platform_data）的结构体变量s3c_led_data中 -> s3c_led_data成员leds函数指针指向s3c_led_info结构体类型的s3c_leds结构体数组中。nleds函数指针指向一个内核中的宏定义ARRAY_SIZE（），可以求出设备的个数。

对于platfrom_driver 驱动链来说：

Platfrom_driver_register -> 调用（platform_driver）结构体类型的结构体s3c_led_driver，结构体中有指向s3c_led_probe的probe指针和remove指针以及driver指针 -> 加载驱动链调用了s3c_led_driver结构体变量后首先便会调用s3c_led_probe函数。而probe函数的参数是platform_device结构体类型的指针。 -> 其中首先定义了一个s3c_led_platfrom_data类型的指针获取设备的信息。然后依次更改LED灯gpio口的状态以及通过判断主设备号静态或者动态的获取设备号。 -> 初始化cdev结构体，并且将fops结构体与之绑定。字符设备驱动注册

注意：设备要在开发板上相关处注册，如：/mine2440/kernel/linux-3.0/arch/arm/mach-s3c2440/mach-smdk2440.c定义设备 （smdk2440板子）

在/driver/net/dm9000中（网卡dm9000）编写好驱动文件后在linux-3.0下Make menuconfig > device driver->network devicesupport 使能网卡驱动 

如果光注册或者是定义其中一样并不能互相关联的。

附上简单的测试程序：

/*********************************************************************************
 *      Copyright:  (C) 2015 songyong<handy_skyoutlook.com>
 *                  All rights reserved.
 *
 *       Filename:  plat_test1.c
 *    Description:  This file 
 *                 
 *        Version:  1.0.0(2015年04月11日)
 *         Author:  sky <[email protected]>
 *      ChangeLog:  1, Release initial version on "2015年04月11日 15时28分34秒"
 *                 
 ********************************************************************************/
#include"plat_ioctl.h"
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<fcntl.h>

/********************************************************************************
 *  Description:
 *   Input Args:
 *  Output Args:
 * Return Value:
 ********************************************************************************/
int main (int argc, char **argv)
{
    int fd;
    
    fd = open("/dev/led",O_RDWR);
    ioctl(fd,LED_ON,0);
    ioctl(fd,LED_ON,1);
    ioctl(fd,LED_ON,2);
    ioctl(fd,LED_BLINK,3);
    close(fd);
    return 0;
} /* ----- End of main() ----- */

----------------------------------------------- 
tftp -gr plat_led.ko 10.228.26.52 

tftp -gr plat_test1   10.228.26.52 

insmod        plat_led.ko                

./ plat_test1            //已自动创建设备节点,运行后123盏亮，第四盏闪。程序很简陋，日后深入了再改进。

-----------------------------------------------

贴上稍微改进后的代码

/*********************************************************************************
 *      Copyright:  (C) 2015 songyong<handy_skyoutlook.com>
 *                  All rights reserved.
 *
 *       Filename:  plat_test1.c
 *    Description:  This file 
 *                 
 *        Version:  1.0.0(2015年04月11日)
 *         Author:  sky <[email protected]>
 *      ChangeLog:  1, Release initial version on "2015年04月12日 15时28分34秒"
 *                 
 ********************************************************************************/
#include"plat_ioctl.h"
#include<stdio.h>
#include<stdlib.h>
#include<unistd.h>
#include<fcntl.h>
#include<sys/ioctl.h>
#include<errno.h>
#include<string.h>

#define    LED_CMD 1
#define    LED_COUNT 2 
/********************************************************************************
 *  Description:
 *   Input Args:
 *  Output Args:
 * Return Value:
 ********************************************************************************/
int main (int argc, char **argv)
{
    int fd;
    int n;
    
    fd = open("/dev/led",O_RDWR);
     n = atoi(argv[LED_COUNT]);

    if(3 != argc)
    {
        printf("args failure:%s", strerror(errno));
    }
    else if(!(strcmp(argv[LED_CMD],"LED_ON")))
    {
           ioctl(fd,LED_ON,n); 
    }
    else if(!(strcmp(argv[LED_CMD],"LED_OFF")))
    {
           ioctl(fd,LED_OFF,n); 
    } 
    else if(!(strcmp(argv[LED_CMD],"LED_BLINK")))
    {
           ioctl(fd,LED_BLINK,n);
    } 
    else printf("failure: %s",strerror(errno));
    close(fd);
    return 0;
} /* ----- End of main() ----- */

在开发板上的操作同上。不同之处是这个代码实现了可以通过命令行来操控LED，相同之处是没有具体模块化- _-#（交叉编译之后可执行文件名为plat_test3）

输入： ./plat_test3 LED_BLINK 0   即可看到第一盏灯闪烁。