linux驱动开发

1、驱动开发环境

 

完成系统移植的三步：u-boot启动引导程序、内核镜像、文件系统，u-boot启动引导程序最好固化到开发板上，内核镜像通过tftp服务从ubuntu下载，文件系统通过nfs服务从ubuntu共享到开发板，开发板启动计数时按任意键进入u-boot命令模式设置bootcmd和bootargs

 

# setenv serverip 192.168.3.120

# setenv ipaddr 192.168.3.233

# setenv bootcmd tftp 41000000 uImage\;tftp 42000000 exynos4412-fs4412.dtb\;bootm 41000000 – 42000000\;

#setenv bootargs root=/dev/nfs\; nfsroot=192.168.3.120:/source/rootfs rw console=ttySAC2,115200  init=/linuxrc  ip=192.168.3.233

# saveenv

注意：192.168.3.120 对应Ubuntu的ip

 

192.168.3.233 对应板子的ip

 

这两个ip应该根据自己的实际情况适当修改

 

重启开发板进入自启动模式自动加载内核和文件系统

 

2、驱动开发工具使用source insight软件和vim工具，当然如果不想频繁地从Windows复制到ubuntu可以使用共享文档，这样就可以在Windows上写好代码在ubuntu中直接编译。

 

设置共享文档步骤：

 

打开VMware，选择虚拟机设置选择选项选择共享文件夹，点击总是启用，点击添加就可以设置共享文件夹了

 

设置完成后可以在ls /mnt/hgfs查看共享目录是否挂载

 

如果没有挂载可以通过vmware-hgfsclient查看共享文件夹

 

挂载共享文件夹命令vmhgfs-fuse .host:/my /mnt/hgfs其中my是查看共享文件夹时显示的名字，/mnt/hgfs是挂载路径，挂载路径必须是空的文件夹否则可能失败

 

source insight---查看和编写代码工具

 

将ubuntu中的linux内核代码复制到Windows中

 

在source insight中新建项目

 

在第一个对话框中，第一个文本框(行编辑器)，输入工程的名字

 

在第二个对话框中，第一个本文框中选择刚解压的Linux内核源码目录（顶层linux-3.14），点击ok

 

在第三个对话框中，在对话框中选择要查看的目录/文件 需要选择的目录文件： include init kernel arch/arm/kernel arch/arm/include/asm driver/base driver/char driver/i2c driver/spi fs/char_dev.c 点击close关闭

 

重新选择project---->open project ​ 选择刚才创建的工程名 ​ ok ​ 如果提示同步，则选择确认进行同步

 

开始编写驱动代码

 

驱动代码必须包含四部分：

 

a.头文件

 

#include <linux/init.h>

#include <linux/module.h>

b.加载和卸载时的函数定义

 

static int __init hello_init(void)

{

    return 0;

}

​

static void __exit hello_exit(void)

{

​

}

c.加载和卸载的入口声明

 

module_init(hello_init);//当使用insmod 驱动名称.ko 加载驱动时执行函数hello_init()

module_exit(hello_exit);//当使用remod 驱动名称 卸载驱动时执行函数hello_exit()

d.协议选择GPL

 

MODULE_LICENSE("GPL");

3、驱动操作

 

a.加载驱动使用命令

 

insmod 驱动程序路径.ko

 

b.加载好驱动后可以通过命令查看驱动

 

lsmod

 

c.卸载驱动命令（不用加.ko）

 

rmmod 驱动程序名

 

字符设备驱动创建框架

1、申请设备号

 

int register_chrdev(unsigned int major,const char *name,const struct file_operations *fops)

参数1：unsigned int major------大于0则是申请对应的主设备号；等于0则是由内核分配主设备号

参数2：const char *name------是注册时的名字

参数3：const struct file_operations *fops------是用来关联文件IO接口的结构体

返回值：当参数1大于0时，正确返回0，失败返回负数

       当参数1等于0时，正确返回主设备号，失败返回负数

2、创建设备节点（生成对应的驱动文件）

 

创建文件信息结构体

 

struct class * class_create(owner,name);

参数1：owner-----拥有者，一般THIS_MODULE

参数2：name-----字符串，描述信息

返回值：struct class *------信息结构体       

创建字符驱动设备文件（节点），一般默认建在/dev下，但是可以在任意目录下创建

 

