动手做一个linux字符驱动

最近学习了一本书《linux 设备驱动开发详解》——宋宝华老师写的，不过买的竟然是第二版的，里面是关于处理器s3c6410的，本来看这书的第一版是讲s3c2410，后来发现其实内容差不多了。

学习了一下里面第2篇，设备驱动的核心理论，涉及很多，基础的知识需要反复的推敲才能明白。

主要内容：

1、模块加载函数

static int __init combine_init(void)
{
//注册设备号和设备名
int result;
dev_t dev_num= MKDEV(combine_major,0);
//dev_t是cdev结构体的成员，定义了设备号，MAJOR(dev_t)，MINOR(dev_t)可以分别获得主设备号和次设备号
char dev_name[] = "combine";
if(combine_major)
{
result = register_chrdev_region(dev_num, 1, dev_name);
//int register_chrdev_region(dev_t from,unsigned count,const char *name);
//第一个参数：设备号；第二个参数：连续分配的设备号；第三个参数：设备名}
else
{
result = alloc_chrdev_region(&dev_num,0,1,dev_name);
//int alloc_chrdev_region(dev_t *dev,unsigned baseminor,unsigned count,const char *name);
combine_major = MAJOR(dev_num);
}
if(result < 0)
{
printk("combine:unable to get major %d\n",combine_major);return result;
}

//关联设备结构体cdev和文件操作结构体fops
cdev_init(&combine_cdev, &combine_fops);
//static struct cdev combine_cdev;
//void cdev_init(struct cdev *,struct file_operation *);
result = cdev_add(&combine_cdev, dev_num, 1);
//int cdev_add(struct cdev *,dev_t,unsigned);
if(result <0 )//加上函数的出错处理
{
printk("combine:unable to add cdev\n");
}
printk("combine device installed \nwith major %d,%s\n",combine_major,dev_name);
return 0;
}

2、模块卸载函数

static void __exit combine_exit(void)
{
cdev_del(&combine_cdev);
//void cdev_del(struct cdev *);
unregister_chrdev_region(MKDEV(combine_major,0), 1);
//void unregister_chrdev_region(dev_t from,unsigned count);
printk("combine device uninstalled\n");}

3、很重要的一个结构体：file_operations文件操作结构体

static struct file_operations combine_fops =
{
.owner = THIS_MODULE,
.open = combine_open,
.release = combine_release,
.read = combine_read,
.write = combine_write,
.ioctl = combine_ioctl,
};

然后就是在驱动函数中利用

中断屏蔽local_irq_disable()，local_irq_enable()，

自旋锁spinlock_t，

信号量struct semaphore sem，

完成量struct completion，

互斥体struct mutex来解决并发与竞态问题。

4、阻塞操作

当应用程序进行read()，write()等系统调用时，若设备的资源不能获取，而用户又希望以阻塞的方式访问设备，驱动程序应在设备驱动的xxx_read()，xxx_write()等操作中将进程阻塞直到资源可以获取，此后应用程序的read()，write()等调用才返回。

用于设备阻塞操作可以使用等待队列wait_queue_head_t my_queue；

将事件加入等待队列wait_event_interrupt(my_queue,condition);

将事件从等待队列中唤醒wake_up_interrupt(&my_queue);

或者利用unsigned int poll(struct file *filp,struct poll_table *wait);查询是否可对设备进行无阻塞访问

struct unsigned int xxx_poll(struct file *filp,poll_table *wait)
{
unsigned int mask=0;
struct xxx_dev *dev = filp->private_data;//获取设备结构体指针
poll_wait(filp,my_queue,wait);
//这个函数加了之后再read中就不用再wait_event_interrupt，
//因为在这里已经实现了阻塞，一旦资源可用就可以在read中实现无阻塞访问
//像read中wait_event_interrupt一样被wake_up_interrupt唤醒

if(...)//可读
mask |= POLLIN | POLLRDNORM;//标示数据可获得
if(...)//可写
mask |= POLLOUT | POLLWRNORM;//标示数据可写入
return mask;<pre name="code" class="cpp">}

5、linux中断编程

<pre name="code" class="html">struct key_irq_desc
{
unsigned int irq;
int pin;
int pin_setting;
int number;
char *name;
};
static struct key_irq_desc key_irqs[] =
{
{IRQ_EINT8,	S3C2410_GPG(0),	S3C2410_GPG0_EINT8,    0,	"key1"},
{IRQ_EINT11,	S3C2410_GPG(3),	S3C2410_GPG3_EINT11,   1,	"key2"},
{IRQ_EINT13,	S3C2410_GPG(5),	S3C2410_GPG5_EINT13,   2,	"key3"},
{IRQ_EINT14,	S3C2410_GPG(6),	S3C2410_GPG6_EINT14,   3,	"key4"},
{IRQ_EINT15,	S3C2410_GPG(7),	S3C2410_GPG7_EINT15,   4,	"key5"},
{IRQ_EINT19,	S3C2410_GPG(11),S3C2410_GPG11_EINT19,  5,	"key6"},
};
static volatile int key_values[] = {0,0,0,0,0,0};
static DECLARE_WAIT_QUEUE_HEAD(key_waitq);
static volatile int ev_press = 0;
static void my_tasklet_func(unsigned long data)
{
printk("key do tasklet\n");
}
static DECLARE_TASKLET(my_tasklet,my_tasklet_func,0);

static irqreturn_t key_interrupt(int irq,void *dev_id)//中断顶半部函数
{
struct key_irq_desc *key_irqs = (struct key_irq_desc *)dev_id;
int up = s3c2410_gpio_getpin(key_irqs->pin);

printk("<1>up=%d\n",up);
if(up)//up 按下去是0，没按是1
key_values[key_irqs->number] = (key_irqs->number + 1) + 0x80;
else
key_values[key_irqs->number] += 1;

ev_press = 1;
wake_up_interruptible(&key_waitq);

tasklet_schedule(&my_tasklet);//在顶半部函数中调度执行底半部函数

return IRQ_RETVAL(IRQ_HANDLED);
}

static int combine_open(struct inode *inode,struct file *file)
{
int i,err;

for(i = 0;i < sizeof(key_irqs) / sizeof(key_irqs[0]);i++)
{
s3c2410_gpio_cfgpin(key_irqs[i].pin,key_irqs[i].pin_setting);
err = request_irq(key_irqs[i].irq, key_interrupt, 0, key_irqs[i].name, (void *)&key_irqs[i]);
//int request_irq(unsigned int irq,irq_handler_t handler,unsigned long irqflags,const char *devname,void *dev_id);		//handler是向系统登记的中断处理顶半部函数，dev_id是传给他的参数
set_irq_type(key_irqs[i].irq,IRQ_TYPE_EDGE_BOTH);
if(err) break;
}
if(err)
{
i--;
for(;i >= 0;i--)
{
disable_irq(key_irqs[i].irq);
free_irq(key_irqs[i].irq, (void *)&key_irqs[i]);
//void free_irq(unsigned int irq,void *dev_id);
}return -EBUSY;}return 0;}

6、下面是完整的按键与蜂鸣器结合的字符驱动函数，资源上传于：http://download.csdn.net/detail/luckywang1103/6537111

<pre name="code" class="cpp">/*********************************************************************************************
* File：		conbine.c
* Author:		luckywang
* Desc：	组合各种驱动,驱动6个按键，和beep驱动，但是现在没有将两者结合起来，只是各自独立驱动
* History:	2013.11.09
*********************************************************************************************/
#include <linux/init.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/input.h>
#include <linux/serio.h>
#include <linux/delay.h>
#include <linux/clk.h>
#include <linux/miscdevice.h>
#include <linux/gpio.h>
#include <asm/io.h>
#include <linux/irq.h>
#include <asm/irq.h>
#include <asm/uaccess.h>
#include <mach/regs-clock.h>
#include <plat/regs-timer.h>
#include <mach/regs-gpio.h>
#include <linux/cdev.h>
#include <linux/sched.h>
#include <mach/hardware.h>
#include <linux/platform_device.h>
#include <linux/interrupt.h>
#include <linux/wait.h>

static int combine_major = 0;
static struct cdev combine_cdev;

#define BEEP_MAGIC 'k'
#define BEEP_START_CMD _IO(BEEP_MAGIC,1)
#define BEEP_STOP_CMD _IO(BEEP_MAGIC,2)

struct key_irq_desc
{
unsigned int irq;
int pin;
int pin_setting;
int number;
char *name;
};

static struct key_irq_desc key_irqs[] =
{
{IRQ_EINT8,	S3C2410_GPG(0),	S3C2410_GPG0_EINT8,	    0,	"key1"},
{IRQ_EINT11,	S3C2410_GPG(3),	S3C2410_GPG3_EINT11,   1,	"key2"},
{IRQ_EINT13,	S3C2410_GPG(5),	S3C2410_GPG5_EINT13,   2,	"key3"},
{IRQ_EINT14,	S3C2410_GPG(6),	S3C2410_GPG6_EINT14,   3,	"key4"},
{IRQ_EINT15,	S3C2410_GPG(7),	S3C2410_GPG7_EINT15,   4,	"key5"},
{IRQ_EINT19,	S3C2410_GPG(11),S3C2410_GPG11_EINT19,5,	"key6"},
};

static volatile int key_values[] = {0,0,0,0,0,0};
static DECLARE_WAIT_QUEUE_HEAD(key_waitq);
static volatile int ev_press = 0;

static void my_tasklet_func(unsigned long data)
{
printk("key do tasklet\n");
}
static DECLARE_TASKLET(my_tasklet,my_tasklet_func,0);

static irqreturn_t key_interrupt(int irq,void *dev_id)
{
struct key_irq_desc *key_irqs = (struct key_irq_desc *)dev_id;
int up = s3c2410_gpio_getpin(key_irqs->pin);

printk("<1>up=%d\n",up);
if(up)//up 按下去是0，没按是1
key_values[key_irqs->number] = (key_irqs->number + 1) + 0x80;
else
key_values[key_irqs->number] += 1;

ev_press = 1;
wake_up_interruptible(&key_waitq);

tasklet_schedule(&my_tasklet);

return IRQ_RETVAL(IRQ_HANDLED);
}

static int combine_open(struct inode *inode,struct file *file)
{
int i,err;

for(i = 0;i < sizeof(key_irqs) / sizeof(key_irqs[0]);i++)
{
s3c2410_gpio_cfgpin(key_irqs[i].pin,key_irqs[i].pin_setting);
err = request_irq(key_irqs[i].irq, key_interrupt, 0, key_irqs[i].name, (void *)&key_irqs[i]);
set_irq_type(key_irqs[i].irq,IRQ_TYPE_EDGE_BOTH);
if(err) break;
}
if(err)
{
i--;
for(;i >= 0;i--)
{
disable_irq(key_irqs[i].irq);
free_irq(key_irqs[i].irq, (void *)&key_irqs[i]);
}
return -EBUSY;
}
return 0;
}

static int combine_release(struct inode *inode,struct file *file)
{
int i;
for(i = 0;i < sizeof(key_irqs) / sizeof(key_irqs[i]);i++)
{
disable_irq(key_irqs[i].irq);
free_irq(key_irqs[i].irq,(void *)&key_irqs[i]);
}
return 0;
}

static int combine_read(struct file *filp,char __user *buff,size_t count,loff_t *offp)
{
unsigned long err;
if(!ev_press)
{
if(filp->f_flags & O_NONBLOCK)
return -EAGAIN;
else
wait_event_interruptible(key_waitq, ev_press);
}

ev_press = 0;
err = copy_to_user(buff,(const void *)key_values,min(sizeof(key_values),count));
memset((void *)key_values,0,sizeof(key_values));

return err ? -EFAULT : min(sizeof(key_values),count);
}

static int combine_write(struct file *file,const char __user *buff,size_t count,loff_t *offp)
{

return 0;
}

void beep_start(void)
{
s3c2410_gpio_pullup(S3C2410_GPB(0),1);
s3c2410_gpio_cfgpin(S3C2410_GPB(0), S3C2410_GPIO_OUTPUT);
s3c2410_gpio_setpin(S3C2410_GPB(0),1);
}

void beep_stop(void)
{
s3c2410_gpio_cfgpin(S3C2410_GPB(0), S3C2410_GPIO_OUTPUT);
s3c2410_gpio_setpin(S3C2410_GPB(0),0);

}

static int combine_ioctl(struct inode *inode,struct file *file,unsigned int cmd,unsigned long arg)
{
switch(cmd)
{
case BEEP_START_CMD:
beep_start();
break;
case BEEP_STOP_CMD:
beep_stop();
break;
default:
break;

}

return 0;
}

static struct file_operations combine_fops =
{
.owner = THIS_MODULE,
.open = combine_open,
.release = combine_release,
.read = combine_read,
.write = combine_write,
.ioctl = combine_ioctl,
};
static int __init combine_init(void)
{
//注册设备号和设备名
int result;
dev_t dev_num= MKDEV(combine_major,0);
char dev_name[] = "combine";
if(combine_major)
{
result = register_chrdev_region(dev_num, 1, dev_name);
}
else
{
result = alloc_chrdev_region(&dev_num,0,1,dev_name);
combine_major = MAJOR(dev_num);
}
if(result < 0)
{
printk("combine:unable to get major %d\n",combine_major);
return result;
}

//关联设备结构体cdev和文件操作结构体fops
cdev_init(&combine_cdev, &combine_fops);
result = cdev_add(&combine_cdev, dev_num, 1);
if(result <0 )//加上函数的出错处理
{
printk("combine:unable to add cdev\n");
}

printk("combine device installed \nwith major %d,%s\n",combine_major,dev_name);

return 0;
}

static void __exit combine_exit(void)
{
//printk("combine driver exit\n");
cdev_del(&combine_cdev);
unregister_chrdev_region(MKDEV(combine_major,0), 1);

printk("combine device uninstalled\n");
}

module_init(combine_init);
module_exit(combine_exit);

MODULE_LICENSE("Dual BSD/GPL");
MODULE_AUTHOR("luckywang");
MODULE_DESCRIPTION("s3c2440 combine driver");
MODULE_VERSION("V0.1");

测试程序

<p></p><p><span style="font-size:14px;"></span></p><pre name="code" class="cpp">/*********************************************************************************************
* File：	combine_test.c
* Author:	luckkywang
* Desc:   combine test code
* History:2013.11.10
*********************************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <linux/ioctl.h>
#include<errno.h>

#define BEEP_MAGIC 'k'
#define BEEP_START_CMD _IO (BEEP_MAGIC, 1)
#define BEEP_STOP_CMD _IO (BEEP_MAGIC, 2)

int main()
{
int i = 0;
int key_values[] = {0,0,0,0,0,0};
int dev_fd;
int ret;
dev_fd = open("/dev/combine",O_RDWR | O_NONBLOCK);
if ( dev_fd == -1 ) {
printf("Cann't open file /dev/beep\n");
exit(1);
}
while(1)
{
ret = read(dev_fd,key_values,sizeof(key_values));
if(ret != sizeof(key_values))
{
if(errno != EAGAIN)
perror("read key\n");
continue;
}
else
{
for(i = 0;i < 6;i++)
{
printf("K%d %s,key_value=0x%02x\n",i+1,(key_values[i] & 0x80) ? "released" : key_values[i] ? "pressed down":"",key_values[i]);
}
key_values[i] = 0;
}
}

/*printf("Start beep\n");
ioctl (dev_fd, BEEP_START_CMD,0);
getchar();
ioctl (dev_fd, BEEP_STOP_CMD,0);
printf("Stop beep and Close device\n");*/
close(dev_fd);
return 0;
}