GPIO实验(2)——基于rk3308b-cc-plus开发板

Lapusss

已于 2023-03-02 17:57:10 修改

阅读量430

点赞数

分类专栏：嵌入式学习文章标签： linux 学习

于 2023-03-02 17:56:49 首次发布

本文链接：https://blog.csdn.net/BigGhostCell/article/details/129305987

版权

嵌入式学习专栏收录该内容

5 篇文章 1 订阅

订阅专栏

本实验目的为用户可以通过应用层程序输入on/off来控制led灯的亮灭。

1.前置知识——简单字符设备的实现

1.1 设备号

1.1.1 主设备号与次设备号

对字符设备的访问是通过文件系统内的设备名称进行的。通常而言，主设备号标识设备对应的驱动程序。次设备号则由内核使用，用于正确确定设备文件所指的设备。你可以通过在/dev目录下利用ls -l查看设备的主次设备号。

dev_t类型用来保存设备编号。它是一个32位的数，其中12位标识主设备号，20位标识次设备号。

MAJOR(dev_t dev);//获取主设备号
MINOR(dev_t dec);//获取次设备号
MKDEV(int major, int minor);//由主次设备号得到设备号

1.1.2 分配和释放设备编号

在建立一个字符设备之前，我们的驱动程序首先要做的事情就是获得一个或者多个设备编号。

int register_chrdev_region(dev_t first, unsigned int count, char *name);//明确知道设备号选它
int alloc_chrdev_region(dev_t dev, unsigned int firstminor, unsigned count, char *name);//不知道就选择它，由内核自动分配主设备号
/*firstminor是要使用的被请求的第一个次设备号一般为0，count是所请求的连续设备编号的个数，name则是设备名称，你会在用户层的应用函数中使用到它*/

1.2 重要数据结构

1.2.1 file_operation

用于建立设备编号与驱动程序操作的连接。被初始化如下。

struct file_operations chr_ops = {
	.owner = THIS_MODULE,
	.open = chr_open,
	.read = chr_read
};//将其中对应的操作绑定到对应函数上

1.2.2 file

代表了一个打开的文件。它由内核在open时创建，并且传递给在该文件上进行操作的所有函数，直到close函数。

1.2.3 inode

内核用inode结构在内部表示文件。对于一个文件来说，可能会有多个表示打开的文件描述符的file结构，但是它们都会指向一个inode结构。该结构中对编写驱动程序代码有用的两个字段如下。

dev_t i_rdev; //该字段包含了真正的设备编号
struct cdev *i_cdev;//struct cdev表示字符设备的内核的内部结构。

1.3 字符设备的注册

当用户想要在运行时获取一个独立的cdev结构，应该如此编写代码

/*首先定义出struct cdev结构体，file_operation结构与设备编号*/
static struct cdev chr_dev;//内核内部使用cdev结构来表示字符设备，内核调用设备前，需要先注册该结构
struct file_operations chr_ops = {
	.owner = THIS_MODULE,
	.open = chr_open,
	.read = chr_read
};
static dev_t ndev;//用来保存设备编号，MAJOR获得主设备号，MINOR获得次设备号

/*然后利用cdev_init函数完成对cdev结构成员的初始化，建立cdev与file_operation的联系*/
cdev_init(&chr_dev, &chr_ops);

/*结构设置好后，利用下面的调用告诉内核该结构的信息*/
alloc_chrdev_region(&ndev, 0, 1, "chr_dev");//动态申请设备号
cdev_add(&chr_dev, ndev, 1);

cdev_add函数可能会失败，一定要对返回值进行检查。

1.4 简单字符设备实现(代码)

open和read函数没有实质内容，可以自己随便写

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/init.h>

//执行顺序：demo_init

static struct cdev chr_dev;
static dev_t ndev;//用来保存设备编号，MAJOR获得主设备号，MINOR获得次设备号

static int chr_open(struct inode *nd, struct file *filp)
{
	int major;
	int minor;

	major = MAJOR(nd->i_rdev); //inode中的i_rdev包含了真正的设备编号
	minor = MINOR(nd->i_rdev);

	printk("chr_open, major = %d, minor = %d\n", major, minor);
	return 0;
}

static ssize_t chr_read(struct file *filp, char __user *u, size_t sz, loff_t *of)
{
	printk("chr_read process!\n");
	return 0;
}

struct file_operations chr_ops = {
	.owner = THIS_MODULE,
	.open = chr_open,
	.read = chr_read
};//将其中对应的操作绑定到对应函数上

static int demo_init(void)
{
	int ret;

	cdev_init(&chr_dev, &chr_ops);//静态内存定义初始化
	ret = alloc_chrdev_region(&ndev, 0, 1, "chr_dev");//由内核自动分配主设备号
	if (ret < 0)
		return ret;
	printk("demo_init(): major = %d, minor = %d\n", MAJOR(ndev), MINOR(ndev));
	ret = cdev_add(&chr_dev, ndev, 1);
	if (ret < 0)
		return ret;
	return 0;
}

