linux设备驱动之LED驱动代码分析

最新推荐文章于 2024-08-16 17:01:07 发布
最新推荐文章于 2024-08-16 17:01:07 发布
阅读量629 收藏 1
点赞数
分类专栏： linux设备驱动
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a710564672/article/details/70827753
版权
     上一篇对一个简单的hello模块进行编写，认识了设备驱动的工作过程。本文来对LED驱动代码进行分析，进一步理解驱动的工作过程。
Linux内核版本：3.0

驱动代码如下：

/*********************************************************************************
 *      Copyright:  (C) 2012 Guo Wenxue<guowenxue@gmail.com>  
 *                  All rights reserved.
 *
 *       Filename:  s3c_led.c
 *    Description:  This file 
 *                 
 *        Version:  1.0.0(07/26/2012~)
 *         Author:  Guo Wenxue <guowenxue@gmail.com>
 *      ChangeLog:  1, Release initial version on "07/26/2012 10:03:40 PM"
 *                 
 ********************************************************************************/

#include <linux/module.h>   /* Every Linux kernel module must include this head */
#include <linux/init.h>     /* Every Linux kernel module must include this head */
#include <linux/kernel.h>   /* printk() */
#include <linux/fs.h>       /* struct fops */
#include <linux/errno.h>    /* error codes */
#include <linux/cdev.h>     /* cdev_alloc()  */
#include <asm/io.h>         /* ioremap()  */
#include <linux/ioport.h>   /* request_mem_region() */

#include <asm/ioctl.h>      /* Linux kernel space head file for macro _IO() to generate ioctl command  */
#ifndef __KERNEL__
#include <sys/ioctl.h>      /* User space head file for macro _IO() to generate ioctl command */
#endif
//#include <linux/printk.h> /* Define log level KERN_DEBUG, no need include here */


#define DRV_AUTHOR                "Guo Wenxue <guowenxue@gmail.com>"
#define DRV_DESC                  "S3C24XX LED driver"

#define DEV_NAME                  "led"
#define LED_NUM                   4

/* Set the LED dev major number */
//#define LED_MAJOR                 79
#ifndef LED_MAJOR
#define LED_MAJOR                 0
#endif

#define DRV_MAJOR_VER             1
#define DRV_MINOR_VER             0
#define DRV_REVER_VER             0

#define DISABLE                   0
#define ENABLE                    1

#define GPIO_INPUT                0x00
#define GPIO_OUTPUT               0x01


#define PLATDRV_MAGIC             0x60
#define LED_OFF                   _IO (PLATDRV_MAGIC, 0x18)
#define LED_ON                    _IO (PLATDRV_MAGIC, 0x19)

#define S3C_GPB_BASE              0x56000010
#define GPBCON_OFFSET             0
#define GPBDAT_OFFSET             4
#define GPBUP_OFFSET              8
#define S3C_GPB_LEN               0x10        /* 0x56000010~0x56000020  */

int led[LED_NUM] = {5,6,8,10};  /* Four LEDs use GPB5,GPB6,GPB8,GPB10 */

static void __iomem *s3c_gpb_membase;


#define s3c_gpio_write(val, reg) __raw_writel((val), (reg)+s3c_gpb_membase)
#define s3c_gpio_read(reg)       __raw_readl((reg)+s3c_gpb_membase)


int dev_count = ARRAY_SIZE(led);
int dev_major = LED_MAJOR;
int dev_minor = 0;
int debug = DISABLE;

static struct cdev      *led_cdev;

