我的第一个嵌入式linux驱动3_完善2

阳光穿透心脏的1/2处 2022-08-21 12:39 35阅读 0赞

/\*

写此文章主要是记录自己的学习笔记，和一些函数的注释，方便自己以后和别人参考，自己是个初学者，有很多不足之处，不喜勿喷，仅供参考

\*/

/\*目的:通过应用函数来实现在点灯  
\*2016年5月1日08:58:21  
\*/  
\#include <linux/module.h>  
\#include <linux/kernel.h>  
\#include <linux/fs.h>  
\#include <linux/init.h>  
\#include <linux/delay.h>  
\#include <asm/uaccess.h>  
\#include <asm/irq.h>  
\#include <asm/io.h>  
\#include <asm/arch/regs-gpio.h>  
\#include <asm/hardware.h>  
  
  
  
  
static struct class \*firstdrv\_class;  
static struct class\_device\*firstdrv\_class\_devs\[4\];  
/\*firstdrv\_class\_devs是指针数组,数组中的每一个元素都是一个class\_device\*类型的指针  
\*/  
  
  
/\*  
first\_drv\_open函数的形参其实就是first\_drv\_open结构体中的open函数的参数，因为调用我们自己写的first\_drv\_open  
函数时，会通过主设备号找到first\_drv\_open结构体，然后执行first\_drv\_open结构体中的open函数，主严是为了参数的传递  
  
  
\*/  
  
  
  
  
int major;  
volatile unsigned long \* gpfcon = NULL;  
volatile unsigned long \* gpfdat = NULL;  
static int first\_drv\_open(struct inode \*inode, struct file \*file)  
\{  
printk("first\_drv\_open\\n");  
/\*  
配置GPF4,5,6为输出  
\*/  
/\*把对应的引脚先清零，然后在置1\*/  
\*gpfcon &= ~((0x3 << (4\*2)) | (0x3 << (5\*2)) | (0x3 << (6\*2)) );  
\*gpfcon |= ((0x1 << (4\*2)) | (0x1 << (5\*2)) | (0x1 << (6\*2)) );  
return 0;  
\}  
  
  
static int first\_drv\_write(struct file \*filp, char \_\_user \*buff, size\_t count, loff\_t \*offp)  
\{  
int val;  
/\*  
测试中的主函数write(fd,&val,4)函数是和first\_drv\_write(struct file \*filp,  
char \_\_user \*buff, size\_t count, loff\_t \*offp)对应的，通过copy\_from\_user(&val,  
buff,count)函数将用户的参数传递到内核中来，使用  
copy\_to\_user(to,from,n)函数从用户内核空间向用户空间传递数据  
\*/  
  
  
copy\_from\_user(&val,buff,count);  
if(val == 1)  
\{  
//点灯  
\*gpfcon &= ~((1<<4) | (1<<5) |(1<<6));  
\}  
else  
\{  
\*gpfcon |= ((1<<4) | (1<<5) |(1<<6));  
\}  
printk("first\_drv\_write\\n");  
return 0;  
\}  
  
  
/\*  
file\_operations是内核中的结构体，里面定义了一些函数，  
  
  
\*/  
  
  
static struct file\_operations first\_drv\_fops = \{  
    .owner  =   THIS\_MODULE,    /\* 这是一个宏，推向编译模块时自动创建的\_\_this\_module变量 \*/  
    .open   =   first\_drv\_open,    //表示将first\_drv\_open函数的地址赋给file\_operations结构体中open函数，  
.write =first\_drv\_write,//以后执行 first\_drv\_open函数时会自动调用file\_operations结构体中的open函数  
\};  
  
  
  
  
/\*  
入口函数  
如果将register\_chrdev的第一个参数设为0，则系统会自动为我们分配一个未被占用的主设备号，  
然后将这个主设备号返回，  
  
  
  
  
  
  
\*/   
int first\_drv\_init(void)  
\{  
major = register\_chrdev(0,"first\_dev",&first\_drv\_fops);//注册函数,告诉内核  
  
  
/\*  
register\_chrdev函数会在主设备号处填充first\_drv\_fops这个结构体，但是不会生成设备信息  
以下代码会在sys目录下生成设备信息，class\_create是创建个类，然后在这个类下生成一个设备  
MKDEV(major, 0)是创建设备，major是主设备号，0是次设备号，xyz是设备名字。  
在入口函数创建，则要在出口函数要把这个设备删掉  
  
  
  
  
firstdrv\_class = class\_create(THIS\_MODULE, "firstdrv");会在sys目录下创建firstdrv这个类，  
在这个类下面会创建一个xyz设备，然后加载模块时mdev会自动创建一个 /dev/xyz  设备节点  
  
  
\*/  
  
  
/\*  
class\_create为该设备创建一个class，再为每个设备调用 class\_device\_create  
创建对应的设备。大致用法如下：  
struct class \*myclass = class\_create(THIS\_MODULE, “my\_device\_driver”);  
class\_device\_create(myclass, NULL, MKDEV(major\_num, 0), NULL, “my\_device”);  
这样的module被加载时，udev daemon就会自动在/dev下创建my\_device设备文件。  
  
  
  
  
内核中定义了struct class结构体，一个struct class   
结构体类型变量对应一个类，内核同时提供了class\_create()  
函数，可以用它来创建一个类，这个类存放于sysfs下面，一旦创建了这个类，再调用  
device\_create()函数在/dev  
目录下创建相应的设备节点。这样，加载模块的时候，用户空间中的udev会自动响应  
device\_create()函数，去/sysfs下寻找对应的类而创建设备节点。  
  
  
  
  
\*/  
  
  
firstdrv\_class = class\_create(THIS\_MODULE, "firstdrv");//创建个类  
  
//if (IS\_ERR(firstdrv\_class)) //是一些判断  
//return PTR\_ERR(firstdrv\_class);     
  
  
firstdrv\_class\_devs = class\_device\_create(firstdrv\_class, NULL, MKDEV(major, 0), NULL, "xyz"); /\* /dev/leds \*/  
//if (unlikely(IS\_ERR(firstdrv\_class\_devs)))  
//return PTR\_ERR(firstdrv\_class\_devs);  
  
  
/\*  
在驱动程序中不能直接操作物理地址，要操作虚拟地址，需要用ioremap来映射  
ioremap 将物理地址0x56000050开始的16个字节之后的地址映射成虚拟地址，返回  
0x56000050对应的虚拟地址，在内核中通过访问虚拟地址就可以访问物理地址  
  
  
\*/  
gpfcon = (volatile unsigned long \*)ioremap(0x56000050,16);  
gpfdat = gpfcon + 1;//指向0x56000050  
  
  
return 0;  
  
  
\}  
  
  
  
  
//出口函数  
void first\_drv\_exit(void)  
\{  
unregister\_chrdev(major,"first\_dev");//卸载驱动  
  
  
class\_device\_unregister(firstdrv\_class\_devs);  
class\_destroy(firstdrv\_class);  
/\*在出口函数中将建立的映射给去掉\*/  
iounmap(gpfcon);  
  
  
\}  
  
  
/\*修饰  
module\_init是定义一个结构体，结构体里面有一个函数指针，指向first\_drv\_init这个入口函数,  
当我们用insmod加载一个驱动时，内核会自动找到这个结构体，调用里面的函数指针，  
指向入口函数  
\*/  
  
  
module\_init(first\_drv\_init);  
module\_exit(first\_drv\_exit);  
  
  
/\*  
实现过程:当使用insmod加载驱动时，首先通过module\_init(first\_drv\_init);找到入口函数first\_drv\_init，  
该函数告诉内核主设备号111和first\_drv\_fops结构体一起向内核注册，这样以后在对主设备号111操作时，  
就会调用first\_drv\_fops结构体中相同的函数来处理。  
\*/  
  
  
  
  
  
  
/\* MODULE\_LICENSE("GPL");描述驱动程序的一些信息，不是必须的   
，如果不加下面的代码，则不知道firstdrv\_class，firstdrv\_class\_devs是怎么实现的  
firstdrv\_class = class\_create(THIS\_MODULE, "firstdrv");//创建个类  
firstdrv\_class\_devs = class\_device\_create(firstdrv\_class, NULL, MKDEV(major, 0), NULL, "xyz");   
  
  
模块许可证声明（必须）  
如果不声明，则在模块加载时会收到内核被污染的警告，一般应遵循GPL协议。  
  
  
  
  
\*/  
  
  
MODULE\_LICENSE("GPL");

