• Linux: IO中断驱动开发教程

    本文章详细介绍了，在Linux内核开发IO中断驱动的流程。主要分为四部分：配置设备树DTS、驱动模块编写、配置Linux内核、应用程序测试。

    1. 配置设备树DTS

    （1）屏蔽原按键设备树IO配置

    打开stm32mp15xx-ya157c.dtsi文件（/arch/arm/boot/dts/stm32mp15xx-ya157c.dtsi），屏蔽如下代码。屏蔽下面的button，是为了方便测试。button按下改成了打印我们的消息。

    图 1. 屏蔽原按键设备树IO配置 

     

    （2）增加外部中断按键配置

    在上一个按键驱动实验的基础上修改即可

    1. gpio_XXXX {
    2. 	compatible = "gpio, XXXX";
    3. 	status = "okay";
    4. 	label = "XXXX_notifier";
    5. 	gpio_XXXX-gpios = <&gpioi 11 (GPIO_ACTIVE_LOW )>;
    6. 	interrupt-parent = <&gpioi>;
    7. 	interrupts = <11 IRQ_TYPE_EDGE_RISING>;
    8. };

    编译和更新DTB文件以后，运行arm板卡，可以发现设备文件，在默认目录下产生。

     2. 驱动模块编写

     

    1. // SPDX-License-Identifier: GPL-2.0-only
    2. /*
    3.  * Driver for XXXX on GPIO line capable of generating interrupt.
    4.  *
    5.  * Copyright 2022 Allen Sun
    6.  */
    7. /*---- Kernel includes ----*/
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13. #include 
    14. #include 
    15. #include 
    16.  
    17. #include 
    18. #include 
    19. #include 
    20. #include 
    21. #include 
    22.  
    23. dev_t dev = 0;
    24. static struct class *dev_class;
    25. static struct cdev cdev;
    26.  
    27. struct gpio_desc *gpio_XXXX;
    28. static int gpio_XXXX_pin_number = 0;
    29. static int gpio_XXXX_irq_number = 0;
    30.  
    31. #define SIGETX 44
    32. static struct task_struct *task = NULL;
    33.  
    34. // application pid, application use ioctl method to set this value
    35. static int app_pid = 0;
    36.  
    37. typedef enum{
    38.         IOCTL_SET_APP_PID = 0x111,
    39. } MODULE_CMD;
    40.  
    41. static int gpio_XXXX_open(struct inode *inode, struct file *file)
    42. {
    43.     printk(KERN_INFO "XXXX_NOTIFIER: gpio_XXXX_open\n");
    44.  
    45.     return 0;
    46. }
    47.  
    48. static ssize_t gpio_XXXX_read(struct file *file, char *userbuf, size_t count, loff_t * ppos)
    49. {
    50.     unsigned char temp = gpio_get_value(gpio_XXXX_pin_number);
    51.  
    52.     if(copy_to_user(userbuf, &temp, 1))
    53.     {
    54.         printk(KERN_ALERT "gpio_XXXX_read copy_to_user failed\n");
    55.         return -EINVAL;
    56.     }
    57.  
    58.     return count;
    59. }
    60.  
    61. static long gpio_XXXX_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
    62. {
    63.     printk(KERN_INFO "gpio_XXXX_ioctl:%s cmd=0x%x,arg=0x%lx\n", __func__, cmd, arg);
    64.  
    65.     if(cmd == IOCTL_SET_APP_PID)
    66.     {
    67.             printk(KERN_INFO "%s, gpio_XXXX_ioctl: owner pid at 0x%lx\n", __func__, arg);
    68.  
    69.             if(copy_from_user(&app_pid, (int *)arg, sizeof(int)))
    70.             {
    71.                 printk(KERN_ALERT "gpio_XXXX_ioctl:copy from user failed\n");
    72.                 return -EFAULT;
    73.             }
    74.  
    75.             printk(KERN_INFO "gpio_XXXX_ioctl: app_pid is %d\n", app_pid);
    76.     }
    77.  
    78.     return 0;
    79. }
    80.  
    81. static struct file_operations gpio_XXXX_fops = {
    82.     .owner = THIS_MODULE,
    83.     .read = gpio_XXXX_read,
    84.     .open = gpio_XXXX_open,
    85.     .unlocked_ioctl = gpio_XXXX_ioctl,
    86.     .compat_ioctl = gpio_XXXX_ioctl,
    87. };
    88.  
    89. // Create the interrupt handler
    90. static irqreturn_t gpio_XXXX_handler(int irq, void * ident)
    91. {
    92.     struct kernel_siginfo info;
    93.  
    94.     if (app_pid == 0)
    95.     {
    96.         printk(KERN_ALERT "XXXX_NOTIFIER: gpio_XXXX_handler not set user pid\n");
    97.         return IRQ_HANDLED;
    98.     }
    99.  
    100.     //Sending signal to app
    101.     memset(&info, 0, sizeof(struct kernel_siginfo));
    102.     info.si_signo = SIGETX;
    103.     info.si_code = 0;
    104.     info.si_int = 1234;
    105.  
    106.     printk(KERN_INFO "gpio_XXXX_handler Interrupt received from GPIO XXXX pin\n");
    107.  
    108.     rcu_read_lock();
    109.     task = pid_task(find_vpid(app_pid), PIDTYPE_PID);
    110.     rcu_read_unlock();
    111.  
    112.     if (task == NULL) {
    113.         printk(KERN_ALERT "XXXX_NOTIFIER: get_current failed\n");
    114.         return -EINVAL;
    115.     }
    116.     else
    117.     {
    118.         printk(KERN_INFO "Sending signal to app\n");
    119.         if(send_sig_info(SIGETX, &info, task) < 0) {
    120.             printk(KERN_ALERT "gpio_XXXX_handler Unable to send signal\n");
    121.         }
    122.     }
    123.  
    124.     return IRQ_HANDLED;
    125. }
    126.  
    127. static const struct of_device_id gpio_XXXX_of_match[] = {
    128. 	// Used to probe, match the DTS file parameter: compatible = "gpio, XXXX";
    129.     { .compatible = "gpio, XXXX", },
    130.     { },
    131. };
    132. MODULE_DEVICE_TABLE(of, gpio_XXXX_of_match);
    133.  
    134. static int gpio_XXXX_probe(struct platform_device *pdev)
    135. {
    136.     // "gpio_XXXX" match the DTS file parameter name: gpio_XXXX-gpios = <&gpioi 11 (GPIO_ACTIVE_LOW )>;
    137.     gpio_XXXX = devm_gpiod_get(&pdev->dev, "gpio_XXXX", GPIOD_ASIS);
    138.  
    139.     if (IS_ERR(gpio_XXXX))
    140.     {
    141.         dev_err(&pdev->dev, "failed to get gpio_XXXX GPIO\n");
    142.         return PTR_ERR(gpio_XXXX);
    143.     }
    144.  
    145.     gpio_XXXX_pin_number = desc_to_gpio(gpio_XXXX);
    146.     gpio_XXXX_irq_number = gpiod_to_irq(gpio_XXXX);
    147.  
    148.     if(alloc_chrdev_region(&dev, 0, 1, "gpio_XXXX_drv") < 0)
    149.     {
    150.         printk(KERN_ALERT "gpio_XXXX_probe alloc_chrdev_region failed\n");
    151.         return -1;
    152.     }
    153.  
    154.     printk(KERN_INFO "XXXX_NOTIFIER Major = %d Minor = %d \n", MAJOR(dev), MINOR(dev));
    155.  
    156.     dev_class = class_create(THIS_MODULE, "gpio_XXXX_chr_class");
    157.  
    158.     if(dev_class == NULL)
    159.     {
    160.         printk(KERN_ALERT "gpio_XXXX_probe class_create failed\n");
    161.         unregister_chrdev_region(dev, 1);
    162.         return -1;
    163.     }
    164.  
    165.     if(device_create(dev_class, NULL, dev, NULL, "gpio_XXXX_chr_device") == NULL)
    166.     {
    167.         printk(KERN_ALERT "gpio_XXXX_probe device_create failed\n");
    168.         class_destroy(dev_class);
    169.         unregister_chrdev_region(dev, 1);
    170.         return -1;
    171.     }
    172.  
    173.     cdev_init(&cdev, &gpio_XXXX_fops);
    174.  
    175.     if(cdev_add(&cdev, dev, 1) < 0)
    176.     {
    177.         printk(KERN_ALERT "gpio_XXXX_probe cdev_add failed\n");
    178.         device_destroy(dev_class, dev);
    179.         class_destroy(dev_class);
    180.         unregister_chrdev_region(dev, 1);
    181.         return -1;
    182.     }
    183.  
    184.     if(request_irq(gpio_XXXX_irq_number, gpio_XXXX_handler, IRQF_TRIGGER_RISING, "gpio_XXXX", NULL) != 0)
    185.     {
    186.         printk(KERN_INFO "could not request irq: %d\n", gpio_XXXX_irq_number);
    187.         gpio_free(gpio_XXXX_pin_number);
    188.  
    189.         return -1;
    190.     }
    191.  
    192.     printk(KERN_INFO "Waiting for interrupts ... \n");
    193.  
    194.     return 0;
    195. }
    196.  
    197. static void gpio_XXXX_shutdown(struct platform_device *pdev)
    198. {
    199.     free_irq(gpio_XXXX_irq_number, THIS_MODULE->name);
    200.     gpio_free(gpio_XXXX_pin_number);
    201. }
    202.  
    203. static struct platform_driver gpio_XXXX_device_driver = {
    204.     .probe      = gpio_XXXX_probe,
    205.     .shutdown   = gpio_XXXX_shutdown,
    206.     .driver     = {
    207.         .name   = "XXXX_notifier",
    208.         .of_match_table = gpio_XXXX_of_match,
    209.     }
    210. };
    211.  
    212. static int __init gpio_XXXX_init (void)
    213. {
    214.     printk("XXXX_NOTIFIER: gpio_XXXX_init \n");
    215.     return platform_driver_register(&gpio_XXXX_device_driver);
    216. }
    217.  
    218. static void __exit gpio_XXXX_exit(void)
    219. {
    220.     platform_driver_unregister(&gpio_XXXX_device_driver);
    221. }
    222.  
    223. module_init(gpio_XXXX_init);
    224. module_exit(gpio_XXXX_exit);
    225.  
    226. MODULE_AUTHOR("Allen Sun");
    227. MODULE_DESCRIPTION("GPIO interrupt test module for embedded Linux");
    228. MODULE_LICENSE("GPL");
    229.  
    230. /*
    231.  * End of file
    232.  */

     Kconfig

    1. # SPDX-License-Identifier: GPL-2.0-only
    2. #
    3. # Input core configuration
    4. #
    5. menuconfig INPUT_XXXX_NOTIFIER
    6. 	bool "XXXXNotifier"
    7. 	default y
    8. 	help
    9. 	  Say Y here, and a list of supported IpccNotifier will be displayed.
    10. 	  This option doesn't affect the kernel.
    12. 	  If unsure, say Y.
    14. if INPUT_XXXX_NOTIFIER
    16. config XXXX_NOTIFIER_GPIO
    17. 	tristate "XXXX NOTIFIER GPIO"
    18. 	depends on GPIOLIB
    19. 	default m
    20. 	help
    21. 	  This driver implements support for XXXX connected
    22. 	  to GPIO pins of various CPUs (and some other chips).
    24. 	  Say Y here if your device has XXXX connected
    25. 	  directly to such GPIO pins.  Your board-specific
    26. 	  setup logic must also provide a platform device,
    27. 	  with configuration data saying which GPIOs are used.
    29. 	  To compile this driver as a module, choose M here: the
    30. 	  module will be called xxxx_notifier.
    32. endif

     Makefile

    1. # SPDX-License-Identifier: GPL-2.0
    2. #
    3. # Makefile for the input core drivers.
    4. #
    5.  
    6. # Each configuration option enables a list of files.
    7.  
    8. obj-$(CONFIG_XXXX_NOTIFIER_GPIO)		+= xxxx_notifier.o

    3. 配置Linux内核

     make menuconfig：设置编译为模块。M：生成.ko Y：编译进内核，不生成.ko文件

     将编译好的驱动文件和内核拷贝到arm开发板上面。重启运行，会看到/dev目录下面有对应的设备节点产生。

     4. 应用程序测试

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12. #include 
    13.  
    14. #define SIGETX 44
    15. int check = 0;
    16.  
    17. typedef enum{
    18.         IOCTL_SET_APP_PID = 0x111,
    19. } APP_CMD;
    20.  
    21. void sig_event_handler(int n, siginfo_t *info, void *unused)
    22. {
    23.     printf ("sig_event_handler Received signal from kernel");
    24.  
    25.     if (n == SIGETX) {
    26.         check = info->si_int;
    27.         printf ("Received signal from kernel : Value =  %u\n", check);
    28.     }
    29. }
    30.  
    31. int main(int argc, char **argv)
    32. {
    33. 	int fd = -1;
    34. 	int count = 1;
    35. 	int app_pid;
    36. 	unsigned char pin_level;
    37. 	struct sigaction act;
    38.  
    39. 	/* install custom signal handler */
    40. 	sigemptyset(&act.sa_mask);
    41. 	act.sa_flags = SA_NODEFER;
    42. 	act.sa_sigaction = sig_event_handler;
    43. 	sigaction(SIGETX, &act, NULL);
    44.  
    45. 	printf("Installed signal handler for SIGETX = %d\n", SIGETX);
    46.  
    47. 	fd = open("/dev/gpio_XXXX_chr_device", O_RDWR);
    48.  
    49. 	if (fd == -1) 
    50. 	{
    51. 		perror("XXXX GPIO Open\n");
    52. 		return -1;
    53. 	}
    54.  
    55. 	count = read(fd, &pin_level, 1);
    56. 	
    57. 	if(count == -1)
    58. 	{
    59. 		perror("XXXX GPIO read\n");
    60. 	}
    61. 	else
    62. 	{
    63. 		printf("XXXX GPIO level is %d\n", pin_level);
    64. 	}
    65.  
    66. 	app_pid = getpid();
    67. 	ioctl(fd, IOCTL_SET_APP_PID, &app_pid);
    68.  
    69. 	while(1)
    70. 	{
    71. 		printf("XXXX notifier heartbeat..\n");
    72. 		sleep(10);
    73. 	}
    74.  
    75. 	if (close(fd) == -1)
    76. 	{
    77. 		perror("Failed to close GPIO character device file");
    78. 		return -1;		
    79. 	}
    80.  
    81. 	return 0;
    82. }

    测试结果：按下用户按钮，app对应的中断处理函数就会执行。

  • 相关阅读:
    教你一文解决 js 数字精度丢失问题
    Struts2+Maven+表单标签向MySql表插入数据实现简单注册
    ThreadLocal源码解析学习
    【C++】模板(初级)
    SpringBoot解决跨域问题的六种方式
    5G工业互联网的“下半场”该拼什么？
    JS操作字符串方法学习系列（5）-每天学习10个方法
    Android 10.0 系统设置蓝牙配对时去掉配对框实现直接配对功能
    设备指纹之安全性详解
    基于ISO14229协议的单帧以及多帧Can发送代码
  • 原文地址：https://blog.csdn.net/xikangsoon/article/details/126260217