Linux LED驱动（非设备树）

1. 虚拟字符设备驱动开发基础

实现开关读写4个系统调用函数
使用copy_to_user()函数实现用户空间和内存空间数据交互，从而实现文件读函数；使用copy_from_user()实现用户空间和内存空间数据交互，从而实现文件写函数。
初始化设备操作函数结构体
实现设备注册和注销函数
使用register_chrdev()函数和module_init()函数注册设备，实现insmod；使用unregister_chrdev()和module_exit()函数注销设备，实现rmmod。
添加LICENSE和作者
使用MODULE_LICENSE()函数和MODULE_AUTHOR()函数添加LICENSE和作者。

Linux设备

Linux驱动加载成功以后会在devices目录（\dev）下生成一个文件，应用程序通过对这个文件进行相应的操作即可实现对硬件的操作。

用户空间和内核空间

对 32 位操作系统而言，它的寻址空间（虚拟地址空间）为 4G（2的32次方）。
操作系统将虚拟地址空间划分为两部分，一部分为内核空间，另一部分为用户空间。
针对 Linux 操作系统而言，最高的 1G 字节(从虚拟地址 0xC0000000 到 0xFFFFFFFF)由内核使用，称为内核空间；而较低的 3G 字节(从虚拟地址 0x00000000 到 0xBFFFFFFF)由各个进程使用，称为用户空间。

Linux字符设备驱动

在Linux内核文件include/linux/fs.h中有个叫做file_operations的结构体，此结构体就是Linux内核驱动操作函数集合。在字符设备驱动开发中最主要的工作就是实现结构体里的这些函数。
Linux驱动的两种运行方式：

将驱动编译进Linux内核中。
将驱动编译成模块(Linux下模块扩展名为.ko)，在Linux内核启动以后使用“insmod”命令加载驱动模块。

常用函数：

// 开/关
open();
release();
// 读/写
write();
read();
// 注册/注销 insmod/rmmod
register_chrdev();
unregister_chrdev();
// license & author
MODULE_LICENSE();
MODULE_AUTHOR();

module_init函数用来向Linux内核注册一个模块加载函数，当使用insmod命令时，xxx_init函数就会被调用。
module_exit()函数用来向Linux内核注册一个模块卸载函数，当使用rmmod命令时，xxx_exit函数就会被调用。
atoi()函数(ASCII to integer的缩写)用于将一个字符串转换为对应的整数。

设备号

设备号由主设备号和次设备号两部分组成，主设备号表示某一个具体的驱动，次设备号表示使用这个驱动的各个设备，高12位为主设备号，主设备号范围为0~4095，低20位为次设备号。

动态设备号申请
alloc_chardev_region();
动态设备号注销
unregister_chrdev_region();

虚拟字符设备驱动：

