手把手带你写一个中断输入设备驱动

[导读] 大家好，我是逸珺。

首先说声抱歉，最近迷上钓鱼了，有时候晚上出去夜钓大板鲫了，停更了一段时间。来几张鱼获图片：

技术还是不太到家，遇到几次大鲤鱼都给溜了，心有不甘，所以最近花了比较多的时间。

言归正传，今天来分享一下以前写一个中断输入设备驱动案例，希望对有需要的朋友能有所帮助。

背景介绍

在一个项目中，有这样一个需求：

主控芯片采用ZYNQ，需要采集外部一个脉冲编码输入信号，这个信号是一个脉冲波形，脉冲数量代表测量结果。比如这有可能是一个电机的霍尔信号输出，代表电机的转速，也有可能是一个光栅编码器的脉冲输出，是什么并不重要。

这个电路本身，利用光耦实现了输入测设备信号与采集端的电气隔离。由于PS端该Bank的电平为3.3V，所以光耦的另一侧也是3.3V。

ZYNQ的PS端运行Linux程序，所以在这个场景下，要从应用程序的角度将外部输入信号用起来，就需要实现这样一个设备驱动程序：

创建设备

在ZYNQ下，使用petalinux工具链，当然本文中对于写这个驱动程序本身换成其他的处理器从代码的角度是类似的。

1.先运行一下工具链环境变量脚本：

source /opt/pkg/petalinux/settings.sh

当然也可以不用手动这样运行，设置成linux开发主机开机自动运行，这里就不赘述怎么设置了，网上很多介绍。

2.创建设备

petalinux-create -t modules --name di-drv

这样在现有的工程下，就自动创建设备文件：

./project-spec/meta-user/recipes-modules/di-drv/files/di-drv.c

修改设备树

./project-spec/meta-user/recipes-bsp/device-tree/files/system-user.dtsi 

中添加

/include/ "system-conf.dtsi"
/ {   
  amba {
     pinctrl_di_default: di-default {   
       mux {   
         groups = "gpio0_0_grp";   
         function = "gpio0";   
       };   
 
       conf {   
          pins = "MIO0";   
          io-standard = <1>;   
          bias-high-impedance;   
          slew-rate = <0>;   
       };   
    };           
  };
 
  di {
    compatible = "di-drv";
    pinctrl-names = "default";
    pinctrl-0 = <&pinctrl_di_default>;
    di-gpios = <&gpio0 0 0>;   
  };      
};

本文中，假定使用的IO引脚为PS_MIO0。

驱动代码

修改上面生成的代码di-drv.c

#include <linux/module.h>  
#include <linux/kernel.h>
#include <linux/init.h>  
#include <linux/ide.h>  
#include <linux/types.h>  
#include <linux/errno.h>
#include <linux/cdev.h>
#include <linux/of.h>
#include <linux/of_address.h>
#include <linux/of_gpio.h>
#include <linux/device.h>
#include <linux/delay.h>
#include <linux/init.h>
#include <linux/gpio.h>
#include <linux/semaphore.h>
#include <linux/timer.h>
#include <linux/of_irq.h>
#include <linux/irq.h>
#include <asm/uaccess.h>
#include <asm/mach/map.h>
#include <asm/io.h>
  
/* 设备节点名称 */  
#define DEVICE_NAME       "di-drv"
/* 设备号个数 */  
#define DEVID_COUNT       1
/* 驱动个数 */  
#define DRIVE_COUNT       1
/* 主设备号 */
#define MAJOR_U
/* 次设备号 */
#define MINOR_U           0
 
struct di_dev {
  /* 字符设备框架 */
  dev_t         devid; //设备号
  struct cdev     cdev;  //字符设备
  struct class    *class;  //类
  struct device    *device; //设备
  struct device_node *nd;   //设备树的设备节点
 
  spinlock_t      lock; //自旋锁变量
 
  int          di_gpio; //DI gpio号
  __u32         di_pulses;//DI counter    
  unsigned int     di_irq; //DI 中断号
};
 
static struct di_dev di_char = {
  .cdev = {
    .owner = THIS_MODULE,
  },
};
 
/* 中断服务函数 */
static irqreturn_t di_handler(int irq, void *dev)
{
  di_char.di_pulses++;
  return IRQ_RETVAL(IRQ_HANDLED);
}
 
/* open函数实现, 对应到Linux系统调用函数的open函数 */  
static int di_drv_open(struct inode *inode_p, struct file *file_p)  
{  
  printk("di_drv module opened\n");  
  file_p->private_data = &di_char; 
  return 0;  
}  
    
/* read函数实现, 对应到Linux系统调用函数的read操作 */  
static ssize_t di_drv_read(struct file *file_p, char __user *buf, size_t len, loff_t *loff_t_p)  
{  
  unsigned long flags;
  int ret;
  union e_int_conv{
  __u8  buf[8];
  __u32 di_raw;
 };  
 
  /* 获取锁 */
  spin_lock_irqsave(&di_char.lock, flags);
  
  union e_int_conv di;
  di.di_raw.di = di_char.di_pulses;
  ret  = copy_to_user(buf, di.buf, 8);
    
  /* 释放锁 */
  spin_unlock_irqrestore(&di_char.lock, flags);
  
  return ret ? ret : 4;
}  
  
/* release函数实现, 对应到Linux系统调用函数的close函数 */  
static int di_drv_release(struct inode *inode_p, struct file *file_p)  
{  
  printk("di_drv module release\n");
  return 0;  
}  
      