static int s3c_hw_init(void)
{
    int          i;
    volatile unsigned long  gpb_con, gpb_dat, gpb_up;

    if(!request_mem_region(S3C_GPB_BASE, S3C_GPB_LEN, "s3c2440 led"))
    {
        return -EBUSY;
    }

    if( !(s3c_gpb_membase=ioremap(S3C_GPB_BASE, S3C_GPB_LEN)) )
    {
        release_mem_region(S3C_GPB_BASE, S3C_GPB_LEN);
        return -ENOMEM;
    }

    for(i=0; i<dev_count; i++)
    {
        /* Set GPBCON register, set correspond GPIO port as input or output mode  */
        gpb_con = s3c_gpio_read(GPBCON_OFFSET);
        gpb_con &= ~(0x3<<(2*led[i]));   /* Clear the currespond LED GPIO configure register */
        gpb_con |= GPIO_OUTPUT<<(2*led[i]); /* Set the currespond LED GPIO as output mode */
        s3c_gpio_write(gpb_con, GPBCON_OFFSET);

        /* Set GPBUP register, set correspond GPIO port pull up resister as enable or disable  */
        gpb_up = s3c_gpio_read(GPBUP_OFFSET);
        //gpb_up &= ~(0x1<<led[i]); /* Enable pull up resister */
        gpb_up |= (0x1<<led[i]);  /* Disable pull up resister */
        s3c_gpio_write(gpb_up, GPBUP_OFFSET);

        /* Set GPBDAT register, set correspond GPIO port power level as high level or low level */
        gpb_dat = s3c_gpio_read(GPBDAT_OFFSET);
        //gpb_dat &= ~(0x1<<led[i]); /* This port set to low level, then turn LED on */
        gpb_dat |= (0x1<<led[i]);  /* This port set to high level, then turn LED off */
        s3c_gpio_write(gpb_dat, GPBDAT_OFFSET);
    }

    return 0;
}


static void turn_led(int which, unsigned int cmd)
{
    volatile unsigned long  gpb_dat;

    gpb_dat = s3c_gpio_read(GPBDAT_OFFSET);

    if(LED_ON == cmd)
    {
        gpb_dat &= ~(0x1<<led[which]); /*  Turn LED On */
    }
    else if(LED_OFF == cmd)
    {
        gpb_dat |= (0x1<<led[which]);  /*  Turn LED off */
    }

    s3c_gpio_write(gpb_dat, GPBDAT_OFFSET);
}

static void s3c_hw_term(void)
{
    int                     i;
    volatile unsigned long  gpb_dat;

    for(i=0; i<dev_count; i++)
    {
        gpb_dat = s3c_gpio_read(GPBDAT_OFFSET);
        gpb_dat |= (0x1<<led[i]);  /* Turn LED off */
        s3c_gpio_write(gpb_dat, GPBDAT_OFFSET);
    }

    release_mem_region(S3C_GPB_BASE, S3C_GPB_LEN);
    iounmap(s3c_gpb_membase);
}


static int led_open(struct inode *inode, struct file *file)
{
    int minor = iminor(inode);

    file->private_data = (void *)minor;

    printk(KERN_DEBUG "/dev/led%d opened.\n", minor);
    return 0;
}

static int led_release(struct inode *inode, struct file *file)
{
    printk(KERN_DEBUG "/dev/led%d closed.\n", iminor(inode));

    return 0;
}

static void print_help(void)
{
    printk("Follow is the ioctl() commands for %s driver:\n", DEV_NAME);
    //printk("Enable Driver debug command: %u\n", SET_DRV_DEBUG);
    printk("Turn LED on command  : %u\n", LED_ON);
    printk("Turn LED off command : %u\n", LED_OFF);

    return;
}

static long led_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
    int which = (int)file->private_data;

    switch (cmd)
    {
        case LED_ON:

            turn_led(which, LED_ON);
            break;

        case LED_OFF:
            turn_led(which, LED_OFF);
            break;

        default:
            printk(KERN_ERR "%s driver don't support ioctl command=%d\n", DEV_NAME, cmd);
            print_help();
            break;
    }

    return 0;
}


static struct file_operations led_fops = 
{
    .owner = THIS_MODULE,
    .open = led_open,
    .release = led_release,
    .unlocked_ioctl = led_ioctl,
};

static int __init s3c_led_init(void)
{
    int                    result;
    dev_t                  devno;

    if( 0 != s3c_hw_init() )
    {
        printk(KERN_ERR "s3c2440 LED hardware initialize failure.\n");
        return -ENODEV;
    }

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

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

    if(NULL == (led_cdev=cdev_alloc()) )
    {
        printk(KERN_ERR "S3C %s driver can't alloc for the cdev.\n", DEV_NAME);
        unregister_chrdev_region(devno, dev_count);
        return -ENOMEM;
    }

    led_cdev->owner = THIS_MODULE;
    cdev_init(led_cdev, &led_fops);

    result = cdev_add(led_cdev, devno, dev_count);
    if (0 != result)
    {   
        printk(KERN_INFO "S3C %s driver can't reigster cdev: result=%d\n", DEV_NAME, result); 
        goto ERROR;
    }


    printk(KERN_ERR "S3C %s driver[major=%d] version %d.%d.%d installed successfully!\n", 
            DEV_NAME, dev_major, DRV_MAJOR_VER, DRV_MINOR_VER,DRV_REVER_VER);
    return 0;


ERROR:
    printk(KERN_ERR "S3C %s driver installed failure.\n", DEV_NAME);
    cdev_del(led_cdev);
    unregister_chrdev_region(devno, dev_count);
    return result;
}

