Linux第87步_阻塞IO实验

阻塞IO是“应用程序”对“驱动设备”进行操作，若不能获取到设备资源，则阻塞IO应用程序的线程会被“挂起”，直到获取到设备资源为止。

“挂起”就是让线程进入休眠，将CPU的资源让出来。线程进入休眠后，当设备文件可以操作时，就必须唤醒这个休眠的线程。通常是在中断函数里完成唤醒工作，Linux内核是采用“等待队列（wait queue）”来完成阻塞线程的唤醒工作。

阻塞IO应用举例：

1、添加“EXTI3.c”

#include "EXTI3.h"
#include <linux/gpio.h>
//使能gpio_request(),gpio_free(),gpio_direction_input(),
//使能gpio_direction_output(),gpio_get_value(),gpio_set_value()
#include <linux/of_gpio.h>
//使能of_gpio_named_count(),of_gpio_count(),of_get_named_gpio()
#include <linux/delay.h>
//Linux内核中用到的延时函数
//使能ndelay()，udelay()，mdelay()
#include <linux/of_irq.h>
//使能irq_of_parse_and_map()
#include <linux/interrupt.h>
//request_irq(),free_irq(),enable_irq(),disable_irq(),disable_irq_nosync()

struct Button_dev strButton;

int Get_gpio_Button_num(void);
int Button_gpio_request(void);
void Button_free(void);
int Read_Button(void);

static irqreturn_t key_interrupt_fun(int irq, void *dev_id)
{
  atomic_set(&strButton.button_irq_status, 1);
  /*设置原子变量值strButton.button_irq_status.counter=1*/
  wake_up_interruptible(&strButton.read_wait); /* 唤醒 */

  return IRQ_HANDLED;
}

int Get_gpio_Button_num(void)
{
  int ret = 0;
  const char *str;

  strButton.button_irq_status = (atomic_t)ATOMIC_INIT(0);
  /*初始化原子变量*/
  atomic_set(&strButton.button_irq_status, 0);
  /*设置原子变量初始值strButton.button_irq_status.counter=0*/
  init_waitqueue_head(&strButton.read_wait);
  /* 初始化等待队列头 */

  strButton.keyvalue=0;

  /* 设置Button所使用的GPIO */
  /* 1、获取设备节点：strButton */
  strButton.nd = of_find_node_by_path("/key0");
  //path="/key0，使用“全路径的节点名“在“stm32mp157d-atk.dts“中查找节点“key0”
  //返回值:返回找到的节点，如果为NULL，表示查找失败。
  if(strButton.nd == NULL) {
    printk("key0 device node not find!\r\n");
    return -EINVAL;
  }

  /* 2.读取status属性 */
  ret = of_property_read_string(strButton.nd, "status", &str);
  //在key0节点中，status = "okay";
  //指定的设备节点strButton.nd
  //proname="status"，给定要读取的属性名字
  //out_string=str:返回读取到的属性值
  //返回值:0，读取成功，负值，读取失败。
  if(ret < 0) return -EINVAL;
  if(strcmp(str, "okay")) return -EINVAL;
  //strcmp(s1,s2),当s1<s2时，返回值为负数
  //strcmp(s1,s2),当s1>2时，返回值为正数
  //strcmp(s1,s2),当s1=s2时，返回值为0

  /* 3、获取compatible属性值并进行匹配 */
  ret = of_property_read_string(strButton.nd, "compatible", &str);
  //在key0节点中，compatible = "zgq,key";
  //指定的设备节点strButton.nd
  //proname="compatible"，给定要读取的属性名字
  //out_string=str:返回读取到的属性值
  //返回值:0，读取成功，负值，读取失败。
  if(ret < 0) {
    printk("key0 node: Failed to get compatible property\n"); 
    return -EINVAL;
  }
  if (strcmp(str, "zgq,key")) {
    printk("key0 node: Compatible match failed\n");
    return -EINVAL;
  }

  /* 4、 根据设备树中的"key-gpio"属性，得到key0所使用的key0编号 */
  strButton.button_gpio_number = of_get_named_gpio(strButton.nd, "key-gpio", 0);
  //在key0节点中，key-gpio = <&gpiog 3 GPIO_ACTIVE_LOW>
  //np=strButton.nd,指定的“设备节点”
  //propname="key-gpio"，给定要读取的属性名字
  //Index=0,给定的GPIO索引为0
  //返回值：正值，获取到的GPIO编号；负值，失败。
  if(strButton.button_gpio_number < 0) {
    printk("can't get key-gpio");
    return -EINVAL;
  }

  /* 5 、获取GPIO对应的中断号 */
  strButton.irq_num = irq_of_parse_and_map(strButton.nd, 0);
  //dev=strButton.nd：为设备节点;
  //Index=0：索引号，intemrupts属性可能包含多条中断信息，通过index指定要获取的信息；
  //返回值：中断号；
  if(!strButton.irq_num){
    return -EINVAL;
  }

  printk("key-gpio num = %d\r\n", strButton.button_gpio_number);
  //打印结果为：“key-gpio num = 99“
  //因为GPIO编号是从0开始的，GPIOG端口的序号是6，每个端口有16个IO口，因此GPIOI0的编号为6*16 + 3 = 99

  return 0;
}