struct device *device_create(   struct class *class,struct device *parent,dev_t devt,void *drvdata,const char *fmt, ...)

参数1：struct class *class--------class结构体，创建的设备文件的信息内容，通过 class_create()函数创建

参数2：struct device *parent--------表示父类对象，一般直接写NULL，结构体地址

参数3：dev_t devt--------设备号可以有函数MKDEV(ma, mi)获得，ma------主设备号, mi------次设备号，也可以由主设备号左移20位或上一个数字得到这个数字不能大于2^20,例：major<<20|0

参数4：void *drvdata-------私有数据，一般填NULL

参数5：const char *fmt, ...--------设备文件名字符串首地址

返回值：struct device *---------设备节点对象（设备文件描述），成功返回地址，失败返回NULL

文件IO接口层实现，应用程序调用文件io时，驱动程序也调用对应的文件io接口函数 在结构体 struct file_operations 每一个成员变量都代表绑定一个系统调用（文件io）函数，只要对结构体中的成员赋值，就代表值绑定上一个文件io函数

 

struct file_operations {

struct module *owner;

loff_t (*llseek) (struct file *, loff_t, int);

ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);

ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);

ssize_t (*aio_read) (struct kiocb *, const struct iovec *, unsigned long, loff_t);

ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned long, loff_t);

int (*iterate) (struct file *, struct dir_context *);

unsigned int (*poll) (struct file *, struct poll_table_struct *);

long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);

long (*compat_ioctl) (struct file *, unsigned int, unsigned long);

int (*mmap) (struct file *, struct vm_area_struct *);

int (*open) (struct inode *, struct file *);

int (*flush) (struct file *, fl_owner_t id);

int (*release) (struct inode *, struct file *);

int (*fsync) (struct file *, loff_t, loff_t, int datasync);

int (*aio_fsync) (struct kiocb *, int datasync);

int (*fasync) (int, struct file *, int);

int (*lock) (struct file *, int, struct file_lock *);

ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);

unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);

int (*check_flags)(int);

int (*flock) (struct file *, int, struct file_lock *);

ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);

ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);

int (*setlease)(struct file *, long, struct file_lock **);

long (*fallocate)(struct file *file, int mode, loff_t offset,

  loff_t len);

int (*show_fdinfo)(struct seq_file *m, struct file *f);

};//函数指针的集合，

驱动控制硬件，控制外设，其实就是控制地址，通过地址往寄存器写入、读出控制 内核驱动是通过虚拟地址操作 初始化硬件

 

地址映射：

void * ioremap(cookie,size)；

参数1：cookie-----物理地址

参数2：size-----映射内容大小，字节

返回值：返回映射成功后的虚拟内存地址

操作虚拟内存地址中的内容就是操作对应的物理地址空间内容

字符设备驱动卸载时需要的函数

 

在卸载入口中实现，清除 与初始化逆序过程进行卸载

 

//1、映射释放（中断释放）

iounmap(映射的虚拟内存地址);----释放映射地址

//2、释放设备文件

void device_destroy(struct class * class,dev_t devt);

//3、释放设备文件结构体

void class_destroy(struct class * cls)

//4、释放设备号

void unregister_chrdev(unsigned int major,const char * name)

字符驱动模型举例：

 

通过字符设备驱动控制一颗LED灯

 

//头文件包含

#include <linux/init.h>

#include <linux/module.h>

#include <linux/fs.h>

#include <linux/device.h>

#include <asm/io.h>

 

#include <asm/uaccess.h>

//使用结构体表示一个驱动对象（面向对象的编程思想）

struct Led_Dev

{

unsigned int *gpx1con;

unsigned int *gpx1dat;

struct class * class;

struct device * dev;

unsigned int major;

unsigned int dev_no;

};

struct Led_Dev led;

//4、文件IO功能与设备功能实现绑定

ssize_t led_read (struct file * flie, char __user * data, size_t size, loff_t * ops)

{

        return 0;

}

ssize_t led_write (struct file * file, const char __user * data, size_t size, loff_t * ops)

{

        //data是应用程序传递的数据的地址，size 传递的大小

        int num;

        copy_from_user(&num,data,size);//从应用程序获取数据存到num中

       

        if(num==1)

        {

                *(led.gpx1dat) |= 1;

        }

        else

        {

                *(led.gpx1dat) &= ~1;

        }

 

        return 0;

}

