Linux 驱动开发 八：新字符设备驱动框架实现和测试

最新推荐文章于 2022-05-12 17:23:47 发布
最新推荐文章于 2022-05-12 17:23:47 发布
阅读量423 收藏 1
点赞数 1
分类专栏： Linux驱动开发 文章标签： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/OnlyLove_/article/details/121881339
版权

新驱动框架以 LED 跑马灯进行测试。

一、创建 VSCode 工程

在工程目录中新建 VSCode 工程：保存工程文件 xxx.code-workspace。

onlylove@ubuntu:~/linux/driver/linux_driver/3_newchrdev$ ls -al
total 20
drwxrwxr-x 2 onlylove onlylove 4096 Dec 10 06:20 .
drwxrwxr-x 5 onlylove onlylove 4096 Dec 10 06:04 ..
-rw-rw-r-- 1 onlylove onlylove   60 Dec 10 06:20 led.code-workspace
-rw-rw-r-- 1 onlylove onlylove  273 Dec 10 06:17 Makefile
-rw-rw-r-- 1 onlylove onlylove  344 Dec 10 06:20 newchrdev.c
onlylove@ubuntu:~/linux/driver/linux_driver/3_newchrdev$

led.code-workspace 为工程文件。

二、添加头文件路径

在 VSCode 中添加 Linux 源码中的头文件路径。打开 VSCode，按下 “Crtl+Shift+P” 打开 VSCode 的控制台，然后输入 “C/C++: Edit configurations(JSON) ”，打开 C/C++ 编辑配置文件，添加 Linux 源码头文件路径，修改后内容如下：

{
    "configurations": [
        {
            "name": "Linux",
            "includePath": [
                "${workspaceFolder}/**",
                "/home/onlylove/linux/linux/lq_linux/linux-imx-rel_imx_4.1.15_2.1.0_ga/include",
                "/home/onlylove/linux/linux/lq_linux/linux-imx-rel_imx_4.1.15_2.1.0_ga/arch/arm/include",
                "/home/onlylove/linux/linux/lq_linux/linux-imx-rel_imx_4.1.15_2.1.0_ga/arch/arm/include/generated"
            ],
            "defines": [],
            "compilerPath": "/usr/bin/gcc",
            "cStandard": "gnu17",
            "cppStandard": "gnu++14",
            "intelliSenseMode": "linux-gcc-x64"
        }
    ],
    "version": 4
}

三、Makefile

KERNELDIR := /home/onlylove/linux/linux/lq_linux/linux-imx-rel_imx_4.1.15_2.1.0_ga
CURRENT_PATH := $(shell pwd)
obj-m := newchrdev.o

build: kernel_modules

kernel_modules:
	$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) modules
clean:
	$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean

四、驱动模块加载和卸载

#include "linux/init.h"
#include "linux/module.h"

/* 驱动入口函数 */
static int __init newchrdev_init(void)
{
    /* 驱动入口函数具体内容 */

    return 0;
}

/* 驱动卸载函数 */
static void __exit newchrdev_exit(void)
{
    /* 驱动卸载函数具体内容 */
}

module_init(newchrdev_init);
module_exit(newchrdev_exit);

MODULE_LICENSE("GPL");

make 编译测试日志如下：

onlylove@ubuntu:~/linux/driver/linux_driver/3_newchrdev$ make
make -C /home/onlylove/linux/linux/lq_linux/linux-imx-rel_imx_4.1.15_2.1.0_ga M=/home/onlylove/linux/driver/linux_driver/3_newchrdev modules
make[1]: Entering directory '/home/onlylove/linux/linux/lq_linux/linux-imx-rel_imx_4.1.15_2.1.0_ga'
  CC [M]  /home/onlylove/linux/driver/linux_driver/3_newchrdev/newchrdev.o
  Building modules, stage 2.
  MODPOST 1 modules
  CC      /home/onlylove/linux/driver/linux_driver/3_newchrdev/newchrdev.mod.o
  LD [M]  /home/onlylove/linux/driver/linux_driver/3_newchrdev/newchrdev.ko
make[1]: Leaving directory '/home/onlylove/linux/linux/lq_linux/linux-imx-rel_imx_4.1.15_2.1.0_ga'
onlylove@ubuntu:~/linux/driver/linux_driver/3_newchrdev$

五、驱动使用数据管理

在编写驱动时，会定义一些变量，如果所有变量独自定义，会造成数据管理混乱。因此使用结构体对数据进行管理。

typedef struct{
	
}newchrdev_t;

newchrdev_t newchrdev;

六、字符设备号分配和释放

1、宏定义

#define NEWCHRDEV_MAJOR 0   /* 主设备号（如果为0则让系统自动分配，如果大于0则使用指定设备号） */
#define NEWCHRDEV_MINOR 0   /* 次设备号 */
#define NEWCHRDEV_COUNT 1   /* 设备号个数 */
#define NEWCHRDEV_NAME  "newchrdev" /* 名子 */

2、数据定义

typedef struct{
    int major;      /* 主设备号 */
    int minor;      /* 次设备号 */
    dev_t devid;    /* 设备号 */
}newchrdev_t;

3、字符设备号分配

static int __init newchrdev_init(void)
{
    /* 驱动入口函数具体内容 */
    /* 1、字符设备号分配 */
    int ret;
    newchrdev.major = NEWCHRDEV_MAJOR;
    if(newchrdev.major){
        newchrdev.minor = NEWCHRDEV_MINOR;
        newchrdev.devid = MKDEV(newchrdev.major, newchrdev.minor);
        ret = register_chrdev_region(newchrdev.devid,NEWCHRDEV_COUNT,NEWCHRDEV_NAME);
    }else{
        ret = alloc_chrdev_region(&newchrdev.devid,0,NEWCHRDEV_COUNT,NEWCHRDEV_NAME);
        newchrdev.major = MAJOR(newchrdev.devid);
        newchrdev.minor = MINOR(newchrdev.devid);
    }
    if(ret < 0){
        printk("newchrdev xxx_chrdev_region failed!\r\n");
        goto newchrdev_chrdev_region_failed;
    }
    printk("newchrdev major=%d,minor=%d\r\n",newchrdev.major,newchrdev.minor);

newchrdev_chrdev_region_failed:   /* 字符设备号分配失败处理函数（未分配资源，因此不做处理） */
    return ret;
}

4、字符设备号释放