int Button_gpio_request(void)
{
  int ret = 0;
  unsigned long irq_flags;

  /* 5.向gpio子系统申请使用“gpio编号” */
  ret = gpio_request(strButton.button_gpio_number, "Button0");
  //gpio=strButton.button_gpio_number，指定要申请的“gpio编号”
  //label="Button"，给这个gpio引脚设置个名字为"Button0"
  //返回值：0，申请“gpio编号”成功;其他值，申请“gpio编号”失败；
  if (ret) {
    printk(KERN_ERR "Button: Failed to request key0\n");
    return ret;
  }

  /* 6、设置PG3为输入模式*/
  ret = gpio_direction_input(strButton.button_gpio_number);
  //gpio=strButton.button_gpio_number,指定的“gpio编号”
  if(ret < 0) {
    printk("can't set gpio!\r\n");
  }

  /* 获取设备树中指定的中断触发类型 */
  irq_flags = irq_get_trigger_type(strButton.irq_num);
  //strButton.irq_num为中断号
  if ( irq_flags==IRQF_TRIGGER_NONE )
     irq_flags = IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING;

  /*申请中断*/
  ret = request_irq(strButton.irq_num, key_interrupt_fun, irq_flags, "Key0_IRQ", NULL);
  //irq=strButton.irq_num：要申请中断的中断号；
  //handler=key_interrupt_fun：中断处理函数，当中断发生以后就会执行此中断处理函数；
  //fags=irq_flags：中断标志；可以在文件“include/linux/interrupt.h”里面查看所有的中断标志；
  //name="Key0_IRQ"：中断名字，设置以后可以在“/proc/interrupts”文件中看到对应的中断名字；
  //dev=NULL：如果将flags设置为IRQF_SHARED的话，dev用来区分不同的中断。
  //一般情况下将dev设置为“设备结构体”，dev会传递给中断处理函数irg_handler_t的第二个参数。
  //返回值：0表示中断申请成功，如果返回“-EBUSY”的话表示中断已经被申请过了, 其他负值，表示中断申请失败。
  if (ret) {
    printk(KERN_ERR "Button: Failed to request irq\n");
    return ret;
  }

  return 0;
}

//函数功能：释放Button的gpio
void Button_free(void)
{
  free_irq(strButton.irq_num, NULL); /* 释放中断 */
  gpio_free(strButton.button_gpio_number);/* 释放IO */
}

//读取按键的值
int Read_Button(void)
{
  u8 ch;
  int status;
  int ret;

  /* 加入等待队列，当有按键按下或松开动作发生时，才会被唤醒 */
  ret=wait_event_interruptible(strButton.read_wait, atomic_read(&strButton.button_irq_status) !=0 );
  /* 读取strButton.button_irq_statusv.counter的值,读取按键中断标志 */ 
  //等待以“strButton.read_wait为等待队列头的等待队列”被唤醒，属于等待队列唤醒；
  //当条件满足atomic_read(&strButton.button_irq_status) !=0时，会执行唤醒，否则会一直阻塞。
  //唤醒后，会将进程设置为"TASK_INTERRUPTIBLE"状态，即进程可以被信号打断。


  ch=10;
  while(ch)//消抖
  {
    mdelay(20);//延时20毫秒消抖
    if(gpio_get_value(strButton.button_gpio_number) == 0) ch=10;
    ch--;
  }
  //mdelay(50);//延时50毫秒消抖

    ch=0;
    if(strButton.keyvalue) ch=1;
    if(ch)//关灯
    {
      strButton.keyvalue=KEY_OFF;//准备中断返回值
      printk("Button: off\r\n");
    }
    else//开灯
    {
      strButton.keyvalue=KEY_ON;//准备中断返回值
      printk("Button: on\r\n");
    }

  status=strButton.keyvalue;//发送中断返回值

  atomic_set(&strButton.button_irq_status, 0);
  /*原子变量初始值strButton.button_irq_status.counter=0, 状态重置 */
  return status;
}

2、添加“EXTI3.h”

#ifndef __EXTI3_H
#define __EXTI3_H

#include <linux/types.h>
/*
数据类型重命名
使能bool,u8,u16,u32,u64, uint8_t, uint16_t, uint32_t, uint64_t
使能s8,s16,s32,s64,int8_t,int16_t,int32_t,int64_t
*/
#include <linux/of.h>   //使能device_node结构
#include <linux/wait.h> //使能wait_queue_head_t结构

#define KEY_ON       1 /* 按键按下 */
#define KEY_OFF      0 /* 按键松开 */

struct Button_dev{
  struct device_node *nd; /*设备节点*/
  int button_gpio_number;   /*Button所使用的GPIO编号*/
  int irq_num; /* 中断号 */

  atomic_t button_irq_status; /*原子变量*/
  wait_queue_head_t read_wait; /* 读等待队列头 */
  int keyvalue;
};
extern struct Button_dev strButton;

extern int Get_gpio_Button_num(void);
extern int Button_gpio_request(void);
extern void Button_free(void);
extern int Read_Button(void);

#endif

3、添加“EXTI3_drv.c”

#include "EXTI3_drv.h"
#include "EXTI3.h"
#include <linux/types.h>
//数据类型重命名
//使能bool,u8,u16,u32,u64, uint8_t, uint16_t, uint32_t, uint64_t
//使能s8,s16,s32,s64,int8_t,int16_t,int32_t,int64_t
#include <linux/ide.h>
//使能copy_from_user(),copy_to_user()
#include <linux/module.h>
//使能EXTI3Driver_init(),EXTI3Driver_exit()
#include <linux/gpio.h>
//使能gpio_request(),gpio_free(),gpio_direction_input(),
//gpio_direction_output(),gpio_get_value(),gpio_set_value()
#include <linux/spinlock.h>
//使能DEFINE_SPINLOCK()，spin_lock_init(),spin_lock(),spin_trylock(),spin_is_locked()
//spin_lock_irq(),spin_unlock_irq(),spin_lock_irqsave(),spin_unlock_irqrestore()

#define EXTI3Driver_CNT    1   //定义设备数量为1
#define EXTI3Driver_NAME  "EXTI3Driver"  //定义设备的名字

