linux 驱动开发基础,Linux驱动开发基础代码

最新推荐文章于 2024-04-20 22:55:07 发布
最新推荐文章于 2024-04-20 22:55:07 发布
阅读量133 收藏
点赞数
文章标签： linux 驱动开发基础

//fifo.c

//先进先出队列

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

#define DEVNAME "GLOBAL_FIFO_DEV"//驱动名称

#define SIZE 2000//缓冲区大小

int major;//主设备号

//设备结构体

struct FIFO_DEV

{

struct cdev cdev;//字符设备结构体

unsigned int current_len;//当前缓冲区中字节数

unsigned char mem[SIZE];//内存缓冲区

struct semaphore sem;//信号量

wait_queue_head_t r_wait;//读等待队列头

wait_queue_head_t w_wait;//写等待队列头

struct fasync_struct *async_queue;//异步结构体指针

};

struct FIFO_DEV *fifo_dev;

//异步通知函数

static int fifo_fasync(int fd,struct file *filp,int mode)

{

struct FIFO_DEV *fifo_dev=filp->private_data;

return fasync_helper(fd,filp,mode,&fifo_dev->async_queue);

}

static int fifo_open(struct inode *inode,struct file *filp)

{

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;

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;

struct FIFO_DEV *fifo_dev=filp->private_data;

DECLARE_WAITQUEUE(wait,current);//定义等待队列

down(&fifo_dev->sem);//获取信息量

add_wait_queue(&fifo_dev->r_wait,&wait);//将等待队列加入写等待队列头

if(fifo_dev->current_len==0)

{

if(filp->f_flags &O_NONBLOCK)

{

ret=-EAGAIN;

goto out;

}

else

{

__set_current_state(TASK_INTERRUPTIBLE);//阻塞当前进程

up(&fifo_dev->sem);//释放信息量

schedule();//调度其它进程

if(signal_pending(current))

{

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;

}

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);//唤醒写等待队列

ret=count;

}

out:up(&fifo_dev->sem);

out2:remove_wait_queue(&fifo_dev->r_wait,&wait);

set_current_state(TASK_RUNNING);

return ret;

}

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;

DECLARE_WAITQUEUE(wait,current);

down(&fifo_dev->sem);

add_wait_queue(&fifo_dev->w_wait,&wait);

if(fifo_dev->current_len==SIZE)

{

if(filp->f_flags &O_NONBLOCK)

{

ret=-EAGAIN;

goto out;

}

else

{

__set_current_state(TASK_INTERRUPTIBLE);

up(&fifo_dev->sem);

schedule();

if(signal_pending(current))

{

ret=-ERESTARTSYS;

goto out2;

}

down(&fifo_dev->sem);

}

}

if(count>SIZE-fifo_dev->current_len)

{

count=SIZE-fifo_dev->current_len;

}

if(copy_from_user(fifo_dev->mem+fifo_dev->current_len,buf,count))

{

ret= -EFAULT;

goto out;

}

else

{

fifo_dev->current_len+=count;

wake_up_interruptible(&fifo_dev->r_wait);

//释放异步读通知道信号

if(fifo_dev->async_queue)

{

kill_fasync(&fifo_dev->async_queue,SIGIO,POLL_IN);

}

ret=count;

}

out:up(&fifo_dev->sem);

out2:remove_wait_queue(&fifo_dev->w_wait,&wait);

set_current_state(TASK_RUNNING);

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;

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)

{

mask|=POLLIN | POLLRDNORM;

}

if(fifo_dev->current_len!=SIZE)

{

mask|=POLLOUT|POLLRDNORM;

}

up(&fifo_dev->sem);

return mask;

}

static const struct file_operations fifo_ops=

{

.owner=THIS_MODULE,

.open=fifo_open,

.release=fifo_release,

.read=fifo_read,

.write=fifo_write,

.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);

}

else

{

ret=alloc_chrdev_region(&devno,0,1,DEVNAME);

major=MAJOR(devno);

}

if(ret<0)

{

return ret;

}

fifo_dev=kmalloc(sizeof(struct FIFO_DEV),GFP_KERNEL);

if(!fifo_dev)

{

ret=-ENOMEM;

goto fail_malloc;

}

memset(fifo_dev,0,sizeof(struct FIFO_DEV));

cdev_init(&fifo_dev->cdev,&fifo_ops);

fifo_dev->cdev.ops=&fifo_ops;

cdev_add(&fifo_dev->cdev,devno,1);

fifo_dev->cdev.owner=THIS_MODULE;

init_MUTEX(&fifo_dev->sem);

init_waitqueue_head(&fifo_dev->r_wait);

init_waitqueue_head(&fifo_dev->w_wait);

fifo_dev->current_len=0;

return 0;

fail_malloc:unregister_chrdev_region(devno,1);

