韦东山2440-学习笔记-字符设备驱动

button字符驱动

#include <linux/module.h>
#include <linux/spinlock.h>
#include <asm/atomic.h>
#include <linux/poll.h>
#include <linux/interrupt.h>
#include <linux/device.h>
#include <linux/cdev.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>

#define DEVICE_NAME "button"

static void button_timeout(unsigned long data);

dev_t dev;
struct cdev *cdev;
struct class *button_class;

static wait_queue_head_t button_press_wait;
static int button_press;
static unsigned int g_value;

static struct fasync_struct *button_async_queue;

static struct timer_list button_timer = TIMER_INITIALIZER(button_timeout, 0, 0); /* 用于消除按键抖动 */

// 定义原子变量，实现只能一个进程打开
static atomic_t can_open = ATOMIC_INIT(1);

struct button_desc {
        unsigned int pin;
        unsigned int val;
        unsigned int irq;
};
static struct button_desc button_desc_arr[3] = {
        { .pin = S3C2410_GPF0, .val = 0x01, .irq = IRQ_EINT0 },
        { .pin = S3C2410_GPF2, .val = 0x02, .irq = IRQ_EINT2 },
        { .pin = S3C2410_GPG3, .val = 0x03, .irq = IRQ_EINT11 },
};

static void
button_timeout(unsigned long data)
{
        int up;
        struct button_desc *bd = (struct button_desc *)data;

        // 从系统删除timer
        del_timer(&button_timer);
        button_timer.data = 0; // 重置

        g_value = bd->val;

        up = s3c2410_gpio_getpin(bd->pin);
        if (up)
                g_value |= 0x80;

        /* 唤醒button_press_wait 上的进程 */
        button_press = 1;
        wake_up_interruptible(&button_press_wait);

        /* 异步通知进程 */
        kill_fasync(&button_async_queue, SIGIO, POLL_IN);
}

static irqreturn_t
buttons_irq_handler(int irq, void *dev_id)
{
        if (button_timer.data != 0) // 避免多次中断导致重复添加定时器
                return IRQ_HANDLED;

        // 设置定时器，延迟读取按键
        button_timer.expires = jiffies + msecs_to_jiffies(100); // 100ms 后读取按键
        button_timer.data = (unsigned long)dev_id;
        mod_timer(&button_timer, button_timer.expires); // 将timer加入系统时间堆

        return IRQ_HANDLED;
}

static int
button_fasync(int fd, struct file *file, int on)
{
        return fasync_helper(fd, file, on, &button_async_queue);
}

static int
button_open (struct inode *inode, struct file *fp)
{
        unsigned int i;

        if (!atomic_dec_and_test(&can_open)) {
                atomic_inc(&can_open);
                return -EBUSY;
        }

        /* 设置gpio为中断模式 */
        s3c2410_gpio_cfgpin(S3C2410_GPF2, S3C2410_GPF2_EINT2);
        s3c2410_gpio_cfgpin(S3C2410_GPF0, S3C2410_GPF0_EINT0);
        s3c2410_gpio_cfgpin(S3C2410_GPG3, S3C2410_GPG3_EINT11);

        /* 注册中断, IRQT_BOTHEDGE : 双边缘触发 */
        for (i = 0; i < sizeof(button_desc_arr)/sizeof(*button_desc_arr); i++) {
                request_irq(button_desc_arr[i].irq, buttons_irq_handler,
                                IRQT_BOTHEDGE, DEVICE_NAME, button_desc_arr + i);
        }

        return 0;
}

static ssize_t
button_read (struct file *fp, char __user *user, size_t sz, loff_t *poffst)
{
        if (fp->f_flags & O_NONBLOCK) { /* 如果是非阻塞操作 */
                if (!button_press)
                        return -EAGAIN;
        }

        /* 若没有数据,button_press 为0，则挂起本进程到等待队列 button_press_wait */
        wait_event_interruptible(button_press_wait, button_press);
        /* 重置 button_press */
        button_press = 0;

        if (copy_to_user(user, &g_value, sz)) {
                printk(DEVICE_NAME " failed to copy_to_user");
                return -1;
        }

        return 0;
}


static int
button_close (struct inode *inode, struct file *fp)
{
        unsigned int i;

        atomic_inc(&can_open);

        for (i = 0; i < sizeof(button_desc_arr)/ sizeof(*button_desc_arr); i++) {
                free_irq(button_desc_arr[i].irq, button_desc_arr + i);
        }

        return 0;
}

static unsigned int
button_poll (struct file *file, struct poll_table_struct *wait)
{
        // 将本进程加入 button_press_wait 等待队列，但当前不会阻塞
        poll_wait(file, &button_press_wait, wait);

        if (button_press) // 这里不重置 button_press 因为 数据还没有读，在read后重置 button_press
                return POLLIN;

        return 0;
}

static const struct file_operations button_ops = {
        .owner = THIS_MODULE,
        .open = button_open,
        .read = button_read,
        .poll = button_poll,
        .release = button_close,
        .fasync = button_fasync,
};

