tinker board 2s平台设备驱动以及设备树操作入门指南

本文链接：https://blog.csdn.net/oHeHui1/article/details/127419880

本文介绍了如何在RK3399开发板上添加一个独立按键模块，通过设备树和平台驱动编程实现信号处理，并成功匹配驱动的过程。涉及设备树修改、编译、安装及测试步骤。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

这次我们使用的是一个独立按键模块，信号线接GPIO A7 引脚，物理编号是21，CPU编号是39 。

1 设备树路径：

arch/arm64/boot/dts/rockchip/rk3399-tinker_board_2.dts

2 在这个文件的第50行下面添加如下内容：

my_platform_device {
	    compatible = "my_platform_device_0921";
		pin = <190000000> ;
		name124 = "name147258" ;
	};

3 编译：
这次编译是基于上次有成功的编译结果，如果没有编译过，请看这里。

 sudo make ARCH=arm64  rk3399-tinker_board_2.img  CROSS_COMPILE=/usr/local/arm/gcc-linaro-7.5.0-2019.12-x86_64_aarch64-linux-gnu/bin/aarch64-linux-gnu-   -j8

4 复制到开发板

scp  boot.img   linaro@192.168.31.82:/home/linaro/a

5 在开发板上安装kernel：

 sudo dd if=boot.img of=/dev/mmcblk1p4

6 重启开发板：

sudo reboot

7 下面是平台驱动代码：

struct of_device_id my_of_match_table ={
		.compatible = "my_platform_device_0921",
} ;


struct platform_driver my_platform_driver = {
		.driver = {
				.of_match_table = &my_of_match_table,
				.name = "my-platform-driver",
				.owner = THIS_MODULE,
				.suspend = mysuspend,
				.resume = myresume, },
				.probe =
	          myprobe, .remove = myremove, };


module_platform_driver(my_platform_driver);

注意 .compatible 字段的值必须和我们刚才在设备树中添加的compatible一模一样，这样设备才能匹配到我们的驱动。

完整的驱动代码如下：

#include <linux/uaccess.h>
#include <linux/fs.h>
#include <linux/stat.h>
#include <linux/cdev.h>
#include <linux/io.h>
#include <linux/gpio.h>
#include <linux/slab.h>
#include <linux/irq.h>
#include <linux/mutex.h>
#include <linux/interrupt.h>
#include <linux/bug.h>			/* For BUG_ON.  */
#include <linux/cpu.h>
#include <linux/init.h> /* Needed for the macros */
#include <linux/kernel.h> /* Needed for pr_info() */
#include <linux/module.h> /* Needed by all modules */
#include <linux/delay.h>
#include <linux/smp.h>
#include <linux/kernel_stat.h>
#include <linux/sched.h>
#include <linux/percpu-defs.h>
#include <linux/wait.h>
#include <linux/gpio/driver.h>
#include <linux/atomic.h>
#include <linux/platform_device.h>
#include <linux/poll.h>
#include <linux/kfifo.h>

#define MY_MAX_MINORS  1
#define   DEVICE_NAME  "device name 500"

#define GPIO_1_BASE  0xFF730000
#define  GPIO1_SWPORTA_DR GPIO_1_BASE
#define  GPIO1_SWPORTA_DDR  0xFF730004

#define  GPIO_INTEN   (GPIO_1_BASE + 0x0030)
#define  GPIO_PIN  39
#define LOCATION  7

DEFINE_KFIFO(myfifo, char, 1024);

struct my_device_data {
	struct cdev cdev;
};

DECLARE_WAIT_QUEUE_HEAD(wq);

static struct my_device_data devs[MY_MAX_MINORS];

static int my_open(struct inode *inode, struct file *file) {
	pr_info("a3 my_open \n");
	return 0;
}

static ssize_t my_write(struct file *filp, const char __user *user_buffer,
		size_t size, loff_t *offset) {
	int ret;
	unsigned int len = 0;
	pr_info("write");
	ret = kfifo_from_user(&myfifo, user_buffer, size, &len);
	if (ret != 0) {
		pr_err("kfifo_from_user error");
		return 0;
	}
	if (len <= 0)
		return 0;
	*offset += len;
	wake_up(&wq);
	return len;
}

static ssize_t my_read(struct file *filp, char __user *user_buffer,
		size_t count, loff_t *offset) {
	int ret;
	unsigned int len = 0;
	pr_info("read");
	ret = kfifo_to_user(&myfifo, user_buffer, count, &len);
	if (len <= 0)
		return 0;
	*offset += len;
	return len;
}