struct EXTI3Driver_dev strEXTI3Driver;

/* 打开设备 */
static int EXTI3Driver_open(struct inode *inode, struct file *filp)
{
  /*通过判断原子变量的值来检查EXTI3有没有被别的应用使用*/
  if (!atomic_dec_and_test(&strEXTI3Driver.lock))
  {
    //当strEXTI3Driver.lock.counter=1时，atomic_dec_and_test()返回1
    //从strEXTI3Driver.lock.counter减1，如果结果为0就返回1，否则返回0;
    atomic_inc(&strEXTI3Driver.lock);/*小于0的话就加1,使其原子变量等于0*/
    return -EBUSY; /* EXTI3被使用，返回忙*/
  }

  filp->private_data = &strEXTI3Driver; /*设置私有数据*/

  printk("EXTI3Driver_open!\r\n");
  return 0;
}

/* 从设备读取数据，保存到首地址为buf的数据块中，长度为cnt个字节 */
//file结构指针变量flip表示要打开的设备文件
//buf表示用户数据块的首地址
//cnt表示用户数据的长度，单位为字节
//loff_t结构指针变量offt表示“相对于文件首地址的偏移”
static ssize_t EXTI3Driver_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{
  int ret = 0;
  int value;

  value=Read_Button();//读取按键的值 
  ret = copy_to_user(buf, &value, sizeof(value));
  //将value拷贝到buf[]中

  return ret;
}

/* 向设备写数据，将数据块首地址为buf的数据，长度为cnt个字节，发送给用户 */
//file结构指针变量flip表示要打开的设备文件
//buf表示用户数据块的首地址
//cnt表示用户数据的长度，单位为字节
//loff_t结构指针变量offt表示“相对于文件首地址的偏移”
static ssize_t EXTI3Driver_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
{
  return 0;
}

/* 关闭/释放设备 */
static int EXTI3Driver_release(struct inode *inode, struct file *filp)
{
  struct EXTI3Driver_dev *dev = filp->private_data;

  atomic_inc(&dev->lock);
  /*关闭驱动文件的时候释放原子变量，便于其它线程使用*/

  printk("EXTI3Driver_release!\r\n");
  return 0;
}

/*声明file_operations结构变量MyCharDevice_fops*/
/*它是指向设备的操作函数集合变量*/
const struct file_operations EXTI3Driver_fops = {
  .owner = THIS_MODULE,
  .open = EXTI3Driver_open,
  .read = EXTI3Driver_read,
  .write = EXTI3Driver_write,
  .release = EXTI3Driver_release,
};

/*驱动入口函数 */
static int  __init EXTI3Driver_init(void)
{
  int ret;

  strEXTI3Driver.lock = (atomic_t)ATOMIC_INIT(0);
  /*初始化原子变量*/

  atomic_set(&strEXTI3Driver.lock, 1);
  /*原子变量初始值strEXTI3Driver.lock.counter=1*/

  ret=Get_gpio_Button_num();//读引脚编号
  if(ret < 0) return ret; 

/* 1、申请“gpio编号”*/
  ret=Button_gpio_request();//申请“gpio编号” 
  if(ret < 0) return ret;//向gpio子系统申请使用“gpio编号” 失败

  /*2、申请设备号*/
  strEXTI3Driver.major=0;
  if(strEXTI3Driver.major)/*如果指定了主设备号*/
  {
    strEXTI3Driver.devid = MKDEV(strEXTI3Driver.major, 0);
    //输入参数strEXTI3Driver.major为“主设备号”
    //输入参数0为“次设备号”，大部分驱动次设备号都选择0
    //将strEXTI3Driver.major左移20位，再与0相或，就得到“Linux设备号”
    ret=register_chrdev_region( strEXTI3Driver.devid,\
                       EXTI3Driver_CNT, \
                       EXTI3Driver_NAME );
    //strEXTI3Driver.devid表示起始设备号
    //EXTI3Driver_CNT表示次设备号的数量
    //EXTI3Driver_NAME表示设备名
    if(ret < 0)
      goto free_gpio;
  }
  else
  { /* 没有定义设备号 */
    ret=alloc_chrdev_region( &strEXTI3Driver.devid,\
                     0, \
                     EXTI3Driver_CNT,\
                     EXTI3Driver_NAME);
    /* 申请设备号 */
    //strEXTI3Driver.devid：保存申请到的设备号
    //0：次设备号的起始地址
    //EXTI3Driver_CNT：要申请的次设备号数量；
    //EXTI3Driver_NAME：表示“设备名字”
    if(ret < 0)
      goto free_gpio;

    strEXTI3Driver.major = MAJOR(strEXTI3Driver.devid);
    /* 获取分配号的主设备号 */
    //输入参数strEXTI3Driver.devid为“Linux设备号”
    //将strEXTI3Driver.devid右移20位得到“主设备号”
    strEXTI3Driver.minor = MINOR(strEXTI3Driver.devid);
    /* 获取分配号的次设备号 */
    //输入参数strEXTI3Driver.devid为“Linux设备号”
    //将strEXTI3Driver.devid与0xFFFFF相与后得到“次设备号”
  }

  /*3、注册字符设备*/
  strEXTI3Driver.cdev.owner = THIS_MODULE;
  //使用THIS_MODULE将owner指针指向当前这个模块
  cdev_init(&strEXTI3Driver.cdev,&EXTI3Driver_fops);
  //注册字符设备，初始化“字符设备结构变量strEXTI3Driver.cdev”
  //strEXTI3Driver.cdev是等待初始化的结构体变量
  //EXTI3Driver_fops就是字符设备文件操作函数集合

  /*4、添加字符设备*/
  ret=cdev_add(&strEXTI3Driver.cdev,strEXTI3Driver.devid,EXTI3Driver_CNT);
  //添加字符设备
  /*&strEXTI3Driver.cdev表示指向要添加的字符设备，即字符设备结构strEXTI3Driver.cdev变量*/
  //strEXTI3Driver.devid表示设备号
  //EXTI3Driver_CNT表示需要添加的设备数量
  if(ret < 0 ) //添加字符设备失败
    goto del_register;

  printk("dev id major = %d,minor = %d\r\n", strEXTI3Driver.major, strEXTI3Driver.minor);
  printk("EXTI3Driver_init is ok!!!\r\n");

  /*5、自动创建设备节点 */
  strEXTI3Driver.class =class_create(THIS_MODULE, EXTI3Driver_NAME);
  if (IS_ERR(strEXTI3Driver.class)){
    goto del_cdev;
  }

  /*6、创建设备 */
  strEXTI3Driver.device = device_create(strEXTI3Driver.class, NULL, strEXTI3Driver.devid, NULL, EXTI3Driver_NAME);
  //创建设备
  //设备要创建在strEXTI3Driver.class类下面
  //NULL表示没有父设备
  //strEXTI3Driver.devid是设备号;
  //参数drvdata=NULL，设备没有使用数据
  //EXTI3Driver_NAME是设备名字
  //如果设置fmt=EXTI3Driver_NAME 的话，就会生成/dev/EXTI3Driver_NAME设备文件。
  //返回值就是创建好的设备。
  if (IS_ERR(strEXTI3Driver.device)){
    goto destroy_class;
  }

  return 0;

destroy_class:
  class_destroy(strEXTI3Driver.class);
  //删除类
  //strEXTI3Driver.class就是要删除的类

del_cdev:
   cdev_del(&strEXTI3Driver.cdev);
   //删除字符设备
   //&strEXTI3Driver.cdev表示指向需要删除的字符设备，即字符设备结构strEXTI3Driver.cdev变量

del_register:
  unregister_chrdev_region(strEXTI3Driver.devid, EXTI3Driver_CNT);
  /* 释放设备号 */
  //strEXTI3Driver.devid：需要释放的起始设备号
  //EXTI3Driver_CNT：需要释放的次设备号数量；

free_gpio://申请设备号失败
  /*释放gpio编号*/
  Button_free();

  return -EIO;
}

