Linux驅動實踐：如何編寫【 GPIO 】設備的驅動程序？

作 者：道哥，10+年嵌入式開發老兵，專註於：C/C++、嵌入式、Linux。

關注下方公眾號，回復【書籍】，獲取 Linux、嵌入式領域經典書籍；回復【PDF】，獲取所有原創文章( PDF 格式)。

目錄

目錄

別人的經驗，我們的階梯！

大家好，我是道哥。

在前幾篇文章中，我們一塊討論了：在 Linux 系統中，編寫字符設備驅動程序的基本框架，主要是從代碼流程和 API 函數這兩方面觸發。

這篇文章，我們就以此為基礎，寫一個有實際應用功能的驅動程序：

  1. 在驅動程序中，初始化 GPIO 設備，自動創建設備節點;

  2. 在應用程序中，打開 GPIO 設備，並發送控制指令設置 GPIO 口的狀態;

示例程序目標

編寫一個驅動程序模塊：mygpio.ko。

當這個驅動模塊被加載的時候，在系統中創建一個 mygpio 類設備，並且在 /dev 目錄下，創建 4 個設備節點：

/dev/mygpio0

/dev/mygpio1

/dev/mygpio2

/dev/mygpio3

因為我們現在是在 x86 平台上來模擬 GPIO 的控制操作，並沒有實際的 GPIO 硬件設備。

因此，在驅動代碼中，與硬件相關部分的代碼，使用宏 MYGPIO_HW_ENABLE 控制起來，並且在其中使用printk輸出打印信息來體現硬件的操作。

在應用程序中，可以分別打開以上這 4 個 GPIO 設備，並且通過發送控制指令，來設置 GPIO 的狀態。

編寫驅動程序

以下所有操作的工作目錄，都是與上一篇文章相同的，即：~/tmp/linux-4.15/drivers/。

創建驅動目錄和驅動程序

$ cd linux-4.15/drivers/
$ mkdir mygpio_driver
$ cd mygpio_driver
$ touch mygpio.c

mygpio.c 文件的內容如下(不需要手敲，文末有代碼下載鏈接)：

#include <linux module.h="">
#include <linux kernel.h="">
#include <linux ctype.h="">
#include <linux device.h="">
#include <linux cdev.h="">

// GPIO 硬件相關宏定義
#define MYGPIO_HW_ENABLE

// 設備名稱
#define MYGPIO_NAME			"mygpio"

// 一共有４個 GPIO 口
#define MYGPIO_NUMBER		4

// 設備類
static struct class *gpio_class;

// 用來保存設備
struct cdev gpio_cdev[MYGPIO_NUMBER];

// 用來保存設備號
int gpio_major = 0;
int gpio_minor = 0;

#ifdef MYGPIO_HW_ENABLE
// 硬件初始化函數，在驅動程序被加載的時候(gpio_driver_init)被調用
static void gpio_hw_init(int gpio)
{
	printk("gpio_hw_init is called: %d. \n", gpio);
}

// 硬件釋放
static void gpio_hw_release(int gpio)
{
	printk("gpio_hw_release is called: %d. \n", gpio);
}

// 設置硬件GPIO的狀態，在控制GPIO的時候(gpio_ioctl)被調研
static void gpio_hw_set(unsigned long gpio_no, unsigned int val)
{
	printk("gpio_hw_set is called. gpio_no = %ld, val = %d. \n", gpio_no, val);
}
#endif

// 當應用程序打開設備的時候被調用
static int gpio_open(struct inode *inode, struct file *file)
{
	
	printk("gpio_open is called. \n");
	return 0;	
}

// 當應用程序控制GPIO的時候被調用
static long gpio_ioctl(struct file* file, unsigned int val, unsigned long gpio_no)
{
	printk("gpio_ioctl is called. \n");
	
	// 檢查設置的狀態值是否合法
	if (0 != val && 1 != val)
	{
		printk("val is NOT valid! \n");
		return 0;
	}

    // 檢查設備範圍是否合法
	if (gpio_no >= MYGPIO_NUMBER)
	{
		printk("dev_no is invalid! \n");
		return 0;
	}

	printk("set GPIO: %ld to %d. \n", gpio_no, val);

#ifdef MYGPIO_HW_ENABLE
    // 操作 GPIO 硬件
	gpio_hw_set(gpio_no, val);
#endif

	return 0;
}

static const struct file_operations gpio_ops={
	.owner = THIS_MODULE,
	.open  = gpio_open,
	.unlocked_ioctl = gpio_ioctl
};