static void __exit newchrdev_exit(void)
{
    /* 驱动卸载函数具体内容 */
    unregister_chrdev_region(newchrdev.devid,NEWCHRDEV_COUNT);
}

七、字符设备注册和注销

字符设备注册的核心就是将 dev 和 ops 建立连接。

1、cdev

struct cdev { 
	struct kobject kobj;                  //内嵌的内核对象.
	struct module *owner;                 //该字符设备所在的内核模块的对象指针.
	const struct file_operations *ops;    //该结构描述了字符设备所能实现的方法，是极为关键的一个结构体.
	struct list_head list;                //用来将已经向内核注册的所有字符设备形成链表.
	dev_t dev;                            //字符设备的设备号，由主设备号和次设备号构成.
	unsigned int count;                   //隶属于同一主设备号的次设备号的个数.
};

2、添加数据

typedef struct{
    struct cdev dev;    /*  */
    int major;          /* 主设备号 */
    int minor;          /* 次设备号 */
    dev_t devid;        /* 设备号 */
}newchrdev_t;

增加 cdev 结构体变量。

static const struct file_operations newchrdevops = {
    .owner   = THIS_MODULE,
};

增加 file_operations 结构体变量。

3、字符设备注册

/* 驱动入口函数 */
static int __init newchrdev_init(void)
{
    /* 驱动入口函数具体内容 */
    /* 1、字符设备号分配 */
    int ret;
    newchrdev.major = NEWCHRDEV_MAJOR;
    if(newchrdev.major){
        newchrdev.minor = NEWCHRDEV_MINOR;
        newchrdev.devid = MKDEV(newchrdev.major, newchrdev.minor);
        ret = register_chrdev_region(newchrdev.devid,NEWCHRDEV_COUNT,NEWCHRDEV_NAME);
    }else{
        ret = alloc_chrdev_region(&newchrdev.devid,0,NEWCHRDEV_COUNT,NEWCHRDEV_NAME);
        newchrdev.major = MAJOR(newchrdev.devid);
        newchrdev.minor = MINOR(newchrdev.devid);
    }
    if(ret < 0){
        printk("newchrdev xxx_chrdev_region failed!\r\n");
        goto newchrdev_chrdev_region_failed;
    }
    printk("newchrdev major=%d,minor=%d\r\n",newchrdev.major,newchrdev.minor);

    /* 2、注册字符设备 */
    newchrdev.dev.owner = THIS_MODULE;
    cdev_init(&newchrdev.dev,&newchrdevops);
    ret = cdev_add(&newchrdev.dev,newchrdev.devid,NEWCHRDEV_COUNT);
    if(ret < 0){
        printk("newchrdev cdev_add failed!\r\n");
        goto newchrdev_cdev_add_failed;
    }

newchrdev_cdev_add_failed:
    unregister_chrdev_region(newchrdev.devid,NEWCHRDEV_COUNT);

newchrdev_chrdev_region_failed:   /* 字符设备号分配失败处理函数（未分配资源，因此不做处理） */
    return ret;
}

4、字符设备注销

/* 驱动卸载函数 */
static void __exit newchrdev_exit(void)
{
    /* 驱动卸载函数具体内容 */
    /* 2、注销字符设备 */
    cdev_del(&newchrdev.dev);
    /* 1、释放设备号 */
    unregister_chrdev_region(newchrdev.devid,NEWCHRDEV_COUNT);
}

八、创建和删除类

1、添加数据

typedef struct{
    struct cdev dev;        /* cdev 结构体 */
    int major;              /* 主设备号 */
    int minor;              /* 次设备号 */
    dev_t devid;            /* 设备号 */
    struct class *class;    /* 类 */
}newchrdev_t;

增加 class 结构体指针变量。

2、创建类

/* 驱动入口函数 */
static int __init newchrdev_init(void)
{
    /* 驱动入口函数具体内容 */
    /* 1、字符设备号分配 */
    int ret;
    newchrdev.major = NEWCHRDEV_MAJOR;
    if(newchrdev.major){
        newchrdev.minor = NEWCHRDEV_MINOR;
        newchrdev.devid = MKDEV(newchrdev.major, newchrdev.minor);
        ret = register_chrdev_region(newchrdev.devid,NEWCHRDEV_COUNT,NEWCHRDEV_NAME);
    }else{
        ret = alloc_chrdev_region(&newchrdev.devid,0,NEWCHRDEV_COUNT,NEWCHRDEV_NAME);
        newchrdev.major = MAJOR(newchrdev.devid);
        newchrdev.minor = MINOR(newchrdev.devid);
    }
    if(ret < 0){
        printk("newchrdev xxx_chrdev_region failed!\r\n");
        goto newchrdev_chrdev_region_failed;
    }
    printk("newchrdev major=%d,minor=%d\r\n",newchrdev.major,newchrdev.minor);

    /* 2、注册字符设备 */
    newchrdev.dev.owner = THIS_MODULE;
    cdev_init(&newchrdev.dev,&newchrdevops);
    ret = cdev_add(&newchrdev.dev,newchrdev.devid,NEWCHRDEV_COUNT);
    if(ret < 0){
        printk("newchrdev cdev_add failed!\r\n");
        goto newchrdev_cdev_add_failed;
    }

    /* 3、创建类 */
    newchrdev.class = class_create(THIS_MODULE,NEWCHRDEV_NAME);
    if (IS_ERR(newchrdev.class)) {
        printk("newchrdev class_create failed!\r\n");
        goto newchrdev_class_create_failed;
    }

    return 0;
newchrdev_class_create_failed:
    cdev_del(&newchrdev.dev);
newchrdev_cdev_add_failed:
    unregister_chrdev_region(newchrdev.devid,NEWCHRDEV_COUNT);

newchrdev_chrdev_region_failed:   /* 字符设备号分配失败处理函数（未分配资源，因此不做处理） */
    return ret;
}

3、删除类

/* 驱动卸载函数 */
static void __exit newchrdev_exit(void)
{
    /* 驱动卸载函数具体内容 */
    /* 3、删除类 */
    class_destroy(newchrdev.class);
    /* 2、注销字符设备 */
    cdev_del(&newchrdev.dev);
    /* 1、释放设备号 */
    unregister_chrdev_region(newchrdev.devid,NEWCHRDEV_COUNT);
}

九、创建和删除设备

1、添加数据

typedef struct{
    struct cdev dev;        /* cdev 结构体 */
    int major;              /* 主设备号 */
    int minor;              /* 次设备号 */
    dev_t devid;            /* 设备号 */
    struct class *class;    /* 类 */
    struct device *device;  /* 设备 */
}newchrdev_t;

