Samsung_tiny4412(驱动笔记07)----spinlock,semaphore,atomic,mutex,completion,interrupt

        }

        ...

六. interrupt接口:

    1. 查看系统中断处理信息: cat /proc/interrupts

    2. 申请并注册中断处理函数:

        static inline int __must_check request_irq( unsigned int irq, irq_handler_t handler,

                                      unsigned long flags, const char *name, void *dev_data);

    3. 释放中断,并取消中断处理函数:

        void free_irq(unsigned int irq, void *dev_data);

    4. 代码执行环境:

        1. 中断上下文:         in_interrupt(); ---> 判断执行环境是否是中断上下文

            1. 软中断上下文:   in_softirq();   ---> 判断执行环境是否是soft irq

            2. 外部中断上下文: in_irq();       ---> 判断执行环境是否是硬件中断处理环境

        2. 进程上下文.

    5. 共享中断方法:

        1. request_irq()指定共享标志 IRQF_SHARED;

        2. request_irq()最后一个参数不能传递NULL,传递当前驱动全局变量地址;

    6. 将系统gpio编号转换成对应的外部中断: gpio_to_irq();

    7. spinlock中断中使用Demo:

        ...

        struct test_s {

            struct file_operations fops;

            spinlock_t lock;

            int major;

        };

        typedef struct test_s test_t;

        ...

        int critical(const char *s, spinlock_t *lock)

        {

            int i;

            unsigned long flag;

            static int cnt = 0;

            /*spin_lock(lock);*/

            /*local_irq_disable();*/

            /*local_irq_save(flag);*/

            /*spin_lock_irq(lock);*/

            spin_lock_irqsave(lock, flag);

            for(i = 0; i < 3; i++)

            {

                printk('count = %d, %s', cnt++, s);

                mdelay(1000);

            }

            spin_unlock_irqrestore(lock, flag);

            /*spin_unlock_irq(lock);*/

            /*local_irq_restore(flag);*/

            /*local_irq_enable();*/

            /*spin_unlock(lock);*/

            return 0;

        }

        static irqreturn_t irq_handler(int irq, void *arg)

        {

            test_t *p = arg;

            critical('irqn', &p->lock);

            return IRQ_HANDLED;

        }

        static ssize_t test_write(struct file *file, const char __user *buf, size_t count, loff_t *pos)

        {

            int ret;

            char kbuf[count + 1];

            test_t *p = file->private_data;

            ret = copy_from_user(kbuf, buf, count);

            if(ret)

                return -EFAULT;

            kbuf[count] = '';

            if(critical(kbuf, &p->lock))

                return -EAGAIN;

            return count;

        }

        ...

        int __init test_init(void)

        {

            int ret;

            spin_lock_init(&test.lock);

            ret = register_chrdev(test.major,

                    DEV_NAME, &test.fops);

            if(ret > 0)

            {

                test.major = ret;

                printk('major = %dn', test.major);

                ret = 0;

            }

            ret = request_irq(IRQ_EINT(26), irq_handler,

                              IRQF_TRIGGER_FALLING,

                              'key1', &test);

            if(ret)

                unregister_chrdev(test.major, DEV_NAME);

            return ret;

        }

        ...

七. 按键驱动大致写法:

    #include <linux/module.h>

    #include

    #include

    #include

    #include

    #include

    #include

    #define DEV_NAME    'test'

    struct timer_list timer;

    struct btn_desc {

        int gpio;

        int num;

        char *name;

    };

    int ev_key = 0;

    char key_state[] = {0, 0, 0, 0};

    DECLARE_WAIT_QUEUE_HEAD(wq);

    struct btn_desc btn[] = {

        { EXYNOS4_GPX3(2), 0, 'key1' },

        { EXYNOS4_GPX3(3), 1, 'key2' },

        { EXYNOS4_GPX3(4), 2, 'key3' },

        { EXYNOS4_GPX3(5), 3, 'key4' }

    };

    void timer_main(unsigned long data)

    {

        ev_key = 1;

        wake_up_interruptible(&wq);

        printk('timer_main.n');

    }

    static irqreturn_t irq_handler(int irq, void *arg)

    {

        struct btn_desc *key = arg;

        key_state[key->num] = 1;

        mod_timer(&timer, jiffies + 20);

        return IRQ_HANDLED;

    }

    static int test_open(struct inode *inode, struct file *file)

    {

        int i, irq, ret;

        for(i = 0; i < ARRAY_SIZE(btn); i++)

        {

            //irq = IRQ_EINT(26+i); //irq可以通过这种方法获得

            irq = gpio_to_irq(btn[i].gpio);

            ret = request_irq(irq, irq_handler, IRQF_TRIGGER_FALLING | IRQF_SHARED,

                        btn[i].name, &btn[i]);

            if(ret)

                break;

        }

        if(ret)

        {

            for(--i; i >= 0; i--)

            {

                irq = gpio_to_irq(btn[i].gpio);

                free_irq(irq, &btn[i]);

            }

            return ret;

        }

        return 0;

    }

    static int test_close(struct inode *inode, struct file *file)

    {

        int i, irq;

        for(i = 0; i < ARRAY_SIZE(btn); i++)

        {

            irq = gpio_to_irq(btn[i].gpio);

            free_irq(irq, &btn[i]);

        }

        return 0;

    }

    static ssize_t test_read(struct file *file, char __user *buf, size_t count, loff_t *pos)

    {

        int ret;

        if(count > ARRAY_SIZE(key_state))

            count = ARRAY_SIZE(key_state);

        while(!ev_key)

        {

            if(file->f_flags & O_NONBLOCK)

                return -EAGAIN;