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

作者：道哥 2021-11-29 07:55:45

系統 Linux

我們一塊討論了：在 Linux 系統中，編寫字符設備驅動程序的基本框架，主要是從代碼流程和 API 函數這兩方面觸發。這篇文章，我們就以此為基礎，寫一個有實際應用功能的驅動程序。

[[437191]]

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

大家好，我是道哥。

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

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

在驅動程序中，初始化 GPIO 設備，自動創建設備節點;
在應用程序中，打開 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() 自動刪除了!

本文轉載自微信公眾號「IOT物聯網小鎮」

責任編輯：姜華來源： IOT物聯網小鎮