添加 device 变量。

2、创建设备

/* 驱动入口函数 */
static int __init newchrdev_init(void)
{
    /* 驱动入口函数具体内容 */
    /* 1、字符设备号分配 */
    int ret;
    newchrdev.major = NEWCHRDEV_MAJOR;
    if(newchrdev.major){
        newchrdev.minor = NEWCHRDEV_MINOR;
        newchrdev.devid = MKDEV(newchrdev.major, newchrdev.minor);
        ret = register_chrdev_region(newchrdev.devid,NEWCHRDEV_COUNT,NEWCHRDEV_NAME);
    }else{
        ret = alloc_chrdev_region(&newchrdev.devid,0,NEWCHRDEV_COUNT,NEWCHRDEV_NAME);
        newchrdev.major = MAJOR(newchrdev.devid);
        newchrdev.minor = MINOR(newchrdev.devid);
    }
    if(ret < 0){
        printk("newchrdev xxx_chrdev_region failed!\r\n");
        goto newchrdev_chrdev_region_failed;
    }
    printk("newchrdev major=%d,minor=%d\r\n",newchrdev.major,newchrdev.minor);

    /* 2、注册字符设备 */
    newchrdev.dev.owner = THIS_MODULE;
    cdev_init(&newchrdev.dev,&newchrdevops);
    ret = cdev_add(&newchrdev.dev,newchrdev.devid,NEWCHRDEV_COUNT);
    if(ret < 0){
        printk("newchrdev cdev_add failed!\r\n");
        goto newchrdev_cdev_add_failed;
    }

    /* 3、创建类 */
    newchrdev.class = class_create(THIS_MODULE,NEWCHRDEV_NAME);
    if(IS_ERR(newchrdev.class)) {
        printk("newchrdev class_create failed!\r\n");
        goto newchrdev_class_create_failed;
    }

    /* 4、创建设备 */
    newchrdev.device = device_create(newchrdev.class,NULL,newchrdev.devid,NULL,NEWCHRDEV_NAME);
    if(IS_ERR(newchrdev.device)){
        printk("newchrdev device_create failed!\r\n");
        goto neschrdev_device_creat_failed;
    }

    return 0;
neschrdev_device_creat_failed:
    class_destroy(newchrdev.class);
newchrdev_class_create_failed:
    cdev_del(&newchrdev.dev);
newchrdev_cdev_add_failed:
    unregister_chrdev_region(newchrdev.devid,NEWCHRDEV_COUNT);

newchrdev_chrdev_region_failed:   /* 字符设备号分配失败处理函数（未分配资源，因此不做处理） */
    return ret;
}

3、删除设备

/* 驱动卸载函数 */
static void __exit newchrdev_exit(void)
{
    /* 驱动卸载函数具体内容 */
    /* 4、删除设备 */
    device_destroy(newchrdev.class,newchrdev.devid);
    /* 3、删除类 */
    class_destroy(newchrdev.class);
    /* 2、注销字符设备 */
    cdev_del(&newchrdev.dev);
    /* 1、释放设备号 */
    unregister_chrdev_region(newchrdev.devid,NEWCHRDEV_COUNT);
}

十、测试新字符驱动框架

1、驱动框架源码

1、newchrdev.c

#include "linux/init.h"
#include "linux/module.h"
#include "linux/kdev_t.h"
#include "linux/fs.h"
#include "linux/cdev.h"
#include "linux/device.h"

#define NEWCHRDEV_MAJOR 0   /* 主设备号（如果为0则让系统自动分配，如果大于0则使用指定设备号） */
#define NEWCHRDEV_MINOR 0   /* 次设备号 */
#define NEWCHRDEV_COUNT 1   /* 设备号个数 */
#define NEWCHRDEV_NAME  "newchrdev" /* 名子 */

typedef struct{
    struct cdev dev;        /* cdev 结构体 */
    int major;              /* 主设备号 */
    int minor;              /* 次设备号 */
    dev_t devid;            /* 设备号 */
    struct class *class;    /* 类 */
    struct device *device;  /* 设备 */
}newchrdev_t;

newchrdev_t newchrdev;

static const struct file_operations newchrdevops = {
    .owner   = THIS_MODULE,
};

/* 驱动入口函数 */
static int __init newchrdev_init(void)
{
    /* 驱动入口函数具体内容 */
    /* 1、字符设备号分配 */
    int ret;
    newchrdev.major = NEWCHRDEV_MAJOR;
    if(newchrdev.major){
        newchrdev.minor = NEWCHRDEV_MINOR;
        newchrdev.devid = MKDEV(newchrdev.major, newchrdev.minor);
        ret = register_chrdev_region(newchrdev.devid,NEWCHRDEV_COUNT,NEWCHRDEV_NAME);
    }else{
        ret = alloc_chrdev_region(&newchrdev.devid,0,NEWCHRDEV_COUNT,NEWCHRDEV_NAME);
        newchrdev.major = MAJOR(newchrdev.devid);
        newchrdev.minor = MINOR(newchrdev.devid);
    }
    if(ret < 0){
        printk("newchrdev xxx_chrdev_region failed!\r\n");
        goto newchrdev_chrdev_region_failed;
    }
    printk("newchrdev major=%d,minor=%d\r\n",newchrdev.major,newchrdev.minor);

    /* 2、注册字符设备 */
    newchrdev.dev.owner = THIS_MODULE;
    cdev_init(&newchrdev.dev,&newchrdevops);
    ret = cdev_add(&newchrdev.dev,newchrdev.devid,NEWCHRDEV_COUNT);
    if(ret < 0){
        printk("newchrdev cdev_add failed!\r\n");
        goto newchrdev_cdev_add_failed;
    }

    /* 3、创建类 */
    newchrdev.class = class_create(THIS_MODULE,NEWCHRDEV_NAME);
    if(IS_ERR(newchrdev.class)) {
        printk("newchrdev class_create failed!\r\n");
        goto newchrdev_class_create_failed;
    }

    /* 4、创建设备 */
    newchrdev.device = device_create(newchrdev.class,NULL,newchrdev.devid,NULL,NEWCHRDEV_NAME);
    if(IS_ERR(newchrdev.device)){
        printk("newchrdev device_create failed!\r\n");
        goto neschrdev_device_creat_failed;
    }

    return 0;
neschrdev_device_creat_failed:
    class_destroy(newchrdev.class);
newchrdev_class_create_failed:
    cdev_del(&newchrdev.dev);
newchrdev_cdev_add_failed:
    unregister_chrdev_region(newchrdev.devid,NEWCHRDEV_COUNT);

newchrdev_chrdev_region_failed:   /* 字符设备号分配失败处理函数（未分配资源，因此不做处理） */
    return ret;
}

