通过字符设备驱动分步注册的方式编写LED驱动并且编写测试文件

头文件

#ifndef __HEAD_H__
#define __HEAD_H__
typedef struct
{
    unsigned int moder;
    unsigned int otyper;
    unsigned int ospeed;
    unsigned int pupdr;
    unsigned int idr;
    unsigned int odr;
}gpio_t;

#define phy_led1_addr 0X50006000
#define phy_led2_addr 0X50007000
#define phy_led3_addr 0X50006000
#define phy_rcc_addr 0X50000A28

#define phy_fengshan_addr 0x50006000
#define phy_fenmingqi_addr 0x50003000


int init_led(void);


#endif

驱动文件

#include <linux/init.h>
#include <linux/module.h>
#include <linux/cdev.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include<linux/slab.h>
#include<linux/uaccess.h>
#include "head.h"
#include<linux/io.h>
#if 0
    unsigned int major=0;
#else
    unsigned int major=500;
#endif

struct cdev* cdev;
unsigned int minor=0;
struct class* cls;
struct device *dev;
dev_t devno; //设备号


//定义内核数组容器
char kbuf[128]={0};
gpio_t* vir_led1;
gpio_t* vir_led2;
gpio_t* vir_led3;
gpio_t* vir_fengshan;
gpio_t* vir_fenmingqi;

unsigned int* vir_rcc;


//填充操作方法结构体
int myopen(struct inode* inode,struct file* file)
{
    printk("file:%s function:%s line:%d\n",__FILE__,__func__,__LINE__);
    return 0;
}

ssize_t myread(struct file* file,char* ubuf,size_t size,loff_t* loff)
{
    printk("file:%s function:%s line:%d\n",__FILE__,__func__,__LINE__);
    unsigned long ret; //定义一个变量来接收copy_to_user返回值,0-接收成功 非0-接收失败
    if(sizeof(kbuf)>size)
    {
        size=sizeof(kbuf);
    }
        ret=copy_to_user(ubuf,kbuf,size);
        if(ret)
        {
            printk("copy_to_user failed!!! 只发送到%ld个字节数据\n",ret);
            return ret;
        }
    return 0;
}

ssize_t mywrite(struct file* file,const char* ubuf,size_t size,loff_t* loff)
{
    unsigned long ret; //定义一个变量来接收copy_to_user返回值,0-接收成功 非0-接收失败
    printk("file:%s function:%s line:%d\n",__FILE__,__func__,__LINE__);
    if(sizeof(kbuf)>size)
    {
        size=sizeof(kbuf);
    }
        ret=copy_from_user(kbuf,ubuf,size);
        if(ret)
        {
            printk("copy_from_user failed!!! 只接收到%ld个字节数据\n",ret);
            return ret;
        }     
         switch(kbuf[0])
        {
            case '1'://LED1
                if(kbuf[1]=='0')//关灯
                    vir_led1->odr &=(~(0x1<<10));
                else //开灯
                vir_led1->odr |=0x1<<10;
            break;
             case '2'://LED2
                if(kbuf[1]=='0')//关灯
                    vir_led2->odr &=(~(0x1<<10));
                else //开灯
                vir_led2->odr |=0x1<<10;
            break;
             case '3'://LED3
                if(kbuf[1]=='0')//关灯
                    vir_led3->odr &=(~(0x1<<8));
                else //开灯
                vir_led3->odr |=0x1<<8;
            break;
            case '4'://风扇
                if(kbuf[1]=='0')//关
                    vir_fengshan->odr &=(~(0x1<<9));
                else //开
                vir_fengshan->odr |=0x1<<9;
            break;
            case '5'://蜂鸣器
                if(kbuf[1]=='0')//关
                    vir_fenmingqi->odr &=(~(0x1<<6));
                else //开
                vir_fenmingqi->odr |=0x1<<6;
            break;
        }
    return 0;
}

int myclose(struct inode* inode,struct file* file)
{
    printk("file:%s function:%s line:%d\n",__FILE__,__func__,__LINE__);
    return 0;
}

//填充操作方法结构体指针并初始化
struct file_operations fops={
    .open=myopen,
    .read=myread,
    .write=mywrite,
    .release=myclose
};

