C++博客-天下-随笔分类-kernel & Driver

韦根驱动

天下 — Fri, 21 Mar 2014 09:33:00 GMT

#include <linux/types.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/poll.h>
#include <linux/errno.h>
#include <linux/gpio.h>
#include <linux/interrupt.h>
#include <linux/miscdevice.h>
#include <linux/ioport.h>
#include <linux/device.h>
#include <asm/io.h>
#include <asm/irq.h>
#include <mach/irqs.h>
#include <mach/regs-gpio.h>

#include "../ioctl_new.h"

static spinlock_t    wiegand_lock;
static int            wiegand_in = 0;
static int            wiegand_in_cur = 0;
static int            wiegand_in_stime = 0;
static int            wiegand_in1_stime = 0;
static int            wiegand_in2_stime = 0;
static unsigned char wiegand_data[40];
static WIEGAND_TYPE    wiegand_mode;

inline void wiegand_delay(int microseconds)
{
    int i;
    while (microseconds--)
    {
        for (i=0; i<65; i++) __asm("NOP");
    }
}

static int wiegand_gettickcount(void)
{
    static int __start_time = 0; //second
    struct timeval tv;

    do_gettimeofday(&tv);

    if (__start_time == 0)
        __start_time = tv.tv_sec;

    return ((tv.tv_sec - __start_time) * 1000 + tv.tv_usec / 1000);
}

inline void wiegand_minus_interrupt(void)
{
    if (wiegand_in != WGNSTAT_RECVFULL)
    {
        if (wiegand_gettickcount() - wiegand_in_stime >= 100)
            wiegand_in_cur = 0;
        wiegand_in_stime = wiegand_gettickcount();
        wiegand_data[wiegand_in_cur++] = 0;
        if (wiegand_in_cur >= 34)
            wiegand_in = WGNSTAT_RECVFULL;
        else if (wiegand_in_cur >= 26)
            wiegand_in = WGNSTAT_RECV26;
    }
}

inline void wiegand_plus_interrupt(void)
{
    if (wiegand_in != WGNSTAT_RECVFULL)
    {
        if (wiegand_gettickcount() - wiegand_in_stime >= 100)
            wiegand_in_cur = 0;
        wiegand_in_stime = wiegand_gettickcount();
        wiegand_data[wiegand_in_cur++] = 1;
        if (wiegand_in_cur >= 34)
            wiegand_in = WGNSTAT_RECVFULL;
        else if (wiegand_in_cur >= 26)
            wiegand_in = WGNSTAT_RECV26;
    }
}

static irqreturn_t wiegand_minus1_interrupt(int irq, void *dev_id)
{
    spin_lock(&wiegand_lock);
//    printk("wiegand_minus1_interrupt\n");
    if (wiegand_gettickcount() - wiegand_in2_stime > 200)
    {
        wiegand_minus_interrupt();
        wiegand_in1_stime = wiegand_in_stime;
    }
    spin_unlock(&wiegand_lock);
    return IRQ_HANDLED;
}

static irqreturn_t wiegand_plus1_interrupt(int irq, void *dev_id)
{
    spin_lock(&wiegand_lock);
//    printk("wiegand_plus1_interrupt\n");
    if (wiegand_gettickcount() - wiegand_in2_stime > 200)
    {
        wiegand_plus_interrupt();
        wiegand_in1_stime = wiegand_in_stime;
    }
    spin_unlock(&wiegand_lock);
    return IRQ_HANDLED;
}

static int wiegand_open(struct inode * inode, struct file * filp);
static int wiegand_release(struct inode * inode,struct file * filp);
static ssize_t wiegand_read(struct file *flip, char *buf, size_t len, loff_t *pos);
static ssize_t wiegand_write(struct file *flip, const char *buf, size_t len, loff_t *pos);
static long wiegand_ioctl(struct file *file, unsigned int cmd, unsigned long arg);

static struct file_operations wiegand_fops = {
    owner:        THIS_MODULE,
    open:        wiegand_open,
    release:    wiegand_release,
    read:        wiegand_read,
    write:        wiegand_write,
    unlocked_ioctl:        wiegand_ioctl,
};

static struct miscdevice wiegand_dev = {
    WIEGAND_MINOR,
    WIEGAND_MODULE_NAME,
    &wiegand_fops
};

static void config_wiegand_pins(void)
{
    s3c2410_gpio_cfgpin(WGNIN_0, WGNIN_0_CON);
    s3c2410_gpio_cfgpin(WGNIN_1, WGNIN_1_CON);
    s3c2410_gpio_cfgpin(WGNOUT0, WGNOUT0_CON);
    s3c2410_gpio_cfgpin(WGNOUT1, WGNOUT1_CON);
#if 0
    if (request_irq(WGNIN_0_IRQ_NUM, &wiegand_minus1_interrupt,
        IORESOURCE_IRQ | IRQF_TRIGGER_RISING,
        WIEGAND_IRQ_MINUS,
        &wiegand_dev)
        || request_irq(WGNIN_1_IRQ_NUM, &wiegand_plus1_interrupt,
        IORESOURCE_IRQ | IRQF_TRIGGER_RISING,
        WIEGAND_IRQ_PLUS,
        &wiegand_dev))

    {
        printk("WIEGAND request_irq Fail\n");
    }
#endif
}

static int wiegand_open(struct inode * inode, struct file * filp)
{
    config_wiegand_pins();
    return 0;
}

static int wiegand_release(struct inode * inode,struct file * filp)
{
#if 0
    free_irq(WGNIN_0_IRQ_NUM, &wiegand_dev);
    free_irq(WGNIN_1_IRQ_NUM, &wiegand_dev);
#endif
    return 0;
}

static ssize_t wiegand_read(struct file *flip, char *buf, size_t len, loff_t *pos)
{
    int result;
    spin_lock(&wiegand_lock);
    if (wiegand_in == WGNSTAT_NONE || len > sizeof(wiegand_data) || (wiegand_gettickcount() - wiegand_in_stime > 1800))        //500
    {
        wiegand_in = WGNSTAT_NONE;
        spin_unlock(&wiegand_lock);
        return 0;
    }
    if (len > wiegand_in_cur)
        len = wiegand_in_cur;
    result = copy_to_user(buf, wiegand_data, len);
    wiegand_in = WGNSTAT_NONE;
    wiegand_in_cur = 0;
    spin_unlock(&wiegand_lock);
    return len;
}

static ssize_t wiegand_write(struct file *flip, const char *buf, size_t len, loff_t *pos)
{
    int i;
    char data[40];

    if (len > sizeof(data))
        return 0;

    i = copy_from_user(data, buf, len);
    for (i=0; i<len; i++)
    {
        if (data[i] == 0)
        {
            WGNOUT0_1; wiegand_delay(wiegand_mode.dwTpw); WGNOUT0_0;
        }
        else
        {
            WGNOUT1_1; wiegand_delay(wiegand_mode.dwTpw); WGNOUT1_0;
        }
        wiegand_delay(wiegand_mode.dwTpi);
    }

    return len;
}

static long wiegand_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
    int result = 0;
    spin_lock(&wiegand_lock);
    switch(cmd)
    {
    case WIEGAND_MODE_SET:
        result = copy_from_user(&wiegand_mode, (void*)arg, sizeof(WIEGAND_TYPE));
        break;
    }
    spin_unlock(&wiegand_lock);
    return (result == sizeof(WIEGAND_TYPE) ? 0 : -1);
}

static int __init s3c2416_wiegand_init(void)
{
    int ret = 0;

    ret = misc_register(&wiegand_dev);
    if (ret)
    {
        printk("probuck s3c2416 WIEGAND Driver" WIEGAND_DRIVER_VERSION "Fail\n");
        goto exit_sb3kt_wiegand_init;
    }
    spin_lock_init(&wiegand_lock);

    printk("probuck s3c2416 WIEGAND Driver" WIEGAND_DRIVER_VERSION "\n");

exit_sb3kt_wiegand_init:
    return ret;
}