/* 驱动卸载函数 */
static void __exit newchrdev_exit(void)
{
    /* 驱动卸载函数具体内容 */
    /* 4、删除设备 */
    device_destroy(newchrdev.class,newchrdev.devid);
    /* 3、删除类 */
    class_destroy(newchrdev.class);
    /* 2、注销字符设备 */
    cdev_del(&newchrdev.dev);
    /* 1、释放设备号 */
    unregister_chrdev_region(newchrdev.devid,NEWCHRDEV_COUNT);
}

module_init(newchrdev_init);
module_exit(newchrdev_exit);

MODULE_LICENSE("GPL");

2、Makefile

KERNELDIR := /home/onlylove/linux/linux/lq_linux/linux-imx-rel_imx_4.1.15_2.1.0_ga
CURRENT_PATH := $(shell pwd)
obj-m := newchrdev.o

build: kernel_modules

kernel_modules:
	$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) modules
clean:
	$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean

2、编译

onlylove@ubuntu:~/linux/driver/linux_driver/3_newchrdev$ ls -l
total 12
-rw-rw-r-- 1 onlylove onlylove   60 Dec 10 06:20 led.code-workspace
-rw-rw-r-- 1 onlylove onlylove  279 Dec 10 06:32 Makefile
-rw-rw-r-- 1 onlylove onlylove 3306 Dec 11 01:32 newchrdev.c
onlylove@ubuntu:~/linux/driver/linux_driver/3_newchrdev$ make
make -C /home/onlylove/linux/linux/lq_linux/linux-imx-rel_imx_4.1.15_2.1.0_ga M=/home/onlylove/linux/driver/linux_driver/3_newchrdev modules
make[1]: Entering directory '/home/onlylove/linux/linux/lq_linux/linux-imx-rel_imx_4.1.15_2.1.0_ga'
  CC [M]  /home/onlylove/linux/driver/linux_driver/3_newchrdev/newchrdev.o
  Building modules, stage 2.
  MODPOST 1 modules
  CC      /home/onlylove/linux/driver/linux_driver/3_newchrdev/newchrdev.mod.o
  LD [M]  /home/onlylove/linux/driver/linux_driver/3_newchrdev/newchrdev.ko
make[1]: Leaving directory '/home/onlylove/linux/linux/lq_linux/linux-imx-rel_imx_4.1.15_2.1.0_ga'
onlylove@ubuntu:~/linux/driver/linux_driver/3_newchrdev$ ls -l
total 36
-rw-rw-r-- 1 onlylove onlylove   60 Dec 10 06:20 led.code-workspace
-rw-rw-r-- 1 onlylove onlylove  279 Dec 10 06:32 Makefile
-rw-rw-r-- 1 onlylove onlylove   73 Dec 11 01:36 modules.order
-rw-rw-r-- 1 onlylove onlylove    0 Dec 11 01:36 Module.symvers
-rw-rw-r-- 1 onlylove onlylove 3306 Dec 11 01:32 newchrdev.c
-rw-rw-r-- 1 onlylove onlylove 5409 Dec 11 01:36 newchrdev.ko
-rw-rw-r-- 1 onlylove onlylove 1266 Dec 11 01:36 newchrdev.mod.c
-rw-rw-r-- 1 onlylove onlylove 2544 Dec 11 01:36 newchrdev.mod.o
-rw-rw-r-- 1 onlylove onlylove 3584 Dec 11 01:36 newchrdev.o
onlylove@ubuntu:~/linux/driver/linux_driver/3_newchrdev$

3、驱动加载

驱动加载前日志查看：

/ # ls
bin           lib           newchrdev.ko  sbin          usr
dev           linuxrc       proc          sys
etc           mnt           root          tmp
/ # lsmod
Module                  Size  Used by    Tainted: G
/ # ls /dev/newchrdev -l
ls: /dev/newchrdev: No such file or directory
/ #

驱动加载后日志查看：

/ # insmod newchrdev.ko
newchrdev major=248,minor=0
/ # lsmod
Module                  Size  Used by    Tainted: G
newchrdev               1335  0
/ # ls /dev/newchrdev -l
crw-rw----    1 0        0         248,   0 Jan  1 00:05 /dev/newchrdev
/ #

驱动卸载后日志查看：

/ # rmmod newchrdev.ko
/ # lsmod
Module                  Size  Used by    Tainted: G
/ # ls /dev/newchrdev -l
ls: /dev/newchrdev: No such file or directory
/ #

整个测试过程日志：

/ # ls
bin           lib           newchrdev.ko  sbin          usr
dev           linuxrc       proc          sys
etc           mnt           root          tmp
/ # lsmod
Module                  Size  Used by    Tainted: G
/ # ls /dev/newchrdev -l
ls: /dev/newchrdev: No such file or directory
/ #
/ #
/ #
/ # insmod newchrdev.ko
newchrdev major=248,minor=0
/ # lsmod
Module                  Size  Used by    Tainted: G
newchrdev               1335  0
/ # ls /dev/newchrdev -l
crw-rw----    1 0        0         248,   0 Jan  1 00:05 /dev/newchrdev
/ #
/ #
/ #
/ # rmmod newchrdev.ko
/ # lsmod
Module                  Size  Used by    Tainted: G
/ # ls /dev/newchrdev -l
ls: /dev/newchrdev: No such file or directory
/ #

十一、LED 驱动

在新字符驱动框架下，编写 LED 驱动，进一步测试新字符驱动框架。

1、映射寄存器

1、定义寄存器物理地址

/* 寄存器物理地址 */
#define CCM_CCGR1_BASE				(0X020C406C)	
#define SW_MUX_GPIO1_IO03_BASE		(0X020E0068)
#define SW_PAD_GPIO1_IO03_BASE		(0X020E02F4)
#define GPIO1_DR_BASE				(0X0209C000)
#define GPIO1_GDIR_BASE				(0X0209C004)

2、定义虚拟地址保存变量

/* 映射后的寄存器虚拟地址指针 */
static void __iomem *IMX6U_CCM_CCGR1;
static void __iomem *SW_MUX_GPIO1_IO03;
static void __iomem *SW_PAD_GPIO1_IO03;
static void __iomem *GPIO1_DR;
static void __iomem *GPIO1_GDIR;