return ret;

}

int __exit fifo_exit(void)

{

cdev_del(&fifo_dev->cdev);

kfree(fifo_dev);

unregister_chrdev_region(MKDEV(major,0),1);

return 0;

}

module_init(fifo_init);

module_exit(fifo_exit);

secondtimer.c：定时器驱动

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

#define DEVNAME "SECONDTIMER_DEV"

#define SECONDTIMER_MAJOR 255

int secondtimer_major=SECONDTIMER_MAJOR;

struct SECONDTIMER_DEV

{

struct cdev cdev;

struct timer_list timerlist;

atomic_t totleCount;

};

struct SECONDTIMER_DEV *secondtimer_dev;

static void secondtimer_handler(unsigned args)

{

mod_timer(&secondtimer_dev->timerlist,jiffies+HZ);

atomic_inc(&secondtimer_dev->totleCount);

printk("kernel current fiffies equ %ld\n",jiffies);

}

static int secondtimer_open(struct inode *inode,struct file *filp)

{

filp->private_data=secondtimer_dev;

init_timer(&secondtimer_dev->timerlist);

secondtimer_dev->timerlist.function=&secondtimer_handler;

secondtimer_dev->timerlist.expires=jiffies+HZ;

add_timer(&secondtimer_dev->timerlist);

atomic_set(&secondtimer_dev->totleCount,0);

return 0;

}

static int secondtimer_release(struct inode *inode,struct file *filp)

{

del_timer(&secondtimer_dev->timerlist);

return 0;

}

static ssize_t secondtimer_read(struct file *filp,char __user *buf,size_t count,loff_t *ppos)

{

int counts=0;

struct SECONDTIMER_DEV *secondtimer_dev=filp->private_data;

counts=atomic_read(&secondtimer_dev->totleCount);

if(put_user(counts,(int *)buf))

{

return -EFAULT;

}

else

{

return sizeof(unsigned int);

}

}

static const struct file_operations secondtimer_ops=

{

.owner=THIS_MODULE,

.open=secondtimer_open,

.release=secondtimer_release,

.read=secondtimer_read,

};

int __init secondtimer_init(void)

{

int ret;

dev_t devno=MKDEV(secondtimer_major,0);

if(secondtimer_major)

{

ret=register_chrdev_region(devno,1,DEVNAME);

}

else

{

ret=alloc_chrdev_region(&devno,0,1,DEVNAME);

secondtimer_major=MAJOR(devno);

}

if(ret<0)

{

return ret;

}

secondtimer_dev=kmalloc(sizeof(struct SECONDTIMER_DEV),GFP_KERNEL);

if(!secondtimer_dev)

{

ret=-ENOMEM;

goto fail_malloc;

}

memset(secondtimer_dev,0,sizeof(struct SECONDTIMER_DEV));

cdev_init(&secondtimer_dev->cdev,&secondtimer_ops);

secondtimer_dev->cdev.ops=&secondtimer_ops;

cdev_add(&secondtimer_dev->cdev,devno,1);

secondtimer_dev->cdev.owner=THIS_MODULE;

return 0;

fail_malloc:unregister_chrdev_region(devno,1);

return ret;

}

int __exit secondtimer_exit(void)

{

cdev_del(&secondtimer_dev->cdev);

kfree(secondtimer_dev);

unregister_chrdev_region(MKDEV(secondtimer_major,0),1);

return 0;

}

module_init(secondtimer_init);

module_exit(secondtimer_exit);

makefile内容如下：

obj-m:= fifo.o

obj-m:= secondtimer.o

KERNELDIR:=/lib/modules/$(shell uname -r)/build

default:

make -C $(KERNELDIR) M=$(shell pwd) modules

install:

insmod fifo.ko

mknod /dev/fifo c 248 0

chmod 777 /dev/fifo

insmod secondtimer.ko

mknod /dev/secondtimer c 255 0

chmod 777 /dev/secondtimer

uninstall:

rmmod fifo.ko

rm -f /dev/fifo

rmmod secondtimer.ko

rm -f /dev/secondtimer

clean:

make -C $(KERNELDIR) M=$(shell pwd) clean

2.测试代码

pollTest.c:轮询操作测试

#include #include #include #include #include

#define FIFO_CLEAR 0x1

#define FIFO_LEN 20

main()

{

int fd,num;

char mem_char[FIFO_LEN];

fd_set rfds,wfds;

*mem_char="abc";

fd=open("/dev/fifo",O_RDWR|O_NONBLOCK);

if(fd!=-1)

{

while(1)

{

FD_ZERO(&rfds);

FD_ZERO(&wfds);

FD_SET(fd,&rfds);

FD_SET(fd,&wfds);

select(fd+1,&rfds,&wfds,NULL,NULL);

if(FD_ISSET(fd,&wfds))

{

num=write(fd,"123",FIFO_LEN);

printf("Poll write!\n");

}

if(FD_ISSET(fd,&rfds))

{

num=read(fd,mem_char,FIFO_LEN);

printf("Poll read!\n");

puts(mem_char);

printf("%s\n",mem_char);

}

sleep(2);

}

}

else

{

printf("File open failure!\n");

}

}