static void __exit s3c_led_exit(void)
{
    dev_t devno = MKDEV(dev_major, dev_minor);

    s3c_hw_term();

    cdev_del(led_cdev);
    unregister_chrdev_region(devno, dev_count);

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

    return ;
}



/* These two functions defined in <linux/init.h> */
module_init(s3c_led_init);
module_exit(s3c_led_exit);

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

MODULE_AUTHOR(DRV_AUTHOR);
MODULE_DESCRIPTION(DRV_DESC);
MODULE_LICENSE("GPL");


一.s3c_led_init(void)

看一个驱动第一步就是找module_init(),先来看s3c_led_int 在这个init函数中所起的作用。 
static int __init s3c_led_init(void)
{
    int                    result;
    dev_t                  devno;

     /*如果硬件初始化失败，打印如下信息并返回-ENODEV*/
    if( 0 != s3c_hw_init() )
    {
        printk(KERN_ERR "s3c2440 LED hardware initialize failure.\n");
        return -ENODEV;
    }

    /*  Alloc the device for driver */
    if (0 != dev_major) /*  Static */ /* 如果已经有了设备号 静态获取主次设备号 */
    {
        devno = MKDEV(dev_major, 0);                //主次设备号和设备名绑定
        result = register_chrdev_region (devno, dev_count, DEV_NAME);
    }
    else                            //动态获取主次设备号
    {
        result = alloc_chrdev_region(&devno, dev_minor, dev_count, DEV_NAME);
        dev_major = MAJOR(devno);
    }

    /*  Alloc for device major failure */     /*  如果设备号申请失败，打印如下信息并返回-ENODEV */
    if (result < 0)                                    //返回值小于0表示分配失败
    {
        printk(KERN_ERR "S3C %s driver can't use major %d\n", DEV_NAME, dev_major);
        return -ENODEV;
    }
    printk(KERN_DEBUG "S3C %s driver use major %d\n", DEV_NAME, dev_major);

    if(NULL == (led_cdev=cdev_alloc()) )    //分配cdev结构体，如果分配失败，打印如下信息
    {
        printk(KERN_ERR "S3C %s driver can't alloc for the cdev.\n", DEV_NAME);
        unregister_chrdev_region(devno, dev_count);
        return -ENOMEM;
    }

    led_cdev->owner = THIS_MODULE;            //指明设备所属模块 
    cdev_init(led_cdev, &led_fops);            //用于初始化cdev结构体，并建立cdev与file_operations 之间的连接

    result = cdev_add(led_cdev, devno, dev_count);  //提交给内核，向内核注册一个cdev结构
    if (0 != result)
    {   
        printk(KERN_INFO "S3C %s driver can't reigster cdev: result=%d\n", DEV_NAME, result);
        goto ERROR;
    }


    printk(KERN_ERR "S3C %s driver[major=%d] version %d.%d.%d installed successfully!\n",
            DEV_NAME, dev_major, DRV_MAJOR_VER, DRV_MINOR_VER,DRV_REVER_VER);
    return 0;


ERROR:
    printk(KERN_ERR "S3C %s driver installed failure.\n", DEV_NAME);
    cdev_del(led_cdev);                                //注销设备，通常发生在驱动模块的卸载函数中 
    unregister_chrdev_region(devno, dev_count);        //释放注册的设备号 
    return result;
}
从中可以看出注册设备驱动的流程为5个部分：
1.硬件寄存器相关的初始化
 这里通过 s3c_hw_init()这个函数对led相关寄存器进行配置
2.注册主次设备号
在建立一个字符设备之前，我们的驱动程序首先要做的事情就是获得一个或者多个设备编号。完成该工作的必要函数是register_chrdev_region,该函数在<linux/fs.h>中声明
               int register_chrdev_region(dev_t first, unsigned int count,  char *name)；