//测试函数

\#include <sys/types.h>  
\#include <sys/stat.h>  
\#include <fcntl.h>  
\#include <stdio.h>  
  
  
/\*my\_first\_drv on    打开  
my\_first\_drv off  灭灯  
\*/  
int main (int argc,char \*\* argv)  
\{  
int fd;  
int val = 1;  
fd = open("/dev/xyz",O\_RDWR);//xxx表示名字不重要  
/\*  
无论我们的主设备号怎么变，/dev/xyz   
这个设备都是系统为我们自动创建的，他的主设备号会根据系统为我们分配的主设备号  
而定，  
\*/  
if(fd < 0)  
printf("can't open!\\n");  
  
  
if(argc != 2)  
\{  
prinf("usage:\\n");  
/\*在linux里面<on|off>表示这个参数不可省略，|表示你可以写on或者off，但是不可省略\*/  
printf("%s<on|off>\\n",argv\[0\]);  
\}  
  
  
  
  
if(strcmp(argv\[1\],"on") == 0)  
\{  
val = 1;  
\}  
else  
\{  
val = 0；  
\}  
  
  
  
write(fd,&val,4);  
  
  
return 0;  
  
  
\}  
/\*  
一般函数是可以带参数的，main函数也不例外，格式通常采用这种固定形式。  
由于main  
不被其他函数调用，所以不能从程序中获取参数。实际上参数是执行时从操作系统上获取?  
模琣rgc是参数个数，argv是参数列表。  
当我们要运行一个可执行文件时，在DOS  
提示符下键入文件名，再输入实际参数即可把这些实参传送到main的形参中去。  
  
  
argc是你主程序参数的个数。  
  
  
argv\[0\]是你编译出来执行时候程序的名字。  
argv\[1\].....是你主程序需要的参数。  
举例说明：如下程序 aa.c  
\#include<stdio.h>  
\#include<stdlib.h>  
\#include<stdring.h>  
int main(int argc, char \*argv\[\])  
\{  
        printf("%d\\n",argc);  
        printf("%s\\n",argv\[0\]);  
        printf("%s\\n",argv\[1\]);  
        printf("%s\\n",argv\[2\]);  
        return 0;  
\}  
编译： gcc -o hello aa.c (也就是编译出来的执行文件叫hello，这是linux  
上的编译方式）  
执行： hello aa  bb  
结果：  
2  
hello  
aa  
bb  
  
  
\*/  
  
  
  
  
  
  
/\*  
\#include<fcntl.h>  
int open(constchar\*pathname,intflags);  
int open(constchar\*pathname,intflags,mode\_tmode);  
返回值：成功则返回文件描述符，否则返回-1  
  
  
对于open函数来说，第三个参数仅当创建新文件时（即 使用了O\_CREAT   
时）才使用，用于指定文件的访问权限位（access permission bits）。pathname   
是待打开/创建文件的POSIX路径名（如/home/user/a.cpp）；flags   
用于指定文件的打开/创建模式，这个参数可由以下常量（定义于fcntl.h  
）通过逻辑位或逻辑构成。  
  
  
1  
2  
3  
  
  
O\_RDONLY只读模式  
O\_WRONLY只写模式  
O\_RDWR读写模式  
  
  
  
  
write: int write(int fd, char \* buf, unsigned count);  
  
  
write函数将buf中的count字节内容写入文件描述符fd  
.成功时返回写的字节数.失败时返回-1. 并设置errno变量. 在网络程序中,  
当我们向套接字文件描述符写时有俩种可能.    
1)write的返回值大于0,表示写了部分或者是全部的数据.    
2)返回的值小于0,此时出现了错误.我们要根据错误类型来处理.  如果错误为EINTR  
表示在写的时候出现了中断错误.    
如果为EPIPE表示网络连接出现了问题(对方已经关闭了连接).  
  
  
  
  
\*/  
  
  
/\*测试结果是:can't open!  
因为在板子上不存在/dev/xxx，如果想要在板子上测试成功的话  
需要使用mknod /dev/xxx c 111 0  
c 代表字符   111 代表主设备号 0 代表次设备号  
mknod /dev/xxx c 111 0 这行命令代表创建设备节点，  
把/dev/xxx设备设为字符设备，主设备号为111，次设备号为0；  
  
  
  
  
\*/