/*驱动出口函数 */
static void __exit EXTI3Driver_exit(void)
{
  /*1、删除字符设备*/
  cdev_del(&strEXTI3Driver.cdev);
  /*删除字符设备*/
  /*&strEXTI3Driver.cdev表示指向需要删除的字符设备，即字符设备结构&strEXTI3Driver.cdev变量*/

  /*2、 释放设备号 */
  unregister_chrdev_region(strEXTI3Driver.devid, EXTI3Driver_CNT);
  /*释放设备号 */
  //strEXTI3Driver.devid：需要释放的起始设备号
  //EXTI3Driver_CNT：需要释放的次设备号数;

  /*3、 删除设备 */
  device_destroy(strEXTI3Driver.class, strEXTI3Driver.devid);
  //删除创建的设备
  //strEXTI3Driver.class是要删除的设备所处的类
  //strEXTI3Driver.devid是要删除的设备号
  
  /*4、删除类*/
  class_destroy(strEXTI3Driver.class);
  //删除类
  //strEXTI3Driver.class就是要删除的类

  /*5、释放gpio编号*/
  Button_free();
}

module_init(EXTI3Driver_init);
//指定EXTI3Driver_init()为驱动入口函数
module_exit(EXTI3Driver_exit); 
//指定EXTI3Driver_exit()为驱动出口函数

MODULE_AUTHOR("Zhanggong");//添加作者名字
MODULE_LICENSE("GPL");//LICENSE采用“GPL协议”
MODULE_INFO(intree,"Y");
//去除显示“loading out-of-tree module taints kernel.”

4、添加“EXTI3_drv.h”

#ifndef __EXTI3_DRIVER_H
#define __EXTI3_DRIVER_H

#include <linux/types.h>
/*
数据类型重命名
使能bool,u8,u16,u32,u64, uint8_t, uint16_t, uint32_t, uint64_t
使能s8,s16,s32,s64,int8_t,int16_t,int32_t,int64_t
*/
#include <linux/cdev.h> //使能cdev结构
#include <linux/cdev.h> //使能class结构和device结构

struct EXTI3Driver_dev{
  dev_t devid; /*声明32位变量devid用来给保存设备号*/
  int major;   /*主设备号*/
  int minor;   /*次设备号*/
  struct cdev  cdev; /*字符设备结构变量cdev */

  struct class *class;     /*类*/
  struct device *device;  /*设备*/

  atomic_t lock;  /*原子变量*/
};
extern struct EXTI3Driver_dev strEXTI3Driver;

#endif

5、添加“LED.c”

#include "LED.h"
#include <linux/gpio.h>
//使能gpio_request(),gpio_free(),gpio_direction_input(),
//使能gpio_direction_output(),gpio_get_value(),gpio_set_value()
#include <linux/of_gpio.h>
//使能of_gpio_named_count(),of_gpio_count(),of_get_named_gpio()

struct MyLED_dev  strMyLED;

int Get_led0_num(void);
int led_GPIO_request(void);
void MyLED_free(void);
void led_switch(u8 sta);

