platform s3c2440_led 驱动代码简要分析<1>

最新推荐文章于 2019-05-07 23:03:25 发布
最新推荐文章于 2019-05-07 23:03:25 发布
阅读量607 收藏 1
点赞数
分类专栏： 设备驱动
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liuzijiang1123/article/details/45100021
版权

首先贴上代码

s3c_driver.h

#ifndef __S3C_DRIVER_H
#define __S3C_DRIVER_H

#include <linux/version.h>
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/module.h>
#include <linux/kref.h>
#include <linux/spinlock.h>
#include <asm/uaccess.h>
#include <linux/mutex.h>
#include <linux/delay.h>
#include <linux/fs.h>
#include <linux/device.h>
#include <linux/i2c.h>
#include <linux/string.h>
#include <linux/bcd.h>
#include <linux/miscdevice.h>
#include <linux/poll.h>
#include <linux/irq.h>
#include <linux/interrupt.h>
#include <linux/sysfs.h>
#include <linux/proc_fs.h>
#include <linux/rtc.h>
#include <linux/spinlock.h>
#include <linux/usb.h>
#include <asm/uaccess.h>
#include <asm/delay.h>
#include <linux/syscalls.h>  /* For sys_access*/
#include <linux/platform_device.h>
#include <linux/unistd.h>
#include <linux/tty.h>
#include <linux/tty_flip.h>
#include <linux/serial.h>
#include <linux/serial_core.h>
#include <linux/irq.h>
#include <mach/regs-gpio.h>


#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,32)
#include <mach/hardware.h>
#include <mach/gpio.h>
#include <asm/irq.h>
#else 
#include <asm-arm/irq.h>
#include <asm/arch/gpio.h>
#include <asm/arch/hardware.h>
#endif
#include "plat_ioctl.h"

/* ===========================================================================
 *         S3C24XX device driver common macro definition 
 *===========================================================================*/

#define ENPULLUP                    1
#define DISPULLUP                   0

#define HIGHLEVEL                   1
#define LOWLEVEL                    0

#define INPUT                       1
#define OUTPUT                      0

#define OFF                         0
#define ON                          1

#define ENABLE                      1
#define DISABLE                     0

#define TRUE                        1
#define FALSE                       0

/* ===========================================================================
 *         S3C24XX device driver name and Major number define 
 *===========================================================================*/


#define DEV_LED_NAME                "led"
#define DEV_LED_MAJOR               203

#define DEV_BUTTON_NAME             "button"
#define DEV_BUTTON_MAJOR            "211"

#define DEV_ADC_NAME                "adc"
#define DEV_ADC_MAJOR               "212"

/*  ***** Bit Operate Define *****/
#define SET_BIT(data, i)   ((data) |=  (1 << (i)))    /*   Set the bit "i" in "data" to 1  */
#define CLR_BIT(data, i)   ((data) &= ~(1 << (i)))    /*   Clear the bit "i" in "data" to 0 */
#define NOT_BIT(data, i)   ((data) ^=  (1 << (i)))    /*   Inverse the bit "i" in "data"  */
#define GET_BIT(data, i)   ((data) >> (i) & 1)        /*   Get the value of bit "i"  in "data" */
#define L_SHIFT(data, i)   ((data) << (i))            /*   Shift "data" left for "i" bit  */
#define R_SHIFT(data, i)   ((data) >> (i))            /*   Shift "data" Right for "i" bit  */


/* ===========================================================================
 *         S3C24XX device driver common function definition 
 *===========================================================================*/

#define SLEEP(x)    {DECLARE_WAIT_QUEUE_HEAD (stSleep); if (10 > x) mdelay ((x * 1000)); \
                        else wait_event_interruptible_timeout (stSleep, 0, (x / 10));}

#define VERSION_CODE(a,b,c)       ( ((a)<<16) + ((b)<<8) + (c))
#define DRV_VERSION               VERSION_CODE(DRV_MAJOR_VER, DRV_MINOR_VER, DRV_REVER_VER)
#define MAJOR_VER(a)              ((a)>>16&0xFF)
#define MINOR_VER(a)              ((a)>>8&0xFF)
#define REVER_VER(a)              ((a)&0xFF)