static void __exit s3c2416_wiegand_cleanup(void)
{
    misc_deregister(&wiegand_dev);
}

module_init(s3c2416_wiegand_init);
module_exit(s3c2416_wiegand_cleanup);
MODULE_LICENSE("GPL");

MODULE_DESCRIPTION("s3c2416 WIEGAND Driver");
MODULE_SUPPORTED_DEVICE("s3c2416 WIEGAND");

天下 2014-03-21 17:33 发表评论

Linux内核的同步机制(2)信号量（semaphore）

天下 — Fri, 12 Apr 2013 10:22:00 GMT

Linux内核的同步机制(2)信号量（semaphore）

　　信号量在创建时需要设置一个初始值，表示同时可以有几个任务可以访问该信号量保护的共享资源，初始值为1就变成互斥锁（Mutex），即同时只能有一个任务可以访问信号量保护的共享资源。

　　一个任务要想访问共享资源，首先必须得到信号量，获取信号量的操作将把信号量的值减1，若当前信号量的值为负数，表明无法获得信号量，该任务必须挂起在该信号量的等待队列等待该信号量可用；若当前信号量的值为非负数，表示可以获得信号量，因而可以立刻访问被该信号量保护的共享资源。

　　当任务访问完被信号量保护的共享资源后，必须释放信号量，释放信号量通过把信号量的值加1实现，如果信号量的值为非正数，表明有任务等待当前信号量，因此它也唤醒所有等待该信号量的任务。

信号量的API有：
DECLARE_MUTEX(name)
该宏声明一个信号量name并初始化它的值为1，即声明一个互斥锁。

//在Linux2.6.26中没找到该宏
DECLARE_MUTEX_LOCKED(name)
该宏声明一个互斥锁name，但把它的初始值设置为0，即锁在创建时就处在已锁状态。因此对于这种锁，一般是先释放后获得。

void sema_init (struct semaphore *sem, int val);
该函用于数初始化设置信号量的初值，它设置信号量sem的值为val。

void init_MUTEX (struct semaphore *sem);
该函数用于初始化一个互斥锁，即它把信号量sem的值设置为1。

void init_MUTEX_LOCKED (struct semaphore *sem);
该函数也用于初始化一个互斥锁，但它把信号量sem的值设置为0，即一开始就处在已锁状态。

void down(struct semaphore * sem);
该函数用于获得信号量sem，它会导致睡眠，因此不能在中断上下文（包括IRQ上下文和softirq上下文）使用该函数。该函数将把sem的值减1，如果信号量sem的值非负，就直接返回，否则调用者将被挂起，直到别的任务释放该信号量才能继续运行。

int down_interruptible(struct semaphore * sem);
该函数功能与down类似，不同之处为，down不会被信号（signal）打断，但down_interruptible能被信号打断，因此该函数有返回值来区分是正常返回还是被信号中断，如果返回0，表示获得信号量正常返回，如果被信号打断，返回-EINTR。

int down_trylock(struct semaphore * sem);
该函数试着获得信号量sem，如果能够立刻获得，它就获得该信号量并返回0，否则，表示不能获得信号量sem，返回值为非0值。因此，它不会导致调用者睡眠，可以在中断上下文使用。

void up(struct semaphore * sem);
该函数释放信号量sem，即把sem的值加1，如果sem的值为非正数，表明有任务等待该信号量，因此唤醒这些等待者。

头文件:
#include
/*
* Copyright (c) 2008 Intel Corporation
* Author: Matthew Wilcox
*
* Distributed under the terms of the GNU GPL, version 2
*
* Please see kernel/semaphore.c for documentation of these functions
*/
#ifndef __LINUX_SEMAPHORE_H
#define __LINUX_SEMAPHORE_H

#include
#include

/* Please don't access any members of this structure directly */
struct semaphore {
    spinlock_t        lock;
    unsigned int        count;
    struct list_head    wait_list;
};

#define __SEMAPHORE_INITIALIZER(name, n)                \
{                                    \
    .lock        = __SPIN_LOCK_UNLOCKED((name).lock),        \
    .count        = n,                        \
    .wait_list    = LIST_HEAD_INIT((name).wait_list),        \
}

#define __DECLARE_SEMAPHORE_GENERIC(name, count) \
    struct semaphore name = __SEMAPHORE_INITIALIZER(name, count)

#define DECLARE_MUTEX(name)    __DECLARE_SEMAPHORE_GENERIC(name, 1)

static inline void sema_init(struct semaphore *sem, int val)
{
    static struct lock_class_key __key;
    *sem = (struct semaphore) __SEMAPHORE_INITIALIZER(*sem, val);
    lockdep_init_map(&sem->lock.dep_map, "semaphore->lock", &__key, 0);
}

#define init_MUTEX(sem)        sema_init(sem, 1)
#define init_MUTEX_LOCKED(sem)    sema_init(sem, 0)

extern void down(struct semaphore *sem);
extern int __must_check down_interruptible(struct semaphore *sem);
extern int __must_check down_killable(struct semaphore *sem);
extern int __must_check down_trylock(struct semaphore *sem);
extern int __must_check down_timeout(struct semaphore *sem, long jiffies);
extern void up(struct semaphore *sem);

#endif /* __LINUX_SEMAPHORE_H */

天下 2013-04-12 18:22 发表评论

Linux内核的同步机制(1)自旋锁（spinlock）

天下 — Fri, 12 Apr 2013 10:21:00 GMT

Linux内核的同步机制(1)、自旋锁（spinlock）

　　自旋锁与互斥锁有点类似，只是自旋锁不会引起调用者睡眠，如果自旋锁已经被别的执行单元保持，调用者就一直循环在那里看是否该自旋锁的保持者已经释放了锁，"自旋"一词就是因此而得名。

　　由于自旋锁使用者一般保持锁时间非常短，因此选择自旋而不是睡眠是非常必要的，自旋锁的效率远高于互斥锁。

　　信号量和读写信号量适合于保持时间较长的情况，它们会导致调用者睡眠，因此只能在进程上下文使用（_trylock的变种能够在中断上下文使用），而自旋锁适合于保持时间非常短的情况，它可以在任何上下文使用。

　　如果被保护的共享资源只在进程上下文访问，使用信号量保护该共享资源非常合适，如果对共巷资源的访问时间非常短，自旋锁也可以。但是如果被保护的共享资源需要在中断上下文访问（包括底半部即中断处理句柄和顶半部即软中断），就必须使用自旋锁。

　　自旋锁保持期间是抢占失效的，而信号量和读写信号量保持期间是可以被抢占的。自旋锁只有在内核可抢占或SMP的情况下才真正需要，在单CPU且不可抢占的内核下，自旋锁的所有操作都是空操作。

　　跟互斥锁一样，一个执行单元要想访问被自旋锁保护的共享资源，必须先得到锁，在访问完共享资源后，必须释放锁。如果在获取自旋锁时，没有任何执行单元保持该锁，那么将立即得到锁；如果在获取自旋锁时锁已经有保持者，那么获取锁操作将自旋在那里，直到该自旋锁的保持者释放了锁。

　　无论是互斥锁，还是自旋锁，在任何时刻，最多只能有一个保持者，也就说，在任何时刻最多只能有一个执行单元获得锁。

自旋锁的API有：

spin_lock_init(x)
该宏用于初始化自旋锁x。自旋锁在真正使用前必须先初始化。该宏用于动态初始化。

DEFINE_SPINLOCK(x)
该宏声明一个自旋锁x并初始化它。该宏在2.6.11中第一次被定义，在先前的内核中并没有该宏。