其中，first是要分配的设备编号范围的起始值。first的次设备号经常被置为0。count是所请求的连续设备编号的个数。name是和该编号范围关联的设备名称。register_chrdev_region () 的返回值在分配成功时为0.在错误情况下，将返回一个负的错误码。
在Linux中有非常多的字符设备，在人为的为字符设备分配设备号时，很可能发生冲突。Linux内核开发者一直在努力将设备号变为动态的。可以使用alloc_chrdev_region()函数达到这个目的 
              int alloc_chrdev_region(dev_t  *dev, unsigned int firstminor unsigned int count,  char *name)；
在上面这个函数中，dev是仅用于输出的参数，在成功完成调用后将保存已分配范围的第一个编号。firstminor 应该是要使用的被请求的第一个次设备号，它通常是0.count和name参数与 register_chrdev_region函数是一样的。
不论采用那种方法分配设备编号，都应该在不再使用它们时释放这些设备编号。设备编号的释放需要使用下面的函数：
void unregister_chrdev_region(dev_t first,unsigned int count);
通常我们在模块的清除函数中调用unregister_chrdev_region函数。此处在 s3c_led_exit()中调用。
3.定义file_operations
file_operations结构是用来建立与驱动程序的连接。这个结构定义在<linux/fs.h>，其中包含一组函数指针。每个打开的文件和一组函数关联。这些操作主要用来实现系统调用。这个结构中的每一个字段必须指向驱动程序中实现特定操作的函数，对于不支持的操作，对应的字段 可置为NULL值。    
4申请cdev结构体，建立与fops链接
5.cdev_add()调用告诉内核cdev结构的信息。
               int cdev_add(struct cdev *dev,dev_t num,unsigned int count);
