linux驱动基础代码

}
else
{
memcpy(fifo_dev->mem,fifo_dev->mem+count,fifo_dev->current_len-count);//数据提前
fifo_dev->current_len-=count;
wake_up_interruptible(&fifo_dev->w_wait);//唤醒写等待队列
struct FIFO_DEV *fifo_dev=filp->private_data;
DECLARE_WAITQUEUE(wait,current);//定义等待队列
down(&fifo_dev->sem);//获取信息量
add_wait_queue(&fifo_dev->r_wait,&wait);//将等待队列加入写等待队列头
ret=count;
}
out:up(&fifo_dev->sem);
out2:remove_wait_queue(&fifo_dev->r_wait,&wait);
set_current_state(TASK_RUNNING);
return ret;
unsigned int current_len;//当前缓冲区中字节数
unsigned char mem[SIZE];//内存缓冲区
struct semaphore sem;//信号量
wait_queue_head_t r_wait;//读等待队列头
wait_queue_head_t w_wait;//写等待队列头
wake_up_interruptible(&fifo_dev->r_wait);
//释放异步读通知道信号
if(fifo_dev->async_queue)
{
kill_fasync(&fifo_dev->async_queue,SIGIO,POLL_IN);
#include <linux/cdev.h>
#include <linux/interrupt.h>
#include <linux/wait.h>
#include <linux/poll.h>
#include <asm/io.h>
#include <asm/system.h>
#include <asm/delay.h>
}
static const struct file_operations fifo_ops=
{
.owner=THIS_MODULE,
.open=fifo_open,
.release=fifo_release,
.read=fifo_read,
.write=fifo_write,
up(&fifo_dev->sem);
schedule();
if(signal_pending(current))
{
ret=-ERESTARTSYS;
goto out2;
{
filp->private_data=fifo_dev;
return 0;
}
static int fifo_release(struct inode *inode,struct file *filp)
{
struct FIFO_DEV *fifo_dev=filp->private_data;
}
else
{
ret=alloc_chrdev_region(&devno,0,1,DEVNAME);
major=MAJOR(devno);
down(&fifo_dev->sem);
poll_wait(filp,&fifo_dev->r_wait,wait);
poll_wait(filp,&fifo_dev->w_wait,wait);
if(fifo_dev->current_len!=0)
{
if(filp->f_flags &O_NONBLOCK)
{
ret=-EAGAIN;
goto out;
}
else
{
__set_current_state(TASK_INTERRUPTIBLE);
}
static ssize_t fifo_write(struct file *filp,char __user *buf,size_t count,loff_t *ppos )
{
int ret;
struct FIFO_DEV *fifo_dev=filp->private_data;
}
if(copy_from_user(fifo_dev->mem+fifo_dev->current_len,buf,count))
{
ret= -EFAULT;
goto out;
}
else
{
fifo_dev->current_len+=count;
}
ret=count;
}
out:up(&fifo_dev->sem);
out2:remove_wait_queue(&fifo_dev->w_wait,&wait);
set_current_state(TASK_RUNNING);
fifo_fasync(-1, filp, 0);//将文件从异步操作中删除
return 0;
}
static ssize_t fifo_read(struct file *filp,char __user *buf,size_t count,loff_t *ppos )
{
int ret=0;
{
ret=-ERESTARTSYS;
goto out2;
}
down(&fifo_dev->sem);
}
}
if(count>fifo_dev->current_len)
{
count=fifo_dev->current_len;
}
if(copy_to_user(buf,fifo_dev->mem,count))//读取数据到用户缓冲区
{
ret= -EFAULT;
goto out;
struct fasync_struct *async_queue;//异步结构体指针
};
struct FIFO_DEV *fifo_dev;
//异步通知函数
static int fifo_fasync(int fd,struct file *filp,int mode)
{
}
down(&fifo_dev-if(count>SIZE-fifo_dev->current_len)
{
count=SIZE-fifo_dev->current_len;
.poll=fifo_poll,
.fasync=fifo_fasync,
};
int __init fifo_init(void)
{
int ret;
dev_t devno=MKDEV(major,0);
if(major)
{
ret=register_chrdev_region(devno,1,DEVNAME);
return ret;
}
static unsigned int fifo_poll(struct file * filp,struct poll_table *wait)
{
int mask=0;
struct FIFO_DEV *fifo_dev=filp->private_data;
DECLARE_WAITQUEUE(wait,current);
down(&fifo_dev->sem);
add_wait_queue(&fifo_dev->w_wait,&wait);
if(fifo_dev->current_len==SIZE)
{
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/module.h>
#include <linux/types.h>
#include <linux/fs.h>
#include <linux/mm.h>
#include <linux/sched.h>
{
__set_current_state(TASK_INTERRUPTIBLE);//阻塞当前进程
up(&fifo_dev->sem);//释放信息量
schedule();//调度其它进程
if(signal_pending(current))
#include <asm/uaccess.h>
#define DEVNAME "GLOBAL_FIFO_DEV"//驱动名称