【1012 分步注册字符设备驱动

原创 已于 2022-10-13 09:28:36 修改 · 317 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#嵌入式硬件

于 2022-10-12 20:17:08 首次发布
本文介绍了一个用于控制三个LED灯的字符设备驱动程序的设计与实现过程。该驱动程序通过映射GPIO寄存器来控制LED的状态，并提供了打开、读取、写入及ioctl等操作接口。

创建三个设备节点分别控制三个LED灯
/dev/led1 /dev/led2 /dev/led3

myled(驱动)

LED1 LED2 LED3

头文件：

#ifndef __MYLED_H__
#define __MYLED_H__

typedef struct
{
    volatile unsigned int MODER;
    volatile unsigned int OTYPER;
    volatile unsigned int OSPEEDR;
    volatile unsigned int PUPDR;
    volatile unsigned int IDR;
    volatile unsigned int ODR;
    volatile unsigned int BSRR;
} gpio_t;
#define PHY_LED1_ADDR 0X50006000
#define PHY_LED2_ADDR 0X50007000
#define PHY_LED3_ADDR 0X50006000
#define PHY_BUZZER_ADDR 0x50003000
#define PHY_FAN_ADDR 0x50006000

#define PHY_RCC_ADDR 0X50000A28
enum LED
{
    LED1 = 1,
    LED2,
    LED3,
};

#define LedON _IOW('a', 1, int)
#define LedOFF _IOW('a', 0, int)
#endif

内核文件：

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/io.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/slab.h>
#include "myled.h"
#define CNAME "myled"

int major =500;
int minor =1;
char kbuf[128] ={0};
gpio_t *vir_led1;
gpio_t *vir_led2;
gpio_t *vir_led3;
unsigned int * vir_rcc;
struct cdev *cdev;
struct class *cls;
struct device *dev;
const int count=3;
struct mutex mutex;
int mycdev_open(struct inode *inode, struct file *filp)
{
    //上锁
    if(!mutex_trylock(&mutex))
    {
        return -EBUSY;
    }
	printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
	return 0;
}
ssize_t  mycdev_read(struct file * filp,char __user *ubuf, size_t size, loff_t *offs)
{
	int ret;
	printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
	if(size > sizeof(kbuf)) 
        size = sizeof(kbuf);
	ret = copy_to_user(ubuf,kbuf,size);
	if(ret){
		printk("copy data to user error\n");
		return -EINVAL; 
	}
	return size;
}
ssize_t  mycdev_write(struct file *filp, const char __user *ubuf, size_t size, loff_t *offs)
{
	int ret;
	printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
	if(size > sizeof(kbuf)) size = sizeof(kbuf);
	ret = copy_from_user(kbuf,ubuf,size);
	if(ret){
		printk("copy data from user error\n");
		return -EINVAL; 
	}
	return size;
}
long ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
    int ret,which;
    switch(cmd)
    {
        case LedON:
            ret=copy_from_user(&which,(void *)arg,sizeof(int));
            if(ret)
            {
                printk("用户向内核拷贝数据失败\n");
                return -EIO;
            }
            switch(which)
            {
                case LED1:
                 vir_led1->ODR |= (1<<10);
                 break;
                case LED2:
                 vir_led2->ODR |= (1<<10);
                 break;
                case LED3:
                 vir_led3->ODR |= (1<<8);
                 break;
            }
            break;
        case LedOFF:
            ret=copy_from_user(&which,(void *)arg,sizeof(int));
            if(ret)
            {
                printk("用户向内核拷贝数据失败\n");
                return -EIO;
            }
            switch(which)
            {
                case LED1:
                 vir_led1->ODR &= ~(1<<10);
                 break;
                case LED2:
                vir_led2->ODR &= ~(1<<10);
                 break;
                case LED3:
                 vir_led3->ODR &= ~(1<<8);
                 break;
            }
            break;
        default:
            printk("功能码错误\n");
            break;
    }
    return 0;
 }