int Get_led0_num(void)
{
  int ret = 0;
  const char *str;

  /* 设置LED所使用的GPIO */
  /* 1、获取设备节点：strMyLED */
  strMyLED.nd = of_find_node_by_path("/led0");
  //path="/led0，使用“全路径的节点名“在“stm32mp157d-atk.dts“中查找节点“led0”
  //返回值:返回找到的节点，如果为NULL，表示查找失败。
  if(strMyLED.nd == NULL) {
    printk("led0 node not find!\r\n");
    return -EINVAL;
  }

  /* 2.读取status属性 */
  ret = of_property_read_string(strMyLED.nd, "status", &str);
  //在led0节点中，status = "okay";
  //指定的设备节点strMyLED.nd
  //proname="status"，给定要读取的属性名字
  //out_string=str:返回读取到的属性值
  //返回值:0，读取成功，负值，读取失败。
  if(ret < 0) return -EINVAL;
  if (strcmp(str, "okay")) return -EINVAL;
  //strcmp(s1,s2),当s1<s2时，返回值为负数
  //strcmp(s1,s2),当s1>2时，返回值为正数
  //strcmp(s1,s2),当s1=s2时，返回值为0

  /* 3、获取compatible属性值并进行匹配 */
  ret = of_property_read_string(strMyLED.nd, "compatible", &str);
  //在led0节点中，compatible = "zgq,led";
  //指定的设备节点strMyLED.nd
  //proname="compatible"，给定要读取的属性名字
  //out_string=str:返回读取到的属性值
  //返回值:0，读取成功，负值，读取失败。
  if(ret < 0) {
    printk("led0 node: Failed to get compatible property\n"); 
    return -EINVAL;
  }
  if (strcmp(str, "zgq,led")) {
    printk("led0 node: Compatible match failed\n");
    return -EINVAL;
  }

  /* 4、 根据设备树中的"led-gpio"属性，得到LED所使用的LED编号 */
  strMyLED.led_gpio_number = of_get_named_gpio(strMyLED.nd, "led-gpio", 0);
  //在led0节点中，led-gpio = <&gpioi 0 GPIO_ACTIVE_LOW>
  //np=strMyLED.nd,指定的“设备节点”
  //propname="led-gpio"，给定要读取的属性名字
  //Index=0,给定的GPIO索引为0
  //返回值：正值，获取到的GPIO编号；负值，失败。
  if(strMyLED.led_gpio_number < 0) {
    printk("can't get led-gpio");
    return -EINVAL;
  }
  printk("led-gpio num = %d\r\n", strMyLED.led_gpio_number);
  //打印结果为：“led-gpio num = 128“
  //因为GPIO编号是从0开始的，GPIOI端口的序号是8，每个端口有16个IO口，因此GPIOI0的编号为8*16=128

  return 0;
}

int led_GPIO_request(void)
{
  int ret = 0;

  /* 5.向gpio子系统申请使用“gpio编号” */
  ret = gpio_request(strMyLED.led_gpio_number, "LED-GPIO");
  //gpio=strMyLED.led_gpio_number，指定要申请的“gpio编号”
  //Iabel="LED-GPIO"，给这个gpio引脚设置个名字为"LED-GPIO"
  //返回值：0，申请“gpio编号”成功;其他值，申请“gpio编号”失败；
  if (ret) {
    printk(KERN_ERR "strMyLED: Failed to request led-gpio\n");
    return ret;
  }

  /* 6、设置PI0为输出，并且输出高电平，默认关闭LED灯 */
  ret = gpio_direction_output(strMyLED.led_gpio_number, 1);
  //gpio=strMyLED.led_gpio_number,指定的“gpio编号”，这里是128，对应的是GI0引脚
  //value=1，设置引脚输出高电平
  //返回值：0，设置“引脚输出为vakued的值”成功;负值，设置“引脚输出为vakued的值”失败。
  if(ret < 0) {
    printk("can't set gpio!\r\n");
  }

  return 0;
}

//函数功能：释放MyLED的gpio
void MyLED_free(void)
{
  gpio_free(strMyLED.led_gpio_number);
}

void led_switch(u8 sta)
{
	if(sta == LEDON) {
    gpio_set_value(strMyLED.led_gpio_number, 0); /* 打开LED灯 */
	}
else if(sta == LEDOFF) {
    gpio_set_value(strMyLED.led_gpio_number, 1); /* 关闭LED灯 */
	}	
}

6、添加“LED.h”

#ifndef __LED_H
#define __LED_H

#include <linux/types.h>
/*
数据类型重命名
使能bool,u8,u16,u32,u64, uint8_t, uint16_t, uint32_t, uint64_t
使能s8,s16,s32,s64,int8_t,int16_t,int32_t,int64_t
*/
#include <linux/of.h>   //使能device_node结构

#define LEDOFF 	0				/* 关灯 */
#define LEDON 	1				/* 开灯 */

struct MyLED_dev{

  struct device_node *nd; /*设备节点*/
  int led_gpio_number;   /*led所使用的GPIO编号*/
};
extern struct MyLED_dev strMyLED;

extern int Get_led0_num(void);
extern int led_GPIO_request(void);
extern void MyLED_free(void);
extern void led_switch(u8 sta);

#endif

7、添加“LED_drv.c”

#include "LED_drv.h"
#include "LED.h"
#include <linux/types.h>
//数据类型重命名
//使能bool,u8,u16,u32,u64, uint8_t, uint16_t, uint32_t, uint64_t
//使能s8,s16,s32,s64,int8_t,int16_t,int32_t,int64_t
#include <linux/ide.h>
//使能copy_from_user(),copy_to_user()
#include <linux/module.h>
//使能LEDDriver_init(),LEDDriver_exit()
#include <linux/gpio.h>
//使能gpio_request(),gpio_free(),gpio_direction_input(),
//gpio_direction_output(),gpio_get_value(),gpio_set_value()

#define LEDDriver_CNT    1   //定义设备数量为1
#define LEDDriver_NAME  "LEDDriver"  //定义设备的名字