SPIN_LOCK_UNLOCKED
该宏用于静态初始化一个自旋锁。

DEFINE_SPINLOCK(x)等同于spinlock_t x = SPIN_LOCK_UNLOCKED

spin_is_locked(x)
该宏用于判断自旋锁x是否已经被某执行单元保持（即被锁），如果是，返回真，否则返回假。

spin_unlock_wait(x)
该宏用于等待自旋锁x变得没有被任何执行单元保持，如果没有任何执行单元保持该自旋锁，该宏立即返回，否则将循环在那里，直到该自旋锁被保持者释放。

spin_trylock(lock)
该宏尽力获得自旋锁lock，如果能立即获得锁，它获得锁并返回真，否则不能立即获得锁，立即返回假。它不会自旋等待lock被释放。

spin_lock(lock)
该宏用于获得自旋锁lock，如果能够立即获得锁，它就马上返回，否则，它将自旋在那里，直到该自旋锁的保持者释放，这时，它获得锁并返回。总之，只有它获得锁才返回。

spin_lock_irqsave(lock, flags)
该宏获得自旋锁的同时把标志寄存器的值保存到变量flags中并失效本地中断。

spin_lock_irq(lock)
该宏类似于spin_lock_irqsave，只是该宏不保存标志寄存器的值。

spin_lock_bh(lock)
该宏在得到自旋锁的同时失效本地软中断。

spin_unlock(lock)
该宏释放自旋锁lock，它与spin_trylock或spin_lock配对使用。如果spin_trylock返回假，表明没有获得自旋锁，因此不必使用spin_unlock释放。

spin_unlock_irqrestore(lock, flags)
该宏释放自旋锁lock的同时，也恢复标志寄存器的值为变量flags保存的值。它与spin_lock_irqsave配对使用。

spin_unlock_irq(lock)
该宏释放自旋锁lock的同时，也使能本地中断。它与spin_lock_irq配对应用。

spin_unlock_bh(lock)
该宏释放自旋锁lock的同时，也使能本地的软中断。它与spin_lock_bh配对使用。

spin_trylock_irqsave(lock, flags)
该宏如果获得自旋锁lock，它也将保存标志寄存器的值到变量flags中，并且失效本地中断，如果没有获得锁，它什么也不做。
　　因此如果能够立即获得锁，它等同于spin_lock_irqsave，如果不能获得锁，它等同于spin_trylock。如果该宏获得自旋锁lock，那需要使用spin_unlock_irqrestore来释放。

spin_trylock_irq(lock)
该宏类似于spin_trylock_irqsave，只是该宏不保存标志寄存器。如果该宏获得自旋锁lock，需要使用spin_unlock_irq来释放。

spin_trylock_bh(lock)
该宏如果获得了自旋锁，它也将失效本地软中断。如果得不到锁，它什么也不做。因此，如果得到了锁，它等同于spin_lock_bh，如果得不到锁，它等同于spin_trylock。如果该宏得到了自旋锁，需要使用spin_unlock_bh来释放。

spin_can_lock(lock)
该宏用于判断自旋锁lock是否能够被锁，它实际是spin_is_locked取反。如果lock没有被锁，它返回真，否则，返回假。该宏在2.6.11中第一次被定义，在先前的内核中并没有该宏。

　　获得自旋锁和释放自旋锁有好几个版本，因此让读者知道在什么样的情况下使用什么版本的获得和释放锁的宏是非常必要的。

　　如果被保护的共享资源只在进程上下文访问和软中断上下文访问，那么当在进程上下文访问共享资源时，可能被软中断打断，从而可能进入软中断上下文来对被保护的共享资源访问，因此对于这种情况，对共享资源的访问必须使用spin_lock_bh和spin_unlock_bh来保护。

　　当然使用spin_lock_irq和spin_unlock_irq以及spin_lock_irqsave和spin_unlock_irqrestore也可以，它们失效了本地硬中断，失效硬中断隐式地也失效了软中断。但是使用spin_lock_bh和spin_unlock_bh是最恰当的，它比其他两个快。

　　如果被保护的共享资源只在进程上下文和tasklet或timer上下文访问，那么应该使用与上面情况相同的获得和释放锁的宏，因为tasklet和timer是用软中断实现的。

　　如果被保护的共享资源只在一个tasklet或timer上下文访问，那么不需要任何自旋锁保护，因为同一个tasklet或timer只能在一个CPU上运行，即使是在SMP环境下也是如此。实际上tasklet在调用tasklet_schedule标记其需要被调度时已经把该tasklet绑定到当前CPU，因此同一个tasklet决不可能同时在其他CPU上运行。

　　timer也是在其被使用add_timer添加到timer队列中时已经被帮定到当前CPU，所以同一个timer绝不可能运行在其他CPU上。当然同一个tasklet有两个实例同时运行在同一个CPU就更不可能了。

　　如果被保护的共享资源只在两个或多个tasklet或timer上下文访问，那么对共享资源的访问仅需要用spin_lock和spin_unlock来保护，不必使用_bh版本，因为当tasklet或timer运行时，不可能有其他tasklet或timer在当前CPU上运行。

　　如果被保护的共享资源只在一个软中断（tasklet和timer除外）上下文访问，那么这个共享资源需要用spin_lock和spin_unlock来保护，因为同样的软中断可以同时在不同的CPU上运行。

　　如果被保护的共享资源在两个或多个软中断上下文访问，那么这个共享资源当然更需要用spin_lock和spin_unlock来保护，不同的软中断能够同时在不同的CPU上运行。

　　如果被保护的共享资源在软中断（包括tasklet和timer）或进程上下文和硬中断上下文访问，那么在软中断或进程上下文访问期间，可能被硬中断打断，从而进入硬中断上下文对共享资源进行访问，因此，在进程或软中断上下文需要使用spin_lock_irq和spin_unlock_irq来保护对共享资源的访问。

　　而在中断处理句柄中使用什么版本，需依情况而定，如果只有一个中断处理句柄访问该共享资源，那么在中断处理句柄中仅需要spin_lock和spin_unlock来保护对共享资源的访问就可以了。

　　因为在执行中断处理句柄期间，不可能被同一CPU上的软中断或进程打断。但是如果有不同的中断处理句柄访问该共享资源，那么需要在中断处理句柄中使用spin_lock_irq和spin_unlock_irq来保护对共享资源的访问。

　　在使用spin_lock_irq和spin_unlock_irq的情况下，完全可以用spin_lock_irqsave和spin_unlock_irqrestore取代，那具体应该使用哪一个也需要依情况而定，如果可以确信在对共享资源访问前中断是使能的，那么使用spin_lock_irq更好一些。

　　因为它比spin_lock_irqsave要快一些，但是如果你不能确定是否中断使能，那么使用spin_lock_irqsave和spin_unlock_irqrestore更好，因为它将恢复访问共享资源前的中断标志而不是直接使能中断。

　　当然，有些情况下需要在访问共享资源时必须中断失效，而访问完后必须中断使能，这样的情形使用spin_lock_irq和spin_unlock_irq最好。

　　需要特别提醒读者，spin_lock用于阻止在不同CPU上的执行单元对共享资源的同时访问以及不同进程上下文互相抢占导致的对共享资源的非同步访问，而中断失效和软中断失效却是为了阻止在同一CPU上软中断或中断对共享资源的非同步访问。
　　

#include

头文件:
#include

#ifndef __LINUX_SPINLOCK_TYPES_H
#define __LINUX_SPINLOCK_TYPES_H

/*
* include/linux/spinlock_types.h - generic spinlock type definitions
*                                  and initializers
*
* portions Copyright 2005, Red Hat, Inc., Ingo Molnar
* Released under the General Public License (GPL).
*/

