简单的完成led灯控制驱动——基于topeet 4412

                    Linux驱动-普通字符设备

编写字符设备用到的头文件：

/*包含初始化宏定义的头文件,代码中的module_init和module_exit在此文件中*/

#include <linux/init.h>

/*包含初始化加载模块的头文件,代码中的MODULE_LICENSE在此头文件中*/

#include <linux/module.h>

/*定义module_param module_param_array的头文件*/

#include <linux/moduleparam.h>

/*定义module_param module_param_array中perm的头文件*/

#include <linux/stat.h>

/*三个字符设备函数*/

#include <linux/fs.h>

/*MKDEV转换设备号数据类型的宏定义*/

#include <linux/kdev_t.h>

/*定义字符设备的结构体*/

#include <linux/cdev.h>

/*分配内存空间函数头文件*/

#include <linux/slab.h>

/*包含函数device_create 结构体class等头文件*/

#include <linux/device.h>

/*自定义头文件*/

#include "char_driver_leds.h"

/*Linux中申请GPIO的头文件*/

#include <linux/gpio.h>

/*三星平台的GPIO配置函数头文件*/

/*三星平台EXYNOS系列平台，GPIO配置参数宏定义头文件*/

#include <plat/gpio-cfg.h>

/*三星平台4412平台，GPIO宏定义头文件*/

#include <mach/gpio-exynos4.h>

个别解释：/*module_param(name, type, perm);

其中,name:表示参数的名字;
     type:表示参数的类型;
     perm:表示参数的访问权限;

2. 数组类型模块参数的定义:

用逗号间隔的列表提供的值;
声明一个数组参数:
module_param_array(name, type, num, perm);
其中,name:表示数组的名字;
     type:表示参数的类型;
     num :表示数组中元素数量;
     perm:表示参数的访问权限;

3.type支持的基本类型有:
bool   :布尔类型
invbool:颠倒了值的bool类型;
charp  :字符指针类型,内存为用户提供的字符串分配;
int    :整型
long   :长整型
short  :短整型
uint   :无符号整型
ulong  :无符号长整型
ushort :无符号短整型

4. perm参数 设定访问权限
modlue_param和module_param_array中的perm用于设定该参数的访问权限;
perm表示该参数在sysfs文件系统中所对应的文件节点的属性;你用该使用<Linux/stat.h>中定义的权限值;这个值控制谁可以存取这些模块参数在sysfs文件系统中的表示;当perm为0时,表示此参数不存在sysfs文件系统下对应的文件节点;否则,模块被加载后,在/sys/module/目录下将会出现以此模块名命名的目录,带有给定的权限;
比如:
#define S_IRWXU 00700
#define S_IRUSR 00400
#define S_IWUSR 00200
#define S_IXUSR 00100
#define S_IRWXG 00070
#define S_IRGRP 00040
#define S_IWGRP 00020
#define S_IXGRP 00010
#define S_IRWXO 00007
#define S_IROTH 00004
#define S_IWOTH 00002
#define S_IXOTH 00001
注意:如果一个参数被sysfs修改了,那么你的模块看到的参数值也被修改了,但是你的模块不会收到任何通知;你应当不要使模块参数可写,除非你准备好检测这个改变并因而作出反应;

5. 也可以在insmod（装载模块）的时候为参数指定值，如果没有指定则使用默认值，如下面的例子。

[cpp] view plain copy

1. MODULE_LICENSE("Dual BSD/GPL");  

2. static int num=10;  

3. module_param(num,int,S_IRUGO);  

4. static int hello_init(void)  

5. {  

6.     printk("Hello module init./n");  

7.     printk("num=%d/n",num);  

8.     return 0;  

9. }  

10. static void   hello_exit(void)  

11. {  

12.     printk("Goodbye module exit./n");  

13. }  

14. module_init(hello_init);  

15. module_exit(hello_exit);  

16. MODULE_DESCRIPTION("a simple module");  

17. MODULE_ALIAS("hello");  

上面的num=10,则10是参数num的默认值。

保存为源文件hello.c, 编译生成hello.ko , 当我们使用insmod进行载入时, 使用

insmod hello.ko num=20

则可以 cat /sys/module/hello/parameters/num ，看到为 20  */

2.变量声明

struct file_operations my_fops = {

.owner = THIS_MODULE,

.open = chardevnode_open,

.release = chardevnode_release,

.unlocked_ioctl = chardevnode_ioctl,

.read = chardevnode_read,

.write = chardevnode_write,

.llseek = chardevnode_llseek,

};

MODULE_LICENSE("Dual BSD/GPL");

/*声明是开源的，没有内核版本限制*/

MODULE_AUTHOR("iTOPEET_dz");

/*声明作者*/

static int led_gpios[] = {

EXYNOS4_GPL2(0),EXYNOS4_GPK1(1),

};

#define LED_NUMARRAY_SIZE(led_gpios)

int numdev_major = DEV_MAJOR;

int numdev_minor = DEV_MINOR;

/*输入主设备号*/

module_param(numdev_major,int,S_IRUSR);

/*输入次设备号*/

module_param(numdev_minor,int,S_IRUSR);

static struct class *myclass;

struct reg_dev *my_devices;

3.Module模块编写

module_init(scdev_init);

/*初始化函数*/

module_exit(scdev_exit);

/*卸载函数*/

static int scdev_init(void)