int  mycdev_close(struct inode *inode, struct file *filp)
{
    mutex_unlock(&mutex);
	printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
	return 0;
}
const struct file_operations fops = {
	.open  = mycdev_open,
	.read  =  mycdev_read,
	.write =  mycdev_write,
    .unlocked_ioctl=ioctl,
	.release =  mycdev_close,
};
int all_led_init(void)
{
    //进行物理地址的映射
    vir_led1=ioremap(PHY_LED1_ADDR,sizeof(gpio_t));
    if(vir_led1==NULL)
    {
        printk("vir_led1 映射失败\n");
        return -ENOMEM;
    }
    printk("vir_led1 映射成功\n");
   vir_led2=ioremap(PHY_LED2_ADDR,sizeof(gpio_t));
    if(vir_led2==NULL)
    {
        printk("vir_led2 映射失败\n");
        return -ENOMEM;
    }
    printk("vir_led2 映射成功\n");
    vir_led3=ioremap(PHY_LED3_ADDR,sizeof(gpio_t));
    if(vir_led3==NULL)
    {
        printk("vir_led3 映射失败\n");
        return -ENOMEM;
    }
    printk("vir_led3 映射成功\n");
    vir_rcc=ioremap(PHY_RCC_ADDR,4);
    if(vir_rcc==NULL)
    {
        printk("vir_rcc 映射失败\n");
        return -ENOMEM;
    }
    printk("vir_rcc 映射成功\n");
    //寄存器的初始化
    //led1
    vir_led1->MODER &= ~(3<<20);
    vir_led1->MODER |= (1<<20);
    vir_led1->ODR &= ~(1<<10);
 
    //led2
    vir_led2->MODER &= ~(3<<20);
    vir_led2->MODER |= (1<<20);
    vir_led2->ODR &= ~(1<<10);
 
    //led3
   vir_led3->MODER &= ~(3<<16);
    vir_led3->MODER |= (1<<16);
    vir_led3->ODR &= ~(1<<8);
 
    (*vir_rcc) |= (3<<4);
    return 0;
}
static int __init mycdev_init(void)
{   
    int ret,i;
    dev_t devno;
    cdev=cdev_alloc();
    if(cdev==NULL)
    {
        printk("分配设备对象失败\n");
        ret = -ENOMEM;
        goto ERR1;

    }
    printk("对象分配成功\n");
    //设备对象初始化
    cdev_init(cdev,&fops);
    if(major==0)//动态申请
    {
        ret=alloc_chrdev_region(&devno,minor,count,"my_led");
        if(ret)
        {
            printk("动态申请设备号失败\n");
            goto ERR2;
        }
        major = MAJOR(devno);
        minor = MINOR(devno);
        printk("动态申请设备号成功\n");
    }
    else
    {
        ret=register_chrdev_region(MKDEV(major,minor),count,"my_led");
        if(ret)
        {
            printk("静态申请设备号失败\n");
            goto ERR2;
        }
          printk("静态申请设备号成功\n");
    }
    //注册设备驱动
    ret=cdev_add(cdev,MKDEV(major,minor),count);
    if(ret)
    {
        printk("字符设备驱动注册失败\n");
        goto ERR3;
    }
    printk("注册字符设备驱动成功\n");
    //自动创建设备节点
    cls=class_create(THIS_MODULE,"led");
    if(IS_ERR(cls))
    {
        printk("创建节点目录失败\n");
        ret=PTR_ERR(cls);
        goto ERR4;
    }
    printk("创建节点目录成功\n");
    //向上提交节点消息
    for(i=1;i<=3;i++)
    {
        dev=device_create(cls,NULL,MKDEV(major,i),NULL,"my_led%d",i);
        if(IS_ERR(dev))
        {
            printk("创建节点失败\n");
            ret =PTR_ERR(dev);
            goto ERR5;
        }
    }

    printk("创建逻辑节点成功\n");
         //寄存器的初始化
    all_led_init();
    return 0;
ERR5:
    for(--i;i>=1;i--)
    {
        device_destroy(cls,MKDEV(major,i));
    }
    class_destroy(cls);
ERR4:
    cdev_del(cdev);
ERR3:
    unregister_chrdev_region(MKDEV(major,minor),count);
ERR2:
    kfree(cdev);
ERR1:
    return ret;
}       