2、完善 file_operations 结构体成员变量

/*
 * @description		: 打开设备
 * @param - inode 	: 传递给驱动的inode
 * @param - filp 	: 设备文件，file结构体有个叫做private_data的成员变量
 * 					  一般在open的时候将private_data指向设备结构体。
 * @return 			: 0 成功;其他 失败
 */
static int led_open(struct inode *inode, struct file *filp)
{
    return 0;
}

/*
 * @description		: 从设备读取数据 
 * @param - filp 	: 要打开的设备文件(文件描述符)
 * @param - buf 	: 返回给用户空间的数据缓冲区
 * @param - cnt 	: 要读取的数据长度
 * @param - offt 	: 相对于文件首地址的偏移
 * @return 			: 读取的字节数，如果为负值，表示读取失败
 */
static ssize_t led_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{
	return 0;
}

/*
 * @description		: 向设备写数据 
 * @param - filp 	: 设备文件，表示打开的文件描述符
 * @param - buf 	: 要写给设备写入的数据
 * @param - cnt 	: 要写入的数据长度
 * @param - offt 	: 相对于文件首地址的偏移
 * @return 			: 写入的字节数，如果为负值，表示写入失败
 */
static ssize_t led_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
{
    return 0;
}

/*
 * @description		: 关闭/释放设备
 * @param - filp 	: 要关闭的设备文件(文件描述符)
 * @return 			: 0 成功;其他 失败
 */
static int led_release(struct inode *inode, struct file *filp)
{
	return 0;
}

static const struct file_operations newchrdevops = {
    .owner   = THIS_MODULE,
    .open = led_open,
	.read = led_read,
	.write = led_write,
	.release = 	led_release,
};

3、设置私有数据

在 open 接口中设置，方便其他接口使用驱动内部数据。

注：目前没有看到私有数据优势。

static int led_open(struct inode *inode, struct file *filp)
{
    filp->private_data = &newchrdev; /* 设置私有数据 */
    return 0;
}

4、初始化 LED

在加载驱动时候进行相关初始化，也可以在 open 接口中初始化。根据个人习惯选择。

1、完成寄存器映射

IMX6U_CCM_CCGR1 = ioremap(CCM_CCGR1_BASE, 4);
SW_MUX_GPIO1_IO03 = ioremap(SW_MUX_GPIO1_IO03_BASE, 4);
SW_PAD_GPIO1_IO03 = ioremap(SW_PAD_GPIO1_IO03_BASE, 4);
GPIO1_DR = ioremap(GPIO1_DR_BASE, 4);
GPIO1_GDIR = ioremap(GPIO1_GDIR_BASE, 4);

2、使能时钟

val = readl(IMX6U_CCM_CCGR1);
val &= ~(3 << 26);	/* 清楚以前的设置 */
val |= (3 << 26);	/* 设置新值 */
writel(val, IMX6U_CCM_CCGR1);

3、设置复用功能

writel(5, SW_MUX_GPIO1_IO03);

4、配置引脚

/*寄存器SW_PAD_GPIO1_IO03设置IO属性
 *bit 16:0 HYS关闭
 *bit [15:14]: 00 默认下拉
 *bit [13]: 0 kepper功能
 *bit [12]: 1 pull/keeper使能
 *bit [11]: 0 关闭开路输出
 *bit [7:6]: 10 速度100Mhz
 *bit [5:3]: 110 R0/6驱动能力
 *bit [0]: 0 低转换率
 */
writel(0x10B0, SW_PAD_GPIO1_IO03);

5、设置GPIO输出功能

val = readl(GPIO1_GDIR);
val &= ~(1 << 3);	/* 清除以前的设置 */
val |= (1 << 3);	/* 设置为输出 */
writel(val, GPIO1_GDIR);

6、设置 LED默认状态

val = readl(GPIO1_DR);
val |= (1 << 3);	
writel(val, GPIO1_DR);

7、取消寄存器映射

当卸载驱动时需要取消寄存器映射，在退出接口中进项相关操作。

/* 取消映射 */
iounmap(IMX6U_CCM_CCGR1);
iounmap(SW_MUX_GPIO1_IO03);
iounmap(SW_PAD_GPIO1_IO03);
iounmap(GPIO1_DR);
iounmap(GPIO1_GDIR);

5、LED 操作

1、定义 LED 点亮和熄灭

#define LEDOFF 					0			/* 关灯 */
#define LEDON 					1			/* 开灯 */

/*
 * @description		: LED打开/关闭
 * @param - sta 	: LEDON(0) 打开LED，LEDOFF(1) 关闭LED
 * @return 			: 无
 */
void led_switch(u8 sta)
{
	u32 val = 0;
	if(sta == LEDON) {
		val = readl(GPIO1_DR);
		val &= ~(1 << 3);	
		writel(val, GPIO1_DR);
	}else if(sta == LEDOFF) {
		val = readl(GPIO1_DR);
		val|= (1 << 3);	
		writel(val, GPIO1_DR);
	}	
}

2、在驱动 write 接口中调用 LED 操作代码，供应用层调用。

static ssize_t led_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
{
    int retvalue;
	unsigned char databuf[1];
	unsigned char ledstat;

	retvalue = copy_from_user(databuf, buf, cnt);
	if(retvalue < 0) {
		printk("kernel write failed!\r\n");
		return -EFAULT;
	}

	ledstat = databuf[0];		/* 获取状态值 */

	if(ledstat == LEDON) {	
		led_switch(LEDON);		/* 打开LED灯 */
	} else if(ledstat == LEDOFF) {
		led_switch(LEDOFF);	/* 关闭LED灯 */
	}

    return 0;
}

以上操作，驱动相关代码完成，编写 app 程序调用驱动进行验证。

十二、LED 应用程序

设计思路：

1、检查传入参数是否正确。

2、打开驱动文件。

3、循环打开和关闭 LED。

4、关闭应用程序需要使用 kill 命令。

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include "stdio.h"

int main(int argc, char *argv[])
{
    int fd = 0, retvalue = 0;
    char writebuf[1];
    unsigned int connect = 0;
    if(argc != 2){
		printf("Error Usage!\r\n");
		return -1;
	}

    fd = open(argv[1],O_RDWR);
    if(fd < 0){
        printf("Can't open file %s\r\n", argv[1]);
        return -1;
    }
    while(1){
        if(connect%2 == 0){
            writebuf[0] = 1;
        }else{
             writebuf[0] = 0;
        }
        retvalue = write(fd, writebuf, sizeof(writebuf));
        connect++;
        if(connect > 1000) connect = 0;
        sleep(1);
    }

    return 0;
}