{

int ret = 0,i;

dev_t num_dev;

printk(KERN_EMERG "numdev_major is %d!\n",numdev_major);

printk(KERN_EMERG "numdev_minor is %d!\n",numdev_minor);

如果在安装模块的时候输入了主次编号用

if(numdev_major){

       //取它的编码 ，静态注册设备

num_dev = MKDEV(numdev_major,numdev_minor);

ret = register_chrdev_region(num_dev,DEVICE_MINOR_NUM,DEVICE_NAME1);

}

else{

/*动态注册设备号*/

ret = alloc_chrdev_region(&num_dev,numdev_minor,DEVICE_MINOR_NUM,DEVICE_NAME1);

/*获得主设备号*/

numdev_major = MAJOR(num_dev);

printk(KERN_EMERG "adev_region req %d !\n",numdev_major);

}

if(ret<0){

printk(KERN_EMERG "register_chrdev_region req %d is failed!\n",numdev_major);

}

//给字符设备申请设备类用来挂载设备节点用

myclass = class(THIS_MODULE,DEVICE_NAME);

//给设备申请内存空间

my_devices = kmalloc(DEVICE_MINOR_NUM * sizeof(struct reg_dev),GFP_KERNEL);

if(!my_devices){

ret = -ENOMEM;

goto fail;

}

//清零内存空间

memset(my_devices,0,DEVICE_MINOR_NUM * sizeof(struct reg_dev));

/*设备初始化*/

for(i=0;i<DEVICE_MINOR_NUM;i++){

//同上

my_devices[i].data = kmalloc(REGDEV_SIZE,GFP_KERNEL);

memset(my_devices[i].data,0,REGDEV_SIZE);

/*设备注册到系统*/

reg_init_cdev(&my_devices[i],i);

/*创建设备节点*/

device_(myclass,NULL,MKDEV(numdev_major,numdev_minor+i),NULL,DEVICE_NAME"%d",i);

}

//硬件端口设置

ret = gpio_init();

if(ret){

printk(KERN_EMERG "gpio_init failed!\n");

}

printk(KERN_EMERG "scdev_init!\n");

/*打印信息，KERN_EMERG表示紧急信息*/

return 0;

fail:

/*注销设备号*/

unregister_chrdev_region(MKDEV(numdev_major,numdev_minor),DEVICE_MINOR_NUM);

printk(KERN_EMERG "kmalloc is fail!\n");

return ret;

}

//卸载设备

static void scdev_exit(void)

{

int i;

printk(KERN_EMERG "scdev_exit!\n");

/*除去字符设备*/

for(i=0;i<DEVICE_MINOR_NUM;i++){

cdev_del(&(my_devices[i].cdev));

/*摧毁设备节点函数d*/

device_destroy(myclass,MKDEV(numdev_major,numdev_minor+i));

}

/*释放设备class*/

class_destroy(myclass);

/*释放内存*/

kfree(my_devices);

/*释放GPIO*/

for(i=0;i<LED_NUM;i++){

gpio_free(led_gpios[i]);

}

unregister_chrdev_region(MKDEV(numdev_major,numdev_minor),DEVICE_MINOR_NUM);

}

4.gpio端口设置

static int gpio_init(void){

int i=0,ret;

for(i=0;i<LED_NUM;i++){

//申请gpio端口

ret = gpio_request(led_gpios[i], "LED");

//错误处理

if (ret) {

printk("%s: request GPIO %d for LED failed, ret = %d\n", DEVICE_NAME,i,ret);

return -1;

}

else{

//设置端口工作方式为输出上拉

s3c_gpio_cfgpin(led_gpios[i], S3C_GPIO_OUTPUT);

gpio_set_value(led_gpios[i], 1);

}

}

return 0;

}

5.字符设备初始化

/*设备注册到系统*/

static void reg_init_cdev(struct reg_dev *dev,int index){

int err;

//算出设备编号

int devno = MKDEV(numdev_major,numdev_minor+index);

/*数据初始化   初始化字符设备*/

cdev_init(&dev->cdev,&my_fops);

dev->cdev.owner = THIS_MODULE;

dev->cdev.ops = &my_fops;

/*注册到系统*/

err = cdev_add(&dev->cdev,devno,1);

if(err){

printk(KERN_EMERG "cdev_add %d is fail! %d\n",index,err);

}

else{

printk(KERN_EMERG "cdev_add %d is success!\n",numdev_minor+index);

}

}

4.应用打开操作

/*打开操作*/

static int chardevnode_open(struct inode *inode, struct file *file){

printk(KERN_EMERG "chardevnode_open is success!\n");

return 0;

}

/*关闭操作*/

static int chardevnode_release(struct inode *inode, struct file *file){

printk(KERN_EMERG "chardevnode_release is success!\n");

return 0;

}

/*IO操作*/

static long chardevnode_ioctl(struct file *file, unsigned int cmd, unsigned long arg){

switch(cmd)

{

case 0:

case 1:

if (arg > LED_NUM) {

return -EINVAL;

}

gpio_set_value(led_gpios[arg], cmd);

break;

default:

return -EINVAL;

}

printk(KERN_EMERG "chardevnode_ioctl is success! cmd is %d,arg is %d \n",cmd,arg);

return 0;

}

ssize_t chardevnode_read(struct file *file, char __user *buf, size_t count, loff_t *f_ops){

return 0;

}

ssize_t chardevnode_write(struct file *file, const char __user *buf, size_t count, loff_t *f_ops){

return 0;

}

loff_t chardevnode_llseek(struct file *file, loff_t offset, int ence){

return 0;

}