#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>#define CHRDEVBASE_MAJOR	200					// 主设备号
#define CHRDEVBASE_NAME		"chrdevbase"		// 设备名static char readbuf[100];		// 读缓冲区
static char writebuf[100];		// 写缓冲区
static char kerneldata[] = {"kernel data!"};// 1. **实现开关读写4个系统调用函数**
static int chrdevbase_open(struct inode *inode, struct file *filp)
{//printk("chrdevbase open!\r\n");return 0;
}static int chrdevbase_release(struct inode *inode, struct file *filp)
{//printk("chrdevbase release！\r\n");return 0;
}static ssize_t chrdevbase_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{int retvalue = 0;/* 向用户空间发送数据 */memcpy(readbuf, kerneldata, sizeof(kerneldata));retvalue = copy_to_user(buf, readbuf, cnt);if(retvalue == 0){printk("kernel senddata ok!\r\n");}else{printk("kernel senddata failed!\r\n");}//printk("chrdevbase read!\r\n");return 0;
}static ssize_t chrdevbase_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
{int retvalue = 0;/* 接收用户空间传递给内核的数据并且打印出来 */retvalue = copy_from_user(writebuf, buf, cnt);if(retvalue == 0){printk("kernel recevdata:%s\r\n", writebuf);}else{printk("kernel recevdata failed!\r\n");}//printk("chrdevbase write!\r\n");return 0;
}// 2. **初始化设备操作函数结构体**
static struct file_operations chrdevbase_fops = {.owner		= THIS_MODULE,.open		= chrdevbase_open,.read		= chrdevbase_read,.write		= chrdevbase_write,.release	= chrdevbase_release,
};// 3. **实现设备注册和注销函数**
static int __init chrdevbase_init(void)
{int retvalue = 0;retvalue = register_chrdev(CHRDEVBASE_MAJOR, CHRDEVBASE_NAME, &chrdevbase_fops);if(retvalue < 0){printk("chrdevbase driver register failed\r\n");}printk("chrdevbase_init()\r\n");return 0;
}static void __exit chrdevbase_exit(void)
{unregister_chrdev(CHRDEVBASE_MAJOR, CHRDEVBASE_NAME);printk("chrdevbase_exit()\r\n");
}module_init(chrdevbase_init);
module_exit(chrdevbase_exit);// 4. **添加LICENSE和作者**
MODULE_LICENSE("GPL");
MODULE_AUTHOR("alientek");

应用程序：

打开文件
从文件读取数据
将数据写入文件
关闭文件

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>static char usrdata[] = {"usr data!"};/** @description		: main主程序* @param - argc	: argv数组元素个数* @param - argv	: 具体参数* @return			: 0 成功;其他 失败*/
int main(int argc, char *argv[])
{int fd, retvalue;char *filename;char readbuf[100], writebuf[100];if(argc != 3){printf("Error Usage!\r\n");return -1;}filename = argv[1];/* 打开驱动文件 */fd  = open(filename, O_RDWR);if(fd < 0){printf("Can't open file %s\r\n", filename);return -1;}if(atoi(argv[2]) == 1){ /* 从驱动文件读取数据 */retvalue = read(fd, readbuf, 50);if(retvalue < 0){printf("read file %s failed!\r\n", filename);}else{/*  读取成功，打印出读取成功的数据 */printf("read data:%s\r\n",readbuf);}}if(atoi(argv[2]) == 2){/* 向设备驱动写数据 */memcpy(writebuf, usrdata, sizeof(usrdata));retvalue = write(fd, writebuf, 50);if(retvalue < 0){printf("write file %s failed!\r\n", filename);}}/* 关闭设备 */retvalue = close(fd);if(retvalue < 0){printf("Can't close file %s\r\n", filename);return -1;}return 0;
}

2. 字符设备驱动下的LED驱动

实现开关读写4个系统调用函数
使用copy_from_user()实现用户空间和内存空间数据交互，并使用readl()函数读取寄存器映射后的虚拟地址的数据，使用writel()函数根据寄存器映射后的虚拟地址将数据写入寄存器，从而实现文件写函数（LED的亮灭）。
初始化设备操作函数结构体
实现设备注册和注销函数
使用ioremap()函数获取物理地址空间对应的虚拟地址空间，然后使能GPIO、关闭中断、设置方向，并使用register_chrdev()函数和module_init()函数注册设备；使用iounmap()函数取消内存映射，并使用unregister_chrdev()和module_exit()函数注销设备。
添加LICENSE和作者
使用MODULE_LICENSE()函数和MODULE_AUTHOR()函数添加LICENSE和作者。

ioremap()

用于获取指定物理地址空间对应的虚拟地址空间。

将物理地址0x10001000对应的32位寄存器映射到虚拟地址addr上：
c addr = ioremap(0x10001000, 4);

iounmap()

用于释放掉映射的虚拟地址空间。
释放掉ioremap函数所做的映射:
iounmap(addr);

readb()/readw()/readl()
writeb()/writew()/writel()