static int __init
button_init(void)
{
        unsigned int major;

        /* 1. 字符设备驱动框架部分 */
        /* 1.1 申请设备号 */
        if (alloc_chrdev_region(&dev, 0, 1, DEVICE_NAME) < 0) {
                printk(DEVICE_NAME "failed to alloc dev\n");
                return -1;
        }

        /* 1.2 构建cdev，并绑定 file_operations */
        cdev = cdev_alloc();
        cdev->ops = &button_ops;
        cdev->owner = THIS_MODULE;

        /* 1.3 将cdev加到系统的哈希表中，如此才能通过设备号找到cdev */
        if (cdev_add(cdev, dev, 1) < 0) {
                printk(DEVICE_NAME "failed to cdev_add\n");
                return -1;
        }

        /* 2. 为了mdev自动创建设备节点 */
        /* 2.1 创建一个/sys/class/button 类 */
        button_class = class_create(THIS_MODULE, DEVICE_NAME);

        /* 2.2 创建/sys/class/button/buttons */
        major = MAJOR(dev);
        device_create(button_class, NULL, MKDEV(major, 0), "buttons");

        /* 3. 初始化等待队列，以实现阻塞操作 */
        init_waitqueue_head(&button_press_wait);

        init_timer(&button_timer);

        return 0;
}

static void __exit
button_exit(void)
{
        int major;

        major = MAJOR(dev);
        device_destroy(button_class, MKDEV(major, 0));
        class_destroy(button_class);

        cdev_del(cdev);
        unregister_chrdev_region(dev, 4);
}

module_init(button_init);
module_exit(button_exit);

MODULE_LICENSE("GPL");

poll

poll 机制分析

应用程序调用poll时，会遍历所有 fd对应 file->f_op->poll()，
驱动模块的poll将当前进程加入等待队列，并检查是否有事件，返回事件个数，
当没有事件时，陷入睡眠

sys_poll
        do_sys_poll(ufds, nfds, &timeout_jiffies) // timeout_jiffies 是输入输出参数，输入超时值,输出剩余的时间
                poll_initwait(&table);
                        init_poll_funcptr(&pwq->pt, __pollwait); // -> table->pt->qproc = __pollwait;

                i = nfds; while(i != 0) {...} // 从用户空间中将poll event参数拷贝到内核空间
                fdcount = do_poll(nfds, head, &table, timeout);
                        for (;;) {
                                if (do_pollfd(pfd, pt)) { // -> mask = file->f_op->poll(file, pwait);
                                        count++;          // 调用驱动的 poll函数，如果mask>0则 count++
                                        pt = NULL;
                                }


                                // 如果 count > 0 ，有事件，返回
                                // 如果 *timeout ==  0 ，超时，返回
                                // 有信号待处理，返回
                                if (count || !*timeout || signal_pending(current))
                                        break;

                                // 睡眠__timeout 时间, 可以被打断
                                __timeout = schedule_timeout(__timeout);

                        }
                        return count; // 返回事件数量

                while() {...} // 将发生的事件拷贝到用户空间

驱动的poll函数

static unsigned int evdev_poll(struct file *file, poll_table *wait)
{
        struct evdev_client *client = file->private_data;
        struct evdev *evdev = client->evdev;

        // 调用 poll_wait , 最终将当前进程加入 驱动构建的等待队列, 但当前不会阻塞，在do_poll中若没有事件，则调用 schedule_timeout 阻塞
        poll_wait(file, &evdev->wait, wait); // >  p->qproc(filp, wait_address, p);
                                             // > __pollwait(filp, wait_address, p);
                                                      init_waitqueue_entry(&entry->wait, current);
                                                      add_wait_queue(wait_address, &entry->wait);

        return ((client->head == client->tail) ? 0 : (POLLIN | POLLRDNORM)) |
                (evdev->exist ? 0 : (POLLHUP | POLLERR));  // 返回 POLLIN 等事件
}

等待队列的函数
wait_queue_head_t wait;
init_waitqueue_head(&wait);
wake_up_interruptible(&wait);

驱动如何使用poll机制 ?

1) file_operations 中定义 poll ，准备等待队列 waitq
2) poll(struct file *file, poll_table *wait_table) {
        poll_wait(file, &waitq, wait_table);  // 将本进程加入等待队列
        // 3) 判断释放有事件
        return event; // 无事件为0，有事件返回 POLLIN POLLOUT 等
}

poll 和 select 在驱动层面都是调用 f_op->poll ，所以驱动实现了poll，应用层可以调用poll和 select

给button驱动加上 poll

static unsigned int
button_poll (struct file *file, struct poll_table_struct *wait)
{
        // 将本进程加入 button_press_wait 等待队列，但当前不会阻塞
        poll_wait(file, &button_press_wait, wait);

        if (button_press) // 这里不重置 button_press 因为 数据还没有读，在read后重置 button_press
                return POLLIN;

        return 0;
}

异步通知