static void __exit mycdev_exit(void)
{
    //1.销毁设备节点
    int i;
    for(i=1;i<=count;i++)
    {
        device_destroy(cls,MKDEV(major,i));
    }
    class_destroy(cls);
    //2.注销字符设备驱动
    cdev_del(cdev);
    //3.释放设备号
    unregister_chrdev_region(MKDEV(major,minor),count);
    //4.释放动态申请的空间
    kfree(cdev);

}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");

应用文件：

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/io.h>
#include <linux/cdev.h>
#include <linux/device.h>
#include <linux/slab.h>
#include "myled.h"
#define CNAME "myled"

int major =500;
int minor =0;
char kbuf[128] ={0};
gpio_t *vir_led1;
gpio_t *vir_led2;
gpio_t *vir_led3;
unsigned int * vir_rcc;
struct cdev *cdev;
struct class *cls;
struct device *dev;
const int count=3;
struct mutex mutex;
int mycdev_open(struct inode *inode, struct file *filp)
{
    //上锁
    if(!mutex_trylock(&mutex))
    {
        return -EBUSY;
    }
	printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
	return 0;
}
ssize_t  mycdev_read(struct file * filp,char __user *ubuf, size_t size, loff_t *offs)
{
	int ret;
	printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
	if(size > sizeof(kbuf)) 
        size = sizeof(kbuf);
	ret = copy_to_user(ubuf,kbuf,size);
	if(ret){
		printk("copy data to user error\n");
		return -EINVAL; 
	}
	return size;
}
ssize_t  mycdev_write(struct file *filp, const char __user *ubuf, size_t size, loff_t *offs)
{
	int ret;
	printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
	if(size > sizeof(kbuf)) size = sizeof(kbuf);
	ret = copy_from_user(kbuf,ubuf,size);
	if(ret){
		printk("copy data from user error\n");
		return -EINVAL; 
	}
	return size;
}
long ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 {
    int ret,which;
    switch(cmd)
    {
        case LedON:
            ret=copy_from_user(&which,(void *)arg,sizeof(int));
            if(ret)
            {
                printk("用户向内核拷贝数据失败\n");
                return -EIO;
            }
            switch(which)
            {
                case LED1:
                 vir_led1->ODR |= (1<<10);
                 break;
                case LED2:
                 vir_led2->ODR |= (1<<10);
                 break;
                case LED3:
                 vir_led3->ODR |= (1<<8);
                 break;
            }
            break;
        case LedOFF:
            ret=copy_from_user(&which,(void *)arg,sizeof(int));
            if(ret)
            {
                printk("用户向内核拷贝数据失败\n");
                return -EIO;
            }
            switch(which)
            {
                case LED1:
                 vir_led1->ODR &= ~(1<<10);
                 break;
                case LED2:
                vir_led2->ODR &= ~(1<<10);
                 break;
                case LED3:
                 vir_led3->ODR &= ~(1<<8);
                 break;
            }
            break;
        default:
            printk("功能码错误\n");
            break;
    }
    return 0;
 }
