嵌入式硬件学习(十)—— LED驱动+杂项设备驱动

目录

一、如何编写一个驱动程序

1、流程简介

  1. 定义文件操作file_operations结构体(static struct file_operations fops)
  2. 实现对应的open、read、write、close相关函数,填入file_operations结构体
  3. 编写入口函数:注册驱动程序
    (1) 申请设备号(alloc_chrdev_region
    (2) 初始化字符设备结构体cdev变量(cdev_init
    (3)将驱动程序注册到内核中(cdev_add )
    (4)初始化硬件,完成虚拟内存和物理内存转换(ioremap
    (5)创建class和device,用来实现设备节点的自动添加(class_createdevice_create
  4. 编写出口函数:卸载驱动程序

2、具体函数

  1. 定义file_operations结构体
cpp 复制代码
	static struct file_operations fops = {
	    .owner = THIS_MODULE,
	    .open = my_open,
	    .read = my_read,
	    .write = my_write,
	    .release = my_release,
	};
  1. 实现对应的open、read、write、close相关函数,填入file_operations结构体
cpp 复制代码
static int my_open(struct inode *inode, struct file *file) {}
static ssize_t my_read(struct file *file, char __user *buf, size_t len, loff_t *offset) {}
static ssize_t my_write(struct file *file, const char __user *buf, size_t len, loff_t *offset) {}
static int my_release(struct inode *inode, struct file *file) {}
  1. 编写入口函数:注册驱动程序
    (1) 申请设备号
cpp 复制代码
int alloc_chrdev_region(dev_t *dev, unsigned baseminor, unsigned count, const char *name);
示例:
dev_t dev_num;
alloc_chrdev_region(&dev_num, 0, 1, "mychardev");

参数解释:
dev:用于返回分配的设备号(主设备号 + 次设备号)。
baseminor:起始次设备号。
count:申请的设备数量。
name:设备名称,用于 /proc/devices。

(2) 初始化cdev变量

(3)将驱动程序注册到内核中

cpp 复制代码
void cdev_init(struct cdev *cdev, const struct file_operations *fops);
int cdev_add(struct cdev *cdev, dev_t dev, unsigned count);
示例:
struct cdev my_cdev;
cdev_init(&my_cdev, &fops);
cdev_add(&my_cdev, dev_num, 1);

参数解释:
cdev:字符设备结构体指针。
fops:文件操作结构体指针。
dev:设备号。
count:设备数量。

(4)初始化硬件

  1. 编写出口函数:卸载驱动程序

  2. 其他完善:实现设备节点的自动添加

(1)创建class

(2)创建device

cpp 复制代码
struct class *class_create(struct module *owner, const char *name);
struct device *device_create(struct class *class, struct device *parent, dev_t devt, void *drvdata, const char *fmt, ...);
示例:
struct class *my_class;
struct device *my_device;
my_class = class_create(THIS_MODULE, "mycharclass");
my_device = device_create(my_class, NULL, dev_num, NULL, "mychardev");

参数解释:
owner:通常为 THIS_MODULE。
name:类名。
parent:父设备,通常为 NULL。
devt:设备号。
drvdata:驱动数据,通常为 NULL。
fmt:设备名称格式。

总结调用流程

cpp 复制代码
static int __init mychardev_init(void) {
    // 申请设备号
    alloc_chrdev_region(&dev_num, 0, 1, "mychardev");
    // 初始化字符设备结构体
    cdev_init(&my_cdev, &fops);
    // 注册字符设备到内核
    cdev_add(&my_cdev, dev_num, 1);
    // 创建类,用于自动创建设备节点
    my_class = class_create(THIS_MODULE, "mycharclass");
    // 创建设备节点 /dev/mychardev
    my_device = device_create(my_class, NULL, dev_num, NULL, "mychardev");
    return 0;
}

二、编写LED驱动程序

1、创建文件操作结构体file_operations

cpp 复制代码
struct file_operations fops =
{	
	.owner = THIS_MODULE,
	.release = led_driver_close,
	.open = led_driver_open,
	.read = led_driver_read,
	.write = led_driver_write,
};

2、编写打开、读写、关闭等函数,填入file_operations中

cpp 复制代码
int led_driver_open(struct inode *p_node, struct file *fp)
{
	printk("open\n");
	return 0;
}
ssize_t led_driver_read(struct file *fp, char __user *user_buffer, size_t n, loff_t * offset)
{
	printk("read\n");
	return 0;
}
ssize_t led_driver_write(struct file *fp, const char __user *user_buffer, size_t n, loff_t *offset)
{
	char s[10];
	
	copy_from_user(s, user_buffer, n);
	ledOn(s[0]);

	printk("write\n");
	return n;
}
int led_driver_close(struct inode *p_node, struct file *fp)
{
	printk("close\n");
	return 0;
}
void ledOn(unsigned int n)
{
	 *regGPBDAT |= (0x0F << 5);
	if(n < 1 || n > 4)
	{
		return;
	}
	*regGPBDAT &= ~(1 << (n + 4));
}

3、编写入口函数:初始化驱动程序

(1)申请主设备号alloc_chrdev_region()

cpp 复制代码
	ret = alloc_chrdev_region(&dev_num, 0, 1, "first device");
	if(ret)
	{
		printk("alloc_chrdev_region is error\n");
		goto alloc_chrdev_region_err;
	}
	
	printk("major = %u, minior = %u\n", MAJOR(dev_num), MINOR(dev_num));

(2)初始化cdev

cpp 复制代码
cdev_init(&led_dev, &fops);

(3)将cdev注册到内核中

cpp 复制代码
ret = cdev_add(&led_dev, dev_num, 1);
	if(ret)
	{
		printk("cdev_add is error\n");
		goto cdev_add_err;
	}

(4)初始化硬件,完成物理地址和虚拟地址的映射

cpp 复制代码
	regGPBCON = ioremap(GPBCON, 4);
	regGPBDAT = ioremap(GPBDAT, 4);

	*regGPBCON &= ~((3 << 10) | (3 << 12) | (3 << 14) | (3 << 16));
	*regGPBCON |= (1 << 10) | (1 << 12) | (1 << 14) | (1 << 16);

	 *regGPBDAT |= (0x0F << 5);

(5)自动创建设备节点:包括class_create和device_create创建

cpp 复制代码
	p_class = class_create(THIS_MODULE, "Led class");
	if(IS_ERR(p_class))
	{
		printk("class_create is error!");
		goto class_create_err;
	}

	p_device = device_create(p_class, NULL, dev_num, NULL, "led");
	if(p_device == NULL)
	{
		printk("device_create is error\n");
		goto device_create_err;
	}

4、编写出口函数:卸载驱动程序

cpp 复制代码
static void __exit led_driver_exit(void)
{
	iounmap(regGPBDAT);
	iounmap(regGPBCON);

	device_destroy(p_class, dev_num);
	class_destroy(p_class);
	cdev_del(&led_dev);
	unregister_chrdev_region(dev_num, 1);
	printk("exot\n");
}

2、整体代码

cpp 复制代码
#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <asm/uaccess.h>
#include <asm/io.h>

#define GPBCON  (0x56000010)
#define GPBDAT  (0x56000014)
static unsigned int *regGPBCON;
static unsigned int *regGPBDAT;

int led_driver_open(struct inode *p_node, struct file *fp)
{
	printk("open\n");
	return 0;
}

ssize_t led_driver_read(struct file *fp, char __user *user_buffer, size_t n, loff_t * offset)
{
	printk("read\n");
	return 0;
}

void ledOn(unsigned int n)
{
	 *regGPBDAT |= (0x0F << 5);
	if(n < 1 || n > 4)
	{
		return;
	}
	*regGPBDAT &= ~(1 << (n + 4));
}

ssize_t led_driver_write(struct file *fp, const char __user *user_buffer, size_t n, loff_t *offset)
{
	char s[10];
	
	copy_from_user(s, user_buffer, n);
	ledOn(s[0]);

	printk("write\n");
	return n;
}

int led_driver_close(struct inode *p_node, struct file *fp)
{
	printk("close\n");
	return 0;
}

struct file_operations fops =
{	
	.owner = THIS_MODULE,
	.release = led_driver_close,
	.open = led_driver_open,
	.read = led_driver_read,
	.write = led_driver_write,
};

static dev_t dev_num;
struct cdev led_dev;
static struct class *p_class;
static struct device *p_device;

static int __init led_driver_init(void)
{	
	int ret;

	ret = alloc_chrdev_region(&dev_num, 0, 1, "first device");
	if(ret)
	{
		printk("alloc_chrdev_region is error\n");
		goto alloc_chrdev_region_err;
	}
	
	printk("major = %u, minior = %u\n", MAJOR(dev_num), MINOR(dev_num));

	
	cdev_init(&led_dev, &fops);
	ret = cdev_add(&led_dev, dev_num, 1);
	if(ret)
	{
		printk("cdev_add is error\n");
		goto cdev_add_err;
	}

	p_class = class_create(THIS_MODULE, "Led class");
	if(IS_ERR(p_class))
	{
		printk("class_create is error!");
		goto class_create_err;
	}

	p_device = device_create(p_class, NULL, dev_num, NULL, "led");
	if(p_device == NULL)
	{
		printk("device_create is error\n");
		goto device_create_err;
	}

	regGPBCON = ioremap(GPBCON, 4);
	regGPBDAT = ioremap(GPBDAT, 4);

	*regGPBCON &= ~((3 << 10) | (3 << 12) | (3 << 14) | (3 << 16));
	*regGPBCON |= (1 << 10) | (1 << 12) | (1 << 14) | (1 << 16);

	 *regGPBDAT |= (0x0F << 5);
	return 0;

device_create_err:
	class_destroy(p_class);
class_create_err:
	cdev_del(&led_dev);
cdev_add_err:
	unregister_chrdev_region(dev_num, 1);
alloc_chrdev_region_err:
	return ret;
}

static void __exit led_driver_exit(void)
{
	iounmap(regGPBDAT);
	iounmap(regGPBCON);

	device_destroy(p_class, dev_num);
	class_destroy(p_class);
	cdev_del(&led_dev);
	unregister_chrdev_region(dev_num, 1);
	printk("exot\n");
}

module_init(led_driver_init);
module_exit(led_driver_exit);

MODULE_LICENSE("GPL");

三、混杂设备驱动

1、简介

linux内核api接口提供了一种混杂设备驱动程序框架,可以大幅度降低编写字符设备驱动程序复杂性。misc 的意思是混合、杂项的,因此misc 驱动也叫做杂项驱动,misc 驱动其实就是最简单的字符设备驱动。所有的misc 设备驱动的主设备号都为10,不同的设备使用不同的从设备号。随着Linux字符设备驱动的不断增加,设备号变得越来越紧张,尤其是主设备号,misc 设备驱动就用于解决此问题。misc 设备会自动创建cdev,不需要像我们以前那样手动创建,因此采用misc 设备驱动可以简化字符设备驱动的编写。

使用混杂设备驱动程序和之前的方法类似,需要注册一个混杂设备。该函数需要一个struct miscdevice结构体变量的地址:

cpp 复制代码
int misc_register(struct miscdevice * misc);

struct miscdevice结构体中我们主要关注3个成员:
1. minor:子设备号,由于主设备号都是10,子设备号必须指定而且不能冲突, 
	linux/miscdevice.h中定义了几个子设备号,如果需要动态获取,就用MISC_DYNAMIC_MINOR
3. name:将来在/dev下的设备名
4. fops:指向文件操作结构体变量的指针

2、程序编写

cpp 复制代码
#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/miscdevice.h>
#include <asm/uaccess.h>
#include <asm/io.h>

#define GPBCON (0x56000010)
#define GPBDAT (0x56000014)
static unsigned int *regGPBCON;
static unsigned int *regGPBDAT;
//2、编写打开、读写、关闭函数,写入到结构体中
int beep_open(struct inode *p_node, struct file *fp)
{
	return 0;
}

int beep_release(struct inode *p_node, struct file *fp)
{
	return 0;
}

ssize_t beep_write(struct file *fp, const char __user *user_buffer, size_t n, loff_t * offset)
{
	int ret;
	copy_from_user(&ret, user_buffer, 4);
	printk("kernel : %d",ret);
	if(ret)
	{
		*regGPBDAT |= (1 << 0);
	}
	else
	{
		*regGPBDAT &= ~(1 << 0);
	}
	return 4;
}
// 1、定义文件操作结构体
static struct file_operations fops =
{
	.owner = THIS_MODULE,
	.open = beep_open,
	.release = beep_release,
	.write = beep_write
};

static struct miscdevice beep_device =
{
	.minor = MISC_DYNAMIC_MINOR,
	.name = "beep",
	.fops = &fops,
};

// 3、编写注册函数:misc_register
static int __init beep_init(void)
{
	int ret;
	ret = misc_register(&beep_device);
	if(ret)
	{
		printk("misc_register is error");
		return ret;
	}
	
	regGPBCON = ioremap(GPBCON, 4);
	regGPBDAT = ioremap(GPBDAT, 4);

	*regGPBCON &= ~(3 << 0);
	*regGPBCON |= (1 << 0);
	return 0;
}
// 4、编写卸载函数
static void __exit beep_exit(void)
{
	iounmap(regGPBCON);
	iounmap(regGPBDAT);
	misc_deregister(&beep_device);
}


module_init(beep_init);
module_exit(beep_exit);

MODULE_LICENSE("GPL");
相关推荐
Warren9837 分钟前
Appium学习笔记
android·windows·spring boot·笔记·后端·学习·appium
彤银浦1 小时前
PHP学习笔记1
笔记·学习·php
正在努力的小河1 小时前
GPIO子系统自主实现(简单版)
linux·单片机·嵌入式硬件
骑驴看星星a12 小时前
数学建模--Topsis(Python)
开发语言·python·学习·数学建模
国科安芯13 小时前
高速CANFD收发器ASM1042在割草机器人轮毂电机通信系统中的适配性研究
网络·单片机·嵌入式硬件·性能优化·机器人·硬件工程
CC呢13 小时前
基于单片机智能路灯控制
单片机·嵌入式硬件·智能路灯
长安即是故里13 小时前
Maxwell学习笔记
笔记·学习
DDUU__13 小时前
STM32低功耗模式
stm32·单片机·嵌入式硬件
小莞尔15 小时前
【51单片机】【protues仿真】基于51单片机宠物投食器系统
c语言·stm32·单片机·嵌入式硬件·51单片机·proteus
逼子格15 小时前
【Protues仿真】基于AT89C52单片机的数码管驱动事例
单片机·嵌入式硬件·硬件工程·硬件工程师·protues·数码管·电路仿真