//对称多处理器
#if defined(CONFIG_SMP)
    #include
#else
    #include
#endif

#include

typedef struct {
    raw_spinlock_t raw_lock;
#ifdef CONFIG_GENERIC_LOCKBREAK
    unsigned int break_lock;
#endif
} spinlock_t;

#define SPINLOCK_MAGIC        0xdead4ead

typedef struct {
    raw_rwlock_t raw_lock;
#ifdef CONFIG_GENERIC_LOCKBREAK
    unsigned int break_lock;
#endif
} rwlock_t;

#define RWLOCK_MAGIC        0xdeaf1eed

#define SPINLOCK_OWNER_INIT    ((void *)-1L)

# define __SPIN_LOCK_UNLOCKED(lockname) \
    (spinlock_t)    {    .raw_lock = __RAW_SPIN_LOCK_UNLOCKED,    \
                SPIN_DEP_MAP_INIT(lockname) }
#define __RW_LOCK_UNLOCKED(lockname) \
    (rwlock_t)    {    .raw_lock = __RAW_RW_LOCK_UNLOCKED,    \
                RW_DEP_MAP_INIT(lockname) }

/*
* SPIN_LOCK_UNLOCKED and RW_LOCK_UNLOCKED defeat lockdep state tracking and
* are hence deprecated.
* Please use DEFINE_SPINLOCK()/DEFINE_RWLOCK() or
* __SPIN_LOCK_UNLOCKED()/__RW_LOCK_UNLOCKED() as appropriate.
*/
#define SPIN_LOCK_UNLOCKED    __SPIN_LOCK_UNLOCKED(old_style_spin_init)
#define RW_LOCK_UNLOCKED    __RW_LOCK_UNLOCKED(old_style_rw_init)

#define DEFINE_SPINLOCK(x)    spinlock_t x = __SPIN_LOCK_UNLOCKED(x)
#define DEFINE_RWLOCK(x)    rwlock_t x = __RW_LOCK_UNLOCKED(x)

#endif /* __LINUX_SPINLOCK_TYPES_H */
　　

天下 2013-04-12 18:21 发表评论

[原]linux中断处理(2)下半部机制:tasklet

天下 — Wed, 10 Apr 2013 07:29:00 GMT

[原]linux中断处理(2)下半部机制:tasklet
1.softirq
适用于性能敏感的子系统

2.tasklet
建立在softirq之上,使用更简单
softirq的不同实例可运行在不同的处理器上,而tasklet则不允许
必须使用define DECLARE_TASKLET 声明tasklet
#define DECLARE_TASKLET(name, func, data) \
struct tasklet_struct name = { NULL, 0, ATOMIC_INIT(0), func, data }

void short_do_tasklet(unsigned long);
DECLARE_TASKLET(short_do_tasklet,short_tasklet,0);

3. 工作队列(work queue)
struct work_struct my_work;      //定义一个工作队列
void my_work_func(unsigned long); //定义一个处理函数

头文件
#include
/* Tasklets --- multithreaded analogue of BHs.

Main feature differing them of generic softirqs: tasklet
is running only on one CPU simultaneously.

Main feature differing them of BHs: different tasklets
may be run simultaneously on different CPUs.

Properties:
* If tasklet_schedule() is called, then tasklet is guaranteed
to be executed on some cpu at least once after this.
* If the tasklet is already scheduled, but its excecution is still not
started, it will be executed only once.
* If this tasklet is already running on another CPU (or schedule is called
from tasklet itself), it is rescheduled for later.
* Tasklet is strictly serialized wrt itself, but not
wrt another tasklets. If client needs some intertask synchronization,
he makes it with spinlocks.
*/

struct tasklet_struct
{
    struct tasklet_struct *next;
    unsigned long state;
    atomic_t count;
    void (*func)(unsigned long);
    unsigned long data;
};

#define DECLARE_TASKLET(name, func, data) \
struct tasklet_struct name = { NULL, 0, ATOMIC_INIT(0), func, data }

使用示例:
static atomic_t fpstatues;
static atomic_t has_image = {0};

static void gc0303_vsync_do_tasklet(ulong data)
{
    ulong curr = gettickcount();
    debug("curr:%lu",curr);

    if (atomic_read(&fpstatues)==0)
    {
        s3c2410_dma_ctrl(DMACH_XD0, S3C2410_DMAOP_FLUSH);
        gc0303_dma_buf.dma_addr = img_phys;
        gc0303_dma_buf.size = bmp_w*bmp_h;
        s3c2410_dma_enqueue(DMACH_XD0,
            (void *)&gc0303_dma_buf,
            gc0303_dma_buf.dma_addr,
            gc0303_dma_buf.size);
        atomic_set(&fpstatues,1);
    }
}

DECLARE_TASKLET(gc0303_vsync_tasklet,gc0303_vsync_do_tasklet,0);

static irqreturn_t gc0303_vsync_handler(int irq,void* dev_id)
{
    if (atomic_read(&fpstatues)==1)
    {
        s3c2410_dma_ctrl(DMACH_XD0, S3C2410_DMAOP_START);
    }
    //调度gc0303_vsync_tasklet
    tasklet_schedule(&gc0303_vsync_tasklet);
    return IRQ_HANDLED;
}

tasklet是作为中断下半部的一个很好的选择，它在性能和易用性之间有着很好的平衡。较之于softirq，tasklet不需要考虑SMP下的并行问题，而又比workqueues有着更好的性能。
tasklet通常作为硬中断的下半部来使用，在硬中断中调用tasklet_schedule(t)。每次硬中断都会触发一次tasklet_schedule(t)，但是每次中断它只会向其中的一个CPU注册，而不是所有的CPU。完成注册后的tasklet由tasklet_action()来执行，在SMP环境下，它保证同一时刻，同一个tasklet只有一个副本在运行，这样就避免了使用softirq所要考虑的互斥的问题。再者，tasklet在执行tasklet->func()前，再一次允许tasklet可调度（注册），但是在该tasklet已有一个副本在其他CPU上运行的情况下，它只能退后执行。总之，同一个硬中断引起的一个tasklet_schedule()动作只会使一个tasklet被注册，而不同中断引起的tasklet则可能在不同的时刻被注册而多次被执行。

tasklet的互斥。由于同一个tasklet不能有多个副本同时运行，所以不需要在多CPU之间互斥。在tasklet运行的过程中，它会被硬中断打断（这也是软中断的优点），所以如果tasklet和其他中断之间的互斥有可能存在。
中断服务程序一般都是在中断请求关闭的条件下执行的,以避免嵌套而使中断控制复杂化。但是，中断是一个随机事件，它随时会到来，如果关中断的时间太长，CPU就不能及时响应其他的中断请求，从而造成中断的丢失。因此，Linux内核的目标就是尽可能快的处理完中断请求，尽其所能把更多的处理向后推迟。例如，假设一个数据块已经达到了网线，当中断控制器接受到这个中断请求信号时，Linux内核只是简单地标志数据到来了，然后让处理器恢复到它以前运行的状态，其余的处理稍后再进行（如把数据移入一个缓冲区，接受数据的进程就可以在缓冲区找到数据）。因此，内核把中断处理分为两部分：上半部（tophalf）和下半部（bottomhalf），上半部（就是中断服务程序）内核立即执行，而下半部（就是一些内核函数）留着稍后处理，

首先，一个快速的“上半部”来处理硬件发出的请求，它必须在一个新的中断产生之前终止。通常，除了在设备和一些内存缓冲区（如果你的设备用到了DMA，就不止这些）之间移动或传送数据，确定硬件是否处于健全的状态之外，这一部分做的工作很少。

下半部运行时是允许中断请求的，而上半部运行时是关中断的，这是二者之间的主要区别。