int  mycdev_close(struct inode *inode, struct file *filp)
{
    mutex_unlock(&mutex);
	printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
	return 0;
}
const struct file_operations fops = {
	.open  = mycdev_open,
	.read  =  mycdev_read,
	.write =  mycdev_write,
    .unlocked_ioctl=ioctl,
	.release =  mycdev_close,
};
int all_led_init(void)
{
    //进行物理地址的映射
    vir_led1=ioremap(PHY_LED1_ADDR,sizeof(gpio_t));
    if(vir_led1==NULL)
    {
        printk("vir_led1 映射失败\n");
        return -ENOMEM;
    }
    printk("vir_led1 映射成功\n");
   vir_led2=ioremap(PHY_LED2_ADDR,sizeof(gpio_t));
    if(vir_led2==NULL)
    {
        printk("vir_led2 映射失败\n");
        return -ENOMEM;
    }
    printk("vir_led2 映射成功\n");
    vir_led3=ioremap(PHY_LED3_ADDR,sizeof(gpio_t));
    if(vir_led3==NULL)
    {
        printk("vir_led3 映射失败\n");
        return -ENOMEM;
    }
    printk("vir_led3 映射成功\n");
    vir_rcc=ioremap(PHY_RCC_ADDR,4);
    if(vir_rcc==NULL)
    {
        printk("vir_rcc 映射失败\n");
        return -ENOMEM;
    }
    printk("vir_rcc 映射成功\n");
    //寄存器的初始化
    //led1
    vir_led1->MODER &= ~(3<<20);
    vir_led1->MODER |= (1<<20);
    vir_led1->ODR &= ~(1<<10);
 
    //led2
    vir_led2->MODER &= ~(3<<20);
    vir_led2->MODER |= (1<<20);
    vir_led2->ODR &= ~(1<<10);
 
    //led3
   vir_led3->MODER &= ~(3<<16);
    vir_led3->MODER |= (1<<16);
    vir_led3->ODR &= ~(1<<8);
 
    (*vir_rcc) |= (3<<4);
    return 0;
}
static int __init mycdev_init(void)
{   
    int ret,i;
    dev_t devno;
    cdev=cdev_alloc();
    if(cdev==NULL)
    {
        printk("分配设备对象失败\n");
        ret = -ENOMEM;
        goto ERR1;

    }
    printk("对象分配成功\n");
    //设备对象初始化
    cdev_init(cdev,&fops);
    if(major==0)//动态申请
    {
        ret=alloc_chrdev_region(&devno,minor,count,"my_led");
        if(ret)
        {
            printk("动态申请设备号失败\n");
            goto ERR2;
        }
        major = MAJOR(devno);
        minor = MINOR(devno);
        printk("动态申请设备号成功\n");
    }
    else
    {
        ret=register_chrdev_region(MKDEV(major,minor),count,"my_led");
        if(ret)
        {
            printk("静态申请设备号失败\n");
            goto ERR2;
        }
          printk("静态申请设备号成功\n");
    }
    //注册设备驱动
    ret=cdev_add(cdev,MKDEV(major,minor),count);
    if(ret)
    {
        printk("字符设备驱动注册失败\n");
        goto ERR3;
    }
    printk("注册字符设备驱动成功\n");
    //自动创建设备节点
    cls=class_create(THIS_MODULE,"led");
    if(IS_ERR(cls))
    {
        printk("创建节点目录失败\n");
        ret=PTR_ERR(cls);
        goto ERR4;
    }
    printk("创建节点目录成功\n");
    //向上提交节点消息
    for(i=1;i<=3;i++)
    {
        dev=device_create(cls,NULL,MKDEV(major,i),NULL,"my_led%d",i);
        if(IS_ERR(dev))
        {
            printk("创建节点失败\n");
            ret =PTR_ERR(dev);
            goto ERR5;
        }
    }

    printk("创建逻辑节点成功\n");
         //寄存器的初始化
    all_led_init();
    return 0;
ERR5:
    for(--i;i>=1;i--)
    {
        device_destroy(cls,MKDEV(major,i));
    }
    class_destroy(cls);
ERR4:
    cdev_del(cdev);
ERR3:
    unregister_chrdev_region(MKDEV(major,minor),count);
ERR2:
    kfree(cdev);
ERR1:
    return ret;
}       

static void __exit mycdev_exit(void)
{
    //1.销毁设备节点
    int i;
    for(i=1;i<=count;i++)
    {
        device_destroy(cls,MKDEV(major,i));
    }
    class_destroy(cls);
    //2.注销字符设备驱动
    cdev_del(cdev);
    //3.释放设备号
    unregister_chrdev_region(MKDEV(major,minor),count);
    //4.释放动态申请的空间
    kfree(cdev);

}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");
与火同行
关注
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值