编译命令如下：

arm-linux-gnueabihf-gcc led.c -o led

十三、驱动源码

#include "linux/init.h"
#include "linux/module.h"
#include "linux/kdev_t.h"
#include "linux/fs.h"
#include "linux/cdev.h"
#include "linux/device.h"
#include "asm/io.h"
#include "asm/uaccess.h"

#define NEWCHRDEV_MAJOR 0   /* 主设备号（如果为0则让系统自动分配，如果大于0则使用指定设备号） */
#define NEWCHRDEV_MINOR 0   /* 次设备号 */
#define NEWCHRDEV_COUNT 1   /* 设备号个数 */
#define NEWCHRDEV_NAME  "newchrdev" /* 名子 */

#define LEDOFF 					0			/* 关灯 */
#define LEDON 					1			/* 开灯 */

/* 寄存器物理地址 */
#define CCM_CCGR1_BASE				(0X020C406C)	
#define SW_MUX_GPIO1_IO03_BASE		(0X020E0068)
#define SW_PAD_GPIO1_IO03_BASE		(0X020E02F4)
#define GPIO1_DR_BASE				(0X0209C000)
#define GPIO1_GDIR_BASE				(0X0209C004)

/* 映射后的寄存器虚拟地址指针 */
static void __iomem *IMX6U_CCM_CCGR1;
static void __iomem *SW_MUX_GPIO1_IO03;
static void __iomem *SW_PAD_GPIO1_IO03;
static void __iomem *GPIO1_DR;
static void __iomem *GPIO1_GDIR;

typedef struct{
    struct cdev dev;        /* cdev 结构体 */
    int major;              /* 主设备号 */
    int minor;              /* 次设备号 */
    dev_t devid;            /* 设备号 */
    struct class *class;    /* 类 */
    struct device *device;  /* 设备 */
}newchrdev_t;

newchrdev_t newchrdev;

/*
 * @description		: LED打开/关闭
 * @param - sta 	: LEDON(0) 打开LED，LEDOFF(1) 关闭LED
 * @return 			: 无
 */
void led_switch(u8 sta)
{
	u32 val = 0;
	if(sta == LEDON) {
		val = readl(GPIO1_DR);
		val &= ~(1 << 3);	
		writel(val, GPIO1_DR);
	}else if(sta == LEDOFF) {
		val = readl(GPIO1_DR);
		val|= (1 << 3);	
		writel(val, GPIO1_DR);
	}	
}

/*
 * @description		: 打开设备
 * @param - inode 	: 传递给驱动的inode
 * @param - filp 	: 设备文件，file结构体有个叫做private_data的成员变量
 * 					  一般在open的时候将private_data指向设备结构体。
 * @return 			: 0 成功;其他 失败
 */
static int led_open(struct inode *inode, struct file *filp)
{
    printk("led_open!\r\n");
    filp->private_data = &newchrdev; /* 设置私有数据 */
    return 0;
}

/*
 * @description		: 从设备读取数据 
 * @param - filp 	: 要打开的设备文件(文件描述符)
 * @param - buf 	: 返回给用户空间的数据缓冲区
 * @param - cnt 	: 要读取的数据长度
 * @param - offt 	: 相对于文件首地址的偏移
 * @return 			: 读取的字节数，如果为负值，表示读取失败
 */
static ssize_t led_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{
    printk("led_read!\r\n");
	return 0;
}

/*
 * @description		: 向设备写数据 
 * @param - filp 	: 设备文件，表示打开的文件描述符
 * @param - buf 	: 要写给设备写入的数据
 * @param - cnt 	: 要写入的数据长度
 * @param - offt 	: 相对于文件首地址的偏移
 * @return 			: 写入的字节数，如果为负值，表示写入失败
 */
static ssize_t led_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
{
    int retvalue;
	unsigned char databuf[1];
	unsigned char ledstat;

    printk("led_write!\r\n");
	retvalue = copy_from_user(databuf, buf, cnt);
	if(retvalue < 0) {
		printk("kernel write failed!\r\n");
		return -EFAULT;
	}

	ledstat = databuf[0];		/* 获取状态值 */

	if(ledstat == LEDON) {	
        printk("ledstat == LEDON!\r\n");
		led_switch(LEDON);		/* 打开LED灯 */
	} else if(ledstat == LEDOFF) {
        printk("ledstat == LEDOFF!\r\n");
		led_switch(LEDOFF);	/* 关闭LED灯 */
	}

    return 0;
}

/*
 * @description		: 关闭/释放设备
 * @param - filp 	: 要关闭的设备文件(文件描述符)
 * @return 			: 0 成功;其他 失败
 */
static int led_release(struct inode *inode, struct file *filp)
{
    printk("led_release!\r\n");
	return 0;
}

static const struct file_operations newchrdevops = {
    .owner   = THIS_MODULE,
    .open = led_open,
	.read = led_read,
	.write = led_write,
	.release = 	led_release,
};