/* file_operations结构体声明 */  
static struct file_operations di_fops = {  
  .owner   = THIS_MODULE,  
  .open   = di_drv_open,  
  .read   = di_drv_read,     
  .release = di_drv_release,   
};  
  
/* 模块加载时会调用的函数 */  
static int __init di_drv_init(void)  
{
  u32 ret = 0;
    
  /* 初始化自旋锁 */
  spin_lock_init(&di_char.lock);
    
  /** gpio框架 **/   
  /* 获取设备节点 */
  di_char.nd = of_find_node_by_path("/di");
  if(di_char.nd == NULL)
  {
    printk("di node not foundr\r\n");
    return -EINVAL;
  }
    
  /* 获取节点中gpio标号 */
  di_char.di_gpio = of_get_named_gpio(di_char.nd, "di-gpios", 0);
  if(di_char.di_gpio < 0)
  {
    printk("Failed to get di-gpios from device tree\r\n");
    return -EINVAL;
  }
  printk("di-gpio num = %d\r\n", di_char.di_gpio);
 
  /* 申请gpio标号对应的引脚 */
  ret = gpio_request(di_char.di_gpio, "di-drv");
  if(ret != 0)
  {
    printk("Failed to request di_gpio\r\n");
    return -EINVAL;
  }
 
  /* 把这个io设置为输入 */
  ret = gpio_direction_input(di_char.di_gpio);
  if(ret < 0)
  {
    printk("Failed to set di_gpio as input\r\n");
    return -EINVAL;
  }
 
  /* 获取中断号 */
  di_char.di_irq = gpio_to_irq(di_char.di_gpio);
  printk("di_irq number is %d \r\n", di_char.di_irq);
  /* 申请中断 */
  ret = request_irq(di_char.di_irq,
             di_handler,
             IRQF_TRIGGER_FALLING | IRQF_TRIGGER_RISING,
             "di-drv", 
             NULL);
  if(ret < 0)
  {
     printk("di_irq %d request failed\r\n", di_char.di_irq);
     return -EFAULT;
  }    
 
  /* 注册设备号 */
  alloc_chrdev_region(&di_char.devid, MINOR_U, DEVID_COUNT, DEVICE_NAME);
    
  /* 初始化字符设备结构体 */
  cdev_init(&di_char.cdev, &di_fops);
    
  /* 注册字符设备 */
  cdev_add(&di_char.cdev, di_char.devid, DRIVE_COUNT);
    
  /* 创建类 */
  di_char.class = class_create(THIS_MODULE, DEVICE_NAME);
  if(IS_ERR(di_char.class)) 
  {
     return PTR_ERR(di_char.class);
  }
    
  /* 创建设备节点 */
  di_char.device = device_create( di_char.class, NULL, 
                    di_char.devid, NULL, 
                    DEVICE_NAME );
  if(IS_ERR(di_char.device)) 
  {
     return PTR_ERR(di_char.device);
  }
 
  di_char.di_pulses = 0;    
  return 0;  
}
 
/* 卸载模块 */  
static void __exit di_drv_exit(void)  
{  
  /* 释放gpio */
  gpio_free(di_char.di_gpio);
 
  /* 释放中断 */
  free_irq(di_char.di_irq, NULL);
 
  /* 注销字符设备 */
  cdev_del(&di_char.cdev);
    
  /* 注销设备号 */
  unregister_chrdev_region(di_char.devid, DEVID_COUNT);
    
  /* 删除设备节点 */
  device_destroy(di_char.class, di_char.devid);
    
  /* 删除类 */
  class_destroy(di_char.class);
    
  printk("DI dev exit ok\n");  
}  
  
/* 标记加载、卸载函数 */  
module_init(di_drv_init);  
module_exit(di_drv_exit);  
  
/* 驱动描述信息 */  
MODULE_AUTHOR("Embinn");  
MODULE_ALIAS("DI input");  
MODULE_DESCRIPTION("DIGITAL INPUT driver");  
MODULE_VERSION("v1.0");  
MODULE_LICENSE("GPL");

这是一个字符驱动的实现，在真实项目中，大部分驱动基本已经被芯片厂商给实现了，但是一些特殊项目的自定义需求，往往就需要去实现自己的驱动。

编译部署

运行以下命令：

petalinux-config -c rootfs

进入modules，使能刚刚创建的模块，退出保存。

运行下面的命令进行编译：

petalinux-build

最终在工程目录下，搜索di-drv.ko，就得到这个驱动的内核模块文件了，拷贝到目标板的某个文件夹下，运行下面的命令装载就完成了：

insmod di-drv.ko

这样在/dev下就会发现新增一个di-drv设备。

当然也可以直接将该驱动放进内核里，这就需要在内核代码树里，添加文件了，这个思路之前有分享过。

总结一下

字符设备是做驱动开发比较容易掌握的驱动类型，也是大多数项目中，需要自己动手写的最多的驱动类型。所以还是应该掌握它。才能实现不同的项目需求。至于用户空间怎么访问这个设备，这里就不赘述了，一个文件打开操作，再来一个读取操作就完事了。

—— The End ——

推荐阅读  点击蓝色字体即可跳转

☞ Linux驱动：手把手教hello world驱动配置、编译进内核或为模块

☞ 步进电机调速，S曲线调速算法

☞ 图文详解Modbus-RTU协议

☞ RS-485总线，这篇很详细

欢迎转发、留言、点赞、分享，感谢您的支持！