Linux驅動實踐：如何編寫【 GPIO 】裝置的驅動程式？

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

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

目錄

目錄

• 示例程式目標
• 編寫驅動程式
  • 建立驅動目錄和驅動程式
  • 建立 Makefile 檔案
  • 編譯驅動模組
  • 載入驅動模組
  • 裝置節點
• 應用程式
• 解除安裝驅動模組

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

大家好，我是道哥。

在前幾篇文章中，我們一塊討論了：在 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>