unsigned int my_poll(struct file *flip, struct poll_table_struct *table) {
	int mask = 0;
	pr_info("my_poll \n");
	poll_wait(flip, &wq, table);
	if (kfifo_is_empty(&myfifo)) {

	} else {
		mask |= POLLIN | POLLRDNORM;
	}
	return mask;
}

int my_close(struct inode *inode, struct file *flip) {
	pr_info("my_close \n");
	return 0;
}

struct fasync_struct *fasync_struct;

int my_fasync(int fd, struct file *flip, int on) {
	return fasync_helper(fd, flip, on, &fasync_struct);
}

static const struct file_operations my_fops = { .owner = THIS_MODULE, .open =
		my_open, .read = my_read, .write = my_write, .poll = my_poll, .release =
		my_close, .fasync = my_fasync, };

static dev_t mydev;

void key_tasklet_handler(unsigned long data) {
	pr_info("tasklet_handler start \n");
	mdelay(5);
	pr_info("tasklet_handler end\n");
}

DECLARE_TASKLET(key_tasklet, key_tasklet_handler, (unsigned long ) &mydev);

static irqreturn_t key_handler(int irq, void *dev_id) {
	pr_info("key_handler \n");
	kill_fasync(&fasync_struct, SIGIO, POLL_OUT);
	tasklet_schedule(&key_tasklet);
	return IRQ_HANDLED;
}

unsigned int num;

int myprobe(struct platform_device *pdev) {
	int i;
	int err;
	int ret;

	unsigned int __iomem *direction = ioremap(GPIO1_SWPORTA_DDR, 4);
			unsigned int a = readl(direction);
			unsigned int __iomem *irq = ioremap(GPIO_INTEN, 4);

	pr_info("myplatformdriver myprobe \n");

	err = alloc_chrdev_region(&mydev, 0, MY_MAX_MINORS, DEVICE_NAME);
	if (err != 0) {
		return err;
	}

	for (i = 0; i < MY_MAX_MINORS; i++) {
		/* initialize devs[i] fields */
		cdev_init(&devs[i].cdev, &my_fops);
		cdev_add(&devs[i].cdev, MKDEV(MAJOR(mydev), i), 1);
	}

	// set direction in
		writel(readl(direction) & (~(1 << LOCATION)), direction);
		//just check
		a = readl(direction);
		pr_err("direction: %d \n", a);

		pr_err("direction 1 or 0  ? : %d \n", (a & (1 << LOCATION)) >> LOCATION);

// enable Interrupt
		writel(readl(irq) | (1 << LOCATION), irq);

		pr_err("Interrupt 1 or 0  ? : %d \n",
		(readl(irq) & (1 << LOCATION)) >> LOCATION);num = gpio_to_irq(GPIO_PIN);
		pr_info("irq_num:%d\n",
		num);ret = request_irq(num, key_handler, IRQF_TRIGGER_FALLING,
					"my_key_driver", NULL);

		if (ret < 0) {
				pr_err("request_irq  failed \n");
				return ret;
			}
		return 0;
}

int myremove(struct platform_device *pdev) {
		int i;
		free_irq(num, NULL);
		pr_info("myplatformdriver myremove \n");
		pr_info("a3 cleanup_module\n");
		for (i = 0; i < MY_MAX_MINORS; i++) {
	/* release devs[i] fields */
			cdev_del(&devs[i].cdev);
}
		unregister_chrdev_region(mydev, MY_MAX_MINORS);
		return 0;
}

int mysuspend(struct device *pdev, pm_message_t state) {
	pr_info("myplatformdriver mysuspend \n");
return 0;
}

int myresume(struct device *pdev) {
	pr_info("myplatformdriver myresume \n");
return 0;
}

struct of_device_id my_of_match_table ={
		.compatible = "my_platform_device_0921",
} ;

struct platform_driver my_platform_driver = {
		.driver = {
				.of_match_table = &my_of_match_table,
				.name = "my-platform-driver",
				.owner = THIS_MODULE,
				.suspend = mysuspend,
				.resume = myresume, },
				.probe =
	          myprobe, .remove = myremove, };


module_platform_driver(my_platform_driver);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Andy");
MODULE_DESCRIPTION("andy one-key driver");
MODULE_ALIAS("one-key");

然后编译此模块，scp至开发板，然后insmod
通过 sudo dmesg -w就可以看到打印的日志。

然后执行：

tree  /sys/bus/platform/drivers/my-platform-driver/

会有以下输出：

/sys/bus/platform/drivers/my-platform-driver/
├── bind
├── module -> ../../../../module/a2
├── my_platform_device -> ../../../../devices/platform/my_platform_device
├── uevent
└── unbind

2 directories, 3 files