static void demo_exit(void)
{
	printk("demo_exit process!\n");
	cdev_del(&chr_dev);
	unregister_chrdev_region(ndev, 1);
}


module_init(demo_init);
module_exit(demo_exit);
MODULE_LICENSE("GPL");

完成编写后，将编译(一定要用开发板的内核来编译)得到的ko文件传入开发板，使用insmod xx.ko，将该模块加载入内核。

/*应用层程序，打开设备文件，并且测试定义的read和close文件，可以通过dmesg命令查看是否成功执行*/
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>

#define CHAR_DEV_NAME "/dev/chr_dev"

int main(void)
{
	int ret;
	int fd;
	char buf[32];

	fd = open(CHAR_DEV_NAME, O_RDONLY | O_NDELAY);
	if (fd < 0) {
		printf("open failed!\n");
		return -1;
	}

	read(fd, buf, 32);
	close(fd);

	return 0;
}

编译时应当使用开发板的编译环境，否则无法运行。

2. 将gpio申请和字符设备注册结合

2.1 补充知识-read与write的实现核心

unsigned long copy_to_user(void __user *to, const void *from, unsigned long count);
unsigned long copy_from_user(void *to, const void __user *from, unsigned long count);

read使用copy_to_user，从设备拷贝数据到用户空间。
write使用copy_from_user，从用户空间拷贝数据到设备。

2.2 补充知识-建立设备（个人理解，不一定正确。。）

1.手动：mknod /dev/dev_name(你的设备名) c(字符设备) major(主设备号) minor(次设备号)

2.自动：现在/sys/class下创建目录 class_create()
然后在/dev下创建设备 device_create()

2.3 dts文件描述与代码

2.3.1 dts文件

leds {
        	status = "okay";
        	compatible = "gpio-myled";
			gpio-myled = <&gpio0 RK_PB2 GPIO_ACTIVE_HIGH>;
    };

2.3.2 驱动程序

#include <linux/io.h>
#include <linux/of.h>
#include <linux/fs.h>
#include <linux/err.h>
#include <linux/init.h>
#include <linux/gpio.h>
#include <linux/cdev.h>

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/string.h>
#include <linux/device.h>
#include <linux/uaccess.h>
#include <linux/of_gpio.h>
#include <linux/interrupt.h>
#include <linux/platform_device.h>


static int GPIO_PIN;
static int majorNumber;
static const char *CLASS_NAME = "led_control_class";/*Class 名称，对应/sys/class*/
static const char *DEVICE_NAME = "led_control_demo";/*Device 名称，对应/dev*/

static struct cdev gpio_dev;
static dev_t ndev;
static int gpio_status;
static char recv_msg[20];

static struct class *gpio_control_class;
static struct device *gpio_control_device;

static int gpio_control_open(struct inode *node, struct file *file);
static ssize_t gpio_control_read(struct file *file, char *buf, size_t len, loff_t *offset);
static ssize_t gpio_control_write(struct file *file, const char *buf, size_t len, loff_t *offset);
static int gpio_control_release(struct inode *node, struct file *file);

/*File opertion 结构体，我们通过这个结构体建立应用程序到内核之间操作的映射*/
static struct file_operations file_oprts = {
	.open = gpio_control_open,
	.read = gpio_control_read,
	.write = gpio_control_write,
	.release = gpio_control_release,
};

struct gpio_myled_info
{
	int myled_gpio;
	int gpio_enable_value;
};

static int gpio_myled_probe(struct platform_device *pdev)
{
	enum of_gpio_flags flag;
	struct gpio_myled_info *gpio_info;
	struct device_node *gpio_myled_node = pdev->dev.of_node;

	printk("Myled GPIO Test Program Probe\n");

	gpio_info = devm_kzalloc(&pdev->dev, sizeof(struct gpio_myled_info *),GFP_KERNEL);
	if (!gpio_info)
	{
		dev_err(&pdev->dev, "devm_kzalloc failed!\n");
		return -ENOMEM;
	}

	GPIO_PIN = of_get_named_gpio_flags(gpio_myled_node, "gpio-myled", 0, &flag);
	if (!gpio_is_valid(GPIO_PIN))
	{
		dev_err(&pdev->dev, "gpio-myled: %d is invalid!\n", GPIO_PIN);
		return -ENODEV;
	}
	if (gpio_request(GPIO_PIN, "gpio-myled"))
	{
		dev_err(&pdev->dev, "gpio-myled: %d request failed!\n", GPIO_PIN);
		gpio_free(GPIO_PIN);
		return -ENODEV;
	}

	gpio_info->myled_gpio = GPIO_PIN;
	gpio_info->gpio_enable_value = (flag == OF_GPIO_ACTIVE_LOW) ? 0:1;
	gpio_direction_output(gpio_info->myled_gpio, gpio_info->gpio_enable_value);
	printk("Myled gpio putout\n");

	return 0;
}