struct LEDDriver_dev strLEDDriver;

/* 打开设备 */
static int LEDDriver_open(struct inode *inode, struct file *filp)
{
  /*通过判断原子变量的值来检查LED有没有被别的应用使用*/
  if (!atomic_dec_and_test(&strLEDDriver.lock))
  {
    //当strLEDDriver.lock.counter=1时，atomic_dec_and_test()返回1
    //从strLEDDriver.lock.counter减1，如果结果为0就返回1，否则返回0;
    atomic_inc(&strLEDDriver.lock);/*小于0的话就加1,使其原子变量等于0*/
    return -EBUSY; /* LED被使用，返回忙*/
  }

  filp->private_data = &strLEDDriver; /*设置私有数据*/
  printk("LEDDriver_open!\r\n");
  return 0;
}

/* 从设备读取数据，保存到首地址为buf的数据块中，长度为cnt个字节 */
//file结构指针变量flip表示要打开的设备文件
//buf表示用户数据块的首地址
//cnt表示用户数据的长度，单位为字节
//loff_t结构指针变量offt表示“相对于文件首地址的偏移”
static ssize_t LEDDriver_read(struct file *filp, char __user *buf, size_t cnt, loff_t *offt)
{
  return 0;
}

/* 向设备写数据，将数据块首地址为buf的数据，长度为cnt个字节，发送给用户 */
//file结构指针变量flip表示要打开的设备文件
//buf表示用户数据块的首地址
//cnt表示用户数据的长度，单位为字节
//loff_t结构指针变量offt表示“相对于文件首地址的偏移”
static ssize_t LEDDriver_write(struct file *filp, const char __user *buf, size_t cnt, loff_t *offt)
{
  int ret = 0;
  unsigned char databuf[1];
  unsigned char ledstat;

  ret = copy_from_user(databuf, buf, cnt);
//将buf[]中的前cnt个字节拷贝到databuf[]中
  if(ret <0){
    printk("kernel write failed!\r\n");
    ret = -EFAULT;
  }

  ledstat = databuf[0];/*获取到应用传递进来的开关灯状态*/
  led_switch(ledstat);/*执行开灯或执行关灯*/

  return ret;
}

/* 关闭/释放设备 */
static int LEDDriver_release(struct inode *inode, struct file *filp)
{
  struct LEDDriver_dev *dev = filp->private_data;

  atomic_inc(&dev->lock);
  /*关闭驱动文件的时候释放原子变量，便于其它线程使用*/
  printk("LEDDriver_release!\r\n");
  return 0;
}

/*声明file_operations结构变量MyCharDevice_fops*/
/*它是指向设备的操作函数集合变量*/
const struct file_operations LEDDriver_fops = {
  .owner = THIS_MODULE,
  .open = LEDDriver_open,
  .read = LEDDriver_read,
  .write = LEDDriver_write,
  .release = LEDDriver_release,
};

/*驱动入口函数 */
static int  __init LEDDriver_init(void)
{
  int ret;

  strLEDDriver.lock = (atomic_t)ATOMIC_INIT(0);
  /*初始化原子变量*/

  atomic_set(&strLEDDriver.lock, 1);
  /*原子变量初始值strLEDDriver.lock.counter=1*/

  ret=Get_led0_num();//读引脚编号
  if(ret < 0) return ret; 

/* 1、申请“gpio编号”*/
  ret=led_GPIO_request();//申请“gpio编号” 
  if(ret < 0) return ret;//向gpio子系统申请使用“gpio编号” 失败

  /*2、申请设备号*/
  strLEDDriver.major=0;
  if(strLEDDriver.major)/*如果指定了主设备号*/
  {
    strLEDDriver.devid = MKDEV(strLEDDriver.major, 0);
    //输入参数strLEDDriver.major为“主设备号”
    //输入参数0为“次设备号”，大部分驱动次设备号都选择0
    //将strLEDDriver.major左移20位，再与0相或，就得到“Linux设备号”
ret=register_chrdev_region( strLEDDriver.devid,\
                       LEDDriver_CNT, \
                       LEDDriver_NAME );
    //strLEDDriver.devid表示起始设备号
    //LEDDriver_CNT表示次设备号的数量
    //LEDDriver_NAME表示设备名
    if(ret < 0)
      goto free_gpio;
  }
  else
  { /* 没有定义设备号 */
ret=alloc_chrdev_region( &strLEDDriver.devid,\
                     0, \
                     LEDDriver_CNT,\
                     LEDDriver_NAME);
    /* 申请设备号 */
    //strLEDDriver.devid：保存申请到的设备号
    //0：次设备号的起始地址
    //LEDDriver_CNT：要申请的次设备号数量；
    //LEDDriver_NAME：表示“设备名字”
    if(ret < 0)
      goto free_gpio;

    strLEDDriver.major = MAJOR(strLEDDriver.devid);
    /* 获取分配号的主设备号 */
    //输入参数strLEDDriver.devid为“Linux设备号”
    //将strLEDDriver.devid右移20位得到“主设备号”
    strLEDDriver.minor = MINOR(strLEDDriver.devid);
    /* 获取分配号的次设备号 */
    //输入参数strLEDDriver.devid为“Linux设备号”
    //将strLEDDriver.devid与0xFFFFF相与后得到“次设备号”
  }

  /*3、注册字符设备*/
  strLEDDriver.cdev.owner = THIS_MODULE;
  //使用THIS_MODULE将owner指针指向当前这个模块
  cdev_init(&strLEDDriver.cdev,&LEDDriver_fops);
  //注册字符设备，初始化“字符设备结构变量strLEDDriver.cdev”
  //strLEDDriver.cdev是等待初始化的结构体变量
  //LEDDriver_fops就是字符设备文件操作函数集合

  /*4、添加字符设备*/
  ret=cdev_add(&strLEDDriver.cdev,strLEDDriver.devid,LEDDriver_CNT);
  //添加字符设备
  /*&strLEDDriver.cdev表示指向要添加的字符设备，即字符设备结构strLEDDriver.cdev变量*/
  //strLEDDriver.devid表示设备号
  //LEDDriver_CNT表示需要添加的设备数量
  if(ret < 0 ) //添加字符设备失败
    goto del_register;

  printk("dev id major = %d,minor = %d\r\n", strLEDDriver.major, strLEDDriver.minor);
  printk("LEDDriver_init is ok!!!\r\n");

  /*5、自动创建设备节点 */
  strLEDDriver.class =class_create(THIS_MODULE, LEDDriver_NAME);
  if (IS_ERR(strLEDDriver.class)){
    goto del_cdev;
  }

  /*6、创建设备 */
  strLEDDriver.device = device_create(strLEDDriver.class, NULL, strLEDDriver.devid, NULL, LEDDriver_NAME);
  //创建设备
  //设备要创建在strLEDDriver.class类下面
  //NULL表示没有父设备
  //strLEDDriver.devid是设备号;
  //参数drvdata=NULL，设备没有使用数据
  //LEDDriver_NAME是设备名字
  //如果设置fmt=LEDDriver_NAME 的话，就会生成/dev/LEDDriver_NAME设备文件。
  //返回值就是创建好的设备。
  if (IS_ERR(strLEDDriver.device)){
    goto destroy_class;
  }

  return 0;

destroy_class:
  class_destroy(strLEDDriver.class);
  //删除类
  //strLEDDriver.class就是要删除的类

del_cdev:
   cdev_del(&strLEDDriver.cdev);
   //删除字符设备
   //&strLEDDriver.cdev表示指向需要删除的字符设备，即字符设备结构strLEDDriver.cdev变量

del_register:
  unregister_chrdev_region(strLEDDriver.devid, LEDDriver_CNT);
  /* 释放设备号 */
  //strLEDDriver.devid：需要释放的起始设备号
  //LEDDriver_CNT：需要释放的次设备号数量；

free_gpio://申请设备号失败
  /*释放gpio编号*/
  MyLED_free();
  return -EIO;
}