但是，内核到底什时候执行下半部，以何种方式组织下半部？这就是我们要讨论的下半部实现机制，这种机制在内核的演变过程中不断得到改进，在以前的内核中，这个机制叫做bottomhalf(简称bh)，在2.4以后的版本中有了新的发展和改进，改进的目标使下半部可以在多处理机上并行执行，并有助于驱动程序的开发者进行驱动程序的开发。下面主要介绍常用的小任务(Tasklet)机制及2.6内核中的工作队列机制。

这里的小任务是指对要推迟执行的函数进行组织的一种机制。其数据结构为tasklet_struct，每个结构代表一个独立的小任务，其定义如下：
structtasklet_struct {
    structtasklet_struct *next;         /*指向链表中的下一个结构*/
    unsignedlong state;                 /* 小任务的状态*/
    atomic_t count;                        /* 引用计数器*/
    void(*func) (unsigned long);        /* 要调用的函数*/
    unsignedlong data;                  /* 传递给函数的参数*/
}；
结构中的func域就是下半部中要推迟执行的函数，data是它唯一的参数。
state域的取值为TASKLET_STATE_SCHED或TASKLET_STATE_RUN。TASKLET_STATE_SCHED表示小任务已被调度，正准备投入运行，TASKLET_STATE_RUN表示小任务正在运行。TASKLET_STATE_RUN只有在多处理器系统上才使用，单处理器系统什么时候都清楚一个小任务是不是正在运行（它要么就是当前正在执行的代码，要么不是）。
count 域是小任务的引用计数器。如果它不为0，则小任务被禁止，不允许执行；只有当它为零，小任务才被激活，并且在被设置为挂起时，小任务才能够执行。
1. 声明和使用小任务大多数情况下，为了控制一个寻常的硬件设备，小任务机制是实现下半部的最佳选择。小任务可以动态创建，使用方便，执行起来也比较快。
我们既可以静态地创建小任务，也可以动态地创建它。选择那种方式取决于到底是想要对小任务进行直接引用还是一个间接引用。如果准备静态地创建一个小任务（也就是对它直接引用），使用下面两个宏中的一个：
DECLARE_TASKLET(name,func, data)
DECLARE_TASKLET_DISABLED(name,func, data)
这两个宏都能根据给定的名字静态地创建一个tasklet_struct结构。当该小任务被调度以后，给定的函数func会被执行，它的参数由data给出。这两个宏之间的区别在于引用计数器的初始值设置不同。第一个宏把创建的小任务的引用计数器设置为0，因此，该小任务处于激活状态。另一个把引用计数器设置为1，所以该小任务处于禁止状态。例如：
DECLARE_TASKLET(my_tasklet,my_tasklet_handler, dev);
这行代码其实等价于
struct tasklet_struct my_tasklet = { NULL, 0, ATOMIC_INIT(0),tasklet_handler,dev};
这样就创建了一个名为my_tasklet的小任务，其处理程序为tasklet_handler，并且已被激活。当处理程序被调用的时候，dev就会被传递给它。
2.  编写自己的小任务处理程序小任务处理程序必须符合如下的函数类型：
void tasklet_handler(unsigned long data)
由于小任务不能睡眠，因此不能在小任务中使用信号量或者其它产生阻塞的函数。但是小任务运行时可以响应中断。
3. 调度自己的小任务通过调用tasklet_schedule()函数并传递给它相应的tasklt_struct指针，该小任务就会被调度以便适当的时候执行：
tasklet_schedule(&my_tasklet);        /*把my_tasklet标记为挂起 */
在小任务被调度以后，只要有机会它就会尽可能早的运行。在它还没有得到运行机会之前，如果一个相同的小任务又被调度了，那么它仍然只会运行一次。
可以调用tasklet_disable()函数来禁止某个指定的小任务。如果该小任务当前正在执行，这个函数会等到它执行完毕再返回。调用tasklet_enable()函数可以激活一个小任务，如果希望把以DECLARE_TASKLET_DISABLED（）创建的小任务激活，也得调用这个函数，如：
tasklet_disable(&my_tasklet);        /*小任务现在被禁止,这个小任务不能运行*/
tasklet_enable(&my_tasklet);        /*  小任务现在被激活*/
也可以调用tasklet_kill()函数从挂起的队列中去掉一个小任务。该函数的参数是一个指向某个小任务的tasklet_struct的长指针。在小任务重新调度它自身的时候，从挂起的队列中移去已调度的小任务会很有用。这个函数首先等待该小任务执行完毕，然后再将它移去。
4.tasklet的简单用法
下面是tasklet的一个简单应用,以模块的形成加载。

#include
#include
#include
#include
#include
#include
#include

static struct tasklet_struct my_tasklet;

static void tasklet_handler (unsigned long d ata)
{
    printk("tasklet_handler is running.\n");
}

static int __init test_init(void)
{
    tasklet_init(&my_tasklet,tasklet_handler,0);
    tasklet_schedule(&my_tasklet);
    return0;
}

static  void __exit test_exit(void)
{
    tasklet_kill(&tasklet);
    printk("test_exit is running.\n");
}
MODULE_LICENSE("GPL");
module_init(test_init);
module_exit(test_exit);

从这个例子可以看出，所谓的小任务机制是为下半部函数的执行提供了一种执行机制，也就是说，推迟处理的事情是由tasklet_handler实现，何时执行，经由小任务机制封装后交给内核去处理。

天下 2013-04-10 15:29 发表评论

[原]linux中断处理(1)上半部机制

天下 — Wed, 03 Apr 2013 03:54:00 GMT

linux中断处理(1)上半部机制
应用程序通过/dev/目录中的设备结点操作设备,通过/sys目录中的收集设备信息.
查看中断:
cat /proc/interrupts

查看中断统计:
cat /proc/stat

1、头文件
#include
#include
2、申明中断处理程序
static spinlock_t    wiegand_lock;  // 使用之前必须初始化,spin_lock_init(&wiegand_lock);
static irqreturn_t wiegand_minus1_interrupt(int irq, void *dev_id)
{
    spin_lock(&wiegand_lock);
    //do something
    //wiegand_minus_interrupt();
    spin_unlock(&wiegand_lock);
    return IRQ_HANDLED;
}

3.注册中断 request_irq()
2.6 内核函数原型如下：
extern int __must_check request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags, const char *name, void *dev_id);
第1个参数:中断号,是要申请的中断号
第2个参数:中断处理函数

第3个参数:中断触发标志
    IRQF_DISABLED         快中断(禁止其他中断)
    IRQF_TRIGGER_RISING    设备在中断线上产生一个上升沿时,发出中断.(说明在中断之前,设备一直将中断线保持在一个电平上)
    IRQF_TRIGGER_FALLING    下降沿触发
    IRQF_TRIGGER_HIGH    高电平触发中断
    IRQF_TRIGGER_LOW    低电平触发中断
    IRQF_TRIGGER_RANDOM    为系统随机发生器提供支持
    IRQF_TRIGGER_SHARED    (表示共享相同的中断号,多个设备共享)
/*
* linux/interrupt.h
* These correspond to the IORESOURCE_IRQ_* defines in
* linux/ioport.h to select the interrupt line behaviour.  When
* requesting an interrupt without specifying a IRQF_TRIGGER, the
* setting should be assumed to be "as already configured", which
* may be as per machine or firmware initialisation.
*/
#define IRQF_TRIGGER_NONE    0x00000000
#define IRQF_TRIGGER_RISING    0x00000001
#define IRQF_TRIGGER_FALLING    0x00000002
#define IRQF_TRIGGER_HIGH    0x00000004
#define IRQF_TRIGGER_LOW    0x00000008
#define IRQF_TRIGGER_MASK    (IRQF_TRIGGER_HIGH | IRQF_TRIGGER_LOW | \
                 IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING)