//fasynctest.c,异步信号通知测试

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

void input_handler(int signum)

{

printf("receive a signal from fifo,signum %d\n",signum);

sleep(3);

}

main()

{

int fd,oflags;

fd=open("/dev/fifo",O_RDWR,S_IRUSR|S_IWUSR);

if(fd!=-1)

{

signal(SIGIO,input_handler);

fcntl(fd,F_SETOWN,getpid());

oflags=fcntl(fd,F_GETFL);

fcntl(fd,F_SETFL,oflags|FASYNC);

while(1)

{

sleep(2);

}

}

else

{

printf("File open failure!\n");

}

}

secondtimerTest.c:定时器驱动测试

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

main()

{

int fd,counter=0,old_counter=0;

fd=open("/dev/secondtimer",O_RDONLY);

if(fd!=-1)

{

while(1)

{

read(fd,&counter,sizeof(int));

if(counter!=old_counter)

{

printf("current counter is %d\n",counter);

old_counter=counter;

}

sleep(2);

}

}

else

{

printf("File open failure!\n");

}

}

步知春
关注
Linux驱动基础开发
01-27
从事这方面的开发工作，主要需要学习:符合linuxposix标准的API函数及系统调用，linux的多任务编程技巧：多进程、多线程、进程间通信、多任务之间的同步互斥等，嵌入式数据库的学习，UI编程：QT、miniGUI等。...
linux字符设备驱动-异步通知笔记
时光左an的博客
03-07 483
一、开发环境 1、内核：Linux 2.6.22.6； 2、JZ2440 3、ubuntu 9.10
字符设备驱动（二）
m0_73492050的博客
12-30 603
（1）阻塞式IO：不能操作就睡觉（2）非阻塞式IO：不能操作就返回错误（3）IO复用（4）信号驱动式IO（5）异步IO。
Linux驱动开发--内核模块基础代码
xinqi_1的博客
06-21 520
Linux内核的插件机制——内核模块类似于浏览器、eclipse这些软件的插件开发，Linux提供了一种可以向正在运行的内核中插入新的代码段、在代码段不需要继续运行时也可以从内核中移除的机制，这个可以被插入、移除的代码段被称为内核模块。内核模块的本质：一段隶属于内核的“动态”代码，与其它内核代码是同一个运行实体，共用同一套运行资源，只是存在形式上是独立的。模块三要素：入口函数 出口函数 MODULE__LICENSE。
linux内核驱动常用代码讲解
墨染锦年的博客
07-24 257
生产者与消费者是两个独立的并发体，他们之间是用缓冲区作为桥梁连接，生产者只需要往缓冲区里丢数据，就可以继续生产下一个数据，而消费者只需要从缓冲区了拿数据即可，这样就不会因为彼此的处理速度而发生阻塞。设备驱动程序通过调用cdev_add把它所管理的设备对象的指针嵌入到一个类型为struct probe的节点之中，然后再把该节点加入到cdev_map所实现的哈希链表中。所谓设备类，是指提供的用户接口相似的一类设备的集合，常见的设备类的有block、tty、input、usb等等。该散列表中的每一个元素是一个。
Linux驱动代码学习
2201_75961424的博客
03-10 919
include //模块的相关头文件#include //初始化的相关头文件#include //文件操作集合#include //copy_to_user的头文件#include //cdev结构体以及cdev_init等。
嵌入式Linux驱动开发基础总结
07-14
1, linux驱动一般分为3大类： ＊ 字符设备＊ 块设备＊ 网络设备 2, 开发环境构建： ＊ 交叉工具链构建＊ NFS和tftp服务器安装 3, 驱动开发中设计到的硬件： ＊ 数字电路知识＊ ARM硬件知识＊ 熟练使用万用表...
linux 驱动开发linux 驱动开发
11-16
在"linux-driver-development-master"这个项目中，可能包含的是一个完整的Linux驱动开发示例或者教程，包含了从基础概念到实际代码实现的全过程，对于学习和实践Linux驱动开发非常有帮助。开发者可以通过阅读源码、...
imx6ull嵌入式linux驱动开发指南pdf（正点原子）
05-21
该资源为 i.MX6ULL 嵌入式 Linux 驱动开发的综合指南，涵盖了基本概念、硬件平台介绍、驱动开发基础知识、驱动开发流程、Roots 文件系统构建、驱动移植与搭建、高级驱动开发技术等方面的知识，为开发者提供了详细的...
Linux驱动开发——高级I/O操作（二）
qq_52479948的博客
04-14 790
之后再用 cat 命令读取数据，把32个数据读出，导致 FIFO为空，继续尝试读取，程序又阻塞，按“Ctrl+C”组合键后程序退出:接下来让 cat 在后台执行，每次echo后，cat 被唤醒，并打印读出的数据，要结束 cat时，用 kill 杀死进程最后后台运行3个echo，数据都超过32个字节，那么这3个echo 都会被阻塞，用 ps 命令查看，然后用 cat 命令读取数据，3个 echo 都被唤醒并且其写入的数据都被读出，再按“Ctrl+C”组合键结束 cat，用 ps 命令查看，发现刚才。
Linux驱动（一）之最简单的驱动程序
cesheng3410的博客
01-04 2937
通过一个简单的字符驱动程序讲解了一下linux驱动的框架和调用流程
Linux设备驱动程序（三）——字符驱动
明天你好的博客
06-23 2477
本章的目的是编写一个完整的字符设备驱动，我们开发一个字符驱动是因为这一类适合大部分简单硬件设备，字符驱动也比块驱动易于理解。贯穿本章，我们展示从一个真实设备驱动提取的代码片段:scull区域装载的简单字符工具。scull 是一个字符驱动，操作一块内存区域好像它是一个设备，在本章，因为 scull 的这个特殊之处，我们可互换地使用“设备”这个词和"scull 使用的内存区"。scull 的优势在于它不依赖硬件，scull 只是操作一些从内核分配的内存。
Linux驱动——字符设备驱动
Linux驱动开发工程师，熟悉Linux/Android底层驱动、TP、显示、IIC、网络等通用外设调试适配，Linux上层应用开发，主要集中在瑞芯微和全志平台。
04-08 2716
1.使用什么工具来写驱动代码：安装source insight工具（1）找到软件提示把工具安装激活（2）把Linux内核代码解压到windows目录中（3）打开工具添加查看的项目第一个对话框：第一个文本框：输入工程名字第二个文本框：路径(默认)第二个对话框： 在项目源码位置，选择 Linux内核代码位置 点击OK 第三个对话框： 选择需要查看的Linux内核代码的包含的源码文件（要查看的内核目录）需要添加的目录：driver/iicinclude。
Linux驱动开发
smallhide的博客
04-12 1097
MX6U嵌入式Linux驱动开发 Linux文件系统类型：ext2、ext3、ext4等 查看磁盘类型：df -T -h 分区命令：fdisk name 格式化命令：mkfs -t 格式类型 name 挂载分区： mount -t 格式类型 设备名 目的文件夹 ARCH ?= $(SUBARCH) 选择的架构 CROSS_COMPILE ?= ()对应的编译器makefile语法：赋值=取决于他所引用变量的最后一次有效值赋值:=只能使用前面已经定义好的值?=前面如果没有被赋值，那变量就为赋值的数据，反之
linux驱动开发简单示例
jiujiederoushan的博客
02-08 989
linux驱动
fcntl使用
hintonic的专栏
11-09 548
fcntl使用 功能描述：根据文件描述词来操作文件的特性。 #include #include   int fcntl(int fd, int cmd);  int fcntl(int fd, int cmd, long arg);  int fcntl(int fd, int cmd, struct flock *lock); [描述] fcntl()针
Linux驱动入门——编写第一个驱动
wei_Embedded_z的博客
12-11 1838
Linux驱动入门——编写第一个驱动 Hello 驱动
Linux驱动代码编写的基本方法
最新发布
GOODNESS00001的博客
04-20 996
与逻辑驱动编写不同，Linux系统提供了多种驱动框架，方便于系统管理和使用各种驱动，Linux的驱动是可以编译成模块的。入口函数需要向内核注册驱动模块，出口函数需要向内核注销驱动模块，写两个空函数是不行的。
Linux异步通知 fasync
ll148305879的博客
06-19 635
Linux异步通知 fasync 我们知道，驱动程序运行在内核空间中，应用程序运行在用户空间中，两者是不能直接通信的。 但在实际应用中，在设备已经准备好的时候，我们希望通知用户程序设备已经ok，用户程序可以读取了，这样应用程序就不需要一直查询该设备的状态，从而节约资源，这就是异步通知。 这个过程如何实现呢？两方面的工作。 1.驱动方面： 1.在设备抽象的数据结构中增加一个stru...
Linux设备驱动开发基础教程
“Linux设备驱动开发入门 - 入门知识，C编程，微处理器编程，用户空间与内核空间，字符设备驱动，2.6.x内核” Linux设备驱动开发是针对Linux...对于初学者，理解这些基本概念和机制是进入Linux驱动开发领域的第一步。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值