/*驱动出口函数 */
static void __exit LEDDriver_exit(void)
{
  /*1、删除字符设备*/
  cdev_del(&strLEDDriver.cdev);
  /*删除字符设备*/
  /*&strLEDDriver.cdev表示指向需要删除的字符设备，即字符设备结构&strLEDDriver.cdev变量*/

  /*2、 释放设备号 */
  unregister_chrdev_region(strLEDDriver.devid, LEDDriver_CNT);
  /*释放设备号 */
  //strLEDDriver.devid：需要释放的起始设备号
  //LEDDriver_CNT：需要释放的次设备号数;

  /*3、 删除设备 */
  device_destroy(strLEDDriver.class, strLEDDriver.devid);
  //删除创建的设备
  //strLEDDriver.class是要删除的设备所处的类
  //strLEDDriver.devid是要删除的设备号
  
  /*4、删除类*/
  class_destroy(strLEDDriver.class);
  //删除类
  //strLEDDriver.class就是要删除的类

  /*5、释放gpio编号*/
  MyLED_free();
}

module_init(LEDDriver_init);
//指定LEDDriver_init()为驱动入口函数
module_exit(LEDDriver_exit); 
//指定LEDDriver_exit()为驱动出口函数

MODULE_AUTHOR("Zhanggong");//添加作者名字
MODULE_LICENSE("GPL");//LICENSE采用“GPL协议”
MODULE_INFO(intree,"Y");
//去除显示“loading out-of-tree module taints kernel.”

8、添加“LED_drv.h”

#ifndef __LED_DRIVER_H
#define __LED_DRIVER_H

#include <linux/types.h>
/*
数据类型重命名
使能bool,u8,u16,u32,u64, uint8_t, uint16_t, uint32_t, uint64_t
使能s8,s16,s32,s64,int8_t,int16_t,int32_t,int64_t
*/
#include <linux/cdev.h>
//使能cdev结构
//使能class结构和device结构

struct LEDDriver_dev{
  dev_t devid; /*声明32位变量devid用来给保存设备号*/
  int major;   /*主设备号*/
  int minor;   /*次设备号*/
  struct cdev  cdev; /*字符设备结构变量cdev */

  struct class *class;     /*类*/
  struct device *device;  /*设备*/

  atomic_t lock;  /*原子变量*/
};
extern struct LEDDriver_dev strLEDDriver;

#endif

9、添加“ButtonLED_APP.c”

#include "stdio.h"
#include "unistd.h"
#include "sys/types.h"
#include "sys/stat.h"
#include "fcntl.h"
#include "stdlib.h"
#include "string.h"

#include <unistd.h>
//Linux系统编程下用到的延时函数
//使能usleep(),sleep()

//#include <delay.h>
//Linux内核中用到的延时函数
//使能ndelay()，udelay()，mdelay()

#define LED_OFF       0 /* 关灯 */
#define LED_ON        1 /* 开灯 */