#define IRQF_TRIGGER_PROBE    0x00000010

typedef irqreturn_t (*irq_handler_t)(int, void *);

第4个参数:中断的标识,中断的标识与/proc/interrupts对应
第5个参数:传入中断处理程序的参数，可以为NULL，在注册共享中断时，此参数不能为NULL，作为共享中断时的中断区别参数。

返回值:如果中断处理成功,返回IREQ_HANDLED,否则,返回IRQ_NONE
/* irqreturn.h */
typedef int irqreturn_t;
#define IRQ_NONE    (0)
#define IRQ_HANDLED    (1)
#define IRQ_RETVAL(x)    ((x) != 0)

中断上下文

中断上下文注意事项:
1)中断上下文代码绝不可以停止运行。不能做任何可能发生休眠的操作,在从中断处理函数中调用一个内核API之前,应该仔细分手它,以确保其内部不会触发阻塞等待!

2)为了在中断处理函数中保护临界区,不能使用互斥体,因为它们也许导致睡眠,应该使用自旋锁代替互斥体.

3)中断处理函数不能与用户空间直接交互数据.
调度器工作于进程之间,如果中断处理函数睡眠并被调度出去.无法调度回来!

4)中断处理函数一方面需要快速地为其他进程让出处理器,另一方面又需要完成它的工作,为了规避这种冲突,中断处理函数通常将工作分成两个部分.顶半部设一个标志以宣称它已经服务了该中断,而重大的工作负载都被丢给了底半部,底半部的执行被延后.在其执行环境中,所有的中断都是使能的.

4.释放中断
extern void free_irq(int irq,void *dev_id)

5、启动用禁用中断
extern void disable_irq_nosync(unsigned int irq);
extern void disable_irq(unsigned int irq);
extern void enable_irq(unsigned int irq);

天下 2013-04-03 11:54 发表评论

驱动学习笔记(1)

天下 — Tue, 04 Dec 2012 00:59:00 GMT

内核符号列表:

cat /proc/kallsyms
cat /proc/iomem

导出内核符号:
EXPORT_SYMBOL(sym)
1、缺省情况下，Linux2.6内核中默认不导出所有的符号,即在2.6的内核中没有这个宏EXPORT_NO_SYMBOLS
2、如果想要自己指定导出哪些变量或函数，先在Makefile中使用-DEXPORT_SYMTAB，然后在源文件中使用EXPORT_SYMBOL(xxx);导出之

echo 8 > /proc/sys/kernel/printk

查看中断:
cat /proc/interrupts

下半部机制
1.tasklet
#define DECLARE_TASKLET(name, func, data) \
struct tasklet_struct name = { NULL, 0, ATOMIC_INIT(0), func, data }

2. 工作队列
struct work_struct my_work; //定义一个工作队列
void my_work_func(unsigned long); //定义一个处理函数

在中断处理函数,tasklet和内核定时器等非进程上下文不能阻塞.

天下 2012-12-04 08:59 发表评论

s3c2410的dma操作的一般步骤

天下 — Tue, 04 Dec 2012 00:58:00 GMT

