字元裝置驅動(七)按鍵非同步通知
阿新 • • 發佈：2018-11-25
目錄
title: 字元裝置驅動(七)按鍵非同步通知
tags: linux
date: 2018-11-24 16:39:47
toc: true
---
按鍵驅動方式對比
- 查詢:耗資源
- 中斷: 沒有超時機制，當沒有中斷作為生產者，read函式一直休眠
- poll機制，加入超時機制
- 上述三種都是app主動去獲取按鍵，使用非同步通知的形式可以使按鍵發生後，通知app去讀取
程序間發訊號
以前使用kill -9 pid實際也就是傳送訊號給程序，訊號9為關閉程序.我們使用 man signal檢視需要標頭檔案 #include <signal.h>測試程式如下如果用在gcc下編譯需要為sleep函式新增標頭檔案#include <unistd.h>
NAME signal - ANSI C signal handling SYNOPSIS #include <signal.h> typedef void (*sighandler_t)(int); sighandler_t signal(int signum, sighandler_t handler);
例項函式如下arm-linux-gcc -o test test.c
#include <stdio.h> #include <signal.h> #include <unistd.h> //typedef void (*sighandler_t)(int); void my_signal_fun(int signum) { static int cnt=0; printf("signum=%d ,%d times\n",signum,++cnt ); } int main(int argc, char const *argv[]) { signal(SIGUSR1,my_signal_fun); while(1) { sleep(100); } return 0; }
測試使用kill -USR1 pid後會列印訊號
[email protected]:~/stu/dri/code/10th$ ./test &
[3] 4356
[email protected]:~/stu/dri/code/10th$ kill -USR1 4356
signum=10 ,1 times
[email protected]:~/stu/dri/code/10th$ kill -10 4356
signum=10 ,2 times目標
驅動程式使用訊號通知應用程式去讀取按鍵
如何讓驅動通知應用
- 應用程式註冊訊號處理函式
- 驅動程式發訊號
- 訊號被髮給應用程式,應用程式需要告訴自己的pid給驅動程式
- 驅動程式 呼叫
void kill_fasync(struct fasync_struct **fp, int sig, int band)發訊號
程式編寫
驅動程式
搜尋下發送訊號的函式kill_fasync，尋找一個字元裝置是怎麼使用的，在drivers/char/rtc.c中有如下呼叫
kill_fasync (&rtc_async_queue, SIGIO, POLL_IN);
//結構體定義如下:
static struct fasync_struct *rtc_async_queue;
struct fasync_struct {
int magic;
int fa_fd;
struct fasync_struct *fa_next; /* singly linked list */
struct file *fa_file;
};訊號的接受者被定義在fasync_struct中，搜尋下其初始化函式，發現函式rtc_fasync被呼叫如下形式，也就是類似於open、close的形式了
static const struct file_operations rtc_fops = {
.owner = THIS_MODULE,
.llseek = no_llseek,
.read = rtc_read,
#ifdef RTC_IRQ
.poll = rtc_poll,
#endif
.ioctl = rtc_ioctl,
.open = rtc_open,
.release = rtc_release,
.fasync = rtc_fasync,
};函式的原型如下，這個函式用來初始化結構體，應用程式會最終呼叫他告知驅動應該訊號給哪個pid
static int rtc_fasync (int fd, struct file *filp, int on)
{
return fasync_helper (fd, filp, on, &rtc_async_queue);
}也就是是說應用程式通過fasync來呼叫驅動具體的rtc_fasync，這個函式會設定fasync_struct這個結構體，這個結構體會被當做驅動傳送訊號函式的引數，也就是說應用程式告訴驅動程式其目標
步驟如下
定義一個
fasync_struct結構體，在中斷中使用傳送訊號定義一個供app函式呼叫的
.fasyncstatic int drv_fasync (int fd, struct file *filp, int on) { printk("driver: drv_fasync\n"); return fasync_helper (fd, filp, on, &drv_async_queue); }
應用程式
設定哪個程序將接受到來自
fd的SIGIO訊號，如何獲取自身程式的pidman pid SYNOPSIS #include <sys/types.h> #include <unistd.h> pid_t getpid(void); pid_t getppid(void);獲取當前的標誌，新增
FASYNC機制
• 複製一個現存的描述符(cmd=F_DUPFD) 。
• 獲得/設定檔案描述符標記(cmd=F_GETFD或F_SETFD) 。
• 獲得/設定檔案狀態標誌(cmd=F_GETFL或F_SETFL) 。
• 獲得/設定非同步I/O有權(cmd=F_GETOWN或F_SETOWN) 。
• 獲得/設定記錄鎖(cmd=F_GETLK,F_SETLK或F_SETLKW)。程式
fcntl(fd, F_SETOWN, getpid()); //告知訊號傳送給哪個程序，
Oflags = fcntl(fd, F_GETFL); //獲取當前的檔案狀態
fcntl(fd, F_SETFL, Oflags | FASYNC); // 改變fasync標記，
//最終會呼叫到驅動的faync > fasync_helper
//初始化/釋放fasync_struct
//這個會觸發驅動函式的fasync完整程式碼如下
驅動
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/irq.h>
#include <asm/uaccess.h>
#include <asm/irq.h>
#include <asm/io.h>
#include <asm/arch/regs-gpio.h>
#include <asm/hardware.h>
#include <linux/poll.h>
//#include <linux/interrupt.h>
volatile unsigned long *gpfcon;
volatile unsigned long *gpfdat;
volatile unsigned long *gpgcon;
volatile unsigned long *gpgdat;
static struct class *drv_class;
static struct class_device *drv_class_dev;
// 定義一個名為`button_waitq`的佇列
static DECLARE_WAIT_QUEUE_HEAD(button_waitq);
// flag=1 means irq happened and need to update
int flag=0;
static struct fasync_struct *drv_async_queue;
struct pin_desc{
unsigned int pin;
unsigned int key_val;
};
/* 鍵值: 按下時, 0x01, 0x02, 0x03, 0x04 */
/* 鍵值: 鬆開時, 0x81, 0x82, 0x83, 0x84 */
static unsigned char key_val;
struct pin_desc pins_desc[4] = {
{S3C2410_GPF0, 0x01},
{S3C2410_GPF2, 0x02},
{S3C2410_GPG3, 0x03},
{S3C2410_GPG11, 0x04},
};
static irqreturn_t buttons_irq(int irq, void *dev_id)
{
printk("irq%d\r\n",irq);
struct pin_desc * pindesc = (struct pin_desc *)dev_id;
unsigned int pinval;
pinval = s3c2410_gpio_getpin(pindesc->pin);
if (pinval)
{
/* 鬆開 */
key_val = 0x80 | pindesc->key_val;
}
else
{
/* 按下 */
key_val = pindesc->key_val;
}
//wake_up_interruptible(&button_waitq); /* 喚醒休眠的程序 */
flag=1;
kill_fasync (&drv_async_queue, SIGIO, POLL_IN);
return IRQ_RETVAL(IRQ_HANDLED);
}
static unsigned drv_poll(struct file *file, poll_table *wait)
{
unsigned int mask = 0;
poll_wait(file, &button_waitq, wait); // 不會立即休眠
if (flag)
mask |= POLLIN | POLLRDNORM;
return mask;
}
static int drv_open(struct inode *inode, struct file *file)
{
/* 配置GPF0,2為輸入引腳 */
/* 配置GPG3,11為輸入引腳 */
request_irq(IRQ_EINT0, buttons_irq, IRQT_BOTHEDGE, "S2", &pins_desc[0]);
request_irq(IRQ_EINT2, buttons_irq, IRQT_BOTHEDGE, "S3", &pins_desc[1]);
request_irq(IRQ_EINT11, buttons_irq, IRQT_BOTHEDGE, "S4", &pins_desc[2]);
request_irq(IRQ_EINT19, buttons_irq, IRQT_BOTHEDGE, "S5", &pins_desc[3]);
return 0;
}
int drv_close(struct inode *inode, struct file *file)
{
free_irq(IRQ_EINT0, &pins_desc[0]);
free_irq(IRQ_EINT2, &pins_desc[1]);
free_irq(IRQ_EINT11,&pins_desc[2]);
free_irq(IRQ_EINT19,&pins_desc[3]);
return 0;
}
static ssize_t drv_write(struct file *file, const char __user *buf, size_t count, loff_t * ppos)
{
//int minor = MINOR(file->f_dentry->d_inode->i_rdev);
//printk("drv_write=%d\n",minor);
return 0;
}
static ssize_t drv_read(struct file *file, char __user *buf, size_t size, loff_t *ppos)
{
if (size != 1)
return -EINVAL;
/* 如果沒有按鍵動作, 休眠 */
//wait_event_interruptible(button_waitq, flag);
/* 如果有按鍵動作, 返回鍵值 */
copy_to_user(buf, &key_val, 1);
flag = 0;
return 1;
}
static int drv_fasync (int fd, struct file *filp, int on)
{
printk("driver: drv_fasync\n");
return fasync_helper (fd, filp, on, &drv_async_queue);
}
static struct file_operations drv_fops = {
.owner = THIS_MODULE, /* 這是一個巨集，推向編譯模組時自動建立的__this_module變數 */
.open = drv_open,
.write = drv_write,
.read = drv_read,
.release = drv_close,
.poll = drv_poll,
.fasync = drv_fasync,
};
static int major;
static int drv_init(void)
{
int minor=0;
major=register_chrdev(0, "drv", &drv_fops); // 註冊, 告訴核心
drv_class = class_create(THIS_MODULE, "drv");
drv_class_dev = class_device_create(drv_class, NULL, MKDEV(major, 0), NULL, "xyz%d", minor);
gpfcon = (volatile unsigned long *)ioremap(0x56000050, 16);
gpfdat = gpfcon + 1;
gpgcon = (volatile unsigned long *)ioremap(0x56000060, 16);
gpgdat = gpgcon + 1;
return 0;
}
static void drv_exit(void)
{
unregister_chrdev(major, "drv"); // 解除安裝
class_device_unregister(drv_class_dev);
class_destroy(drv_class);
iounmap(gpfcon);
iounmap(gpgcon);
}
module_init(drv_init);
module_exit(drv_exit);
MODULE_AUTHOR("xxx");
MODULE_VERSION("0.1.0");
MODULE_DESCRIPTION("S3C2410/S3C2440 LED Driver");
MODULE_LICENSE("GPL");
App
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#include <poll.h>
#include <signal.h>
#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>
int fd;
void my_signal_fun(int signum)
{
unsigned char key_val;
read(fd, &key_val, 1);
printf("key_val: 0x%x\n", key_val);
}
int main(int argc, char **argv)
{
unsigned char key_val;
int ret;
int Oflags;
signal(SIGIO, my_signal_fun);
fd = open("/dev/xyz0", O_RDWR);
if (fd < 0)
{
printf("can't open!\n");
}
fcntl(fd, F_SETOWN, getpid());
Oflags = fcntl(fd, F_GETFL);
fcntl(fd, F_SETFL, Oflags | FASYNC);
while (1)
{
sleep(1000);
}
return 0;
}測試
可以發現開啟檔案的時候會有提示driver: drv_fasync，說明App會主動呼叫.fasync
# insmod dri.ko
# 後臺執行
# ./test &
# driver: drv_fasync
#實際休眠狀態的
# ps
PID Uid VSZ Stat Command
798 0 1308 S ./test
....
# 按鍵按下正常列印
# irq55
key_val: 0x3
irq55
key_val: 0x83
irq18