这里，dev是cdev结构，num是该设备对应的第一个设备编号，count诗应该和该设备关联的设备编号的数量。count经常取1.
同样的，在模块清楚函数中调用void cdev_del(struct cdev *dev)移除字符设备，移除后就不再访问cdev结构了。
二.s3c_led_exit(void) 
/*s3c_led_exit()执行功能与s3c_led_init()函数的功能完全相反。该函数主要的功能为卸载驱动，释放内存，释放设备节点和设备号*/
static void __exit s3c_led_exit(void)
{
    dev_t devno = MKDEV(dev_major, dev_minor);

    s3c_hw_term();

    cdev_del(led_cdev);                            //移除字符设备
    unregister_chrdev_region(devno, dev_count);    //释放设备编号

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

    return ;
}
s3c_led_exit()执行功能与s3c_led_init()函数的功能完全相反。该函数主要的功能为卸载驱动，释放内存，释放设备节点和设备号。
三.硬件初始化函数s3c_hw_init(void) 
static int s3c_hw_init(void)    //static只能在本C文件使用
{
    int          i;
    volatile unsigned long  gpb_con, gpb_dat, gpb_up;  //volatile防止编译器优化代码

    if(!request_mem_region(S3C_GPB_BASE, S3C_GPB_LEN, "s3c2440 led"))  /*向内核申请内存资源，其起始地址为S3C_GPB_BASE，大小为s3c_GPB_LEN;如果申请失败，返回-EBUSY*/
    {
        return -EBUSY;
    }

    if( !(s3c_gpb_membase=ioremap(S3C_GPB_BASE, S3C_GPB_LEN)) )     /*申请成功后，将I/O内存资源的物理地址映射成核心虚地址。以后操作寄存器一律操作虚拟地址即s3c_gpb_membase的地址*/       
    {
        release_mem_region(S3C_GPB_BASE, S3C_GPB_LEN);
        return -ENOMEM;
    }

    for(i=0; i<dev_count; i++)
    {
        /* Set GPBCON register, set correspond GPIO port as input or output mode  */
        gpb_con = s3c_gpio_read(GPBCON_OFFSET);        //读取GPBCON寄存器的值
        gpb_con &= ~(0x3<<(2*led[i]));   /* Clear the currespond LED GPIO configure register先将相应的led的gpio引脚复位清零*/   
        gpb_con |= GPIO_OUTPUT<<(2*led[i]); /* Set the currespond LED GPIO as output mode 然后将相应的led的gpio引脚设置为输出模式*/
        s3c_gpio_write(gpb_con, GPBCON_OFFSET);        /*再将设置好的GPBCON引脚信息写入寄存器中 */

        /* Set GPBUP register, set correspond GPIO port pull up resister as enable or disable  */
        gpb_up = s3c_gpio_read(GPBUP_OFFSET);        //读取GPBUP的虚拟地址并保存在gpb_up中 
        //gpb_up &= ~(0x1<<led[i]); /* Enable pull up resister */
        gpb_up |= (0x1<<led[i]);  /* Disable pull up resister */
        s3c_gpio_write(gpb_up, GPBUP_OFFSET);        //将设置好的GPBUP引脚信息写入寄存器中

        /* Set GPBDAT register, set correspond GPIO port power level as high level or low level */
        gpb_dat = s3c_gpio_read(GPBDAT_OFFSET);        //读取GPBDAT的虚拟地址并保存在gpb_dat中 
        //gpb_dat &= ~(0x1<<led[i]); /* This port set to low level, then turn LED on */
        gpb_dat |= (0x1<<led[i]);  /* This port set to high level, then turn LED off */
        s3c_gpio_write(gpb_dat, GPBDAT_OFFSET);        //将设置好的GPBDAT引脚信息写入寄存器中 
    }

    return 0;
}
request_mem_region： 寄存器的地址是不变的，寄存器不属于标准内存，而是属于I/O内存。但linux并不知道这些，比如他不知道LED寄存器的地址是0x56000010 ，所以要访问硬件LED的时候驱动程序必须先向linux申请从0x56000010 开始的一段地址，用的便是request_mem_region(res->start, size, pdev->name)，
其中，参数start是I/O内存资源的起始物理地址，参数n指定I/O内存资源的大小。在请求IO内存资源成功后， 然后再将申请到的地址空间用ioremap转化成虚拟地址再去访问........
当然如果你访问LED 的时候却向内核申请了比如0x57000000(在0x57000000还未被申请的情况下，应该可以申请成功),这样访问到的寄存器便不是LED了.request_mem_region仅仅是linux对IO内存的管理，意思指这块内存我已经占用了，别人就不要动了，也不能被swap出去。这是因为request_mem_region源码，里面有个死循环在保护已被申请过的资源不被其他代码再request_mem_region成功。使用这些寄存器时，可以不调用request_mem_region，但这样的话就不能阻止别人对他的访问了。
四.file_operations结构体 
static struct file_operations led_fops =         //定义fop结构体，针对该驱动提供的系统调用和操作
{
    .owner = THIS_MODULE,
    .open = led_open,                            //open为指向led_open()的函数指针
    .release = led_release,
    .unlocked_ioctl = led_ioctl,
};
file_operations结构是用来建立与驱动程序的连接。这个结构定义在<linux/fs.h>，其中包含一组函数指针。每个打开的文件和一组函数关联。这些操作主要用来实现系统调用。这个结构中的每一个字段必须指向驱动程序中实现特定操作的函数，对于不支持的操作，对应的字段 可置为NULL值。
五.系统调用函数
1.led_open(struct inode *inode, struct file *file )     
static int led_release(struct inode *inode, struct file *file)
{
    printk(KERN_DEBUG "/dev/led%d closed.\n", iminor(inode));

    return 0;
}
release方法的作用正好与open相反。此方法完成以下任务：(1)释放由open分配的，保存在filp->private_data中的所有内容。(2)在最后一次关闭操作时关闭设备。
3.led_ioctl( struct file *file, unsigned int cmd, unsigned long arg ) 
static long led_ioctl(struct file *file, unsigned int cmd, unsigned long arg)    //参数为用户程序空间传过来的参数
{
    int which = (int)file->private_data;            //获取次设备号

    switch (cmd)
    {
        case LED_ON:

            turn_led(which, LED_ON);
            break;

        case LED_OFF:
            turn_led(which, LED_OFF);
            break;

        default:
            printk(KERN_ERR "%s driver don't support ioctl command=%d\n", DEV_NAME, cmd);
            print_help();
            break;
    }

    return 0;
}
大部分驱动程序除了读取和写入设备之外，还需执行各种类型的硬件控制。这些操作通常通过ioctl方法支持，该方法实现了同名的系统调用。其原型为  
               int (*ioctl) (struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg);