#define dbg_print(format,args...) if(DISABLE!=debug) \
        {printk("[kernel] ");printk(format, ##args);}    

static inline void print_version(int version)
{
#ifdef __KERNEL__
        printk("%d.%d.%d\n", MAJOR_VER(version), MINOR_VER(version), REVER_VER(version));
#else
        printf("%d.%d.%d\n", MAJOR_VER(version), MINOR_VER(version), REVER_VER(version));
#endif
}


#endif /* __S3C_DRIVER_H */
因为是3个驱动的头文件所以比较大

plat_ioctl.h

#ifndef __PLAT_IOCTL_H
#define __PLAT_IOCTL_H

#include <asm/ioctl.h>

/*===========================================================================
 *                Common ioctl command definition 
 *===========================================================================*/

#define PLATDRV_MAGIC           0x60

/*===========================================================================
 *                 ioctl command for all the drivers 0x01~0x0F
 *===========================================================================*/

/*args is enable or disable*/
#define SET_DRV_DEBUG               _IO (PLATDRV_MAGIC, 0x01)
#define GET_DRV_VER                 _IO (PLATDRV_MAGIC, 0x02)

/*===========================================================================
 *                 ioctl command for few ioctl() cmd driver 0x10~0x2F
 *===========================================================================*/

/* LED driver */
#define LED_OFF                     _IO (PLATDRV_MAGIC, 0x18)
#define LED_ON                      _IO (PLATDRV_MAGIC, 0x19)
#define LED_BLINK                   _IO (PLATDRV_MAGIC, 0x1A)
#define ADC_SET_CHANNEL             _IO (PLATDRV_MAGIC, 0x1B)

/*===========================================================================
 *                   ioctl command for GPRS driver 0x30~0x4F
 *===========================================================================*/
#define GPRS_POWERDOWN              _IO (PLATDRV_MAGIC, 0x30)
#define GPRS_POWERON                _IO (PLATDRV_MAGIC, 0x31)
#define GPRS_RESET                  _IO (PLATDRV_MAGIC, 0x32)
#define GPRS_POWERMON               _IO (PLATDRV_MAGIC, 0x33)
#define GPRS_CHK_SIMDOOR            _IO (PLATDRV_MAGIC, 0x36)
#define GPRS_SET_DTR                _IO (PLATDRV_MAGIC, 0x37)
#define GPRS_SET_RTS                _IO (PLATDRV_MAGIC, 0x38)
#define GPRS_GET_RING               _IO (PLATDRV_MAGIC, 0x39)
#define SET_PWUP_TIME               _IO (PLATDRV_MAGIC, 0x3A)
#define SET_PWDOWN_TIME             _IO (PLATDRV_MAGIC, 0x3B)
#define SET_RESET_TIME              _IO (PLATDRV_MAGIC, 0x3C)
#define GPRS_CHK_MODEL              _IO (PLATDRV_MAGIC, 0x3E) 

/*===========================================================================
 *                   ioctl command for EEPROM driver 0x50~0x5F
 *===========================================================================*/
#define LL_POWEROFF                 _IO (PLATDRV_MAGIC, 0x50)
#define LL_POWERON                  _IO (PLATDRV_MAGIC, 0x51)
#define LL_STOP                     _IO (PLATDRV_MAGIC, 0x52)
#define LL_START                    _IO (PLATDRV_MAGIC, 0x53)
#define LL_READ                     _IO (PLATDRV_MAGIC, 0x54)
#define LL_WRITE                    _IO (PLATDRV_MAGIC, 0x55)
#define LL_DATALOW                  _IO (PLATDRV_MAGIC, 0x56)
#define LL_ACKNAK                   _IO (PLATDRV_MAGIC, 0x57)


#endif                          /* __PLAT_IOCTL_H */






******************************************************************************************************************************************************************

#include "s3c_driver.h"

#define DRV_AUTHOR                "Guo Wenxue <guowenxue@gmail.com>"
#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);
    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, MKDEV(dev_major,0), NULL, DEV_NAME);

#else
    device_create (led_device.dev_class, NULL, MKDEV(dev_major,0), 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;//jiffies为当前时间
    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)); 
	for()
    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");