int led_open (struct inode * inode, struct file * file)

{

        printk("open ok\n");

        return 0;

}

int led_close (struct inode * inode, struct file * file)

{

        printk("close ok\n");

        return 0;

}

 

 

const struct file_operations fops=

{

.open = led_open,

.release = led_close,

.write = led_write

 

};

 

//驱动加载与卸载函数实现

static int __init led_init(void)

{

led.major = 250;

led.dev_no = led.major<<20|0;

//1、申请设备号

 

 

int res = register_chrdev(led.major,"led_dev",&fops);

if(res !=0 )

{

printk("register dev error\n");

goto err_1;

//return -1;

}

//2、创建设备文件

led.class = class_create(THIS_MODULE,"led_cls");

if (IS_ERR(led.class))

{

printk("class create error\n");

goto err_2;

//unregister_chrdev(major,name);

//return -1;

}

led.dev = device_create(led.class, NULL, led.dev_no,NULL,"led");

if(IS_ERR(led.dev))

{

printk("device create error\n");

goto err_3;

//class_destroy(class);

//unregister_chrdev(major,name);

//return -1;

}

//3、驱动设备控制硬件

//硬件寄存器地址映射

led.gpx1con = ioremap(0x11000c20, 4);

if(led.gpx1con==NULL)

{

printk("gpx1con ioremap error\n");

goto err_4;

//device_destroy(class, dev_no);

//class_destroy(class);

//unregister_chrdev(major,name);

//return -1;

}

led.gpx1dat = ioremap(0x11000c24, 4);

if(led.gpx1dat==NULL)

{

printk("gpx1dat ioremap error\n");

goto err_5;

//iounmap(gpx1con);

//device_destroy(class, dev_no);

//class_destroy(class);

//unregister_chrdev(major,name);

//return -1;

}

//硬件初始化

*(led.gpx1con) = *(led.gpx1con) & ~0xf | 1;

*(led.gpx1dat) |= 1;

return 0;

 //出错处理的代码   

err_5:

//1、映射地址释放

iounmap(led.gpx1con);

 

err_4: //2、设备文件释放

device_destroy(led.class,led.dev_no);//释放设备文件

 

err_3:

class_destroy(led.class);//释放文件信息结构体

 

err_2: //3、驱动设备号注销

unregister_chrdev(led.major,"led_dev");

 

err_1:

return -1;

}

 

 

static void __exit led_exit(void)

{

//卸载驱动，与初始化逆序

//1、映射地址释放

iounmap(led.gpx1con);

iounmap(led.gpx1dat);

//2、设备文件释放

 

device_destroy(led.class, led.dev_no);//释放设备文件

class_destroy(led.class);//释放文件信息结构体

 

//3、驱动设备号注销

 

unregister_chrdev(led.major,"led_dev");

 

}

 

//驱动加载与卸载

module_init(led_init);

module_exit(led_exit);

 

//协议包含GPL

MODULE_LICENSE("GPL");

驱动中实现中断

中断驱动---检测外部中断 获取外设的数据内容，通过中断信号进行获取 在驱动中设置外设为中断模式：当外设产生设定的特定信号（就是中断） 在驱动中实现中断处理操作（函数）

 

本文以按键中断为例

 

需要使用按键设备，需要先在设备树中说明使用的按键是一个中断设备，我使用的板子是Samsung的Exynos系列，按键使用的是KEY3

 

 

开发板管脚

 

 

查看数据手册得到GPX1_2使用的中断是XEINT_10

 

 

 

 

 

在设备树中：arch/arm/boot/dts/exynos4x12-pinctrl.dtsi

 

gpx1: gpx1 {

                    gpio-controller;

                    #gpio-cells = <2>;

 

                    interrupt-controller;

                    interrupt-parent = <&gic>;

                    interrupts = <0 24 0>, <0 25 0>, <0 26 0>, <0 27 0>,

                                  <0 28 0>, <0 29 0>, <0 30 0>, <0 31 0>;

                    #interrupt-cells = <2>;

            };

 

在设备树中添加自己的硬件设备信息---添加key3节点-----描述当前设备的的信息内容（中断号）

arch/arm/boot/dts/exynos4412-fs4412.dts：实现硬件描述（中断号）

 