/* 驱动入口函数 */
static int __init newchrdev_init(void)
{
    /* 驱动入口函数具体内容 */
    int ret;
    u32 val = 0;
    
    /* (1)、寄存器地址映射 */
  	IMX6U_CCM_CCGR1 = ioremap(CCM_CCGR1_BASE, 4);
	SW_MUX_GPIO1_IO03 = ioremap(SW_MUX_GPIO1_IO03_BASE, 4);
  	SW_PAD_GPIO1_IO03 = ioremap(SW_PAD_GPIO1_IO03_BASE, 4);
	GPIO1_DR = ioremap(GPIO1_DR_BASE, 4);
	GPIO1_GDIR = ioremap(GPIO1_GDIR_BASE, 4);
    /* (2)、使能时钟 */
    val = readl(IMX6U_CCM_CCGR1);
    val &= ~(3 << 26);	/* 清楚以前的设置 */
    val |= (3 << 26);	/* 设置新值 */
    writel(val, IMX6U_CCM_CCGR1);
    /* (3)、设置复用功能 */
    writel(5, SW_MUX_GPIO1_IO03);
    /* (4)、配置引脚 */
    /*寄存器SW_PAD_GPIO1_IO03设置IO属性
	 *bit 16:0 HYS关闭
	 *bit [15:14]: 00 默认下拉
     *bit [13]: 0 kepper功能
     *bit [12]: 1 pull/keeper使能
     *bit [11]: 0 关闭开路输出
     *bit [7:6]: 10 速度100Mhz
     *bit [5:3]: 110 R0/6驱动能力
     *bit [0]: 0 低转换率
	 */
	writel(0x10B0, SW_PAD_GPIO1_IO03);
    /* (5)、设置GPIO1_IO03为输出功能 */
    val = readl(GPIO1_GDIR);
	val &= ~(1 << 3);	/* 清除以前的设置 */
	val |= (1 << 3);	/* 设置为输出 */
	writel(val, GPIO1_GDIR);
    /* (6)、设置LED默认状态 */
    val = readl(GPIO1_DR);
	val |= (1 << 3);	
	writel(val, GPIO1_DR);

    /* 1、字符设备号分配 */
    newchrdev.major = NEWCHRDEV_MAJOR;
    if(newchrdev.major){
        newchrdev.minor = NEWCHRDEV_MINOR;
        newchrdev.devid = MKDEV(newchrdev.major, newchrdev.minor);
        ret = register_chrdev_region(newchrdev.devid,NEWCHRDEV_COUNT,NEWCHRDEV_NAME);
        printk("newchrdev.major > 0!\r\n");
    }else{
        ret = alloc_chrdev_region(&newchrdev.devid,0,NEWCHRDEV_COUNT,NEWCHRDEV_NAME);
        newchrdev.major = MAJOR(newchrdev.devid);
        newchrdev.minor = MINOR(newchrdev.devid);
        printk("newchrdev.major = 0!\r\n");
    }
    if(ret < 0){
        printk("newchrdev xxx_chrdev_region failed!\r\n");
        goto newchrdev_chrdev_region_failed;
    }
    printk("newchrdev devid = %d newchrdev major=%d,minor=%d\r\n",newchrdev.devid,newchrdev.major,newchrdev.minor);

    /* 2、注册字符设备 */
    newchrdev.dev.owner = THIS_MODULE;
    cdev_init(&newchrdev.dev,&newchrdevops);
    ret = cdev_add(&newchrdev.dev,newchrdev.devid,NEWCHRDEV_COUNT);
    if(ret < 0){
        printk("newchrdev cdev_add failed!\r\n");
        goto newchrdev_cdev_add_failed;
    }

    /* 3、创建类 */
    newchrdev.class = class_create(THIS_MODULE,NEWCHRDEV_NAME);
    if(IS_ERR(newchrdev.class)) {
        printk("newchrdev class_create failed!\r\n");
        goto newchrdev_class_create_failed;
    }

    /* 4、创建设备 */
    newchrdev.device = device_create(newchrdev.class,NULL,newchrdev.devid,NULL,NEWCHRDEV_NAME);
    if(IS_ERR(newchrdev.device)){
        printk("newchrdev device_create failed!\r\n");
        goto neschrdev_device_creat_failed;
    }

    printk("newchrdev_init succed!\r\n");
    return 0;

neschrdev_device_creat_failed:
    class_destroy(newchrdev.class);
newchrdev_class_create_failed:
    cdev_del(&newchrdev.dev);
newchrdev_cdev_add_failed:
    unregister_chrdev_region(newchrdev.devid,NEWCHRDEV_COUNT);

newchrdev_chrdev_region_failed:   /* 字符设备号分配失败处理函数（未分配资源，因此不做处理） */
    printk("failed!\r\n");
    return ret;
}

/* 驱动卸载函数 */
static void __exit newchrdev_exit(void)
{
    /* 驱动卸载函数具体内容 */
    /* 取消映射 */
	iounmap(IMX6U_CCM_CCGR1);
	iounmap(SW_MUX_GPIO1_IO03);
	iounmap(SW_PAD_GPIO1_IO03);
	iounmap(GPIO1_DR);
	iounmap(GPIO1_GDIR);

    /* 4、删除设备 */
    device_destroy(newchrdev.class,newchrdev.devid);
    /* 3、删除类 */
    class_destroy(newchrdev.class);
    /* 2、注销字符设备 */
    cdev_del(&newchrdev.dev);
    /* 1、释放设备号 */
    unregister_chrdev_region(newchrdev.devid,NEWCHRDEV_COUNT);
    printk("newchrdev_exit succed!\r\n");
}

module_init(newchrdev_init);
module_exit(newchrdev_exit);

MODULE_LICENSE("GPL");

根据需要进行调整修改，以上源码经过测试可以在正点原子 i.MX6ULL 开发板正常运行。