摘要: Code highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/-->s3c2410的dma操作的一般步骤一般的，在s3c2440中，要想进行dma传输，需要一下七个步骤：一：/* s3c2410_request_dma * * ge... 阅读全文

天下 2012-12-04 08:58 发表评论

Linux设备驱动程序学习笔记:(1) 字符设备驱动入门1

天下 — Thu, 08 Nov 2012 08:04:00 GMT

//这是一个最简单的字符设备驱动,入门专用.
//scull1.h
#ifndef _SCULL1_H
#define _SCULL1_H

#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/types.h>
#include <linux/fs.h>
#include <linux/version.h>
#include <asm/uaccess.h>
#include <linux/cdev.h>
#include <linux/mm.h>
#include <linux/errno.h>

#define SCULL_MAJOR 0
#define SCULL_SIZE    0x1000
#define SCULL_CMD_CLEAR    0x01

struct scull_dev{
    struct cdev cDev;
    char   mem[SCULL_SIZE];
};

int scull_open(struct inode* inode,struct file* filp);

ssize_t scull_read(struct file *filp, char __user *buf, size_t count,loff_t *f_pos);

ssize_t scull_write(struct file *filp, const char __user *buf, size_t count,loff_t *f_pos);

int scull_release(struct inode* inode,struct file* filp);

#endif

//scull1.c
#include "scull1.h"

MODULE_LICENSE("Dual BSD/GPL");
MODULE_AUTHOR("Aaron.xu");
MODULE_DESCRIPTION("hello driver test");
MODULE_VERSION("0.1");

static int scull_major = SCULL_MAJOR;
struct scull_dev mydev;

struct file_operations scull_fops =
{
    .owner     = THIS_MODULE,
    .open     = scull_open,
    .release = scull_release,
    .read     = scull_read,
    .write     = scull_write,
};

static void scull_setup_cdev(void)
{
    int err;
    dev_t devid = MKDEV(scull_major,0);


    cdev_init(&mydev.cDev,&scull_fops);

    printk(KERN_INFO "&mydev.cDev.ops:%p \n",&mydev.cDev.ops);

    mydev.cDev.owner    = THIS_MODULE;
    mydev.cDev.ops        = &scull_fops;

    printk(KERN_INFO "&mydev.cDev.ops:%p \n",&mydev.cDev.ops);

    err    = cdev_add(&mydev.cDev,devid,1);
    if (err!=0)
    {
        printk(KERN_ERR "cdev_add Error,err:%d \n",err);
    }
}

static int scull_init(void)
{
    int err;
    dev_t devid = MKDEV(scull_major,0);

    if (scull_major)
    {
        err = register_chrdev_region(devid,1,"scull1");
    }
    else
    {
        err = alloc_chrdev_region(&devid,0,1,"scull1");
        scull_major = MAJOR(devid);
    }

    if (err !=0 )
    {
        printk(KERN_ERR "register chrdev region error,err:%d \n",err);
        return err;
    }

    scull_setup_cdev();
    return 0;
}

static void scull_exit(void)
{
    cdev_del(&mydev.cDev);
    unregister_chrdev_region(MKDEV(scull_major,0),1);
}

int scull_open(struct inode* inode,struct file* filp)
{
    filp->private_data = &mydev;
    return 0;
}

ssize_t scull_read(struct file *filp, char __user *buf, size_t count,loff_t *f_pos)
{
    unsigned long pos = *f_pos;
    int err = 0;
    int ret = 0;
    struct scull_dev* p_mydev = filp->private_data;

    if (pos >= SCULL_SIZE)
    {
        return 0;
    }

    if (count > (SCULL_SIZE - pos) )
    {
        count = SCULL_SIZE - pos;
    }

    err = copy_to_user(buf,p_mydev->mem+pos,count);
    if (err !=0 )
    {
        ret = -EFAULT;
    }
    else
    {
        *f_pos += count;
        ret = count;
        printk(KERN_INFO "read %d byte(s) from %lu \n",ret,pos);
    }
    return ret;
}

ssize_t scull_write(struct file *filp, const char __user *buf, size_t count,loff_t *f_pos)
{
    unsigned long pos = *f_pos;
    int err = 0;
    int ret = 0;
    struct scull_dev* p_mydev = filp->private_data;

    if (pos >= SCULL_SIZE)
    {
        return 0;
    }

    if (count > (SCULL_SIZE - pos) )
    {
        count = SCULL_SIZE - pos;
    }

    err = copy_from_user(p_mydev->mem+pos,buf,count);
    if (err !=0 )
    {
        ret = -EFAULT;
    }
    else
    {
        *f_pos += count;
        ret = count;
        printk(KERN_INFO "write %d byte(s) from %lu \n",ret,pos);
    }
    return ret;
}

int scull_release(struct inode* inode,struct file* filp)
{
    return 0;
}

module_init(scull_init);
module_exit(scull_exit);

//Makefile
obj-m    +=scull1.o
KERNELDIR    := /usr/src/linux-headers-2.6.32-5-686
PWD    :=$(shell pwd)
.PHONY: test clean all
all:
    $(MAKE) -C $(KERNELDIR) M=$(PWD) modules
clean:
    rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.c .tmp_versionsm *.order *.symvers .tmp_versions

test:
    insmod ./scull1.ko
    rmmod scull1
    dmesg -c

//创建设备节点
make_dev_node
#!/bin/bash
DEVICE="scull1"
MAJOR=`awk "\\$2==\"$DEVICE\" {print \\$1}" /proc/devices`
cmd="mknod /dev/$DEVICE c $MAJOR 0"
echo $cmd
`$cmd`

天下 2012-11-08 16:04 发表评论

module_param()说明

天下 — Tue, 06 Nov 2012 07:54:00 GMT

module_param()说明
在用户态下编程可以通过main()的来传递命令行参数，而编写一个内核模块则通过module_param()
module_param宏是Linux 2.6内核中新增的，该宏被定义在include/linux/moduleparam.h文件中，具体定义如下：

#define module_param(name, type, perm)      \
    module_param_named(name, name, type, perm)

其中使用了 3 个参数:要传递的参数变量名, 变量的数据类型, 以及访问参数的权限。

perm参数的作用是什么？

最后的 module_param 字段是一个权限值,表示此参数在sysfs文件系统中所对应的文件节点的属性。你应当使用 <linux/stat.h> 中定义的值. 这个值控制谁可以存取这些模块参数在 sysfs 中的表示.当perm为0时，表示此参数不存在 sysfs文件系统下对应的文件节点。否则, 模块被加载后，在/sys/module/ 目录下将出现以此模块名命名的目录, 带有给定的权限.。
权限在include/linux/stat.h中有定义
比如：
#define S_IRWXU 00700
#define S_IRUSR 00400
#define S_IWUSR 00200
#define S_IXUSR 00100

#define S_IRWXG 00070
#define S_IRGRP 00040
#define S_IWGRP 00020
#define S_IXGRP 00010

#define S_IRWXO 00007
#define S_IROTH 00004
#define S_IWOTH 00002
#define S_IXOTH 00001

使用 S_IRUGO 作为参数可以被所有人读取, 但是不能改变; S_IRUGO|S_IWUSR 允许 root 来改变参数. 注意, 如果一个参数被 sysfs 修改, 你的模块看到的参数值也改变了, 但是你的模块没有任何其他的通知. 你应当不要使模块参数可写, 除非你准备好检测这个改变并且因而作出反应.

>>>

这个宏定义应当放在任何函数之外, 典型地是出现在源文件的前面.定义如：

static char *whom = "world";
static int howmany = 1;
module_param(howmany, int, S_IRUGO);
module_param(whom, charp, S_IRUGO);

模块参数支持许多类型:
bool
invbool
一个布尔型( true 或者 false)值(相关的变量应当是 int 类型). invbool 类型颠倒了值, 所以真值变成 false, 反之亦然.

charp ：一个字符指针值. 内存为用户提供的字串分配, 指针因此设置.
int
long
short
uint
ulong
ushort
基本的变长整型值. 以 u 开头的是无符号值.

数组参数, 用逗号间隔的列表提供的值, 模块加载者也支持. 声明一个数组参数, 使用:
module_param_array(name,type,num,perm);

这里 name 是你的数组的名子(也是参数名),
type 是数组元素的类型,
num 是一个整型变量,
perm 是通常的权限值.

如果数组参数在加载时设置, num 被设置成提供的数的个数. 模块加载者拒绝比数组能放下的多的值.

测试模块，源程序hello.c内容如下：

#include <linux/init.h>
#include <linux/module.h>
#include <linux/moduleparam.h>

MODULE_LICENSE("Dual BSD/GPL");

static char *who= "world";
static int times = 1;
module_param(times,int,S_IRUSR);
module_param(who,charp,S_IRUSR);

static int hello_init(void)
{
    int i;
    for(i=0;i<times;i++)
       printk(KERN_ALERT "(%d) hello, %s!\n",i,who);
     return 0;
}

static void hello_exit(void)
{
    printk(KERN_ALERT"Goodbye, %s!\n",who);
}

module_init(hello_init);
module_exit(hello_exit);

编译生成可执行文件hello

插入:
# insmod hello.ko who="world" times=5

出现5次"hello,world!"：

#（1）hello,world!
#（2）hello,world!
#（3）hello,world!
#（4）hello,world!
#（5）hello,world!

卸载：
# rmmod hello

出现：
#Goodbye,world!

天下 2012-11-06 15:54 发表评论

深入理解linux内核第三版(定时测试)

天下 — Fri, 03 Aug 2012 08:40:00 GMT

天下 2012-08-03 16:40 发表评论

Linux设备驱动程序:gnu make 扩展语法

天下 — Fri, 16 Mar 2012 03:11:00 GMT

要点:
在用户空间驱动程序
insmod
modprobe
rmmod

一些宏:
LINUX_VERSION_CODE
整数宏

GNU make 扩展语法

obj-m   +=hello.o
KERNELDIR   := /usr/src/linux-headers-2.6.32-5-686
PWD :=$(shell pwd)
.PHONY: test clean all
all:
    $(MAKE) -C $(KERNELDIR) M=$(PWD) modules
clean:
    rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.c .tmp_versionsm *.order *.symvers .tmp_versions

test:
    insmod ./hello.ko
    rmmod hello
    dmesg -c

obj-m
由内核构造系统使用的makefilet符号,用来确定在当前目录中应构造哪些模块.
即m:指定把对象编译为模块

obj-y
指定把对象编译进内核中

如果我们要构造的模块为module.ko,并由file1.c和file2.c则正确的makefile可如下编写:
obj-m :=module.o
module-objs :=file1.o file2.o

为了让上面的makefile可以工作,必须在大的内核构造系统环境中调用它们,所以上述命令首先要改变-C指定的目录,即:
$(MAKE) -C $(KERNELDIR)
然后指定M变量目录,即让makefile在构造modules目标之前返回到模块源代码的目录,既当前目录 M=$(PWD),最后modules目标指向obj-m变量中设定的模块.

M不是一个编译选项，而是一个变量，从顶层makefile文件里可以找到它的定义
文件在
/usr/src/linux-headers-2.6.32-5-common/Makefile

69 ifeq ("$(origin M)", "command line")
70 KBUILD_EXTMOD := $(M)
71 endif

-C 用于指定内核源代码的目录

-M 用于module所在的目录

如果一个模块包括了多个.c文件(如 file1.c , file2.c),则应该以如下方式编写Makefile
obj-m := modulename.o
module-objs := file1.o file2.o

天下 2012-03-16 11:11 发表评论

中断及中断处理过程

天下 — Wed, 16 Nov 2011 09:25:00 GMT

中断及中断处理过程

1. 中断和异常的概念区别

Intel的官方文档里将中断和异常理解为两种中断当前程序执行的不同机制。这是中断和异常的共同点。不同点在于：

中断(interrupt)是异步的事件，典型的比如由I/O设备触发；异常(exception)是同步的事件，典型的比如处理器执行某条指令时发现出错了等等。

中断又可以分为可屏蔽中断和非可屏蔽中断，异常又分为故障、陷阱和异常中止3种，它们的具体区别很多书籍和官方文档都解释的比较清楚这里不再赘述。

关于它们的区别有两点是需要注意的：

1）平常所说的屏蔽中断是不包括异常的，即异常不会因为CPU的IF位被清（关中断，指令：cli）而受影响，比如缺页异常，即使关了中断也会触发CPU的处理。

2）通常说的int 80h这种系统调用使用的中断方式实际上硬件上是理解为异常处理的，因此也不会被屏蔽掉，这也很好理解，int 80h这种中断方式是程序里主动触发的，对于CPU来说属于同步事件，因此也就属于异常的范畴。

2. 中断（异常）处理过程

需要明确的一点是CPU对于中断和异常的具体处理机制本质上是完全一致的，即：

当CPU收到中断或者异常的信号时，它会暂停执行当前的程序或任务，通过一定的机制跳转到负责处理这个信号的相关处理程序中，在完成对这个信号的处理后再跳回到刚才被打断的程序或任务中。这里只描述保护模式下的处理过程，搞清楚了保护模式下的处理过程（更复杂），实模式下的处理机制也就容易理解了。

具体的处理过程如下：

0）中断响应的事前准备：

系统要想能够应对各种不同的中断信号，总的来看就是需要知道每种信号应该由哪个中断服务程序负责以及这些中断服务程序具体是如何工作的。系统只有事前对这两件事都知道得很清楚，才能正确地响应各种中断信号和异常。

[a]系统将所有的中断信号统一进行了编号（一共256个：0～255），这个号称为中断向量，具体哪个中断向量表示哪种中断有的是规定好的，也有的是在给定范围内自行设定的。

中断向量和中断服务程序的对应关系主要是由IDT（中断向量表）负责。操作系统在IDT中设置好各种中断向量对应的中断描述符（一共有三类中断门描述符：任务门、中断门和陷阱门），留待CPU查询使用。而IDT本身的位置是由idtr保存的，当然这个地址也是由OS填充的。

[b]中断服务程序具体负责处理中断（异常）的代码是由软件，也就是操作系统实现的，这部分代码属于操作系统内核代码。也就是说从CPU检测中断信号到加载中断服务程序以及从中断服务程序中恢复执行被暂停的程序，这个流程基本上是硬件确定下来的，而具体的中断向量和服务程序的对应关系设置和中断服务程序的内容是由操作系统确定的。

1）CPU检查是否有中断/异常信号

CPU在执行完当前程序的每一条指令后，都会去确认在执行刚才的指令过程中中断控制器（如：8259A）是否发送中断请求过来，如果有那么CPU就会在相应的时钟脉冲到来时从总线上读取中断请求对应的中断向量[2]。

对于异常和系统调用那样的软中断，因为中断向量是直接给出的，所以和通过IRQ（中断请求）线发送的硬件中断请求不同，不会再专门去取其对应的中断向量。

2）根据中断向量到IDT表中取得处理这个向量的中断程序的段选择符

CPU根据得到的中断向量到IDT表里找到该向量对应的中断描述符，中断描述符里保存着中断服务程序的段选择符。

3）根据取得的段选择符到GDT中找相应的段描述符

CPU使用IDT查到的中断服务程序的段选择符从GDT中取得相应的段描述符，段描述符里保存了中断服务程序的段基址和属性信息，此时CPU就得到了中断服务程序的起始地址。

这里，CPU会根据当前cs寄存器里的CPL和GDT的段描述符的DPL，以确保中断服务程序是高于当前程序的，如果这次中断是编程异常（如：int 80h系统调用），那么还要检查CPL和IDT表中中断描述符的DPL，以保证当前程序有权限使用中断服务程序，这可以避免用户应用程序访问特殊的陷阱门和中断门[3]。

4）CPU根据特权级的判断设定即将运行的中断服务程序要使用的栈的地址

CPU会根据CPL和中断服务程序段描述符的DPL信息确认是否发生了特权级的转换，比如当前程序正运行在用户态，而中断程序是运行在内核态的，则意味着发生了特权级的转换，这时CPU会从当前程序的TSS信息（该信息在内存中的首地址存在TR寄存器中）里取得该程序的内核栈地址，即包括ss和esp的值，并立即将系统当前使用的栈切换成新的栈。这个栈就是即将运行的中断服务程序要使用的栈。紧接着就将当前程序使用的ss,esp压到新栈中保存起来。

6）保护当前程序的现场

CPU开始利用栈保护被暂停执行的程序的现场：依次压入当前程序使用的eflags，cs，eip，errorCode（如果是有错误码的异常）信息。

官方文档[1]给出的栈变化的示意图如下：

7）跳转到中断服务程序的第一条指令开始执行

CPU利用中断服务程序的段描述符将其第一条指令的地址加载到cs和eip寄存器中，开始执行中断服务程序。这意味着先前的程序被暂停执行，中断服务程序正式开始工作。

8）中断服务程序处理完毕，恢复执行先前中断的程序

在每个中断服务程序的最后，必须有中断完成返回先前程序的指令，这就是iret（或iretd）。程序执行这条返回指令时，会从栈里弹出先前保存的被暂停程序的现场信息，即eflags,cs,eip重新开始执行。

天下 2011-11-16 17:25 发表评论

Debian 6 驱动开发环境搭建

天下 — Tue, 01 Nov 2011 06:24:00 GMT

Debian 6 驱动开发环境搭建
1.安装相关工具
apt-get install -y gcc g++ gdb make build-essential

2.查看系统版本,并安装内核头文件
root@192.168.20.128:~/ # uname -r
2.6.32-5-686
apt-cache search linux-headers-2.6.32-5-686
apt-get install -y linux-headers-2.6.32-5-686

3.查看内核头文件位置
看下会安装到哪:
apt-cache show linux-headers-2.6.32-5-686

有这么句:
These files are going to be installed into
/usr/src/linux-headers-2.6.32-5-686, and can be used for building modules

就是这里啦.
/usr/src/linux-headers-2.6.32-5-686

4.好了,接下来写测试例子:hello,抄了http://bbs.chinaunix.net/thread-3570849-1-1.html
上的代码:
文件1:hello.c
#include
#include
MODULE_LICENSE("GPL");

static int hello_init(void)
{
    printk(KERN_ALERT "Hello, world\n");
    return 0;
}

static void hello_exit(void)
{
    printk(KERN_ALERT "Goodbye, cruel world\n");
}

module_init(hello_init);
module_exit(hello_exit);

文件2:Makefile:
obj-m   +=hello.o
KERNELDIR   := /usr/src/linux-headers-2.6.32-5-686
PWD :=$(shell pwd)
.PHONY: test clean all
all:
    $(MAKE) -C $(KERNELDIR) M=$(PWD) modules
clean:
    rm -rf *.o *~ core .depend .*.cmd *.ko *.mod.c .tmp_versionsm *.order *.symvers

test:
    insmod ./hello.ko
    rmmod hello
    dmesg -c

5.好了,现在测试开始,成功的话,就可以看到下面的文字了.
如果有问题的话,向google大神请教吧.另外要看
root@192.168.20.128:~/cpp # make
make -C /usr/src/linux-headers-2.6.32-5-686 M=/root/cpp modules
make[1]: Entering directory `/usr/src/linux-headers-2.6.32-5-686'
  CC [M]  /root/cpp/hello.o
  Building modules, stage 2.
  MODPOST 1 modules
  CC      /root/cpp/hello.mod.o
  LD [M]  /root/cpp/hello.ko
make[1]: Leaving directory `/usr/src/linux-headers-2.6.32-5-686'
root@192.168.20.128:~/cpp # make test
insmod ./hello.ko
rmmod hello
dmesg -c
[  673.500413] Hello, world
[  673.504907] Goodbye, cruel world
root@192.168.20.128:~/cpp #

6.最后.安装开发帮助文档
apt-get install -y manpages-kernel-dev linux-manual
man 9 printk
man 9 module_init

参考资料:
http://bbs.chinaunix.net/thread-3570849-1-1.html

天下 2011-11-01 14:24 发表评论