#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>#define LED_MAJOR		200			/* 主设备号 */
#define LED_NAME		"led"		/* 设备名字 *//* * GPIO相关寄存器地址定义*/
#define ZYNQ_GPIO_REG_BASE			0xE000A000
#define DATA_OFFSET					0x00000040
#define DIRM_OFFSET					0x00000204
#define OUTEN_OFFSET				0x00000208
#define INTDIS_OFFSET				0x00000214
#define APER_CLK_CTRL				0xF800012C/* 映射后的寄存器虚拟地址指针 */
static void __iomem *data_addr;
static void __iomem *dirm_addr;
static void __iomem *outen_addr;
static void __iomem *intdis_addr;
static void __iomem *aper_clk_ctrl_addr;// 1. **实现开关读写4个系统调用函数**
static int led_open(struct inode *inode, struct file *filp)
{return 0;
}static ssize_t led_read(struct file *filp, char __user *buf,size_t cnt, loff_t *offt)
{return 0;
}static ssize_t led_write(struct file *filp, const char __user *buf,size_t cnt, loff_t *offt)
{int ret;int val;char kern_buf[1];ret = copy_from_user(kern_buf, buf, cnt);	// 得到应用层传递过来的数据if(0 > ret) {printk(KERN_ERR "kernel write failed!\r\n");return -EFAULT;}val = readl(data_addr);if (0 == kern_buf[0])val &= ~(0x1U << 7);		// 如果传递过来的数据是0则关闭ledelse if (1 == kern_buf[0])val |= (0x1U << 7);			// 如果传递过来的数据是1则点亮ledwritel(val, data_addr);return 0;
}static int led_release(struct inode *inode, struct file *filp)
{return 0;
}// 2. **初始化设备操作函数结构体**
static struct file_operations led_fops = {.owner		= THIS_MODULE,.open		= led_open,.read		= led_read,.write		= led_write,.release	= led_release,
};// 3. **实现设备注册和注销函数**
static int __init led_init(void)
{u32 val;int ret;/* 1.寄存器地址映射 */data_addr = ioremap(ZYNQ_GPIO_REG_BASE + DATA_OFFSET, 4);dirm_addr = ioremap(ZYNQ_GPIO_REG_BASE + DIRM_OFFSET, 4);outen_addr = ioremap(ZYNQ_GPIO_REG_BASE + OUTEN_OFFSET, 4);intdis_addr = ioremap(ZYNQ_GPIO_REG_BASE + INTDIS_OFFSET, 4);aper_clk_ctrl_addr = ioremap(APER_CLK_CTRL, 4);/* 2.使能GPIO时钟 */val = readl(aper_clk_ctrl_addr);val |= (0x1U << 22);writel(val, aper_clk_ctrl_addr);/* 3.关闭中断功能 */val |= (0x1U << 7);writel(val, intdis_addr);/* 4.设置GPIO为输出功能 */val = readl(dirm_addr);val |= (0x1U << 7);writel(val, dirm_addr);/* 5.使能GPIO输出功能 */val = readl(outen_addr);val |= (0x1U << 7);writel(val, outen_addr);/* 6.默认关闭LED */val = readl(data_addr);val &= ~(0x1U << 7);writel(val, data_addr);/* 7.注册字符设备驱动 */ret = register_chrdev(LED_MAJOR, LED_NAME, &led_fops);if(0 > ret){printk(KERN_ERR "Register LED driver failed!\r\n");return ret;}return 0;
}static void __exit led_exit(void)
{/* 1.卸载设备 */unregister_chrdev(LED_MAJOR, LED_NAME);/* 2.取消内存映射 */iounmap(data_addr);iounmap(dirm_addr);iounmap(outen_addr);iounmap(intdis_addr);iounmap(aper_clk_ctrl_addr);
}module_init(led_init);
module_exit(led_exit);// 4. **添加LICENSE和作者**
MODULE_AUTHOR("DengTao <773904075@qq.com>");
MODULE_DESCRIPTION("Alientek ZYNQ GPIO LED Driver");
MODULE_LICENSE("GPL");

