一. 设计驱动程序的步骤：
1、定义一个字符设备结构体struct cdev，用来描述某个字符设备
struct cdev {
struct kobject kobj; //内核管理字符设备时使用该程序，驱动程序设计不需要初始化它
struct module *owner; //当前字符设备属于哪个内核模块，一般设置THIS_MODULE
const struct file_operations *ops; //文件操作集合
struct list_head list; //用于管理cdev的内核链表的节点
dev_t dev; //用来存放设备号
unsigned int count; //此设备（号）的个数
};
2、初始化字符设备结构体，其中有一个非常重要的成员，文件操作集合成员
struct file_operations-------需要事先定义文件操作集合结构体
void cdev_init(struct cdev *cdev, const struct file_operations *fops) //初始化字符设备结构体
参数：
- cdev:字符设备
- fops:文件操作集合
struct file_operations {
struct module *owner;
loff_t (*llseek) (struct file *, loff_t, int);
ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
ssize_t (*aio_read) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
int (*readdir) (struct file *, void *, filldir_t);
unsigned int (*poll) (struct file *, struct poll_table_struct *);
long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
int (*mmap) (struct file *, struct vm_area_struct *);
int (*open) (struct inode *, struct file *);
int (*flush) (struct file *, fl_owner_t id);
int (*release) (struct inode *, struct file *);
int (*fsync) (struct file *, loff_t, loff_t, int datasync);
int (*aio_fsync) (struct kiocb *, int datasync);
int (*fasync) (int, struct file *, int);
int (*lock) (struct file *, int, struct file_lock *);
ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
int (*check_flags)(int);
int (*flock) (struct file *, int, struct file_lock *);
ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
int (*setlease)(struct file *, long, struct file_lock **);
long (*fallocate)(struct file *file, int mode, loff_t offset,
loff_t len);
};
3、申请设备号（主设备号，次设备号）
（1）设备号介绍
- 设备号是一个32bit的无符号整数。
- 高12bit是主设备号——表示某一类设备，主设备号相同，使用同一个驱动程序
- 低20bit是次设备号——表示这一类设备中的具体某个设备。
- 完整的设备号=（major<<20|（minor<<0）。
如下图，都使用mmc的驱动程序，不同的设备次设备号不一样，以此来区分不同的设备。
- 内核中提供大的设备号相关的宏
#define MINORBITS 20
#define MINORMASK ((1U << MINORBITS) - 1)
#define MAJOR(dev) ((unsigned int) ((dev) >> MINORBITS)) //从完整设备号中获取主设备号
#define MINOR(dev) ((unsigned int) ((dev) & MINORMASK)) //从完整设备号中获取次设备号
#define MKDEV(ma,mi) (((ma) << MINORBITS) | (mi)) //用主次设备号合成完整设备号
（2）设备号的动态申请
int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count,
const char *name)
参数：
- dev:指向的内存用来存申请到的设备号的第一个。
- baseminor:次设备号从几开始。
- count:申请几个。
- name:设备名。注意：设备名和设备文件名不是一样的。用同一个驱动的设备设备名一样，但是设备文件名不一样，应用层是通过设备文件名去访问驱动程序的。
返回值：
- 申请成功返回0，失败返回负的错误码。
（3）设备号的静态申请
int register_chrdev_region(dev_t from, unsigned count, const char *name)
参数：
- from:指定设备号的第一个。
- 申请几个
- 自定义的设备名
返回值：
- 申请成功返回0；失败返回负的错误码。
（4）释放设备号
void unregister_chrdev_region(dev_t from, unsigned count)
- from:从哪个设备号开始释放。
- count:释放几个。
4、字符设备的注册和注销
（1）注册
int cdev_add(struct cdev *p, dev_t dev, unsigned count)
参数：
- p:指向待注册的字符设备结构体
- dev:设备号
- count:注册几个。
返回值：
- 注册成功返回0，失败则返回错误码。
（2）注销
void cdev_del(struct cdev *p)
5、创建跟字符设备对应的设备文件-----应用程序操作设备文件
（1）手动创建----mknod命令
- 如果驱动程序中没有自动创建设备文件，先将驱动文件first_cdev_drv.ko进行安装
insmod firt_cdev_drv.ko
- 查看驱动安装是否成功
cat /proc/devices
- 查看驱动程序中申请的主设备号和次设备号，然后手动创建设备文件
mknod /dev/first_cdev_node c 244 0
- 创建成功后，在/dev/目录下会看到一个first_cdev_node的设备文件。
注意：
手动创建的设备文件，在驱动模块卸载时，不会自动删除，如果需要删除，使用rm命令删除即可。
rm /dev/first_dev_node
（2）自动创建
基本原理：驱动程序提供信息（设备文件名、设备号），根文件系统中的应用程序mdev根据驱动提供的信息，在/dev目录下自动创建出设备文件
- 创建class(创建目录)
struct class * class_create (struct module *owner, const char *name)
参数：
owner : 一般设置为THIS_MODULE.
name : 自定义的class名字
- 销毁class
void class_destroy(struct class *cls)
- 在class下创建device
struct device *device_create(struct class *class, struct device *parent, dev_t devt, void *drvdata, const char *fmt, ...)
参数：
class :在哪个class创建device。
parent:待创建设备的父设备是哪个。
devt: 设备号。
drvdata: 设备驱动的私有数据，一般设置为NULL.
fmt：自定义的device的名字（设备文件名）。
返回值：
成功返回strct device*.
失败返回ERR_PTR()
- 销毁设备
void device_destroy(struct class *class, dev_t devt)
6、申请IO内存（为了资源的互斥访问）和释放IO内存
（1）申请IO内存
request_mem_region(start,n,name）
#define request_mem_region(start,n,name) __request_region(&iomem_resource, (start), (n), (name), 0)
struct resource * __request_region(struct resource *parent, resource_size_t start, resource_size_t n, const char *name, int flags）
参数：
- Start：要申请使用的IO内存（物理内存）的起始地址
- n ：要申请的IO内存的大小（字节为单位）
- name：自定义的IO内存的名字
返回值：
- 成功返回struct resource *。
- 失败返回NULL。
（2）释放IO内存
#define release_mem_region(start,n) __release_region(&iomem_resource, (start), (n))
void __release_region(struct resource *parent, resource_size_t start,resource_size_t n)
7、把IO内存映射成虚拟内存，得到虚拟地址
（1）映射虚拟内存
void __iomem *ioremap(unsigned long phys_addr, size_t size)
参数：
- phys_addr：待映射为虚拟内存的物理内存的起始地址。
- size: 大小，字节为单位。
返回值：
成功返回与物理内存对应的虚拟内存的起始地址。
（2）取消映射
void iounmap(volatile void __iomem *io_addr)
8、驱动程序与应用程序之间的数据交互
（1）写操作
应用层：
write(fd, buf, size);
驱动层：
static ssize_t xxx_write (struct file *filp, const char __user *user, size_t size, loff_t *oft)
{
copy_from_user
}
驱动层主要将用户空间的数据拷贝到驱动层的函数：
static inline unsigned long __must_check copy_from_user(void *to, const void __user *from, unsigned long n)
函数类型：
- __must_check ：必须检查该函数的返回值，否则编译时报警告。
- __user : from指针指向的是用户空间某处。
参数：
- to:指向内核空间的某片内存，这片内存用于存储从用户空间拷贝过来的数据
- from: from指针指向的是用户空间某处，从用户空间的此处拷贝数据
- n: 拷贝数据的大小，单位是字节
返回值：
- 返回的是剩余的未拷贝的字节数。
（2）读操作
应用层：
read(fd, buf ,10)
驱动层：
ssize_t xxx_read (struct file *, char __user *, size_t, loff_t *)
{
copy_to_user
}
static inline unsigned long __must_check copy_to_user(void __user *to, const void *from, unsigned long n)
二、驱动程序编写
功能：《6818开发板流水灯实现》
1、驱动程序解析
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/cdev.h>
#include <linux/fs.h>
#include <linux/types.h>
#include <linux/device.h>
#include <linux/ioport.h>
#include <linux/io.h>
#include <linux/uaccess.h>
static struct cdev led_cdev;//定义字符设备
static dev_t dev;
struct class * led_class=NULL;
struct device * led_device = NULL;
struct resource *led_res = NULL;
static void __iomem * GPIOCBASE = NULL;
static void __iomem * GPIOCOUT = NULL;
static void __iomem * GPIOCOUTENB = NULL;
static void __iomem * GPIOCALTFN0 = NULL;
static void __iomem * GPIOCALTFN1 = NULL;
ssize_t led_write (struct file * filp, const char __user *buf, size_t size, loff_t *oft)
{
char kbuf[2]={0};
int ret;
if(size !=2 )
{
printk(KERN_ALERT"size error\n");
return -EINVAL;
}
//获取用于空间的数据
ret = copy_from_user(kbuf, buf, size);
if(ret !=0 )
{
printk(KERN_ALERT"copy_from_user error\n");
return (size-ret);
}
//printk(KERN_ALERT"ret = %d,kbuf[0]=%d,kbuf[1]=%d\n",ret,kbuf[0],kbuf[1]);
//根据用户空间的数据，操作不同的LED
switch(kbuf[0])//哪一个LED
{
case 8 :
if(kbuf[1]==1)
*(unsigned int *)GPIOCOUT &= ~(1<<17);//D8---GPIOC17
else if(kbuf[1]==0)
*(unsigned int *)GPIOCOUT |= (1<<17);
else
return -EINVAL; //代表无效的参数，可以在内核源码中找到EINVAL是一个宏，代表一个错误码
break;
case 9 :
if(kbuf[1]==1)
*(unsigned int *)GPIOCOUT &= ~(1<<8);//D9---GPIOC8
else if(kbuf[1]==0)
*(unsigned int *)GPIOCOUT |= (1<<8);
else
return -EINVAL;
break;
case 10 :
if(kbuf[1]==1)
*(unsigned int *)GPIOCOUT &= ~(1<<7);//D10---GPIOC7
else if(kbuf[1]==0)
*(unsigned int *)GPIOCOUT |= (1<<7);
else
return -EINVAL;
break;
default:
return -EINVAL;
}
return size;
}
//定义文件操作集合结构体
static struct file_operations fops =
{
//.open = led_open,//操作集合中没有提供.open和.release
//.release = led_close,//使用系统默认的，其它操作函数没有默认
.write = led_write,
};
//入口函数
static int __init led_init (void)
{
int ret;
printk("<1>""led_init\n");
//申请设备号
ret = alloc_chrdev_region(&dev, 0, 1, "led_chrdev");
if(ret != 0)
{
printk(KERN_ALERT"alloc_chrdev_region fail\n");
goto alloc_chrdev_region_err;
}
//初始化
led_cdev.owner = THIS_MODULE;
cdev_init(&led_cdev,&fops);
//注册字符设备
ret = cdev_add(&led_cdev, dev, 1);
if(ret != 0)
{
printk(KERN_ALERT"cdev_add fail\n");
goto cdev_add_err;
}
//创建class(创建目录)
led_class = class_create(THIS_MODULE, "led_class");
if (IS_ERR(led_class))
{
printk(KERN_ALERT"class_create fail\n");
ret = -EBUSY;
goto class_create_err;
}
//在class下创建device
led_device = device_create(led_class, NULL, dev, NULL, "led_node");
if (IS_ERR(led_device))
{
printk(KERN_ALERT"class_create fail\n");
ret = -ENOMEM;
goto device_create_err;
}
//申请物理内存(IO内存)
led_res = request_mem_region(0xc001c000, 0x44,"led_iomem");
if(led_res == NULL)
{
printk(KERN_ALERT"request_mem_region fail\n");
ret = -EBUSY;
goto request_mem_region_err;
}
//io内存的动态映射
GPIOCBASE = ioremap(0xc001c000,0x44);
if(GPIOCBASE == NULL)
{
printk(KERN_ALERT"ioremap fail\n");
ret = -EBUSY;
goto ioremap_err;
}
GPIOCOUT = GPIOCBASE;
GPIOCOUTENB = GPIOCBASE + 0x4;
GPIOCALTFN0 = GPIOCBASE + 0x20;
GPIOCALTFN1 = GPIOCBASE + 0x24;
//printk(KERN_ALERT"GPIOCBASE = %p\n",GPIOCBASE);
//通过映射得到的虚拟地址操作寄存器
//选择与LED相连引脚为复用功能1---GPIOC7/8/17
//*(unsigned int *)GPIOCALTFN0 &= ~(0xf<<14);
writel( (readl(GPIOCALTFN0) & (~(0xf<<14))),GPIOCALTFN0 );
*(unsigned int *)GPIOCALTFN0 |= (1<<14) |(1<<16);
*(unsigned int *)GPIOCALTFN1 &= ~(0x3<<2);
*(unsigned int *)GPIOCALTFN1 |= (1<<2) ;
//设置GPIOC7/8/17为output
*(unsigned int *)GPIOCOUTENB |= (1<<7) |(1<<8)|(1<<17);
//默认都灭
*(unsigned int *)GPIOCOUT |= (1<<7) |(1<<8)|(1<<17);
return 0;
//各个资源创建申请失败要跳转进行销毁，注意：如果goto跳转到ioremap_err，则会继续执行request_mem_region_err、device_create_err、class_create_err...一直到return。不是只执行一个标签下的语句（这是跳转语句特点）
ioremap_err:
//释放IO内存
release_mem_region(0xc001c000,0x44);
request_mem_region_err:
//销毁device
device_destroy(led_class, dev);
device_create_err:
//销毁前面创建成功的class
class_destroy(led_class);
class_create_err:
//注销前面注册成的字符设备
cdev_del(&led_cdev);
cdev_add_err:
//释放前面申请成功的设备号
unregister_chrdev_region(dev, 1);
alloc_chrdev_region_err:
return ret;
}
//出口函数 :卸载驱动模块的时候会执行exit函数，此函数是按照init的反向顺序去销毁和释放资源的。
static void __exit led_exit(void)
{
printk(KERN_ALERT"led_exit\n");
//取消映射
iounmap(GPIOCBASE);
//释放IO内存
release_mem_region(0xc001c000,0x44);
//销毁device
device_destroy(led_class, dev);
//销毁class
class_destroy(led_class);
//注销字符设备
cdev_del(&led_cdev);
//释放设备号
unregister_chrdev_region(dev, 1);
}
module_init(led_init);
module_exit(led_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("XLG");
MODULE_DESCRIPTION("first chardev drv");
3、应用层程序
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <errno.h>
#include <stdio.h>
int main(void)
{
char buf[2] = {0};//buf[0]存入LED编号，buf[1]存入LED的亮灭状态
int ret;
int fd = open("/dev/led_node",O_RDWR);
if(fd < 0)
{
perror("open failed");
return -1;
}
while(1)
{
buf[0] = 10;buf[1]=0;
ret = write(fd,buf,2);
if(ret < 0)
{
perror("write failed");
}
buf[0] = 8;buf[1]=1;
write(fd,buf,2);
sleep(1);
buf[0] = 8;buf[1]=0;
write(fd,buf,2);
buf[0] = 9;buf[1]=1;
write(fd,buf,2);
sleep(1);
buf[0] = 9;buf[1]=0;
write(fd,buf,2);
buf[0] = 10;buf[1]=1;
write(fd,buf,2);
sleep(1);
}
close(fd);
return 0;
}
2、Makefile
obj-m += led_drv.o CROSS_DIR=/home/gec/6818GEC/prebuilts/gcc/linux-x86/arm/arm-eabi-4.8/bin/arm-eabi- KERN_DIR=/home/gec/6818GEC/kernel all: make ARCH=arm CROSS_COMPILE=$(CROSS_DIR) -C $(KERN_DIR) M=`pwd` modules
#编译应用层程序 cp *.ko /opt/nfs arm-linux-gcc test.c -o test cp test /opt/nfs clean: make ARCH=arm CROSS_COMPILE=$(CROSS_DIR) -C $(KERN_DIR) M=`pwd` modules clean rm test -f