今天从最简单的GPIO驱动开始学习驱动的学习，首先需要了解一些最为简单基本知识，我们知道，linux系统对于程序的执行分为内核态和用户态，这两种状态之间的转换是通过异常来完成的，同时，在ARM体系结构，又划分了很多的处理器运行状态，而在内核态和用户态之间存在着一些区别，各自对内存的访问空间的范围是不一样的，对于用户态，寻址空间是受限制的，用户态下的应用程序，能访问的地址空间只能是用户态下受限的部分，也是已经通过mmu之类的东西map之后的地址，如果强制性的对某一块受限的地址控制进行操作，操作实质是并不能带到你的目的，地址会映射到其他的内存地址，而在内核态下，可以像写裸机程序一样，对处理器的寄存器进行直接的操作，虽然是这样，还是有一些小的差别，这就是linux对中断和定时器的管理，内核态对这两种资源的操作还是跟裸机程序有一些差别，这就是为什么linux系统是弱实时系统原因了。
既然内核态和用户态是两种不同的形态，他们之间的数据是怎么进行交换的？ 这里需要注意的是在驱动开发当中，数据的交换一般是通过指针作为中介，而我们知道，寻址空间在两种状态之间不是同一个意义，所以需要一个函数或者子功能模块完成在内核态与用户态之间进行数据的交换，这里有两个函数就是专门进行这种数据交换的：
|
unsigned long copy_from_user (void * to, const void __user * from, unsigned long n);
unsigned long copy_to_user (void __user * to, const void * from, unsigned long n);
|
那么应用程序与驱动程序都有什么区别？除了能够寻址的空间不一样外，各自的执行空间也是不一样的，应用程序处理自己编写函数外，还有一些是通过调用系统的库函数完成的，而这些库函数很多是通过系统调用来完成的，系统调用就属于内核态。内核态的很多调用，都是建立的驱动基础上.r
同时需要注意的是，在内核态，是不能调用glibc库的，也就是在用户态下的库都是不能使用的，那是不是在内核态，所有的函数都需要自己实现？ 当时不是，在内核态下，也有自己的库，这些库提供和用户态下相似的调用，但具体函数可能不太一样，具体情况具体分析了。
典型的驱动应该完成什么功能： 完成设备的初始化和释放、完成数据的交换【用户态与内核态之间、驱动与硬件之间】、IO控制操作、错误检测。简单的说了，驱动要完成的操作即使完成设备的初始化和释放、完成对数据结构的填充和具体函数的实现，这就是驱动要完成的操作，这里数据结构是一个专门的结构体，这个结构是由内核来维护的，在这个结构体中存储了驱动的实际操作的很多函数，比如read()、write()、open()、close()，这里同时通过指针来完成操作的。如下：
|
static struct file_operations myDriver_fops = {
owner: THIS_MODULE,
write: myDriver_write,
read: myDriver_read,
ioctl: myDriver_ioctl,
open: myDriver_open,
release: myDriver_release,
};
|
这个结构就是我们平常对设备文件操作函数的具体实现，这里只是记录实体函数的函数指针，内核是怎么知道这个结构体的？ 通常，在内核中，会维护一个主设备号与这种结构体的数据结构，通过查询设备的主设备号就可以知道具体的操作函数了，这就是为什么同一类设备的主设备号都是一样的，应为主设备号就对应同一种设备、同一种驱动程序，他们之间是相互对应的，而副设备号只是表示了同一种设备的次序。
还需要注意的时，驱动的函数不是全部实现的，它只是在需要的时候才会调用，而且，驱动程序不是可执行程序，是一个目标文件，所以它的编译过程也是不一样的，下边是一个示例的驱动编译的makefile，很有用:
|
OUTPUT = tst-driver.o【与.c要同名】
OUTPUT_DIR = output
KERNEL = /usr/src/arm-s3c2410/kernel【指定平台的源码路径，路径到kernel就可以了】
CROSSPREFIX = /usr/local/arm/2.95.3/bin/arm-linux-【编译通常是2.95.3】
CFLAGS = -Wall -I$(KERNEL)/include -c -DDEBUG
#CFLAGS += -DEXPORT_SYMTAB -DMODVERSIONS -include $(KERNEL)/include/linux/modversions.h
DEST = $(foreach fn, $(OUTPUT), $(OUTPUT_DIR)/$(fn))
all: $(OUTPUT_DIR)/install.sh
$(OUTPUT_DIR)/install.sh: $(OUTPUT_DIR) $(DEST)
@rm $@ -f
@echo -e " $(foreach fn, $(OUTPUT), "insmod $(fn)\\n")" >> $@
@echo "Finished!"
$(OUTPUT_DIR):
@mkdir $@
@chmod 777 -R $@
$(OUTPUT_DIR)/%.o: %.c
@echo -n "Compling $^..."
@$(CROSSPREFIX)gcc $(CFLAGS) $^ -o $@
@echo "OK"
clean:
@find . \( -name '*.[oas]' -o -name install.sh \) -type f -print | xargs rm -f
@echo "Cleaned!"
|
对于一个字符型的驱动，它的框架还是很简单，通常情况下，在编写一个字符型的驱动时，只需要在现有框架的基础上，填充必要的函数就可以了，没有必要自己构架框架，而事实上，这个框架也只有一种，也就是内核只认识这一种框架，就是填充一个结构体，实现函数功能。
|
#ifndef __KERNEL__
#define __KERNEL__
#endif
#ifndef MODULE
#define MODULE
#endif
#include <linux/config.h>
#include <linux/module.h>
#include <linux/kernel.h> /* printk() */
#include <linux/init.h> /* __init __exit */
#include <linux/types.h> /* size_t */
#include <linux/fs.h> /* file_operation */
//#include /* Error number */
//#include /* udelay */
#include <asm/uaccess.h> /* copy_to_user, copy_from_user */
#include <asm/hardware.h>
#include "tst-driver.h"
#define DRIVER_NAME "myDriver"
#ifdef DEBUG
#define PRINTK(fmt, arg...) printk(KERN_NOTICE fmt, ##arg)
#else
#define PRINTK(fmt, arg...)
#endif
static int myDriver_open(struct inode *inode, struct file *filp)
{
}
static int myDriver_release(struct inode *inode, struct file *filp)
{
}
static ssize_t myDriver_read(struct file *filp, char *buf, size_t count, loff_t *f_pos)
{
}
static ssize_t myDriver_write(struct file *filp, const char *buf, size_t count, loff_t *f_pos)
{
}
static int myDriver_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
{
}
/* Driver Operation structure */
static struct file_operations myDriver_fops = {
owner: THIS_MODULE,
write: myDriver_write,
read: myDriver_read,
ioctl: myDriver_ioctl,
open: myDriver_open,
release: myDriver_release,
};
/* Module Init & Exit function */
#ifdef CONFIG_DEVFS_FS
devfs_handle_t devfs_myDriver_dir;
devfs_handle_t devfs_myDriver_raw;
#endif
static int __init myModule_init(void)
{
}
static void __exit myModule_exit(void)
{
}
MODULE_AUTHOR("xxxx");
MODULE_LICENSE("Dual BSD/GPL");
module_init(myModule_init);
module_exit(myModule_exit);
|
包含必要的头文件，对struct file_operations myDriver_fops 填入具体函数的函数指针，完成函数功能的实现，就是这样。驱动有两个函数需要注意，就是module_init()中指定的函数，这个函数是驱动初始化的时候执行的，而module_exit()中指定的函数是在驱动挂载的时候执行的，对一个驱动程序，在实现结构体填充之后，还需要想内核注册，这里的注册使用函数：
register_chrdev(0, DRIVER_NAME, &myDriver_fops);
这个函数完成了主设备号与驱动结构体之间的对应联系。
字符型的驱动就是这些，下边介绍一些与驱动相关的命令，在我们编译成功后，生成的文件是xxx.o,这是一个驱动的目标文件，如果要加载到内核，需要命令：
insmod xxx.o ,如果要列举当前系统加载的动态驱动目标文件可以使用：lsmod
如果写卸载加载的驱动目标，可以使用rmmod,加入驱动后，如果要对实际的设备操作，还需要建立设备文件，也就是该设备在文件系统中的节点，这里可以使用：
mknod 设备名 驱动类型: c/字符 b/块 主设备号 从设备号
下边是一个GPIO驱动的实现：
tst-driver.c文件
|
#ifndef __KERNEL__
#define __KERNEL__
#endif
#ifndef MODULE
#define MODULE
#endif
#include <linux/config.h>
#include <linux/module.h>
#include <linux/kernel.h> /* printk() */
#include <linux/init.h> /* __init __exit */
#include <linux/types.h> /* size_t */
#include <linux/fs.h> /* file_operation */
//#include /* Error number */
//#include /* udelay */
#include <asm/uaccess.h> /* copy_to_user, copy_from_user */
#include <asm/hardware.h>
#include <asm-arm/arch-s3c2410/S3C2410.h>
#include "tst-driver.h"
#define DRIVER_NAME "myDriver"
#ifdef DEBUG
#define PRINTK(fmt, arg...) printk(KERN_NOTICE fmt, ##arg)
#else
#define PRINTK(fmt, arg...)
#endif
/*
KERN_EMERG 用于紧急事件,一般是系统崩溃前的提示信息
KERN_ALERT 用于需要立即采取动作的场合
KERN_CRIT 临界状态,通常设计验证的硬件或软件操作失败
KERN_ERR 用于报告错误状态.设备驱动程序通常会用它报告来自硬件的问题
KERN_WARNING 就可能出现的问题提出警告.这些问题通常不会对系统造成严重破坏
KERN_NOTICE 有必要提示的正常情况.许多安全相关的情况用这个级别汇报
KERN_INFO 提示性信息.有很多驱动程序在启动时用这个级别打印相关信息
KERN_DEBUG 用于调试的信息
*/
#undef CONFIG_DEVFS_FS
static int myDriver_Major = 0; /* Driver Major Number */
static unsigned int gpio_state=0; /* 16bit, 1: out 0: in */
/* Driver Operation Functions */
static int myDriver_open(struct inode *inode, struct file *filp)
{
// int Minor = MINOR(inode->i_rdev);
// filp->private_data = 0;
MOD_INC_USE_COUNT;
PRINTK("myDriver open called!\n");
return 0;
}
static int myDriver_release(struct inode *inode, struct file *filp)
{
// int Minor = MINOR(inode->i_rdev);
MOD_DEC_USE_COUNT;
PRINTK("myDriver release called!\n");
return 0;
}
static ssize_t myDriver_read(struct file *filp, char *buf, size_t count, loff_t *f_pos)
{
unsigned int gpio;
PRINTK("myDriver read called!\n");
gpio=GPFDAT;
copy_to_user(buf, &gpio,1);
return 0;
}
static ssize_t myDriver_write(struct file *filp, const char *buf, size_t count, loff_t *f_pos)
{
char gpiof=0x0;
PRINTK("myDriver write called!\n");
PRINTK("\tcount=%d, pos=%d\n", count, (int)*f_pos);
copy_from_user(&gpiof, buf,1);
GPFDAT=gpiof;
return 0;
}
static int myDriver_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
{
PRINTK("myDriver ioctl called(%d)!\n", cmd);
switch(cmd)
{
case GPIO_IN:
GPFCON=arg;
gpio_state=arg;
break;
case GPIO_OUT:
GPFCON=arg;
gpio_state=arg;
break;
case GPIO_SET_BIT:
GPFDAT=GPFDAT | (1<<arg);
break;
case GPIO_CLR_BIT:
GPFDAT=GPFDAT & (~( 1<<arg));
break;
}
return 0;
}
/* Driver Operation structure */
static struct file_operations myDriver_fops = {
owner: THIS_MODULE,
write: myDriver_write,
read: myDriver_read,
ioctl: myDriver_ioctl,
open: myDriver_open,
release: myDriver_release,
};
/* Module Init & Exit function */
#ifdef CONFIG_DEVFS_FS
devfs_handle_t devfs_myDriver_dir;
devfs_handle_t devfs_myDriver_raw;
#endif
static int __init myModule_init(void)
{
/* Module init code */
PRINTK("myModule_init\n");
/* Driver register */
myDriver_Major = register_chrdev(0, DRIVER_NAME, &myDriver_fops);
if(myDriver_Major < 0)
{
PRINTK("register char device fail!\n");
return myDriver_Major;
}
PRINTK("register myDriver OK! Major = %d\n", myDriver_Major);
#ifdef CONFIG_DEVFS_FS
devfs_myDriver_dir = devfs_mk_dir(NULL, "myDriver", NULL);
devfs_myDriver_raw = devfs_register(devfs_myDriver_dir, "raw0", DEVFS_FL_DEFAULT, myDriver_Major, 0, S_IFCHR | S_IRUSR | S_IWUSR, &myDriver_fops, NULL);
PRINTK("add dev file to devfs OK!\n");
#endif
PRINTK("init GPF OK!\n");
GPFCON=0x55555555;
GPFUP=0x0000;
GPFDAT=0xffff;
return 0;
}
static void __exit myModule_exit(void)
{
/* Module exit code */
PRINTK("myModule_exit\n");
/* Driver unregister */
if(myDriver_Major > 0)
{
#ifdef CONFIG_DEVFS_FS
devfs_unregister(devfs_myDriver_raw);
devfs_unregister(devfs_myDriver_dir);
#endif
unregister_chrdev(myDriver_Major, DRIVER_NAME);
}
return;
}
MODULE_AUTHOR("tastesweet@yeah.net");
MODULE_LICENSE("Dual BSD/GPL");
module_init(myModule_init);
module_exit(myModule_exit);
|
tst-driver.h文件：
|
#ifndef __TST_DRIVER_H__
#define __TST_DRIVER_H__
#define TSTDRV_MAGIC 0xd0
#define GPIO_IN 0
#define GPIO_OUT 1//_IO(TSTDRV_MAGIC, 1)
#define GPIO_SET_BIT 2//_IO(TSTDRV_MAGIC, 2)
#define GPIO_CLR_BIT 3//_IO(TSTDRV_MAGIC, 3)
#define TSTDRV_MAXNR 4
#endif //#ifndef __TST_DRIVER_H__
|
这里的_io是一个宏操作，没有特殊的地方，就是将TSTDRV_MAGIC与后边的数字合并，生成唯一的数字，这里完全可以直接使用数据代换。
阅读(1640) | 评论(3) | 转发(0) |
