linux设备驱动之plat_led驱动

最新推荐文章于 2022-08-20 21:07:34 发布
最新推荐文章于 2022-08-20 21:07:34 发布
阅读量289 收藏
点赞数
分类专栏： linux设备驱动
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a710564672/article/details/77131860
版权

上一篇介绍了platform总线，现在基于platform分析plat_led驱动代码。

/*********************************************************************************
 *      Copyright:  (C) 2017 Huang Weiming<710564672@qq.com>  
 *                  All rights reserved.
 *
 *       Filename:  plat_led.c
 *    Description:  This is the common LED driver runs on S3C24XX.
 *                 
 *        Version:  1.0.0(10/27/2011~)
 *         Author:  Huang Weiming <710564672@qq.com>
 *      ChangeLog:  1, Release initial version on "06/05/2017 04:09:58 PM"
 *                 
 ********************************************************************************/
#include "s3c_driver.h"

#define DRV_AUTHOR                "Huang Weiming<710564672@qq.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
   
   
    
    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
    
    
     
     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
     
     
      
      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");
先来看入口函数 static int __init s3c_led_init(void)

1.static int __init s3c_led_init(void)

static int __init s3c_led_init(void)//LED初始化  
{  
   int       ret = 0;  
   /*设备注册：把指定设备添加到内核中平台总线的设备列表，等待匹配,匹配成功则回调驱动中probe函数；*/
   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");  
   
   /*驱动注册：把指定驱动添加到内核中平台总线的驱动列表，等待匹配,匹配成功则回调驱动中probe；*/
   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;  
}
根据前面介绍的基于platform总线，驱动的初始化函数通过platform_driver_register函数或者driver_register函数实现平台设备与平台驱动的关联。实现过程是通过传递设备与驱动所定义的结构体信息传递给函数，定义代码如下：

2.device与driver结构体

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,系统通过这个函数完成相关匹配）
当设备和驱动匹配成功，程序跳转执行probe()函数

3.static int s3c_led_probe(struct platform_device *dev)

static int s3c_led_probe(struct platform_device *dev)//设备和驱动相互识别是调用从由内核把platform_device传到probe函数  
{  
    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);  //设置相应gpio为输出模式
         if(ON == pdata->leds[i].status)  
         {  
            s3c2410_gpio_setpin(pdata->leds[i].gpio, pdata->leds[i].active_level);  //LED管脚亮
         }  
         Else 
         {  
            s3c2410_gpio_setpin(pdata->leds[i].gpio, ~pdata->leds[i].active_level);  //LED管脚灭 
         }  
    }  
   
    /*  Alloc the device for driver */  
if (0 != dev_major)  												//如果已经有主设备号
 {  
        devno = MKDEV(dev_major, dev_minor);  						//生成devno值
        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结构体空间
    led_device.data = dev->dev.platform_data;  							//获取平台数据
    cdev_init (&(led_device.cdev), &led_fops);  						//注册cdev结构体
    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 */  
	/*启用内核定时器，初始 timer_list 的结构的一些变量*/
    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));  							//将blink_timer 加入内核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;  
   
}
可以看出，该函数主要做了以下几件事：

（1）初始化LED灯

（2）分配设备编号

（3）初始化led_device结构体并注册cdev结构体 

（4）自动创建设备节点
（5）初始化定时器

4.file_operations结构体

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*/  
};
file_operations结构是用来建立与驱动程序的连接。这个结构定义在<linux/fs.h>，其中包含一组函数指针。每个打开的文件和一组函数关联。这些操作主要用来实现系统调用。这个结构中的每一个字段必须指向驱动程序中实现特定操作的函数，对于不支持的操作，对应的字段 可置为NULL值。

5.系统调用函数

（1）led_open函数

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;
}
这里重点看看 container_of：
container_of 在Linux内核中是一个常用的宏，用于从包含在某个结构中的指针获得结构本身的指针。简单说就是通过一个结构变量中一个成员的地址找到这个结构体变量的首地址。在本函数中即获得结构体led_device的地址。

具体关于container_of可以参考这篇博客  点击打开链接

（2）led_ioctl函数

static long led_ioctl(struct file *file, unsigned int cmd, unsigned long arg)  
{  
    struct s3c_led_platform_data *pdata = file->private_data;  
   
    switch (cmd)  								//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;  
   /*如果传入LED_OFF命令，则关闭LED灯*/
        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;  
   /*如果传入LED_OFF命令，则开启LED灯*/
        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;  
   /*如果传入LED_BLINK命令，则闪烁LED灯*/
        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;  
}
该l函数主要实现用户空间和内核空间命令的传递，从而实现对LED等亮灭以及闪烁的控制。
6.定时器中断服务函数void led_timer_handler(unsigned long data)