lqonlylove
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
i.MX6 EPIT定时器驱动
a3121772305的博客
12-22 778
注：这个驱动参考了https://blog.csdn.net/wince_lover/article/details/54577898#comments这位大神的博客。 该大神给出了思路，驱动框架。大家可以直接去看他这个，即可以学习一下，也节约钱。 如果你想走捷径，就看我这个吧。 本来这个专栏都快没有动力继续往下写了的。之前弄这个专栏的目的也只是为了给自己做个笔记，方便后面查看，结果今天竟然收到了一个订阅，然后瞬间又有动力了。 这一章介绍一下i.MX6 EPIT硬件定时器。下一章我们介绍一下i...
Linux字符设备驱动框架
01-29
字符设备是Linux三大设备之一(另外两种是块设备，网络设备)，字符设备就是字节流形式通讯的I/O设备,绝大部分设备都是字符设备，常见的字符设备包括鼠标、键盘、显示器、串口等等，当我们执行ls -l/dev的时候，就能...
一个简单的字符设备驱动程序和测试程序
howhot2008的博客
11-09 4631
------------------------字符设备驱动程序------------------------------ #include  #include  #include  #include  #include  #include  #include  #include  #include      MODULE_DESCRIPTION("a test
Linux字符设备驱动程序的编写和测试
xiaomu_Y的博客
02-18 2072
Linux字符设备驱动编写和测试 文章目录Linux字符设备驱动编写和测试一、字符设备结构体 一、字符设备结构体          字符设备驱动、块设备驱动和网络设备驱动作为linux内核三大驱动设备，字符设备主要完成字节的读写操作，常见的应用有鼠标、键盘等，结构体形式如下所示： struct cdev{ struct kobject kobj; //设备管理机制 struct module *owner;//所说模块
Linux之ARM （I.MX6ULL） EPIT定时器详解
一只青木呀
09-20 772
EPIT定时器详解1、EPIT定时器简介1.1、总结 定时器是最常用的外设，常常需要使用定时器来完成精准的定时功能， I.MX6U 提供了多种硬件定时器，有些定时器功能非常强大。我们从最基本的 EPIT 定时器开始，学习如何配置 EPIT 定时器，使其按照给定的时间，周期性的产生定时器中断，在定时器中断里面我们可以做其它的处理，比如翻转 LED 灯。 1、EPIT定时器简介 EPIT 的全称是： Enhanced Periodic Interrupt Timer，直译过来就是增强的周期中断定时器，它主要是完
字符设备驱动（实验一）——保姆级教程
m0_56145255的博客
05-12 1004
文章目录前言环境搭建CLion 远程服务配置创建项目修改CMakeLists.txt文件应用程序与驱动的关系cdev与设备结构体的关系项目源码驱动代码应用程序Makefile开发板测试Ubuntu测试TipsGit下载 前言 这里采用的模拟方法是在内核空间开辟一段内存空间来模拟一个字符设备，其功能就是可以对这块内存空间实现读写的功能，和mmap的功能和原理相似，只是实现方法不同。 环境搭建 这里使用的工具是CLion进行编写代码，在虚拟机上进行编译身成.ko文件。因为只是一个模拟嘛，入门。不需要配置设备树
Linux 字符设备驱动框架详细介绍
09-15
主要介绍了Linux 字符设备驱动框架详细介绍的相关资料,字符设备就是字节流形式通讯的I/O设备,绝大部分设备都是字符设备，这里提供简单的实例，需要的朋友可以参考下
Linux字符设备驱动框架笔记
01-09
字符设备是Linux三大设备之一(另外两种是块设备，网络设备)，字符设备是字节流形式通讯的I/O设备，绝大部分设备都是字符设备，常见的字符设备包括鼠标、键盘、显示器、串口等等，当我们执行 ls -l /dev 的时候，能...
Linux下的PCI设备开发以及字符驱动程序框架的研究.pdf
09-06
Linux下的PCI设备开发以及字符驱动程序框架的研究.pdf
linux 添加字符设备驱动程序及测试程序
02-24
linux下采用模块方法，添加一个新的设备驱动程序。 要求添加字符设备的驱动。 另附一个应用程序，测试添加的驱动程序
linux设备树详解
09-20
现在的linux内核(Linux3.X)都已支持设备树机制(dts)，不管你是玩内核还是玩驱动，一定会碰到设备树，而网上虽然有很多博客，但都讲的不够清晰，看了还是不懂，半桶水，学员急需一套讲解设备树比较透彻的课程，所以我们来了，致力于帮助广大学员扫清设备树在驱动以及内核学习中的障碍。
Linux 26 字符设备驱动一
分享各种网络协议知识
06-17 235
功能 实现简单的字符操作（从用户空间向内核空间写入一串字符；从内核空间读一个字符到内核空间） 众所周知，字符设备是linux下最基本，也是最常用到的设备，它是学习Linux驱动入门最好的选择，计算机的东西很多都是相通的，掌握了其中一块，其他就可以触类旁通了。在写驱动前，必须先搞清楚字符设备的框架大概是怎样的，弄清楚了流程，才开始动手，不要一开始就动手写代码！ 这里内核是基于Linux 2.6，3....
arm_linux驱动开发之字符设备驱动开发
L1153413073的博客
09-01 226
1、先要了解设备函数据结构 2、然后将驱动注册到内核中 #define CHRDEVBASE_MAJOR 200 /* 主设备号 */ #define CHRDEVBASE_NAME "chrdevbase" /* 设备名 */ static char readbuf[100]; /* 读缓冲区 */ static char writebuf[100]; /* 写缓冲区 */ static char kern...
Linux设备驱动 | LED字符设备驱动实验
欲盖弥彰1314
03-25 671
Linux字符设备驱动 Linux实现了一套字符设备驱动框架，编写字符设备驱动就按照框架进行编写。 字符设备驱动结构框图： 图片来自 – 《Linux设备驱动开发详解》 最很重要的就是实现struct file_operations该结构中的函数。 struct file_operations 结构体定义了字符设备驱动提供给虚拟文件系统的接口函数 struct file_operations结构体定义： struct file_operations { struct module *owner; lo
linux 字符设备驱动测试,一个简单字符型设备驱动及其测试
weixin_39788382的博客
05-05 187
驱动对一些人来说很难，而对一些人来说很容易。窃以为，理解简单设备驱动模型不难，深入理解并与Linux内核设计联系到一起需要花费时间。对于移植者来说，如何将自己自定义的模块天衣无缝放到内核中，是比较重要的——不过，有许多现在的“模板”可供参考，总算不用白手起家。本文所述的仅是一个独立的、简单的字符型设备驱动。最简单的字符设备当属经典的“Hello World”。而这个比它复杂一点：在用户空间写一字符...
Linux 编写简单驱动并测试
assiduous_me的博客
11-07 1475
字符驱动编写 1. 编写一个字符驱动 在 driver/char/ 目录下新建一个 hello_dev.c 文件，用来编写一个字符驱动 代码如下： #include <linux/module.h> #include <linux/moduleparam.h> #include <linux/cdev.h> #include <linux/fs.h> #include <linux/wait.h> #include <linux/poll.h
Linux 新字符设备驱动开发模板
安迪西_嵌入式攻城狮
10-26 455
新字符设备驱动开发
用测试驱动开发的思路重构ADC LINUX驱动(一)
kao2406的博客
04-16 705
用测试驱动开发的思路重构ADC LINUX驱动(一) 前言 测试驱动开发(TDD)是上个世纪末开始流行的一种敏捷开发模式。在大型的互联网应用或者知名IT公司中有不少拥趸，而本人在开发嵌入式代码的时候，从来没有实践或者使用TDD。从本人躺过的无数个坑里面，深感如果单元测试覆盖率高，或者用TDD的方式开发，或许会少很多低级的、逻辑上的、甚至是很多高级的错误。 国外有一本关于嵌入式TDD的教材...
linux设备驱动开发详解:基于最新的linux4.0内核
最新发布
06-24
新的特性如内核自带的驱动框架、自动化的内存管理、图形化的用户空间接口等，都大大简化了设备驱动的开发难度。 此外，Linux 4.0内核还增强了对硬件设备的支持，包括新的USB 3.1规范、Type-C接口、Intel Skylake等...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值