static struct of_device_id myled_match_table[] = {
	{ .compatible = "gpio-myled",},
	{},
};

static struct platform_driver gpio_myled_driver = {
	.driver = {
		.name = "gpio-myled",
		.owner = THIS_MODULE,
		.of_match_table = myled_match_table,
	},
	.probe = gpio_myled_probe,
};

/*当用户打开这个设备文件时，调用这个函数*/
static int gpio_control_open(struct inode *node, struct file *file)
{
	printk(KERN_ALERT "GPIO init\n");
	return 0;
}

/*当用户试图从设备空间读取数据时，调用这个函数*/
static ssize_t gpio_control_read(struct file *file, char *buf, size_t len, loff_t *offset)
{
	int cnt = 0;/*将内核空间的数据copy到用户空间*/
	cnt = copy_to_user(buf, &gpio_status, 1);
	if (cnt == 0) {
		return 0;
	} else {
		printk(KERN_ALERT "ERROR occur when reading!!\n");
		return -EFAULT;
	}
	return 1;
}

/*当用户往设备文件写数据时，调用这个函数*/
static ssize_t gpio_control_write(struct file *file, const char *buf, size_t len, loff_t *offset)
{
	/*将用户空间的数据copy到内核空间*/
	int cnt = copy_from_user(recv_msg, buf, len);
	if (cnt == 0) {
		if (memcmp(recv_msg, "on", 2) == 0) {
			printk(KERN_INFO "gpio ON!\n");
			gpio_set_value(GPIO_PIN, 1);
			gpio_status = 1;
		} else if (memcmp(recv_msg, "off", 3) == 0) {
			printk(KERN_INFO "gpio OFF!\n");
			gpio_set_value(GPIO_PIN, 0);
			gpio_status = 0;
		}
	} else {
		printk(KERN_ALERT "ERROR occur when writing!!\n");
		return -EFAULT;
	}
	return len;
}

/*当用户打开设备文件时，调用这个函数*/
static int gpio_control_release(struct inode *node, struct file *file)
{
	printk(KERN_INFO "Release!!\n");
	return 0;
}

static int gpio_myled_init(void)
{
	platform_driver_register(&gpio_myled_driver);
	printk(KERN_ALERT "Driver init\r\n");/*注册一个新的字符设备，返回主设备号*/
	cdev_init(&gpio_dev, &file_oprts);
	if (alloc_chrdev_region(&ndev, 0, 1, DEVICE_NAME) < 0) {
		printk(KERN_ALERT "Register failed!!\r\n");
	return 0;
	}
	if (cdev_add(&gpio_dev, ndev, 1) < 0) {
		printk("add wrong!\n");
		return 0;
	}
	majorNumber = MAJOR(ndev);
	printk(KERN_ALERT "Registe success,major number is %d\r\n", majorNumber);

	/*以CLASS_NAME创建一个class结构，这个动作将会在/sys/class目录创建一个名为CLASS_NAME的目录*/
	gpio_control_class = class_create(THIS_MODULE, CLASS_NAME);
	if (IS_ERR(gpio_control_class)) {
		unregister_chrdev_region(ndev, 1);
		return PTR_ERR(gpio_control_class);
	}

	/*以DEVICE_NAME为名，参考/sys/class/CLASS_NAME在/dev目录下创led建一个设备：/dev/DEVICE_NAME*/
	gpio_control_device = device_create(gpio_control_class, NULL, MKDEV(majorNumber, 0), NULL, DEVICE_NAME);
	if (IS_ERR(gpio_control_device)) {
		class_destroy(gpio_control_class);
		unregister_chrdev_region(ndev, 1);
		return PTR_ERR(gpio_control_device);
	}
	printk(KERN_ALERT "gpio_control device init success!!\r\n");
	return 0;
}
module_init(gpio_myled_init);

static void gpio_myled_exit(void)
{

	device_destroy(gpio_control_class, MKDEV(majorNumber, 0));
	class_unregister(gpio_control_class);
	class_destroy(gpio_control_class);
	unregister_chrdev_region(ndev, 1);
	platform_driver_unregister(&gpio_myled_driver);
}
module_exit(gpio_myled_exit);

MODULE_AUTHOR("Pato");
MODULE_LICENSE("GPL");

2.3.3 测试代码

#include <stdio.h>
#include <stdlib.h>
#include <error.h>
#include <fcntl.h>
#include <string.h>
#include <unistd.h>
static char buf[256] = {1};
int main(int argc,char *argv[])
{
    int fd = open("/dev/led_control_demo",O_RDWR);
    if(fd < 0)
    {
        perror("Open file failed!!!\r\n");
        return -1;
    }
    printf("Please input <on> or <off>:\n");
    scanf("%s",buf);
    if(strlen(buf) > 3){
    	printf("Ivalid input!\n");
    }
    else
    {
        int ret = write(fd,buf,strlen(buf));
        if(ret < 0){
        	perror("Failed to write!!");
        }
    }
     close(fd);
    return 0;
    
 }