最好来看看定时器中断服务函数，通过该函数控制灯的闪烁

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)				//判断LED灯的亮灭  
        {  
              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);//计时器更新，jiffies是全局变量，在头文件  
    }  
}
mod_timer函数 
当一个定时器已经被插入到内核动态定时器链表中后，内核通过函数mod_timer来修改定时器的超时时间。 
mod_timer函数也可以操作那些已经初始化，但还没有被激活的定时器，如果定时器没有激活，mod_timer会激活它。如果调用时定时器未被激活，该函数返回0，否则返回1。一旦从mod_timer函数返回，定时器都将被激活而且设置了新的定时值。
关于内核定时器的使用可以参考这篇博客   点击打开链接


大致流程就分析完了，下一篇将编写测试程序驱动该LED设备






Star_hwm
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
嵌入式linux驱动与软件详解之一 led驱动与程序
老王嵌入式
05-13 993
其实从大三的时候就接触过一些嵌入式linux的东西，只不过当时基础不扎实，周围的师兄和老师也没有能弄明白的，苦苦弄了一年之后还是决定先暂时放弃。后来扎实的学过了stm32和软件编程后，基本的设计思路已经清晰了，所以打算开始学习实践一下三年前未完成的夙愿。        今天先从最简单的led程序说起，简单的弄明白了，复杂的也不会有多难了，闲话少说，开始整理思路。我选用的开发平台是mini24
plat_led驱动总结
萬象森羅，能者獨秀！
04-12 695
plat_led驱动总结@(linux 编程)[led, 驱动]platform驱动介绍在学习platform驱动之前，我写过最原始的 led 驱动程序，其包含了硬件初始化和设备注册的所有工作。这种模型理解起来直观易懂，但是在实际的应用当中却显得不那么理想。设备信息和驱动代码冗余在一起，一旦设备信息发生一点变化将会导致整个驱动程序的大幅度修改甚至重写，十分的麻烦。因此，linux引入了platfor
Linux嵌入式LED如何读取状态,嵌入式Linux之我行——LED驱动在2440上的实例开发
weixin_29343153的博客
05-05 237
嵌入式Linux之我行，主要讲述和总结了本人在学习嵌入式linux中的每个步骤。一为总结经验，二希望能给想入门嵌入式Linux的朋友提供方便。如有错误之处，谢请指正。一、开发环境主 机：VMWare--Fedora 9开发板：Mini2440--64MB Nand编译器：arm-linux-gcc-4.3.2二、实现步骤1. 硬件原理图分析。由原理图得知LED电路是共阳极的，并分别由2440的G...
实现一个platporm架构的LED驱动
nucleare的博客
12-17 378
目标：编写一个platporm架构的LED驱动 参考知识： 在Linux字符设备驱动编程模型中，只要应用程序open()了相应的设备文件，就可以使用ioctl通过驱动程序来控制我们的硬件，这种模型直观，但是从软件设计的角度看，却是一种十分糟糕的方式，它有一个致命的问题，就是设备信息和驱动代码冗余在一起，一旦硬件信息发生改变甚至设备已经不在了，就必须要修改驱动源码，非常的麻烦，为了解决这种驱动代码和设备信息耦合的问题，Linux提出了platform bus(平台总线)的概念，即使用虚拟总线将设备信息和驱
FL2440添加自带led驱动
萬象森羅，能者獨秀！
04-20 485
FL2440添加自带led驱动在之前学习驱动自己写过led的驱动程序，其实s3c2440对于驱动已经支持得非常好，内核里面已经有了led的驱动程序，我们要使能led驱动只需要稍作修改。make menuconfig 配置 Device Drivers ---> [*] LED Support ---> [*] LED Class Support
plat_device.rar_platform 驱动_platform设备
09-14
标题"plat_device.rar_platform 驱动_platform设备"暗示了这是一个关于Linux平台驱动程序的压缩包，其中可能包含了驱动源码、相关应用程序以及构建这些组件的Makefile。这个压缩包可能是为了帮助开发者理解和调试...
CAN_Pro_plat_II.rar
02-23
CAN_Pro_plat_II.rar 是一个与CAN (Controller Area Network)技术相关的压缩包，主要包含CANPro软件的安装程序。CANPro是一款强大的CAN数据解析和分析工具，广泛应用于汽车电子、工业自动化等领域，它能够帮助工程师...
nounou_ball_plat_system_
10-01
"nounou_ball_plat_system_" 是一个基于MATLAB编写的控制系统，用于模拟和分析球与盘（Ball and Plate System）的动态行为。球与盘系统是一个经典的控制理论问题，常被用来教学和研究自动控制系统的稳定性、鲁棒性和...
irq.rar_linux irq驱动_linux 中断_linux 中断 实例_s3c2440 irq
最新发布
09-19
总的来说，这个压缩包中的代码详细描述了如何在Linux环境下，特别是在S3C2440平台上实现中断驱动，包括平台驱动和设备驱动的编写，以及中断处理的机制。这对于理解Linux内核中断系统以及在嵌入式开发中处理硬件事件...
Linux 平台下的 ilitek 触摸屏驱动
03-29
Linux 平台下的 ilitek 触摸屏驱动。 包内是对Linux平台下的ilitek驱动。适用于mtk,allwin,rockchip,amlogic等不同平台下的ilitek触摸屏驱动，内含区分不同平台的配置说明文档.通过宏来区分不同的平台。 ilitek tp ...
mini2440驱动奇谭——LED驱动与测试（动态加载）
Github: lianghuiyong
10-05 3343
实现功能：开发板动态加载led驱动模块并能通过测试程序 系统：Ubuntu 14.04 驱动交叉编译内核：linux-2.6.32.2 //建立交叉编译 开发板：mini2440 （128M nandflash） //关于怎么烧写linux到开发板请点击，Linux RootFs 选择rootfs_rtm_2440.img （光盘目录：image/linux/rtm ） 开发所需工具：NFS网络文件 minicom vim linux文件目录：/opt/F
linux内核led添加流程,fl2440——linux内核自带的led驱动添加
weixin_35751412的博客
05-07 281
======================================================================================================================主机操作系统：Centos 6.7交叉编译器环境：arm-linux-gcc-4.5.4 (可通过命令/opt/buildroot-2012.08/arm920t/...
platform驱动学习一之led实例
crazy boy
04-03 1441
前几天学习了platform驱动，学习过程中参考了网上的好多篇博客，总算是对platform驱动有了一定的了解，写个博客总结一下！下面我将对platform驱动代码及驱动整个流程进行分析，加之我的理解！ 学习platform驱动之前我们肯定要先了解一下platform的一些基础知识！  1、什么是platform(平台)总线？       （1）. 相对于USB、PCI、I2C、SPI等
platform之led驱动分析及测试程序
樊茂林的博客
04-07 1125
什么是paltform总线： 一个现实的linux设备和驱动通常都需要挂接在一种总线上，比较常见的总线有USB、PCI总线等。但是，在嵌入式系统里面，SoC系统中集成的独立的外设控制器、挂接在SoC内存空间的外设却不依附与此类总线。基于这样的背景下，2.6内核加入了platform虚拟总线。platform机制将设备本身的资源注册进内核，有内核统一管理，在驱动程序使用这些资源时使用统一的接口，这
Linux·platform驱动框架
m0_64560763的博客
08-20 1529
驱动框架-platform驱动框架
读linux-2.6.38内核，分析led驱动内核
僧哥叨叨叨
01-10 297
先关注几个目录，内核的drivers/目录下找到leds，然后找到s3c24xx.c文件， static struct platform_driver s3c24xx_led_driver = { .probe = s3c24xx_led_probe, .remove = s3c24xx_led_remove, .driver = {
linux之平台总线led_dev,led_drv,ledapp程序demo
weixin_42399752的博客
07-29 384
plat_led_dev.c #include <linux/init.h> #include <linux/module.h> #include <linux/platform_device.h> #define GPC0_CONF_REG 0xe0200060 #define GPC0_SIZE 8 // 24表示需要使用6个寄存器， 8表示使...
unsigned long long妙用
Seddon2001的博客
07-24 2668
洛谷 P2181 对角线 使用unsigned long long可以防止爆精度 以下是各精度的范围 #include <iostream> #include <cstdio> using namespace std; int main() { unsigned long long a,b; cin>>a; b=a*(a-1)/2*(a-2)/3*(a-3)/4; printf("%lld",b); // 那为什么这样一定是对的呢？
unsigned long 的用法
gary_zh的专栏
01-25 6100
在很多函数调用里面都有 unsigned long 参数，事实上他不只是传递一个数，更重要的是他还能代表一个地址，即当一个指针使用，下面就举例说明。 一，内核定时器的使用。 内核定时器一般分为声明、注册、删除等操作。 #include Struct timer_list {        Unsigned long expires;        Void (*function
ARM嵌入式Linux：设备分类与驱动开发基础
首先，它强调了在Linux 2.6.39内核的ARM架构下进行设备驱动的开发，着重介绍了设备分类的四种方法： 1. 基本设备分类：将设备分为字符设备（如UART、PWM）和块设备（如硬盘、内存）两大类，它们分别以"c"和"b"开头...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值