应用程序：

打开文件
将字符串转为数据，并将数据写入文件（开关LED）
关闭文件

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>/** @description		: main主程序* @param - argc	: argv数组元素个数* @param - argv	: 具体参数* @return			: 0 成功;其他 失败*/
int main(int argc, char *argv[])
{int fd, ret;unsigned char buf[1];if(3 != argc) {printf("Usage:\n""\t./ledApp /dev/led 1		@ close LED\n""\t./ledApp /dev/led 0		@ open LED\n");return -1;}/* 打开设备 */fd = open(argv[1], O_RDWR);if(0 > fd) {printf("file %s open failed!\r\n", argv[1]);return -1;}/* 将字符串转换为int型数据 */buf[0] = atoi(argv[2]);/* 向驱动写入数据 */ret = write(fd, buf, sizeof(buf));if(0 > ret){printf("LED Control Failed!\r\n");close(fd);return -1;}/* 关闭设备 */close(fd);return 0;
}

3. 新字符设备驱动开发基础

struct cdev test_cdev;

在Linux里使用cdev结构体表示一个字符设备，此结构体中就包含file_operations和设备号。

cdev_init()

使用cdev_init()函数对次结构体进行初始化。

cdev_add()

首先使用cdev_init()函数完成对cdev结构体变量的初始化，然后使用cdev_add()函数向Linux系统添加这个字符设备。

cdev_del()

卸载驱动的时候使用cdev_del函数从Linux内核中删除相应的字符设备。

udev

使用udev自动创建节点。
一般在cdev_add函数后面添加自动创建设备节点相关代码，使用class_create()函数创建一个class类，再使用device_create()函数在类下面创建设备；卸载驱动程序时先使用device_destroy()函数删除设备，再使用class_destroy()删除掉类。

文件私有数据

每个硬件设备都有一些属性，比如主设备号(dev_t)，类(class)、设备(device)、开关状态(state)等等，在编写驱动的时候可以将这些属性组成一个结构体，并在编写驱动open函数的时候将设备结构体作为私有数据添加到设备文件中。

register_chrdev_region()

分配设备编号，注册设备与注销设备的函数均在fs.h中申明，如下：
extern int register_chrdev_region(dev_t, unsigned, const char ); //静态的申请和注册设备号
extern int alloc_chrdev_region(dev_t, unsigned, const char);//动态的申请注册一个设备号
extern int register_chrdev(unsigned int, const char *,struct file_operations *);//int为0时候动态注册，非零时候静态注册。
extern int unregister_chrdev(unsigned int, const char *);
extern void unregister_chrdev_region(dev_t, unsigned);

4. 新字符设备驱动下的LED驱动

定义设备结构体
设备结构体包含cdev、类、设备、设备号等。
实现开关读写4个系统调用函数
在文件打开函数中使用filp->private_data设置私有数据；使用copy_from_user()实现用户空间和内存空间数据交互，并使用readl()函数读取寄存器映射后的虚拟地址的数据，使用writel()函数根据寄存器映射后的虚拟地址将数据写入寄存器，从而实现文件写函数（LED的亮灭）。
初始化设备操作函数结构体
实现设备注册和注销函数
使用ioremap()函数获取物理地址空间对应的虚拟地址空间，然后使能GPIO、关闭中断、设置方向，使用register_chrdev_region()函数、alloc_chrdev_region()函数创建设备号，并使用module_init()函数指定设别注册函数实现insmod，使用cdev_init()初始化cdev，使用cdev_add()添加cdev，使用class_create()创建类，使用device_create()创建设备；使用device_destroy()注销设备，使用class_destroy()注销类，使用cdev_del()删除cdev，使用unregister_chrdev_region()注销设备号，使用led_iounmap()取消地址映射，并使用module_exit()函数指定设备注销函数实现rmmod。
添加LICENSE和作者
使用MODULE_LICENSE()函数和MODULE_AUTHOR()函数添加LICENSE和作者。