当我第一眼看到这个代码的时候我首先是被里面的各种结构体嵌套给弄糊涂了。

简要的分析了一下，结构体嵌套之间的关系，和一些比较难懂的地方，没做太多深入研究。

内核从2.6开始就引用了platform平台总线的概念，其中每个设备的资源用platform_device结构体来描述。(这个图是我自己理解画出来的，很粗糙·-。-)

         

 

 


当你需要加入某个设备的时候，你将其“挂”到platform设备总线上，就是定义一个platform_device的结构体变量，然后再调用platform_add_devices 或platform_device_register向系统中注册设备，前者可以一次性注册多个平台设备。

platform_device结构体                             

                        

 struct platform_device 

{                        

 const char * name;//设备名                 

 

 u32 id;                                         

 

 struct device dev;     //设备结构                         

 

 u32 num_resources;//设备所使用各类资源数量 

 

 struct resource * resource;// 资源            

 

 };         

首先看到我们定义的platform_s3c_led设备的代码

 

static struct platform_device s3c_led_device =

{

    .name    = "s3c_led", //驱动结构体里面也有这样一个name，是驱动和设备相互找到自己的一个“重要线索”

    .id      = 1,

.dev     =    

 {

        .platform_data = &s3c_led_data, 

        .release = platform_led_release,

     },

};

 

 

上面的.dev中对.platform_data进行了设备的信息转移，这样我们就需要看到我们用来保存信息的结构体static struct s3c_led_platform_data   s3c_led_data.

 

struct s3c_led_platform_data

{

    struct s3c_led_info    *leds;

    int                     nleds;

};

 

static struct  s3c_led_platform_data  s3c_led_data = 

{

    .leds = s3c_leds,

    .nleds = ARRAY_SIZE(s3c_leds),

};

 

首先定义了一个s3c_led_platform_data的结构体，这个是led设备的私有数据结构体，接着就马上定义了一个此类型结构体变量用来保存我们设备的私有信息。

 

在这里我们发现里面还有其他的结构体，这个就是这个代码比较难理解的地方，一层一层的结构体进行了嵌套。

 

struct s3c_led_info 这个结构体是用来保存led硬件设备的信息。

 

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 */           

};

 

然后又定义了此结构体的一个数组s3c_leds[ ],这个数组里面保存了具体每盏灯的硬件信息。

然后将信息再转移到s3c_led_data中（一共有几盏灯，每盏灯的具体信息）。

OK上述就是platform_s3c_led_device里面.dev中数据转移的操作。

 

然后其中还有一个realease的操作，传入了platform_led_release这个函数，这里我感觉转了一点点弯。

 

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

    }

}

 

里面我个人最难理解的就是里面传地址的那行代码：

struct s3c_led_platform_data *pdata = dev->platform_data; 

弄了很久才有一点眉头，让我慢慢跟你解析:

因为这个函数是我们注册成功后才会去调用，当我们注册成功后，这样我们内核中就有了s3c_led_device这样一个结构体了，当你调用这个函数的时候里面的形参是struct device *dev,因为注册过了，所以存在了这里的*dev其实就是&s3c_led_data,系统会自动去调用这个当形参。

struct device *dev =&s3c_led_device->dev;

struct s3c_led_platform_data *pdata =dev->platform_data;

pdata=&s3c_led_data;

 

接着说platform_driver：

它与设备一样，也是有一条platform平台总线，上面“挂着”设备驱动，并用platform_driver结构体来描述每个驱动。

  

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 (*suspend_late)(struct platform_device *, pm_message_t state); 
        

 int (*resume_early)(struct platform_device *); 
        

 int (*resume)(struct platform_device *); //恢复函数，在开机时被调用
       

  struct device_driver driver; //设备驱动结构
};       

 

 

 

 