/*
参数argc: argv[]数组元素个数
参数argv[]:是一个指针数组
返回值: 0 成功;其他 失败
./ButtonLED_APP /dev/EXTI3Driver /dev/LEDDriver
*/
int main(int argc, char *argv[])
{
  int fd_button;
  int fd_led;

  int retvalue;
  int keyvalue;
  int status;

  /* 1. 判断参数 */
  if(argc != 3)
  {
    printf("Error Usage!\r\n");
    return -1;
  }

  //argv[]是指向输入参数“./ButtonLED_APP /dev/EXTI3Driver /dev/LEDDriver”
  /* 2. 打开文件 */
  fd_button = open(argv[1], O_RDONLY);
  //O_RDONLY表示只读模式；
  //如果打开“/dev/EXTI3Driver”文件成功，则fd_button为“文件描述符”,argv[1]="/dev/EXTI3Driver"
  if(fd_button < 0)
  {
    printf("Can't open file %s\r\n", argv[1]);
    return -1;
  }

  fd_led = open(argv[2], O_RDWR);
  //如果打开“/dev/LEDDriver”文件成功，则fd_led为“文件描述符”,argv[2]=“/dev/LEDDriver”
  if(fd_led < 0)
  {
    printf("Can't open file %s\r\n", argv[2]);
    return -1;
  }

  /* 3. 读文件 */
  while(1)
  {
    read(fd_button, &keyvalue, sizeof(keyvalue));
		if (keyvalue == LED_ON)
    {
      //如果按键按下
      printf("KEY0 Press, value = %#X\r\n", keyvalue);/* 按下 */
      status = LED_ON;
      write(fd_led, &status, 1);
      sleep(1);//保证LED亮1妙
    }
    else if (keyvalue == LED_OFF)
    {
      //如果按键松开
      printf("KEY0 Press, value = %#X\r\n", keyvalue);/* 按下 */
      status = LED_OFF;
      write(fd_led, &status, 1);
      //file结构指针变量fd_led表示要打开的设备文件
      //buf=&status表示用户数据块的首地址
      //cnt=1表示用户数据的长度，单位为字节
    }
  }

  /* 关闭设备 */
  retvalue = close(fd_button);
  //fd_button表示要关闭的“文件描述符”
  //返回值等于0表示关闭成功
  //返回值小于0表示关闭失败
  if(retvalue < 0)
  {
    printf("Can't close file %s\r\n", argv[1]);
    return -1;
  }

  retvalue = close(fd_led);
  //fd_led表示要关闭的“文件描述符”
  //返回值等于0表示关闭成功
  //返回值小于0表示关闭失败
  if(retvalue < 0)
  {
    printf("Can't close file %s\r\n", argv[2]);
    return -1;
  }

  return 0;
}

10、添加“Makefile”

#Linux一个Makefile编译多个内核驱动
KERNELDIR := /home/zgq/linux/atk-mp1/linux/my_linux/linux-5.4.31
#使用“:=”将其后面的字符串赋值给KERNELDIR
CURRENT_PATH := $(shell pwd)
#采用“shell pwd”获取当前打开的路径
#使用“$(变量名)”引用“变量的值”
MyAPP := ButtonLED_APP

obj-m := MyButton.o MyLED.o

MyButton-y := EXTI3_drv.o EXTI3.o
MyLED-y := LED_drv.o LED.o

CC := arm-none-linux-gnueabihf-gcc

drv:
	$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) modules

app:
	$(CC)  $(MyAPP).c  -o $(MyAPP)

clean:
	$(MAKE) -C $(KERNELDIR) M=$(CURRENT_PATH) clean
	rm $(MyAPP)

install:
	sudo cp *.ko $(MyAPP) /home/zgq/linux/nfs/rootfs/lib/modules/5.4.31/ -

11、添加“c_cpp_properties.json”

{
    "configurations": [
        {
            "name": "Linux",
            "includePath": [
                "${workspaceFolder}/**",
                "/home/zgq/linux/atk-mp1/linux/my_linux/linux-5.4.31",
                "/home/zgq/linux/Linux_Drivers/IO_Block", 
                "/home/zgq/linux/atk-mp1/linux/my_linux/linux-5.4.31/arch/arm/include",
                "/home/zgq/linux/atk-mp1/linux/my_linux/linux-5.4.31/include",
                "/home/zgq/linux/atk-mp1/linux/my_linux/linux-5.4.31/arch/arm/include/generated"
            ],
            "defines": [],
            "compilerPath": "/usr/bin/gcc",
            "cStandard": "gnu11",
            "cppStandard": "gnu++14",
            "intelliSenseMode": "gcc-x64"
        }
    ],
    "version": 4
}

12、编译

输入“make clean回车”

输入“make drv回车”

输入“make app回车”

输入“make install回车”

输入“ls /home/zgq/linux/nfs/rootfs/lib/modules/5.4.31/ -l回车”查看是存在“ButtonLED_APP,MyButton.ko和MyLED.ko”

13、测试

启动开发板，从网络下载程序

输入“root”

输入“cd /lib/modules/5.4.31/回车”

切换到“/lib/modules/5.4.31/”目录

注意：“lib/modules/5.4.31/”在虚拟机中是位于“/home/zgq/linux/nfs/rootfs/”目录下，但在开发板中，却是位于根目录中。

输入“ls -l”查看“ButtonLED_APP,MyButton.ko和MyLED.ko”是否存在

输入“depmod”,驱动在第一次执行时，需要运行“depmod”

输入“modprobe MyButton.ko”，加载“MyButton.ko”模块

输入“modprobe MyLED.ko”，加载“MyLED.ko”模块

输入“lsmod”查看有哪些驱动在工作

输入“cat /proc/interrupts”，查看中断是否注册；

输入“ls /dev/EXTI3Driver -l回车”，发现节点文件“/dev/EXTI3Driver”

输入“ls /dev/LEDDriver -l回车”，发现节点文件“/dev/LEDDriver”

输入“./ButtonLED_APP /dev/EXTI3Driver /dev/LEDDriver回车”

按下按钮，等待串口输出“KEY0 Press, value = 0X1”，同时LED会亮。