key3_node {

                    compatible = "key3";

                    interrupt-parent = <&gpx1>;

                    interrupts = <2 4>;//26

    };

在驱动中申请中断，实现中断处理

 

a、获取到中断号

获取设备树节点，返回值就是从设备树中找到的节点

struct device_node *of_find_node_by_path(const char *path);

 

从节点中获取到中断号，返回值就是中断号

unsigned int irq_of_parse_and_map(struct device_node *dev,int index)；

 

b、申请中断

int request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags,const char *name, void *dev)

参数1：

unsigned int irq：申请中断的中断号

 

参数2：

irqreturn_t (*)(int, void *)    ----   irq_handler_t

irq_handler_t handler：函数指针，进行注册中断，当产生中断时调用对应的函数进行处理

参数3：

unsigned long flags：中断处理的触发方式

#define IRQF_TRIGGER_NONE0x00000000

#define IRQF_TRIGGER_RISING0x00000001

#define IRQF_TRIGGER_FALLING0x00000002

#define IRQF_TRIGGER_HIGH0x00000004

#define IRQF_TRIGGER_LOW0x00000008

 

参数4：

const char *name：字符串首地址，中断的描述信息

/proc/inruppter

参数5：

void *dev：传递给参数2的函数进行自动调用的（作为参数2这个函数的参数）

 

返回值：

成功返回0，失败返回非0

释放中断：

void free_irq(unsigned int irq,void * dev_id)

参数1：

unsigned int irq

中断号

参数2:

void * dev_id：与申请中断第五个参数保持一致

中断分上下两部分：

 

上部分处理时间短、不费时间的中断处理

 

下部分处理一些费时间的中断

 

下部分就是将耗时操作延后处理，一般在上半部分的处理函数中调用

 

1、softirq：软中断，处理级别比较高，在内核机制中，需要修改内核源码功能 ​ 2、tasklet：实际上就是内部调用了softirq ​ 3、workqueue：工作队列

 

驱动中申请中断举例：

 

#include <linux/init.h>

#include <linux/module.h>

#include <linux/fs.h>

#include <linux/device.h>

#include <linux/of.h>

#include <linux/of_irq.h>

#include <linux/interrupt.h>

#include <linux/sched.h>

#include <linux/wait.h>

 

#include <asm/io.h>

#include <asm/uaccess.h>

 

char c;

 

struct key_desc{

unsigned int major;

struct class * cls;

dev_t devno;

struct device * dev;

}key;

 

irqreturn_t key_irq_handler(int i, void * j)

{

c='q';

printk("irqno : %d;input char %c\n",i,c);

 

return IRQ_HANDLED;

}

 

 

//3、文件IO接口功能关联

ssize_t key_read (struct file * file, char __user * data, size_t size, loff_t * ops)

{

 

printk("key read\n");

int n = copy_to_user(data, &c, 1);

c='w';

return 0;

}

int key_open (struct inode * inode , struct file * file)

{

printk("key open\n");

return 0;

}

 

int key_release (struct inode * inode , struct file *file)

{

printk("key close\n");

return 0;

}

 

const struct file_operations fops = {

.read = key_read,

.release = key_release,

.open = key_open

};

 

static int __init keydev_init(void)

{

key.major = 252;

//1、申请设备号

int res = register_chrdev( key.major,"key", &fops);

if(res<0)

{

goto err1;

 

}

//2、设备文件

key.cls = class_create(THIS_MODULE, "cls");

if(IS_ERR(key.cls))

{

goto err2;

 

}

key.devno = key.major << 20 | 0;

key.dev = device_create(key.cls, NULL,key.devno ,NULL,"key_dev");

if(IS_ERR(key.dev))

{

goto err3;

 

}

//4、硬件初始化

//a.获取中断号

struct device_node * node = of_find_node_by_path("/key3");//查找设备树中节点为key_3

if(IS_ERR(node))

{

goto err4;

 

}

int irqno = irq_of_parse_and_map(node, 0);//申请中断号

if(irqno<0)

{

goto err5;

}

//b.申请中断

res = request_irq(irqno, key_irq_handler,IRQF_TRIGGER_FALLING,"key_in", NULL);

if(res<0)

{

goto err6;

}

return 0;

err6:

irqno = -1;

 

err5:

node=NULL;

 

err4:

device_destroy(key.cls, key.devno);

 

err3:

class_destroy(key.cls);

 

err2:

unregister_chrdev(key.major, "key");

 

err1:

return -1;

}

 