static int __init gpio_driver_init(void)
{
	int i, devno;
	dev_t num_dev;

	printk("gpio_driver_init is called. \n");

	// 動態申請設備號(嚴謹點的話，應該檢查函數返回值)
	alloc_chrdev_region(&num_dev, gpio_minor, MYGPIO_NUMBER, MYGPIO_NAME);

	// 獲取主設備號
	gpio_major = MAJOR(num_dev);
	printk("gpio_major = %d. \n", gpio_major);

	// 創建設備類
	gpio_class = class_create(THIS_MODULE, MYGPIO_NAME);

	// 創建設備節點
	for (i = 0; i < MYGPIO_NUMBER; ++i)
	{
		// 設備號
		devno = MKDEV(gpio_major, gpio_minor + i);
		
		// 初始化 cdev 結構
		cdev_init(&gpio_cdev[i], &gpio_ops);

		// 註冊字符設備
		cdev_add(&gpio_cdev[i], devno, 1);

		// 創建設備節點
		device_create(gpio_class, NULL, devno, NULL, MYGPIO_NAME"%d", i);
	}

#ifdef MYGPIO_HW_ENABLE
    // 初始化 GPIO 硬件
	for (i = 0; i < MYGPIO_NUMBER; ++i)
	{
		gpio_hw_init(i);
	}
#endif

	return 0;
}

static void __exit gpio_driver_exit(void)
{
	int i;
	printk("gpio_driver_exit is called. \n");

	// 刪除設備和設備節點
	for (i = 0; i < MYGPIO_NUMBER; ++i)
	{
		cdev_del(&gpio_cdev[i]);
		device_destroy(gpio_class, MKDEV(gpio_major, gpio_minor + i));
	}

	// 釋放設備類
	class_destroy(gpio_class);

#ifdef MYGPIO_HW_ENABLE
    // 釋放 GPIO 硬件
	for (i = 0; i < MYGPIO_NUMBER; ++i)
	{
		gpio_hw_release(i);
	}
#endif

	// 註銷設備號
	unregister_chrdev_region(MKDEV(gpio_major, gpio_minor), MYGPIO_NUMBER);
}

MODULE_LICENSE("GPL");
module_init(gpio_driver_init);
module_exit(gpio_driver_exit);

相對於前幾篇文章來說，上面的代碼稍微有一點點複雜，主要是多了宏定義 MYGPIO_HW_ENABLE 控制部分的代碼。

比如：在這個宏定義控制下的三個與硬件相關的函數：

gpio_hw_init()

gpio_hw_release()

gpio_hw_set()

就是與GPIO硬件的初始化、釋放、狀態設置相關的操作。

代碼中的注釋已經比較完善了，結合前幾篇文章中的函數說明，還是比較容易理解的。

從代碼中可以看出：驅動程序使用 alloc_chrdev_region 函數，來動態註冊設備號，並且利用了 Linux 應用層中的 udev 服務，自動在 /dev 目錄下創建了設備節點。

另外還有一點：在上面示例代碼中，對設備的操作函數只實現了 open 和 ioctl 這兩個函數，這是根據實際的使用場景來決定的。

這個示例中，只演示了如何控制 GPIO 的狀態。

你也可以稍微補充一下，增加一個read函數，來讀取某個GPIO口的狀態。

控制 GPIO 設備，使用 write 或者 ioctl 函數都可以達到目的，只是 ioctl 更靈活一些。

創建 Makefile 文件

$ touch Makefile

內容如下：

ifneq ($(KERNELRELEASE),)
	obj-m := mygpio.o
else
	KERNELDIR ?= /lib/modules/$(shell uname -r)/build
	PWD := $(shell pwd)
default:
	$(MAKE) -C $(KERNELDIR) M=$(PWD) modules
clean:
	$(MAKE) -C $(KERNEL_PATH) M=$(PWD) clean
endif

編譯驅動模塊

$ make

得到驅動程序： mygpio.ko 。

加載驅動模塊

在加載驅動模塊之前，先來檢查一下系統中，幾個與驅動設備相關的地方。

先看一下 /dev 目錄下，目前還沒有設備節點( /dev/mygpio[0-3] )。

$ ls -l /dev/mygpio*
ls: cannot access '/dev/mygpio*': No such file or directory

再來查看一下 /proc/devices 目錄下，也沒有 mygpio 設備的設備號。

$ cat /proc/devices

為了方便查看打印信息，把dmesg輸出信息清理一下：

$ sudo dmesg -c

現在來加載驅動模塊，執行如下指令:

$ sudo insmod mygpio.ko

當驅動程序被加載的時候，通過 module_init( ) 註冊的函數 gpio_driver_init() 將會被執行，那麼其中的打印信息就會輸出。

還是通過 dmesg 指令來查看驅動模塊的打印信息：

$ dmesg

可以看到：操作系統為這個設備分配的主設備號是 244，並且也打印了GPIO硬件的初始化函數的調用信息。

此時，驅動模塊已經被加載了!

來查看一下 /proc/devices 目錄下顯示的設備號：

$ cat /proc/devices

設備已經註冊了，主設備號是: 244 。

設備節點

由於在驅動程序的初始化函數中，使用 cdev_add 和 device_create 這兩個函數，自動創建設備節點。

所以，此時我們在 /dev 目錄下，就可以看到下面這4個設備節點：

現在，設備的驅動程序已經加載了，設備節點也被創建好了，應用程序就可以來控制 GPIO 硬件設備了。

應用程序

應用程序仍然放在 ~/tmp/App/ 目錄下。

$ mkdir ~/tmp/App/app_mygpio
$ cd ~/tmp/App/app_mygpio
$ touch app_mygpio.c

文件內容如下：

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <assert.h>
#include <fcntl.h>
#include <sys ioctl.h="">

#define MY_GPIO_NUMBER		4

// 4個設備節點
char gpio_name[MY_GPIO_NUMBER][16] = {
	"/dev/mygpio0",
	"/dev/mygpio1",
	"/dev/mygpio2",
	"/dev/mygpio3"
};


int main(int argc, char *argv[])
{
	int fd, gpio_no, val;

    // 參數個數檢查
	if (3 != argc)
	{
		printf("Usage: ./app_gpio gpio_no value \n");
		return -1;
	}

	gpio_no = atoi(argv[1]);
	val = atoi(argv[2]);

    // 參數合法性檢查
	assert(gpio_no < MY_GPIO_NUMBER);
	assert(0 == val || 1 == val);

	// 打開 GPIO 設備
	if((fd = open(gpio_name[gpio_no], O_RDWR | O_NDELAY)) < 0){
		printf("%s: open failed! \n", gpio_name[gpio_no]);
		return -1;
	}

	printf("%s: open success! \n", gpio_name[gpio_no]);

	// 控制 GPIO 設備狀態
	ioctl(fd, val, gpio_no);
	
	// 關閉設備
	close(fd);
}

以上代碼也不需要過多解釋，只要注意參數的順序即可。

接下來就是編譯和測試了：

$ gcc app_mygpio.c -o app_mygpio

執行應用程序的時候，需要攜帶2個參數：GPIO 設備編號(0 ~ 3)，設置的狀態值(0 或者 1)。

這裡設置一下/dev/mygpio0這個設備，狀態設置為1：

$ sudo ./app_mygpio 0 1
[sudo] password for xxx: <輸入用戶密碼>
/dev/mygpio0: open success!

如何確認/dev/mygpio0這個GPIO的狀態確實被設置為1了呢？當然是看 dmesg 指令的打印信息：

$ dmesg

通過打印信息可以看到：確實執行了【設置 mygpio0 的狀態為 1】的動作。

再繼續測試一下：設置 mygpio0 的狀態為 0：

$ sudo ./app_mygpio 0 0

當然了，設置其他幾個GPIO口的狀態，都是可以正確執行的！

卸載驅動模塊

卸載指令：

$ sudo rmmod mygpio

此時，/proc/devices 下主設備號 244 的 mygpio 已經不存在了。

再來看一下 dmesg的打印信息：

可以看到：驅動程序中的 gpio_driver_exit( ) 被調用執行了。

並且，/dev 目錄下的 4 個設備節點，也被函數 device_destroy() 自動刪除了！


—— End ——

文中的測試代碼，已經放在網盤了。

在公眾號【IOT物聯網小鎮】後台回復關鍵字：1128，即可獲取下載地址。

謝謝！

推薦閱讀

【1】《Linux 從頭學》系列文章

【2】C語言指針-從底層原理到花式技巧，用圖文和代碼幫你講解透徹

【3】原來gdb的底層調試原理這麼簡單

【4】內聯彙編很可怕嗎？看完這篇文章，終結它！

其他系列專輯：精選文章、應用程序設計、物聯網、 C語言。


星標公眾號，第一時間看文章！

</fcntl.h></assert.h></unistd.h></stdlib.h></stdio.h>

Tags:

VirMach 便宜 VPS

QNews

QNews