inode和filp两个指针的值对应于应用程序传递的文件描述符fd，这和传给open方法的参数一样。参数cmd由用户空间不经修改的传递给驱动程序，可选的arg参数以unsigned long的形式传递给驱动程序。
大多数ioctl的实现都包括一个switch语句来根据cmd参数选择对应的操作。不同的命令被赋予不同的数值，该数值通常使用符号名代替，这些符号名有C语言的预处理语句定义。所以，为了访问这些符号，，用户程序也要包含这些头文件。
六.turn_led(int which, unsigned int cmd) 
static void turn_led(int which, unsigned int cmd)
{
    volatile unsigned long  gpb_dat;

    gpb_dat = s3c_gpio_read(GPBDAT_OFFSET);            //设置gpb_dat变量来存储GPBDAT的在内存中的虚拟地址

    if(LED_ON == cmd)
    {
        gpb_dat &= ~(0x1<<led[which]); /*  Turn LED On */
    }
    else if(LED_OFF == cmd)
    {
        gpb_dat |= (0x1<<led[which]);  /*  Turn LED off */
    }

    s3c_gpio_write(gpb_dat, GPBDAT_OFFSET);            //设置好的GPBDAT引脚信息写入内存 
}
该函数也好理解，通过用户程序传过来的参数，操作寄存器控制LED 具体哪盏灯的 亮灭。
七.s3c_hw_term(void) 
static void s3c_hw_term(void)
{
    int                     i;
    volatile unsigned long  gpb_dat;

    for(i=0; i<dev_count; i++)
    {
        gpb_dat = s3c_gpio_read(GPBDAT_OFFSET);
        gpb_dat |= (0x1<<led[i]);  /* Turn LED off */
        s3c_gpio_write(gpb_dat, GPBDAT_OFFSET);
    }

    release_mem_region(S3C_GPB_BASE, S3C_GPB_LEN);    //释放已申请的内存资源
    iounmap(s3c_gpb_membase);                        //取消物理地址到虚拟地址的映射关系 
}
调用LED结束后释放所占内存资源及设置相应GPIO引脚关闭LED。

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