static void __exit key_exit(void)

{

 

device_destroy(key.cls, key.devno);

class_destroy(key.cls);

unregister_chrdev(key.major, "key");

}

 

module_init(keydev_init);

module_exit(key_exit);

 

MODULE_LICENSE("GPL");

 

 

 

 

 

 

测试程序

 

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <stdio.h>

 

 

int main()

{

 

 

char buf;

int num;

int fd = open("/dev/key_dev",O_RDONLY);

while(1)

{

 

num=0;

num = read(fd,&buf,1);

printf("%d%c\n",num,buf);

}

return 0;

}

Makefile

 

#编译驱动代码

KERNEL_PATH = /home/ubuntu/code/kernel/linux-3.14

#APP=beep_test#测试程序的名字不包括后缀

MODULES_PATH = $(shell pwd)

obj-m += key_int.o #把.c编译为.o文件注意.o前的名字与驱动文件名字一致

 

#编译为驱动程序.ko 要借助已经编译过的内核

all:

make modules -C $(KERNEL_PATH) M=$(MODULES_PATH)

# arm-none-linux-gnueabi-gcc $(APP).c -o $(APP)

 

install:

# cp *.ko $(APP) /home/ubuntu/rootfs

cp *.ko /home/ubuntu/rootfs

 

驱动中的阻塞IO与非阻塞IO实现

 

驱动中实现阻塞： 要创建等待队列头： wait_queue_head_t head; init_waitqueue_head(&head);

 

1、在需要等待的位置（没有数据），就阻塞等待

 

wait_event_interruptible(wq,condition)-----根据参数是否进行阻塞等待，完成阻塞等待

 

参数1：

wq：等待队列头，把当前进程加入到哪个等待队列中

 

参数2：

condition：是否执行阻塞等待的条件

 

condition：真---不进行阻塞

condition：假---进行阻塞

 

2、合适位置进行阻塞唤醒

wake_up_interruptible(&head);

非阻塞：在进行读写操作时，如果没有数据，就立即返回，如果有数据读取数据然后立即返回 应用程序：设置为非阻塞打开 int fd = open("/dev/key3",O_RDONLY | O_NONBLOCK);

 

驱动文件中在阻塞前面添加：

if((file->f_flags & O_NONBLOCK != 0) && (condition == 0))

return -1；

驱动总线模型： 驱动框架： 0、声明实现入口函数（module_init、module_exit） 1、申请设备号（register_chrdev） 2、创建设备节点（class_create、device_create） 3、硬件初始化 ioremap地址映射 中断申请 4、实现文件IO接口

 

总线模型： 总线bus 驱动driver 设备device

 

总线bus: struct bus_type：总线对象，描述一条总线，管理device、driver，进行匹配

 

struct bus_type

{

const char*name;：总线名字

int (*match)(struct device *dev, struct device_driver *drv);总线调用匹配设备和驱动，返回值就表示匹配成功与否

}；

注册总线： ​ int bus_register(struct bus_type * bus); ​ 参数： ​ struct bus_type * bus：总线对象 ​ 注销总线： ​ void bus_unregister(struct bus_type * bus);

 

驱动driver： struct device_driver ：驱动对象，描述一个驱动，对驱动进行说明

 

struct device_driver { ​ const char *name;：驱动的名字 ​ struct bus_type bus;总线对象，表示要把驱动注册到哪条总线 ​ int (probe) (struct device dev);如果匹配成功，则调用该驱动的probe函数，创建驱动（申请设备号。。。） ​ int (remove) (struct device *dev);当设备对象和驱动对象移除总线时会调用 ​ } ​ 注册驱动到总线： ​ int driver_register(struct device_driver * drv)； ​ 从总线上注销： ​ void driver_unregister(struct device_driver * drv);

 

设备device: struct device { struct kobject kobj;//所有对象的父类 const char *init_name;设备名 struct bus_type *bus;总线对象，表示要把设备注册到哪条总线 void platform_data;自定义数据，指向任意类型，可以存储设备信息 void (release)(struct device *dev);设备对象从总线移除时会调用 }； 注册设备到总线： int device_register(struct device * dev); 从总线上注销： void device_unregister(struct device * dev);