这里我们同样也定义了s3c_led的platform_driver结构体。

 

static struct platform_driver s3c_led_driver = { 

    .probe      = s3c_led_probe, 

    .remove     = s3c_led_remove, 

    .driver     = { 

        .name       = "s3c_led", 

        .owner      = THIS_MODULE, 

    },

};

 

probe函数一般完成硬件设备使能，struct resource的获取以及虚拟地址的动态映射和具体类型设备的注册（因为平台设备只是一种虚拟的设备类型);remove函数完成硬件设备的关闭，struct resource以及虚拟地址的动态映射的释放和具体类型设备的注销。（struct resource是platform_device里面的结构体成员）

 

Ps:probe函数里面首先是获得设备的私有数据，然后将led状态进行初始化，再申请设备号，接着就是初始化一个cdev传入已经设置好的file operations最后cdev加入内核。

 

当然probe函数里面的传值跟上面那个platform_led_release函数里面的差不多只是有一点点变化，就是形参要求得不同，我们可以这样理解。

struct platform_device *dev =&s3c_led_device;

struct s3c_led_platform_data *pdata =dev->dev.platform_data;

pdata=&s3c_led_data;

 

 

 

当定义好这2个platform类型的设备和驱动后，我们就需要看其led初始化函数了，里面包含了这2个platform类型的设备和驱动的注册。

 

 static int __init s3c_led_init(void)

{

   int       ret = 0;

 

   ret = platform_device_register(&s3c_led_device);//将设备加入platform设备总线中

   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);//将驱动加入platform设备总线中

   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;

}

 

 

然后是led卸载模块函数

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

同样这2个函数都会各自被上面2个宏使用，即加载led设备和驱动和卸载led设备和驱动。


总结：以上是我对platform_led.c里面的我个人认为的必须要理解的难点解析，对于具体的一些操作函数和timer时钟函数，和led闪烁的函数还没去深入研究。

 

文字肯定都是比较生涩的，我还是最后用图形来总结一下吧。

 

其实就是设备那个地方的定义了一层又一层的嵌套，比较麻烦。





首先我们定义了一个platform_device结构体类型的s3c_led_device，一个led设备的结构体，然后呢我们需要把灯的数据呀，所以又定义了一s3c_led_platform_data结构体类

型的s3c_led_data用来保存我们灯的数据，当然灯肯定不止一盏啊，所以就需要用数组来保存，而且每盏灯的具体信息也是很多的，所以我们又定义了一个s3c_led_info结构

体类型的s3c_leds[]数组来保存，当然这些结构体要有关联就得互相包含，所以：s3c_led_info包含于s3c_led_platform_data最后再把s3c_led_data的地址传s3c_led_device

里面的void *类型的platform_data，就这样3者互相形参了联系，我个人认为这里就体现了一种编程的一种分类的思想，把很多东西细化一下，方便管理.还有一个难点我在上面也

提到过了，就是注册后，系统调用时数据的传递。


接下来是我将贴出我的实现代码。