Star_hwm
关注
专栏目录
LED驱动代码
10-23
想要学习LED可以看一下，这是一个很容易看懂的代码
Linux LED字符设备驱动，基于平台驱动的LED字符设备驱动，支持多个LED灯，没有体现分层设计思想
03-04
尽管这个驱动支持多个LED灯，但并没有体现Linux驱动的分层设计思想。分层设计通常意味着将驱动分解为更小、更独立的模块，如总线驱动、设备驱动、功能驱动等，以提高代码的可维护性和复用性。 LED字符设备驱动通常...
linux led驱动框架分析
longjingcha110的博客
12-19 340
linux的驱动框架重点代码在 /drivers/leds/led-class.c /drivers/leds/led-core.c 两个文件 subsys_initcall(leds_init); subsys_initcall 宏定义: 将声明的函数链接在指定的段中 由/arch/arm/kernel/vmlinux.lds.S 脚本文件指定链接 leds_init class_create ...
树莓派--LED驱动例程（01）
最新发布
2401_82904490的博客
08-16 1035
define PIN 26 // GPIO26 引脚号使用宏定义 GPIO 的一些控制寄存器和物理地址，PIN 26即我们需要控制的引脚。GPIO_BASE是树莓派的 GPIO 寄存器基地址，GPSET0设置 GPIO 输出寄存器的偏移，GPFSEL0为GPIO 功能选择寄存器的偏移，使用GPCLR0清除 GPIO 输出寄存器的偏移，GPIO_FSEL_OUTP用于设置 GPIO 为输出模式的值。
【TINY4412】LINUX移植笔记：（7）LED驱动分析
大水猫
01-14 1875
【TINY4412】LINUX移植笔记：（7）LED驱动分析 宿主机 ： 虚拟机 Ubuntu 16.04 LTS / X64 目标板[底板]： Tiny4412SDK - 1506 目标板[核心板]： Tiny4412 - 1412 LINUX内核： 4.12.0 交叉编译器： gcc-arm-none-eabi-5
Linux LED驱动源码简析
Quartz's Blog
10-17 549
驱动的加载与卸载函数驱动加载服务函数int major; static int first_drv_init(void) { major = register_chrdev(0, "first_drv", &first_drv_fops); // 注册驱动，其中第一个参数为0，则表示采用系统动态分配的主设备号 //第二个参数是其注册的设备名 //第三个很重
浅谈linux的LED驱动
若云流风的专栏
04-13 2240
从简单的LED程序来看整个系统的框架。
Linux LED字符设备驱动，基于平台驱动的LED字符设备驱动，支持多个LED灯，体现Linux驱动的分层设计思想
03-04
整个驱动分为三个部分，板级驱动(led_dev.c)定义板级资源，芯片级驱动(led_imx6ull.c)定义了芯片相关的结构和操作，系统级驱动(leddrv.c)定义了字符设备相关的接口。更改硬件只需要替换led_dev.c，更换芯片需要替换...
嵌入式Linux字符设备驱动-分层后的LED字符设备驱动-系统级驱动+芯片级驱动
03-02
基于最基本的Linux LED字符设备进行改进，在原来的基础上将驱动进行分层设计，拆分出通用的部分作为系统级驱动，剩余的跟芯片相关的部分作为芯片级驱动，以后...体现Linux驱动分层设计思想，以及面向对象的接口抽象。
经过进一步分层后的Linux LED字符设备驱动，系统级驱动 + 芯片级驱动 + 板级驱动
03-02
Linux LED字符设备驱动是Linux内核驱动模型的一个实例，它展示了如何通过分层设计来管理硬件资源，特别是...通过分析这些文件，开发者可以学习如何将这些理论知识应用到实际项目中，以构建高效的Linux LED驱动程序。
嵌入式Linux设备驱动程序开发指南.pdf
03-16
总的来说，《嵌入式Linux设备驱动程序开发指南》为读者提供了一个深入理解嵌入式Linux驱动开发的全面指南，结合理论与实践，有助于提升开发者在这个重要领域的专业技能。无论是初学者还是经验丰富的工程师，都能从中...
LED灯的驱动程序源代码
12-29
LED驱动程序源码是本人写的一个关于开发板上的LED灯的闪烁的程序。
led驱动和源码
11-09
1）驱动源码：led.c 2）驱动文件：ked.ko 具体示例请查看博客 https://blog.csdn.net/qq_39188039/article/details/83892197
LED的C语言驱动代码
09-06
LED的C语言驱动代码
led驱动51源代码
01-21
MD BIT P3.0 LD BIT P3.1 L1 BIT P0.4 L2 BIT P0.5 AD BIT P1.2 ORG 00H AJMP START ORG 0020H
linux驱动之一、LED驱动（驱动代码小结附：github代码链接）
Ace's Blog
06-03 2823
前言：最近在学习韦东山老师的arm驱动部分教学，本文记录一下自己对最基本的驱动框架结构的理解，以及最基本的led驱动实现的方法。 一、相关知识点（涉及接口、结构体、调用关系等） 一个软件系统可以分为以下四层：应用程序、库、内核、驱动，借用韦老师一副图，如下图： 即：应用层开发的功能，各个接口会通过库、通过内核调用到底层驱动程序的对应接口，从而执行对应的功能。 也就是说我们做驱动开发时，需要理解驱动...
LED驱动代码编写
Heavysea的博客
12-15 4199
为了编写LED驱动程序，需要查看开发板的原理图，查看需要配置的引脚。这里LED驱动代码的编写基于100ask-imx6ull mini开发板。 一、查看原理图 由LED硬件图可以得知配置GPIO5_3 输出低电平，LED点亮，GPIO5_3输出高电平，LED熄灭。 具体的寄存器操作应该是怎样的？ 1.使能寄存器，但有些芯片的GPIO是没有使能开关的，即它总是使能的。 2.选择引脚功能，一个引脚可以用于GPIO、串口、USB或其他功能，有对应的寄存器来选择引脚的功能。 3.对于已经设置为GPIO功能的引脚，
第四部分 linux led驱动代码分析
Never too old to learn.
06-16 9176
一、LED驱动 1、对led驱动的测试 对于向led这样的设备模型，系统认为所有的设备都是挂接在总线上的，而要使设备工作，就需要相应的驱动。设备模型会产生一个虚拟的文件系统——sysfs，它给用户提供了一个从用户空间去访问内核设备的方法，它在linux里的路径是/sys。如果要写程序访问sysfs，可以像读写普通文件一样来操作/sys目录下的文件。 对于led的移植不需要任何的修改，首先需要
用LED驱动框架注册led设备的示例代码
weixin_42031299的博客
05-10 645
1、LED驱动框架分析 参考博客： 2、简单的用LED驱动框架注册led设备的代码 #include <linux/module.h> #include <linux/init.h> #include <linux/fs.h> #include <linux/leds.h> #include <mach/regs-gpio.h> #include <mach/gpio-bank.h> #include <linux/
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值