内核主动通知应用程序有事件，需要应用程序把自己的进程号注册到驱动模块的异步通知队列，
当事件发生时，驱动模块 kill_fasync 给所有已注册进程发信号 SIGIO

• 应用程序调用 f_ops->fasync 将自己的pid注册进驱动的异步通知队列

      int olfags;
      fcntl(fd, F_SETOWN, getpid());
      olfags = fcntl(fd, F_GETFL);
      fcntl(fd, F_SETFL, olfags | FASYNC);

      signal(SIGIO, signal_io_handler);

• 当事件发生时，驱动调用 kill_fasync给已注册的进程发送信号SIGIO

  static irqreturn_t
  buttons_irq_handler(int irq, void *dev_id)
  {
      struct button_desc *bd = dev_id;
      unsigned int up;

      g_value = bd->val;
      up = s3c2410_gpio_getpin(bd->pin);
      if (up)
          g_value |= 0x80;

      /* 唤醒button_press_wait 上的进程 */
      button_press = 1;
      wake_up_interruptible(&button_press_wait);

      kill_fasync(&button_async_queue, SIGIO, POLL_IN);

      return IRQ_HANDLED;
  }

  static int
  button_fasync(int fd, struct file *file, int on)
  {
      return fasync_helper(fd, file, on, &button_async_queue);
  }

  static const struct file_operations button_ops = {
      .owner = THIS_MODULE,
      .open = button_open,
      .read = button_read,
      .poll = button_poll,
      .release = button_close,
      .fasync = button_fasync,
  };

原子操作实现互斥

atomic_t v = ATOMIC_INIT(0)
atomic_dec_and_test(atomic_t *)
atomic_inc(atomic_t *);

使用原子操作实现互斥，
定义一个原子变量作为资源计数，
获得资源时需要 atomic_dec_and_test，如果没有资源则atomic_inc 并退出。
进程退出时要释放资源 atomic_inc
比如实现 button驱动只能一个进程打开

  // 定义原子变量，实现只能一个进程打开
  static atomic_t can_open = ATOMIC_INIT(1);

  static int
  button_open (struct inode *inode, struct file *fp)
  {
      unsigned int i;

      //   #define atomic_dec_and_test(v) (atomic_sub_return(1, (v)) == 0)
      // !(--can_open == 0)      
      if (!atomic_dec_and_test(&can_open)) {
          atomic_inc(&can_open);  // ++can_open
          return -EBUSY;
      }
      ...
  }

  static int
  button_close (struct inode *inode, struct file *fp)
  {
      atomic_inc(&can_open);
  }

信号量

信号量也能实现互斥，并且当获得资源失败时，进程可以睡在该信号量上，等待被唤醒。

定义信号量
struct semaphore sem;
初始化信号量
void sema_init(struct semaphore *sem, int val);
void init_MUTEX(struct semaphore *sem); // 初始值为0
static DECLARE_MUTEX(button_lock); // 定义互斥锁

获得信号量
void down(struct semaphore *sem); // 获得失败，则陷入 不可打断的休眠，直到其他进程 up信号量，或被 SIGKILL杀死
int down_interruptible(struct semaphore *sem); // 获得失败，则陷入可打断休眠，直到其他进程up信号量，获得被信号打断返回1，成功获得信号量返回0

      if (down_interruptible(&soft->algolock))
          return -ERESTARTSYS;

int down_trylock(struct semaphore *sem); // 获得失败，则返回 1，获得成功返回 0

      /* try to get control of the write buffer */
      if (down_trylock(&sd->sd_wbs)) {
          /* somebody else has it now;
           * if we're non-blocking, then exit...
           */
          if (file->f_flags & O_NONBLOCK) {
              return -EAGAIN;
          }
          /* ...or if we want to block, then do so here */
          if (down_interruptible(&sd->sd_wbs)) {
              /* something went wrong with wait */
              return -ERESTARTSYS;
          }
      }

释放信号量
void up(struct semaphore *sem);

阻塞和非阻塞

应用程序在读操作时，f_ops->read 检查是否有数据，无则 wait_event_interruptible 将本进程加入 事件队列，
驱动模块需注册中断，当中断发生时，wake_up_interruptible 唤醒队列上所有进程

判断非阻塞
驱动程序可以获得 file->f_flags & O_NONBLOCK 以判断是否非阻塞处理
如果是非阻塞，并没有资源，则返回 -EAGAIN

按键消抖和定时器

由于机械按键的回弹导致刚按下时电压来回跳动，导致触发多次中断，所以应收到第一次中断设置一个定时器延迟处理中断，期间的其他中断忽略
定时器操作

// 定义定时器
  static struct timer_list button_timer = TIMER_INITIALIZER(button_timeout, 0, 0); 
// 初始化定时器，但不会加入系统
      init_timer(&button_timer);

// 设置定时器并加入系统
      button_timer.expires = jiffies + msecs_to_jiffies(100); // 100ms 后读取按键
      button_timer.data = (unsigned long)dev_id;
      mod_timer(&button_timer, button_timer.expires); 

// 从系统中删除定时器
      del_timer(&button_timer);