#include <linux/types.h>
#include <linux/kernel.h>
#include <linux/delay.h>
#include <linux/ide.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <asm/mach/map.h>
#include <asm/uaccess.h>
#include <asm/io.h>
#include <linux/cdev.h>#define NEWCHRLED_CNT		1				/* 设备号个数 */
#define NEWCHRLED_NAME		"newchrled"		/* 名字 *//* * GPIO相关寄存器地址定义*/
#define ZYNQ_GPIO_REG_BASE			0xE000A000
#define DATA_OFFSET					0x00000040
#define DIRM_OFFSET					0x00000204
#define OUTEN_OFFSET				0x00000208
#define INTDIS_OFFSET				0x00000214
#define APER_CLK_CTRL				0xF800012C/* 映射后的寄存器虚拟地址指针 */
static void __iomem *data_addr;
static void __iomem *dirm_addr;
static void __iomem *outen_addr;
static void __iomem *intdis_addr;
static void __iomem *aper_clk_ctrl_addr;// 0. **定义设备结构体**
/* newchrled设备结构体 */
struct newchrled_dev {dev_t devid;			/* 设备号 */struct cdev cdev;		/* cdev */struct class *class;	/* 类 */struct device *device;	/* 设备 */int major;				/* 主设备号 */int minor;				/* 次设备号 */
};static struct newchrled_dev newchrled;	/* led设备 */// 1. **实现开关读写4个系统调用函数**
static int led_open(struct inode *inode, struct file *filp)
{filp->private_data = &newchrled;	/* 设置私有数据 */return 0;
}static ssize_t led_read(struct file *filp, char __user *buf,size_t cnt, loff_t *offt)
{return 0;
}static ssize_t led_write(struct file *filp, const char __user *buf,size_t cnt, loff_t *offt)
{int ret;int val;char kern_buf[1];ret = copy_from_user(kern_buf, buf, cnt);	// 得到应用层传递过来的数据if(0 > ret) {printk(KERN_ERR "kernel write failed!\r\n");return -EFAULT;}val = readl(data_addr);if (0 == kern_buf[0])val &= ~(0x1U << 7);		// 如果传递过来的数据是0则关闭ledelse if (1 == kern_buf[0])val |= (0x1U << 7);			// 如果传递过来的数据是1则点亮ledwritel(val, data_addr);return 0;
}static int led_release(struct inode *inode, struct file *filp)
{return 0;
}static inline void led_ioremap(void)
{data_addr = ioremap(ZYNQ_GPIO_REG_BASE + DATA_OFFSET, 4);dirm_addr = ioremap(ZYNQ_GPIO_REG_BASE + DIRM_OFFSET, 4);outen_addr = ioremap(ZYNQ_GPIO_REG_BASE + OUTEN_OFFSET, 4);intdis_addr = ioremap(ZYNQ_GPIO_REG_BASE + INTDIS_OFFSET, 4);aper_clk_ctrl_addr = ioremap(APER_CLK_CTRL, 4);
}static inline void led_iounmap(void)
{iounmap(data_addr);iounmap(dirm_addr);iounmap(outen_addr);iounmap(intdis_addr);iounmap(aper_clk_ctrl_addr);
}// 2. **初始化设备操作函数结构体**
static struct file_operations newchrled_fops = {.owner		= THIS_MODULE,.open		= led_open,.read		= led_read,.write		= led_write,.release	= led_release,
};// 3. **实现设备注册和注销函数**
static int __init led_init(void)
{u32 val;int ret;/* 1.寄存器地址映射 */led_ioremap();/* 2.使能GPIO时钟 */val = readl(aper_clk_ctrl_addr);val |= (0x1U << 22);writel(val, aper_clk_ctrl_addr);/* 3.关闭中断功能 */val |= (0x1U << 7);writel(val, intdis_addr);/* 4.设置GPIO为输出功能 */val = readl(dirm_addr);val |= (0x1U << 7);writel(val, dirm_addr);/* 5.使能GPIO输出功能 */val = readl(outen_addr);val |= (0x1U << 7);writel(val, outen_addr);/* 6.默认关闭LED */val = readl(data_addr);val &= ~(0x1U << 7);writel(val, data_addr);/* 7.注册字符设备驱动 *//* 创建设备号 */if (newchrled.major) {newchrled.devid = MKDEV(newchrled.major, 0);ret = register_chrdev_region(newchrled.devid, NEWCHRLED_CNT, NEWCHRLED_NAME);if (ret)goto out1;} else {ret = alloc_chrdev_region(&newchrled.devid, 0, NEWCHRLED_CNT, NEWCHRLED_NAME);if (ret)goto out1;newchrled.major = MAJOR(newchrled.devid);newchrled.minor = MINOR(newchrled.devid);}printk("newcheled major=%d,minor=%d\r\n",newchrled.major, newchrled.minor); /* 初始化cdev */newchrled.cdev.owner = THIS_MODULE;cdev_init(&newchrled.cdev, &newchrled_fops);/* 添加一个cdev */ret = cdev_add(&newchrled.cdev, newchrled.devid, NEWCHRLED_CNT);if (ret)goto out2;/* 创建类 */newchrled.class = class_create(THIS_MODULE, NEWCHRLED_NAME);if (IS_ERR(newchrled.class)) {ret = PTR_ERR(newchrled.class);goto out3;}/* 创建设备 */newchrled.device = device_create(newchrled.class, NULL,newchrled.devid, NULL, NEWCHRLED_NAME);if (IS_ERR(newchrled.device)) {ret = PTR_ERR(newchrled.device);goto out4;}return 0;out4:class_destroy(newchrled.class);out3:cdev_del(&newchrled.cdev);out2:unregister_chrdev_region(newchrled.devid, NEWCHRLED_CNT);out1:led_iounmap();return ret;
}static void __exit led_exit(void)
{/* 注销设备 */device_destroy(newchrled.class, newchrled.devid);/* 注销类 */class_destroy(newchrled.class);/* 删除cdev */cdev_del(&newchrled.cdev);/* 注销设备号 */unregister_chrdev_region(newchrled.devid, NEWCHRLED_CNT);/* 取消地址映射 */led_iounmap();
}/* 驱动模块入口和出口函数注册 */
module_init(led_init);
module_exit(led_exit);MODULE_AUTHOR("DengTao <773904075@qq.com>");
MODULE_DESCRIPTION("Alientek ZYNQ GPIO LED Driver");
MODULE_LICENSE("GPL");

应用程序：

打开文件
将字符串转为数据，并将数据写入文件（开关LED）
关闭文件

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>/** @description		: main主程序* @param - argc	: argv数组元素个数* @param - argv	: 具体参数* @return			: 0 成功;其他 失败*/
int main(int argc, char *argv[])
{int fd, ret;unsigned char buf[1];if(3 != argc) {printf("Usage:\n""\t./ledApp /dev/led 1		@ close LED\n""\t./ledApp /dev/led 0		@ open LED\n");return -1;}/* 打开设备 */fd = open(argv[1], O_RDWR);if(0 > fd) {printf("file %s open failed!\r\n", argv[1]);return -1;}/* 将字符串转换为int型数据 */buf[0] = atoi(argv[2]);/* 向驱动写入数据 */ret = write(fd, buf, sizeof(buf));if(0 > ret){printf("LED Control Failed!\r\n");close(fd);return -1;}/* 关闭设备 */close(fd);return 0;
}