//物理地址映射虚拟地址以及虚拟地址操作寄存器初始化
int init_led(void)
{
    //物理地址映射虚拟地址
    vir_led1=ioremap(phy_led1_addr,sizeof(gpio_t));
    if(vir_led1==NULL)
    {
        printk("ioremap failed:%d\n",__LINE__);
        return -ENOMEM;
    }
    vir_led2=ioremap(phy_led2_addr,sizeof(gpio_t));
    if(vir_led2==NULL)
    {
        printk("ioremap failed:%d\n",__LINE__);
        return -ENOMEM;
    }
    vir_led3=ioremap(phy_led3_addr,sizeof(gpio_t));
    if(vir_led3==NULL)
    {
        printk("ioremap failed:%d\n",__LINE__);
        return -ENOMEM;
    }

    vir_fengshan=ioremap(phy_fengshan_addr,sizeof(gpio_t));
      if(vir_fengshan==NULL)
    {
        printk("ioremap failed:%d\n",__LINE__);
        return -ENOMEM;
    }

     vir_fenmingqi=ioremap(phy_fenmingqi_addr,sizeof(gpio_t));
      if(vir_fenmingqi==NULL)
    {
        printk("ioremap failed:%d\n",__LINE__);
        return -ENOMEM;
    }

    vir_rcc=ioremap(phy_rcc_addr,4);
    if(vir_rcc==NULL)
    {
        printk("ioremap failed:%d\n",__LINE__);
        return -ENOMEM;
    }


    printk("物理地址映射成功\n");
    //寄存器初始化
    //rcc使能
    (*vir_rcc)|=0x3<<4;
    (*vir_rcc)|=0x1<<1; //蜂鸣器

    //led1初始化
    vir_led1->moder&=(~(0x3<<20));
    vir_led1->moder|=(0x1<<20);
    vir_led1->odr&=(~(0x1<<10));

    //led2初始化
    vir_led2->moder&=(~(0x3<<20));
    vir_led2->moder|=(0x1<<20);
    vir_led2->odr&=(~(0x1<<10));

    //led3初始化
    vir_led3->moder&=(~(0x3<<16));
    vir_led3->moder|=(0x1<<16);
    vir_led3->odr&=(~(0x1<<8));
    //蜂鸣器初始化
    vir_fenmingqi->moder&=(~(0x3<<12));
    vir_fenmingqi->moder|=(0x1<<12);
    vir_fenmingqi->odr&=(~(0x1<<6));
    //风扇初始化
    vir_fengshan->moder&=(~(0x3<<18));
    vir_fengshan->moder|=(0x1<<18);
    vir_fengshan->odr&=(~(0x1<<9));
    printk("寄存器初始化成功\n");
    return 0;
}





static int __init mycdev_init(void)
{
    int ret;
    //分配字符设备驱动对象空间
    cdev =cdev_alloc();
    if(NULL==cdev)
    {
        
        printk("字符设备驱动对象空间申请失败\n");
        ret=-ENOMEM;
        goto ERR1;
    }
    //初始化字符设备驱动对象
    cdev_init(cdev,&fops);
    //申请设备号
    if(major==0) //动态申请设备号
    {
        ret=alloc_chrdev_region(&devno,minor,3,"myled");
        if(ret)
        {
            printk("动态申请设备号失败\n");
            goto ERR2;
        }
        //通过设备号获取主设备号和次设备号
        major=MAJOR(devno);
        minor=MINOR(devno);
    }
    else if(major>0)  //静态指定设备号
    {
        ret=register_chrdev_region(MKDEV(major,minor),3,"myled");
        if(ret)
        {
            printk("静态指定设备号失败\n");
            goto ERR2;
        }
    }
    printk("申请设备号成功\n");
    //注册
    ret=cdev_add(cdev,MKDEV(major,minor),3);
    if(ret)
    {
        printk("注册字符设备驱动对象失败\n");
        goto ERR3;
    }
    //向上提交目录
    cls=class_create(THIS_MODULE,"myled");
    if(IS_ERR(cls))
    {
        printk("向上提交目录失败\n");
        ret=PTR_ERR(cls);
        goto ERR4;
    }
    printk("次昂上提交目录成功\n");

    //向上提交设备节点信息
    int i;
    for(i=0;i<3;i++)
    {
        dev=device_create(cls,NULL,MKDEV(major,i),NULL,"myled%d",i);
        if(IS_ERR(dev))
        {
            printk("向上提交设备信息失败\n");
            ret=PTR_ERR(dev);
            goto ERR5;
        }
    }

    //调用初始化函数以及物理地址映射虚拟地址函数
    init_led();

    return 0;

ERR5:
    for(--i;i>=0;i--)
    {
        device_destroy(cls,MKDEV(major,i));
    }
    class_destroy(cls);
ERR4:
    cdev_del(cdev);
ERR3:
    unregister_chrdev_region(MKDEV(major,minor),3);
ERR2:
    kfree(cdev);
ERR1:
    return ret;
}


static void __exit mycdev_exit(void)
{
    //销毁设备信息结构体
    int i;
    for(i=0;i<3;i++)
    {
        device_destroy(cls,MKDEV(major,i));
    }
    //销毁目录结构体
    class_destroy(cls);
    //注销字符设备驱动对象
    cdev_del(cdev);
    //释放设备号
    unregister_chrdev_region(MKDEV(major,minor),3);
    //释放对象空间
    kfree(cdev);

    //取消物理地址映射
    iounmap(vir_led1);
    iounmap(vir_led2);
    iounmap(vir_led3);
    iounmap(vir_rcc);
    //注销字符设备驱动
    unregister_chrdev(major,"mychrdev");


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

应用测试文件

#include<stdio.h>
#include<stdlib.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<unistd.h>
#include<string.h>

int main(int argc, char const *argv[])
{
    //定义一个容器
    char sel[128]={0};
    //打开驱动文件生成文件描述符
    int fd=open("/dev/mychrdev",O_RDWR);
    if(fd<0)
    {
        printf("打开驱动文件失败\n");
        exit(-1);
    }

    //终端输入
    while(1)
    {
    printf("请输入字符选择哪盏灯亮灭(亮:1,灭:0) 1(led1) 2(led2) 3(led3)\n");
    printf("风扇(开启1,关闭0) 蜂鸣器(开启1,关闭0):4(风扇) 5(蜂鸣器)\n");
    fgets(sel,sizeof(sel),stdin);
    sel[strlen(sel)-1]='\0';
     //向设备文件中写入数据
     write(fd,sel,sizeof(sel)); 
    }
     //关闭文件描述符
     close(fd);
    return 0;
}