Muscle_Mliu
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
linux与arm开发：gpio输出驱动（QQ2440开发板led驱动）总结
joygo007的专栏
10-06 471
采用linux 2.4版的架构函数设计led驱动，将qq2440的gpio直接做成流水灯。 linux2.4版的字符型设备简单的驱动构成： 1、定义设备名和设备号： #define DEVICE_NAME "gh_leds" #define LED_MAJOR 200 2、定义设备驱动操作的函数： 定义open、read、write、ioctl、close时对设备进行哪些操作...
S3C2440学习之GPIO按键控制LED灯
BLSpan的博客
02-21 3584
/* 名称:S3C2440学习之GPIO按键控制LED灯 说明:这是实验2440GPIO的输入功能。基本的流程和51单片机开发的差不多。都是对GPIO端口寄存器的控制不同的是，51单片机可以直接对进行位控制，而2440中GPIO只能对32位的寄存器进行写入或者读出。这样的话，对于有些逻辑操作要稍微复杂点。还有个不同的是，无论是STM32还是51在进行IO按键输入的时候，都需要进...
S3C2440 LED 驱动程序详解
hardward1的专栏
07-28 352
#include #include #include #include #include #include #include #include #include #include #include //定义驱动名，驱动设备号 #define DEVICE_NAME "leds" #define LED_MAJOR 231 //静态长整形数组，存放与
Linux 字符设备驱动
SongYuLong
05-18 405
字符设备驱动 主设备号和次设备号的获取 MAJOR(dev) MINOR(dev) MKDEV(ma,mi) 字符设备加载和卸载函数 struct xxx_dev { struct cdev cdev; ..... }; static init __init xxx_init(void) { if(xxx_major) result = regi
linux SPI驱动 - 模拟gpio
xiaofengcanyue2013的专栏
01-07 8007
重要的结构体分析： struct spi_master { struct device dev;
GPIO.rar_ gpio s3c2440 _GPIO-test_QQ2440_io驱动_port GPIO ARM9
09-22
标题中的“GPIO.rar_ gpio s3c2440 _GPIO-test_QQ2440_io驱动_port GPIO ARM9”表明这是一个关于S3C2440处理器的GPIO（General Purpose Input/Output）驱动程序的压缩包，适用于GPIO测试以及QQ2440开发板的IO驱动。...
leddriver.rar_linux AD驱动_s3c2440
09-20
在本文中，我们将深入探讨与"leddriver.rar_linux AD驱动_s3c2440"相关的技术细节，包括Linux下的AD（Analog-to-Digital）驱动程序、S3C2440微处理器以及如何在Linux2.6.12内核中实现驱动程序的开发和测试。...
wince_bsp.zip_S3C2440A_CE6_BSP.msi_s3c2440_s3c2440 bsp_s3c2440 w
09-19
1. 驱动开发：开发S3C2440 BSP时，需要编写或适配各种硬件驱动，如中断控制器、GPIO、串口、LCD、定时器等，确保WinCE6能够正确控制这些硬件。 2. 配置文件调整：根据实际硬件配置修改平台配置文件，如Platform.bib...
ftdi_arm wince6_driver_ftdiarm_s3c2440_wince6ftdidriver_mini2440
10-03
标题中的"ftdi_arm wince6_driver_ftdiarm_s3c2440_wince6ftdidriver_mini2440" 指的是一个专为Windows CE 6.0 (WinCE6) 设计的FTDI（FPGA可编程接口设备）驱动程序，适用于ARM架构，特别是S3C2440处理器，并且与...
irq.rar_linux irq驱动_linux 中断_linux 中断 实例_s3c2440 irq
09-19
总的来说，这个压缩包中的代码详细描述了如何在Linux环境下，特别是在S3C2440平台上实现中断驱动，包括平台驱动和设备驱动的编写，以及中断处理的机制。这对于理解Linux内核中断系统以及在嵌入式开发中处理硬件事件...
s3c2440简单驱动编程-led
深蓝的专栏
01-24 739
OS      ：linux         cpu     ：s3c2440         开发板：TQ2440 先制作一个驱动的基本构架：         找到外接硬件的对应管教：         现在开始根据手册查找开发板信息（这一步是开发板级信息），由于目标是控制led，故先去“TQ2440的底板原理图”查找管教信息。根据led的电路连接，查找到其对应的cpu管教为GPB5
s3c2440- led驱动分析及其测试程序
crazy boy
03-26 1318
*********************************************************************************************************************************** #操作系统:CentOS6.7 #开发板  ：fl2440 #cpu        :s3c2440(arm920t) #编译器
字符设备LED驱动的改良——自动创建文件结点和platform总线LED驱动
WuYujun's blog
05-07 537
之前写的字符驱动，安装驱动之后还需要自己mknod创建文件节点、而且设备和驱动都在一个驱动文件里，嵌入式的产品那么多，如果对应的硬件变了，那整个驱动代码就不可重用了，可移植性很差，下面说说怎么解决这些问题。 一、自动创建设备文件结点 实际上Linux内核为我们提供了一组函数，可以用来在模块加载的时候自动在/dev目录下创建相应设备节点，并在卸载模块时删除该节点，当然前提条件是用户空间移植了ud...
platform驱动学习一之led实例
crazy boy
04-03 1443
前几天学习了platform驱动，学习过程中参考了网上的好多篇博客，总算是对platform驱动有了一定的了解，写个博客总结一下！下面我将对platform驱动代码及驱动整个流程进行分析，加之我的理解！ 学习platform驱动之前我们肯定要先了解一下platform的一些基础知识！  1、什么是platform(平台)总线？       （1）. 相对于USB、PCI、I2C、SPI等
AX88772B 驱动移植
weixin_34056162的博客
09-13 1262
Linux kernel 3.2.0 捏自带的AX88772B 不稳定，现用 AX88772B 官方的驱动进行移植测试。 驱动下载地址： http://www.asix.com.tw/cs/products.php?op=pItemdetail&amp;PItemID=105;71;101&amp;PLine=71 驱动相关修改： // vim Makefile : TARG...
framebuffer的入门介绍-实现程序分析
热门推荐
liuzijiang1123的专栏
07-20 1万+
如想想对lcd屏进行操作（例如在lcd屏幕上画线，或者显示视频数据），我们就必须得了framebuffer（帧缓冲），网上各种百度，大多都说的很官方，至少很难找到那些让人觉得很生动的描述，让我们这些出入门的菜鸟能好好了解一下。 下面就是我结合老师的指点和论坛上的解释再加上自己的理解写的一些东西。****************************************************...
tslib移植-selected device is not a touchscreen I understand 错误解决
liuzijiang1123的专栏
05-17 1万+
这篇文章必须要写，因为昨天移植了触摸屏的驱动后又移植了tslib，拷到开发板上运行后出现了这个错误，更恐怖的是花了一个晚上的时间，早上来实验室才弄好，网上找了好多这个错误的解决方法，很多都不是蛮详细的，都比较不适合我们新手去看。  不过千辛万苦的是找到了这个博客，最后帮助我解决了，大家可以参考一下   http://blog.csdn.net/zhaocj/article/details/37
ov9650学习（1）
liuzijiang1123的专栏
08-26 2366
前言：对于ov9650的学习做一个记录，目标是在我的fl2440的板子上移植ov9650的驱动并实现在lcd上显示摄像头拍摄的内容，虽然最后还是花屏，但是还需要做一个记录，记下自己学习到的一点东西。希望发到网上然后得到广大网友的帮助，如果能对你们学习的过程中有帮助我也是荣幸。 内核：linux-3.0 开发板：fl2440 交叉编译器：arm-linux-gcc 3.81
关于make menuconfig中选项只有空格和M的原因
liuzijiang1123的专栏
05-07 1884
当我面进行内核配置的时候有些选项只有M和空格2个选项，当我面按Y的时候会出现下面的情况 阅读可知它是存在一定的依赖关系的 仔细观看选项上面有NOTE！ 它是依赖SCSI里面的选项的 OK当我们选把SCSI  device support选成了*号后， 可以看见我们usb mass storage support有*号的选择了 经
<dependencies> <dependency> <groupId>com.huntall</groupId> <artifactId>huntall-platform-spring-boot-V2.0${app.server}</artifactId> <version>${huntall.platform.version}</version> <type>war</type> <scope>runtime</scope> </dependency> <dependency> <groupId>com.huntall</groupId> <artifactId>huntall-platform-spring-boot-V2.0${app.server}</artifactId> <version>${huntall.platform.version}</version> <type>jar</type> <classifier>api</classifier> <scope>provided</scope> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId> <version>${spring-boot.version}</version> </dependency> </dependencies>
最新发布
07-25
<version>${huntall.platform.version}</version> <scope>compile</scope> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值