久久久久久毛片免费播放,精品蜜臀久久久久99网站,久久久久久无码Av成人影院

韦根驱动

天下 — 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 发表评论

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

Linux内核的同步机�?2)信号量（semaphore�Q?br />
　　信号量在创徏旉��要设�|�一个初始��|��表示同时可以有几个�Q务可以访问该信号量保护的�׃�n资源�Q�初始��gؓ1��变成互斥锁�Q�Mutex�Q�，卛_��时只能有一个�Q务可以访问信号量保护的共享资源�?br />
　　一个�Q务要惌��问共享资源，首先必须得到信号量，获取信号量的操作��把信号量的值减1�Q�若当前信号量的��gؓ负数�Q�表明无法获得信号量�Q�该��d��必须挂�v在该信号量的�{�待队列�{�待该信号量可用�Q�若当前信号量的��gؓ非负敎ͼ�表示可以获得信号量，因而可以立刻访问被该信号量保护的共享资源�?br />
　　当�Q务访问完被信号量保护的共享资源后�Q�必��释放信号量�Q�释放信号量通过把信号量的值加1实现�Q�如果信号量的��gؓ非正敎ͼ�表明有�Q务等待当前信号量�Q�因此它也唤醒所有等待该信号量的��d��?br />
信号量的API有：
DECLARE_MUTEX(name)
该宏声明一个信号量name�q�初始化它的��gؓ1�Q�即声明一个互斥锁�?br />
//在Linux2.6.26中没扑ֈ�该宏
DECLARE_MUTEX_LOCKED(name)
该宏声明一个互斥锁name�Q�但把它的初始��D��|��ؓ0�Q�即锁在创徏时就处在已锁状态。因此对于这�U�锁�Q�一般是先释攑֐�获得�?br />
void sema_init (struct semaphore *sem, int val);
该函用于数初始化讄��信号量的初��|��它设�|�信号量sem的��gؓval�?br />
void init_MUTEX (struct semaphore *sem);
该函数用于初始化一个互斥锁�Q�即它把信号量sem的��D��|��ؓ1�?br />
void init_MUTEX_LOCKED (struct semaphore *sem);
该函��C��用于初始化一个互斥锁�Q�但它把信号量sem的��D��|��ؓ0�Q�即一开始就处在已锁状态�?br />
void down(struct semaphore * sem);
该函数用于获得信号量sem�Q�它会导致睡眠，因此不能在中断上下文�Q�包括IRQ上下文和softirq上下文）使用该函数。该函数��把sem的值减1�Q�如果信号量sem的值非负，��q��接返回，否则调用者将被挂��P��直到别的��d��释放该信号量才能�l�箋�q�行�?br />
int down_interruptible(struct semaphore * sem);
该函数功能与down�c�M��Q�不同之处�ؓ�Q�down不会被信��P��signal�Q�打断，但down_interruptible能被信号打断�Q�因此该函数有返回值来区分是正常返回还是被信号中断�Q�如果返�?�Q�表�C��得信号量正常�q�回�Q�如果被信号打断�Q�返�?EINTR�?br />
int down_trylock(struct semaphore * sem);
该函数试着获得信号量sem�Q�如果能够立刻获得，它就获得该信号量�q�返�?�Q�否则，表示不能获得信号量sem�Q�返回��gؓ�?倹{��因此，它不会导致调用者睡眠，可以在中断上下文使用�?br />
void up(struct semaphore * sem);
该函数释放信号量sem�Q�即把sem的值加1�Q�如果sem的��gؓ非正敎ͼ�表明有�Q务等待该信号量，因此唤醒�q�些�{�待者�?nbsp;

头文�?
#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 发表评论

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

Linux内核的同步机�?1)、自旋锁�Q�spinlock�Q?br />
　　自旋锁与互斥锁有点类��|��只是自旋锁不会引赯��用者睡眠，如果自旋锁已�l�被别的执行单元保持�Q�调用者就一直��@环在那里看是否该自旋锁的保持者已�l�释放了锁，"自旋"一词就是因此而得名�?br />
　　�׃��自旋锁��用者一般保持锁旉��非常短，因此选择自旋而不是睡眠是非常必要的，自旋锁的效率�q�高于互斥锁�?br />
　　信号量和��d��信号量适合于保持时间较长的情况�Q�它们会��D��调用者睡眠，因此只能在进�E�上下文使用�Q�_trylock的变�U�能够在中断上下文��用）�Q�而自旋锁适合于保持时间非常短的情况，它可以在��M��上下文��用�?br />
　　如果被保护的�׃�n资源只在�q�程上下文访问，使用信号量保护该�׃�n资源非常合适，如果对共巯��源的讉K��旉��非常短，自旋锁也可以。但是如果被保护的共享资源需要在中断上下文访问（包括底半部即中断处理句柄和顶半部卌��Y中断�Q�，��必��M��用自旋锁�?br />
　　自旋锁保持期间是抢占失效的，而信号量和读写信号量保持期间是可以被抢占的。自旋锁只有在内核可抢占或SMP的情况下才真正需要，在单CPU且不可抢占的内核下，自旋锁的所有操作都是空操作�?br />
　　跟互斥锁一��P��一个执行单元要惌��问被自旋锁保护的�׃�n资源�Q�必��d��得到锁，在访问完�׃�n资源后，必须释放锁。如果在获取自旋锁时�Q�没有�Q何执行单元保持该锁，那么��立卛_��到锁�Q�如果在获取自旋锁时锁已�l�有保持者，那么获取锁操作将自旋在那里，直到该自旋锁的保持者释放了锁�?br />
　　无论是互斥锁�Q�还是自旋锁�Q�在��M��时刻�Q�最多只能有一个保持者，也就��_��在�Q何时��L��多只能有一个执行单元获得锁�?br />
自旋锁的API有：

spin_lock_init(x)
该宏用于初始化自旋锁x。自旋锁在真正��用前必须先初始化。该宏用于动态初始化�?br />
DEFINE_SPINLOCK(x)
该宏声明一个自旋锁x�q�初始化它。该宏在2.6.11中第一�ơ被定义�Q�在先前的内�怸��q�没有该宏�?br />
SPIN_LOCK_UNLOCKED
该宏用于静态初始化一个自旋锁�?br />
DEFINE_SPINLOCK(x)�{�同于spinlock_t x = SPIN_LOCK_UNLOCKED

spin_is_locked(x)
该宏用于判断自旋锁x是否已经被某执行单元保持�Q�即被锁�Q�，如果是，�q�回真，否则�q�回假�?br />
spin_unlock_wait(x)
该宏用于�{�待自旋锁x变得没有被�Q何执行单元保持，如果没有��M��执行单元保持该自旋锁�Q�该宏立卌��回，否则��@环在那里�Q�直到该自旋锁被保持者释放�?br />
spin_trylock(lock)
该宏��力获得自旋锁lock�Q�如果能立即获得锁，它获得锁�q�返回真�Q�否则不能立卌��得锁�Q�立卌��回假。它不会自旋�{�待lock被释放�?br />
spin_lock(lock)
该宏用于获得自旋锁lock�Q�如果能够立卌��得锁�Q�它��马上返回，否则�Q�它��自旋在那里�Q�直到该自旋锁的保持者释放，�q�时�Q�它获得锁�ƈ�q�回。��M��Q�只有它获得锁才�q�回�?br />
spin_lock_irqsave(lock, flags)
该宏获得自旋锁的同时把标志寄存器的��g��存到变量flags中�ƈ失效本地中断�?br />
spin_lock_irq(lock)
该宏�c�M��于spin_lock_irqsave�Q�只是该宏不保存标志寄存器的倹{�?br />
spin_lock_bh(lock)
该宏在得到自旋锁的同时失效本地��Y中断�?br />
spin_unlock(lock)
该宏释放自旋锁lock�Q�它与spin_trylock或spin_lock配对使用。如果spin_trylock�q�回假，表明没有获得自旋锁，因此不必使用spin_unlock释放�?br />
spin_unlock_irqrestore(lock, flags)
该宏释放自旋锁lock的同�Ӟ��也恢复标志寄存器的��gؓ变量flags保存的倹{��它与spin_lock_irqsave配对使用�?br />
spin_unlock_irq(lock)
该宏释放自旋锁lock的同�Ӟ��也��能本��C��断。它与spin_lock_irq配对应用�?br />
spin_unlock_bh(lock)
该宏释放自旋锁lock的同�Ӟ��也��能本地的软中断。它与spin_lock_bh配对使用�?br />
spin_trylock_irqsave(lock, flags)
该宏如果获得自旋锁lock�Q�它也将保存标志寄存器的值到变量flags中，�q�且失效本地中断�Q�如果没有获得锁�Q�它什么也不做�?br />　　因此如果能够立即获得锁，它等同于spin_lock_irqsave�Q�如果不能获得锁�Q�它�{�同于spin_trylock。如果该宏获得自旋锁lock�Q�那需要��用spin_unlock_irqrestore来释放�?br />
spin_trylock_irq(lock)
该宏�c�M��于spin_trylock_irqsave�Q�只是该宏不保存标志寄存器。如果该宏获得自旋锁lock�Q�需要��用spin_unlock_irq来释放�?br />
spin_trylock_bh(lock)
该宏如果获得了自旋锁�Q�它也将失效本地软中断。如果得不到锁，它什么也不做。因此，如果得到了锁�Q�它�{�同于spin_lock_bh�Q�如果得不到锁，它等同于spin_trylock。如果该宏得��C��自旋锁，需要��用spin_unlock_bh来释放�?br />
spin_can_lock(lock)
该宏用于判断自旋锁lock是否能够被锁�Q�它实际是spin_is_locked取反。如果lock没有被锁�Q�它�q�回真，否则�Q�返回假。该宏在2.6.11中第一�ơ被定义�Q�在先前的内�怸��q�没有该宏�?nbsp;

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

　　如果被保护的�׃�n资源只在�q�程上下文访问和软中断上下文讉K��Q�那么当在进�E�上下文讉K��׃�n资源�Ӟ��可能被��Y中断打断�Q�从而可能进入��Y中断上下文来对被保护的共享资源访问，因此对于�q�种情况�Q�对�׃�n资源的访问必��M��用spin_lock_bh和spin_unlock_bh来保护�?nbsp;

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

　　如果被保护的�׃�n资源只在�q�程上下文和tasklet或timer上下文访问，那么应该使用与上面情�늛�同的获得和释��N��的宏�Q�因为tasklet和timer是用软中断实现的�?nbsp;

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

　　timer也是在其被��用add_timer��d��到timer队列中时已经被帮定到当前CPU�Q�所以同一个timer�l�不可能�q�行在其他CPU上。当然同一个tasklet有两个实例同时运行在同一个CPU��更不可能了�?nbsp;

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

　　如果被保护的�׃�n资源只在一个��Y中断�Q�tasklet和timer除外�Q�上下文讉K��Q�那么这个共享资源需要用spin_lock和spin_unlock来保护，因�ؓ同样的��Y中断可以同时在不同的CPU上运行�?nbsp;

　　如果被保护的�׃�n资源在两个或多个软中断上下文讉K��Q�那么这个共享资源当然更需要用spin_lock和spin_unlock来保护，不同的��Y中断能够同时在不同的CPU上运行�?nbsp;

　　如果被保护的�׃�n资源在��Y中断�Q�包括tasklet和timer�Q�或�q�程上下文和��中断上下文讉K��Q�那么在软中断或�q�程上下文访问期��_��可能被硬中断打断�Q�从而进入硬中断上下文对�׃�n资源�q�行讉K��Q�因此，在进�E�或软中断上下文需要��用spin_lock_irq和spin_unlock_irq来保护对�׃�n资源的访问�?nbsp;

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

　　因�ؓ在执行中断处理句柄期��_��不可能被同一CPU上的软中断或�q�程打断。但是如果有不同的中断处理句柄访问该�׃�n资源�Q�那么需要在中断处理句柄中��用spin_lock_irq和spin_unlock_irq来保护对�׃�n资源的访问�?nbsp;

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

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

　　当然�Q�有些情况下需要在讉K��׃�n资源时必��M��断失效，而访问完后必��M��断��能，�q�样的情形��用spin_lock_irq和spin_unlock_irq最好�?nbsp;

　　需要特别提醒读者，spin_lock用于��L��在不同CPU上的执行单元对共享资源的同时讉K��以及不同�q�程上下文互相抢占导致的对共享资源的非同步访问，而中断失效和软中断失效却是�ؓ了阻止在同一CPU上��Y中断或中断对�׃�n资源的非同步讉K��?nbsp;
　　

#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
适用于性能敏感的子�pȝ��

2.tasklet
建立在softirq之上,使用更简�?br />softirq的不同实例可�q�行在不同的处理器上,而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;      //定义一个工作队�?/span>
void my_work_func(unsigned long); //定义一个处理函�?/span>

头文�?br />#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 }

使用�C�Z��:
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是作��Z��断下半部的一个很好的选择�Q�它在性能和易用性之间有着很好的��^衡。较之于softirq�Q�tasklet不需要考虑SMP下的�q�行问题�Q�而又比workqueues有着更好的性能�?br />tasklet通常作�ؓ��中断的下半部来使用�Q�在��中断中调用tasklet_schedule(t)。每�ơ硬中断都会触发一�ơtasklet_schedule(t)�Q�但是每�ơ中断它只会向其中的一个CPU注册�Q�而不是所有的CPU。完成注册后的tasklet由tasklet_action()来执行，在SMP环境下，它保证同一时刻�Q�同一个tasklet只有一个副本在�q�行�Q�这样就避免了��用softirq所要考虑的互斥的问题。再者，tasklet在执行tasklet->func()前，再一�ơ允许tasklet可调度（注册�Q�，但是在该tasklet已有一个副本在其他CPU上运行的情况下，它只能退后执行。��M��Q�同一个硬中断引�v的一个tasklet_schedule()动作只会使一个tasklet被注册，而不同中断引��L��tasklet则可能在不同的时刻被注册而多�ơ被执行�?br />
tasklet的互斥。由于同一个tasklet不能有多个副本同时运行，所以不需要在多CPU之间互斥。在tasklet�q�行的过�E�中�Q�它会被��中断打断（�q�也是��Y中断的优点）�Q�所以如果tasklet和其他中断之间的互斥有可能存在�?br />中断服务�E�序一般都是在中断��h��关闭的条件下执行�?以避免嵌套而��中断控制复杂化。但是，中断是一个随��Z��Ӟ��它随时会到来�Q�如果关中断的时间太长，CPU��׃��能及时响应其他的中断��h��Q�从而造成中断的丢失。因此，Linux内核的目标就是尽可能快的处理完中断请求，��其所能把更多的处理向后推�q�。例如，假设一个数据块已经辑ֈ�了网�U�，当中断控制器接受到这个中断请求信��h��Q�Linux内核只是��单地标志数据到来了，然后让处理器恢复到它以前�q�行的状态，其余的处理稍后再�q�行�Q�如把数据移入一个缓冲区�Q�接受数据的�q�程��可以在�~�冲区找到数据）。因此，内核把中断处理分��Z��部分�Q�上半部�Q�tophalf�Q�和下半部（bottomhalf�Q�，上半部（��是中断服务�E�序�Q�内核立��x��行，而下半部�Q�就是一些内核函敎ͼ�留着�E�后处理�Q?br />
首先�Q�一个快速的“上半�?#8221;来处理硬件发出的��h��Q�它必须在一个新的中断��生之前终止。通常�Q�除了在讑֤�和一些内存缓冲区�Q�如果你的设备用��C��DMA�Q�就不止�q�些�Q�之间移动或传送数据，��定��g是否处于健全的状态之外，�q�一部分做的工作很少�?br />
下半部运行时是允�怸�断请求的�Q�而上半部�q�行时是关中断的�Q�这是二者之间的主要区别�?br />
但是�Q�内核到底什时候执行下半部�Q�以何种方式�l�织下半部？�q�就是我们要讨论的下半部实现机制�Q�这�U�机制在内核的演变过�E�中不断得到改进�Q�在以前的内�怸��Q�这个机制叫做bottomhalf(��U�bh)�Q�在2.4以后的版本中有了新的发展和改�q�，改进的目标��下半部可以在多处理机上�ƈ行执行，�q�有助于驱动�E�序的开发者进行驱动程序的开发。下面主要介�l�常用的��Q�?Tasklet)机制�?.6内核中的工作队列机制�?br />
�q�里的小��d��是指对要推迟执行的函数进行组�l�的一�U�机制。其数据�l�构为tasklet_struct�Q�每个结构代表一个独立的��Q务，其定义如下：
structtasklet_struct {
    structtasklet_struct *next;         /*指向链表中的下一个结�?/span>*/
    unsignedlong state;                 /* ��Q务的状�?/span>*/
    atomic_t count;                        /* 引用计数�?/span>*/
    void(*func) (unsigned long);        /* 要调用的函数*/
    unsignedlong data;                  /* 传递给函数的参�?/span>*/
}�Q?br />�l�构中的func域就是下半部中要推迟执行的函敎ͼ�data是它唯一的参数�?br />state域的取��gؓTASKLET_STATE_SCHED或TASKLET_STATE_RUN。TASKLET_STATE_SCHED表示��Q务已被调度，正准备投入运行，TASKLET_STATE_RUN表示��Q务正在运行。TASKLET_STATE_RUN只有在多处理器系�l�上才��用，单处理器�pȝ��什么时候都清楚一个小��d��是不是正在运行（它要么就是当前正在执行的代码�Q�要么不是）�?br />count 域是��Q务的引用计数器。如果它不�ؓ0�Q�则��Q务被��止�Q�不允许执行�Q�只有当它�ؓ�Ӟ��Q务才被激�z�，�q�且在被讄��为挂��h��Q�小��d��才能够执行�?br />1. 声明和��用小��d��大多数情况下�Q��ؓ了控制一个寻常的��g讑֤��Q�小��d��机制是实��C��半部的最佳选择。小��d��可以动态创建，使用方便�Q�执行�v来也比较快�?br />我们既可以静态地创徏��Q务，也可以动态地创徏它。选择那种方式取决于到底是惌��对小��d��q�行直接引用�q�是一个间接引用。如果准备静态地创徏一个小��d��Q�也��是对它直接引用�Q�，使用下面两个宏中的一个：
DECLARE_TASKLET(name,func, data)
DECLARE_TASKLET_DISABLED(name,func, data)
�q�两个宏都能�Ҏ��l�定的名字静态地创徏一个tasklet_struct�l�构。当该小��d��被调度以后，�l�定的函数func会被执行�Q�它的参数由data�l�出。这两个宏之间的区别在于引用计数器的初始��D��|�不同。第一个宏把创建的��Q务的引用计数器设�|��ؓ0�Q�因此，该小��d��处于�Ȁ�zȝ��态。另一个把引用计数器设�|��ؓ1�Q�所以该��Q务处于禁止状态。例如：
DECLARE_TASKLET(my_tasklet,my_tasklet_handler, dev);
�q�行代码其实�{��h�?br />struct tasklet_struct my_tasklet = { NULL, 0, ATOMIC_INIT(0),tasklet_handler,dev};
�q�样��创��Z��一个名为my_tasklet的小��d��Q�其处理�E�序为tasklet_handler�Q��ƈ且已被激�z�R��当处理�E�序被调用的时候，dev��׃��被传递给它�?br />2.  �~�写自己的小��d��处理�E�序��Q务处理程序必��ȝ��合如下的函数�c�d��Q?br />void tasklet_handler(unsigned long data)
�׃��Q务不能睡眠，因此不能在小��d��中��用信号量或者其它��生阻塞的函数。但是小��d��q�行时可以响应中断�?br />3. 调度自己的小��d��通过调用tasklet_schedule()函数�q�传递给它相应的tasklt_struct指针�Q�该��Q务就会被调度以便适当的时候执行：
tasklet_schedule(&my_tasklet);        /*把my_tasklet标记为挂�?nbsp;*/
在小��d��被调度以后，只要有机会它��׃��可能早的运行。在它还没有得到�q�行��Z��之前�Q�如果一个相同的��Q务又被调度了�Q�那么它仍然只会�q�行一�ơ�?br />可以调用tasklet_disable()函数来禁止某个指定的��Q务。如果该��Q务当前正在执行，�q�个函数会等到它执行完毕再返回。调用tasklet_enable()函数可以�Ȁ�z�M��个小��d��Q�如果希望把以DECLARE_TASKLET_DISABLED�Q�）创徏的小��d��Ȁ�z�，也得调用�q�个函数�Q�如�Q?br />tasklet_disable(&my_tasklet);        /*��Q务现在被��止,�q�个��Q务不能运�?/span>*/
tasklet_enable(&my_tasklet);        /*  ��Q务现在被�Ȁ�z?/span>*/
也可以调用tasklet_kill()函数从挂��L��队列中去掉一个小��d��。该函数的参数是一个指向某个小��d��的tasklet_struct的长指针。在��Q务重新调度它自��n的时候，从挂��L��队列中移��d��调度的小��d��会很有用。这个函数首先等待该��Q务执行完毕，然后再将它移厅R�?br />4.tasklet的简单用�?br />下面是tasklet的一个简单应�?以模块的形成加蝲�?br />
#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);

从这个例子可以看出，所谓的��Q务机制是��Z��半部函数的执行提供了一�U�执行机�Ӟ��也就是说�Q�推�q�处理的事情是由tasklet_handler实现�Q�何时执行，�l�由��Q务机制封装后交给内核��d��理�?/div>

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

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

linux中断处理(1)上半部机�?br />应用�E�序通过/dev/目录中的讑֤��l�点操作讑֤�,通过/sys目录中的攉��讑֤�信息.
查看中断:
cat /proc/interrupts

查看中断�l�计:
cat /proc/stat

1、头文�g
#include
#include
2、申明中断处理程�?nbsp;
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 内核函数原型如下�Q?br />extern int __must_check request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags, const char *name, void *dev_id);
�W?个参�?中断�?是要甌��的中断号
�W?个参�?中断处理函数

�W?个参�?中断触发标志
    IRQF_DISABLED         快中�?��止其他中断)
    IRQF_TRIGGER_RISING    讑֤�在中断线上��生一个上升沿�?发出中断.(说明在中断之�?讑֤�一直将中断�U�保持在一个电�q�上)
    IRQF_TRIGGER_FALLING    下降沿触�?br />    IRQF_TRIGGER_HIGH    高电�q��发中�?br />    IRQF_TRIGGER_LOW    低电�q��发中�?br />    IRQF_TRIGGER_RANDOM    为系�l�随机发生器提供支持
    IRQF_TRIGGER_SHARED    (表示�׃�n相同的中断号,多个讑֤��׃�n)
/*
* 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 *);

�W?个参�?中断的标�?中断的标识与/proc/interrupts对应
�W?个参�?传入中断处理�E�序的参敎ͼ�可以为NULL�Q�在注册�׃�n中断�Ӟ��此参��C��能�ؓNULL�Q�作为共享中断时的中断区别参数�?br />
�q�回�?如果中断处理成功,�q�回IREQ_HANDLED,否则,�q�回IRQ_NONE
/* irqreturn.h */
typedef int irqreturn_t;
#define IRQ_NONE    (0)
#define IRQ_HANDLED    (1)
#define IRQ_RETVAL(x)    ((x) != 0)

中断上下�?br />
中断上下文注意事��?
1)中断上下文代码绝不可以停止运行。不能做��M��可能发生休眠的操�?在从中断处理函数中调用一个内核API之前,应该仔细分手�?以确保其内部不会触发��d��{�待!

2)��Z��在中断处理函��C��保护临界�?不能使用互斥�?因�ؓ它们也许��D��睡眠,应该使用自旋锁代替互斥体.

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

4)中断处理函数一斚w��需要快速地为其他进�E�让出处理器,另一斚w��又需要完成它的工�?��Z��规避�q�种冲突,中断处理函数通常��工作分成两个部�?��半部设一个标志以宣称它已�l�服务了该中�?而重大的工作负蝲都被丢给了底半部,底半部的执行被�g�?在其执行环境�?所有的中断都是使能�?

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 发表评论

驱动学习�W�记(1)

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

内核�W�号列表:

cat /proc/kallsyms
cat /proc/iomem

导出内核�W�号:
EXPORT_SYMBOL(sym)
1、缺省情况下�Q�Linux2.6内核中默认不导出所有的�W�号,卛_��2.6的内�怸�没有�q�个宏EXPORT_NO_SYMBOLS
2、如果想要自己指定导出哪些变量或函数�Q�先在Makefile中��?/span>-DEXPORT_SYMTAB�Q�然后在源文件中使用EXPORT_SYMBOL(xxx);导出�?br />
echo 8 > /proc/sys/kernel/printk

查看中断:
cat /proc/interrupts

下半部机�?br />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; //定义一个工作队�?/span>
void my_work_func(unsigned long); //定义一个处理函�?/span>

在中断处理函�?tasklet和内核定时器�{�非�q�程上下文不能阻�?

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

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

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

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

Linux讑֤�驱动�E�序学习�W�记:(1) 字符讑֤�驱动入门1

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

//�q�是一个最��单的字符讑֤�驱动,入门专用.
//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()说明
在用��h��下�~�程可以通过main()的来传递命令行参数�Q�而编写一个内核模块则通过module_param()
module_param宏是Linux 2.6内核中新增的�Q�该宏被定义在include/linux/moduleparam.h文�g中，具体定义如下�Q?br />
#define module_param(name, type, perm)      \
    module_param_named(name, name, type, perm)

其中使用�?nbsp;3 个参�?要传递的参数变量�? 变量的数据类�? 以及讉K��参数的权限�?br />
perm参数的作用是什么？

最后的 module_param 字段是一个权限�?表示此参数在sysfs文�g�pȝ��中所对应的文件节点的属性。你应当使用 <linux/stat.h> 中定义的�? �q�个值控制谁可以存取�q�些模块参数�?nbsp;sysfs 中的表示.当perm�?�Ӟ��表示此参��C��存在 sysfs文�g�pȝ��下对应的文�g节点�?nbsp;否则, 模块被加载后�Q�在/sys/module/ 目录下将出现以此模块名命名的目录, 带有�l�定的权�?�?br />权限在include/linux/stat.h中有定义
比如�Q?br />#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 作�ؓ参数可以被所有�h��d��, 但是不能改变; S_IRUGO|S_IWUSR 允许 root 来改变参�? 注意, 如果一个参数被 sysfs 修改, 你的模块看到的参数��g��改变�? 但是你的模块没有��M��其他的通知. 你应当不要��模块参数可写, 除非你准备好��这个改变�ƈ且因而作出反�?

>>>

�q�个宏定义应当放在�Q何函��C��? 典型地是出现在源文�g的前�?定义如：

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

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

charp �Q�一个字�W�指针�? 内存为用��h��供的字串分配, 指针因此讄��.
int
long
short
uint
ulong
ushort
基本的变长整型�? �?nbsp;u 开头的是无�W�号�?

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

�q�里 name 是你的数�l�的名子(也是参数�?,
type 是数�l�元素的�c�d��,
num 是一个整型变�?
perm 是通常的权限�?

如果数组参数在加载时讄��, num 被设�|�成提供的数的个�? 模块加蝲者拒�l�比数组能放下的多的�?

��试模块�Q�源�E�序hello.c内容如下�Q?nbsp;

#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��?/span>"hello,world!"�Q?nbsp;

#�Q?/span>1�Q�hello,world!
#�Q?/span>2�Q�hello,world!
#�Q?/span>3�Q�hello,world!
#�Q?/span>4�Q�hello,world!
#�Q?/span>5�Q�hello,world!

卸蝲�Q?nbsp;
# rmmod hello

出现�Q?nbsp;
#Goodbye,world!

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

深入理解linux内核�W�三�?定时��试)

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

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

Linux讑֤�驱动�E�序:gnu make 扩展语法

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

要点:
在用��L��间驱动程�?/span>
insmod
modprobe
rmmod

一些宏:
LINUX_VERSION_CODE
整数�?/span>

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
由内核构造系�l��用的makefilet�W�号,用来��定在当前目录中应构造哪些模�?
即m:指定把对象编译�ؓ模块

obj-y
指定把对象编译进内核�?/span>

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

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

M不是一个编译选项�Q�而是一个变量，从顶层makefile文�g里可以找到它的定�?
文�g�?/span>
/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文�g(�?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

中断及中断处理过�E?/div>

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

Intel的官�Ҏ��档里��中断和异常理解��Z��U�中断当前程序执行的不同机制。这是中断和异常的共同点。不同点在于�Q?/div>

中断(interrupt)是异步的事�g�Q�典型的比如由I/O讑֤�触发�Q�异�?exception)是同步的事�g�Q�典型的比如处理器执行某条指令时发现出错了等�{��?/div>

中断又可以分为可屏蔽中断和非可屏蔽中断，异常又分为故障、陷阱和异常中止3�U�，它们的具体区别很多书�c�和官方文档都解释的比较清楚�q�里不再赘述�?/div>

关于它们的区别有两点是需要注意的�Q?/div>

1�Q��^常所说的屏蔽中断是不包括异常的，卛_��怸�会因为CPU的IF位被清（关中断，指��o�Q�cli�Q�而受影响�Q�比如缺��异常，即��关了中断也会触发CPU的处理�?/div>

2�Q�通常说的int 80h�q�种�pȝ��调用使用的中断方式实际上��g上是理解为异常处理的�Q�因此也不会被屏蔽掉�Q�这也很好理解，int 80h�q�种中断方式是程序里��d��触发的，对于CPU来说属于同步事�g�Q�因此也��属于异常的范畴�?/div>

2. 中断�Q�异常）处理�q�程

需要明��的一�Ҏ��CPU对于中断和异常的具体处理机制本质上是完全一致的�Q�即�Q?/div>

当CPU收到中断或者异常的信号�Ӟ��它会暂停执行当前的程序或��d��Q�通过一定的机制跌��{到负责处理这个信��L��相关处理�E�序中，在完成对�q�个信号的处理后再蟩回到刚才被打断的�E�序或�Q务中。这里只描述保护模式下的处理�q�程�Q�搞清楚了保护模式下的处理过�E�（更复杂）�Q�实模式下的处理机制也就�Ҏ��理解了�?/div>

具体的处理过�E�如下：

0�Q�中断响应的事前准备�Q?/div>

�pȝ��要想能够应对各种不同的中断信��P��ȝ��来看��是需要知道每�U�信号应该由哪个中断服务�E�序负责以及�q�些中断服务�E�序具体是如何工作的。系�l�只有事前对�q�两件事都知道得很清楚，才能正确地响应各�U�中断信号和异常�?/div>

[a]�pȝ��所有的中断信号�l�一�q�行了编��P��一�?56个：0�?55�Q�，�q�个��L��Z��断向量，具体哪个中断向量表示哪种中断有的是规定好的，也有的是在给定范围内自行讑֮�的�?

中断向量和中断服务程序的对应关系主要是由IDT�Q�中断向量表�Q�负责。操作系�l�在IDT中设�|�好各种中断向量对应的中断描�q�符�Q�一共有三类中断门描�q�符�Q��Q务门、中断门和陷阱门�Q�，留待CPU查询使用。而IDT本��n的位�|�是由idtr保存的，当然�q�个地址也是由OS填充的�?/div>

[b]中断服务�E�序具体负责处理中断�Q�异常）的代码是��p�Y�Ӟ��也就是操作系�l�实现的�Q�这部分代码属于操作�pȝ��内核代码。也��是说从CPU��中断信号到加蝲中断服务�E�序以及从中断服务程序中恢复执行被暂停的�E�序�Q�这个流�E�基本上是硬件确定下来的�Q�而具体的中断向量和服务程序的对应关系讄��和中断服务程序的内容是由操作�pȝ��定的�?/div>

1�Q�CPU��查是否有中断/异常信号

CPU在执行完当前�E�序的每一条指令后�Q�都会去��认在执行刚才的指��o�q�程中中断控制器�Q�如�Q?259A�Q�是否发送中断请求过来，如果有那么CPU��׃��在相应的旉��脉冲到来时从�ȝ��上读取中断请求对应的中断向量[2]�?/div>

对于异常和系�l�调用那��L��软中断，因�ؓ中断向量是直接给出的�Q�所以和通过IRQ�Q�中断请求）�U�发送的��g中断��h��不同�Q�不会再专门��d��其对应的中断向量�?/div>

2�Q�根据中断向量到IDT表中取得处理�q�个向量的中断程序的�D�选择�W?/div>

CPU�Ҏ��得到的中断向量到IDT表里扑ֈ�该向量对应的中断描述�W�，中断描述�W�里保存着中断服务�E�序的段选择�W��?/div>

3�Q�根据取得的�D�选择�W�到GDT中找相应的段描述�W?/div>

CPU使用IDT查到的中断服务程序的�D�选择�W�从GDT中取得相应的�D�|��q�符�Q�段描述�W�里保存了中断服务程序的�D�基址和属性信息，此时CPU��得��C��中断服务�E�序的�v始地址�?/div>

�q�里�Q�CPU会根据当前cs寄存器里的CPL和GDT的段描述�W�的DPL�Q�以��保中断服务�E�序是高于当前程序的�Q�如果这�ơ中断是�~�程异常�Q�如�Q�int 80h�pȝ��调用�Q�，那么�q�要��查CPL和IDT表中中断描述�W�的DPL�Q�以保证当前�E�序有权限��用中断服务程序，�q�可以避免用户应用程序访问特�D�的陷阱门和中断门[3]�?/div>

4�Q�CPU�Ҏ��Ҏ��U�的判断讑֮�卛_��q�行的中断服务程序要使用的栈的地址

CPU会根据CPL和中断服务程序段描述�W�的DPL信息��认是否发生了特权��的�{换，比如当前�E�序正运行在用户态，而中断程序是�q�行在内核态的�Q�则意味着发生了特权��的�{换，�q�时CPU会从当前�E�序的TSS信息�Q�该信息在内存中的首地址存在TR寄存器中�Q�里取得该程序的内核栈地址�Q�即包括ss和esp的��|��q�立卛_��pȝ��当前使用的栈切换成新的栈。这个栈��是卛_��q�行的中断服务程序要使用的栈。紧接着��将当前�E�序使用的ss,esp压到新栈中保存�v来�?/div>

6�Q�保护当前程序的现场

CPU开始利用栈保护被暂停执行的�E�序的现场：依次压入当前�E�序使用的eflags�Q�cs�Q�eip�Q�errorCode�Q�如果是有错误码的异常）信息�?/div>

官方文档[1]�l�出的栈变化的示意图如下�Q?/div>

7�Q�蟩转到中断服务�E�序的第一条指令开始执�?/div>

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

8�Q�中断服务程序处理完毕，恢复执行先前中断的程�?/div>

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

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

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

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

2.查看�pȝ��版本,�q�安装内核头文�g
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.查看内核头文件位�|?br />看下会安装到�?/span>:
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

��是�q�里�?/span>.
/usr/src/linux-headers-2.6.32-5-686

4.好了,接下来写��试例子:hello,抄了http://bbs.chinaunix.net/thread-3570849-1-1.html
上的代码:
文�g1: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);

文�g2: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.好了,现在��试开�?/span>,成功的话,��可以看��C��面的文字�?/span>.
如果有问题的�?/span>,向google大神��h��?/span>.另外要看
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.最�?/span>.安装开发帮助文�?br />apt-get install -y manpages-kernel-dev linux-manual
man 9 printk
man 9 module_init

参考资�?/span>:
http://bbs.chinaunix.net/thread-3570849-1-1.html

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