驱动开发

最新推荐文章于 2024-07-27 17:35:08 发布
weixin_44905771
最新推荐文章于 2024-07-27 17:35:08 发布
阅读量83
点赞数
文章标签：驱动开发
本文链接：https://blog.csdn.net/weixin_44905771/article/details/131948989
版权
编写LED驱动，创建三个设备文件，每个设备文件绑定一个设备
 head.h
#ifndef __HEAD_H__
#define __HEAD_H__


#define RCC_MP_AHB4ENSETR 0x50000A28

#define PHY_LED1_MODER 0X50006000
#define PHY_LED1_ODR   0X50006014
//#define PHY_LED_RCC   0X50000A28

#define PHY_LED2_MODER 0X50007000
#define PHY_LED2_ODR   0X50007014

#define PHY_LED3_MODER 0X50006000
#define PHY_LED3_ODR   0X50006014

//LED功能码
#define LED_ON _IO('l',1)
#define LED_OFF _IO('l',0)
#endif



test.c
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include "head.h"
int main(int argc, char const *argv[])
{
        int a, b, fd;
        char buf[128] = {0};
        while (1)
        {
                printf("请输入要控制的灯 1(LED1) 2(LED2) 3(LED3)>>");
                scanf("%d", &b);
                printf("调用open\n");
                switch (b)
                {
                case 1:
                        fd = open("/dev/myled0", O_RDWR);
                        if (fd < 0)
                        {
                                printf("打开设备文件失败\n");
                                exit(-1);
                        }
                        break;
                case 2:
                        fd = open("/dev/myled1", O_RDWR);
                        if (fd < 0)
                        {
                                printf("打开设备文件失败\n");
                                exit(-1);
                        }
                        break;
                case 3:
                        fd = open("/dev/myled2", O_RDWR);
                        if (fd < 0)
                        {
                                printf("打开设备文件失败\n");
                                exit(-1);
                        }
                        break;
                }


                while (1)
                {
                        // 从终端获取
                        printf("请输入指令\n");
                        printf("0(关灯)  1(开灯)  2(退出)\n");
                        printf("请输入>>>>");
                        scanf("%d", &a);
                        if (a == 2)
                        {
                                break;
                        }
                        switch (a)
                        {
                        case 1:
                                ioctl(fd, LED_ON); // 开灯
                                break;
                        case 0:
                                ioctl(fd, LED_OFF);
                                break;
                        default:
                                printf("输入错误\n");
                                break;
                        }
                }
                close(fd);
        }
        return 0;
}



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

char kbuf[128] = {0};
unsigned int major;
unsigned int *vir_moder;
unsigned int *vir_odr;
unsigned int *vir_rcc;
unsigned int *vir1_moder;
unsigned int *vir1_odr;
unsigned int *vir1_rcc;
unsigned int *vir2_moder;
unsigned int *vir2_odr;
unsigned int *vir2_rcc;

struct cdev *cdev;
dev_t dev;
unsigned int major = 500;
unsigned int minor = 0;
struct class *cls;
struct device *dev1;

int mycdev_open(struct inode *inode, struct file *file)
{
    int a=inode->i_rdev;//获取当前设备文件对应的设备号
    file->private_data=(void *)MINOR(a);//将次设备号保存到当前文件的file结构中
        printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
        return 0;
}

long mycdev_ioctl(struct file *file,unsigned int cmd,unsigned long arg)
{
    unsigned int a=(unsigned int)file->private_data;
        switch(cmd)
        {
        case LED_ON:
                switch (a)
                {
                case 0:
                        *vir_odr |= (0x1 << 10);//LED1开灯
                        break;
                case 1:
                        *vir1_odr |= (0x1 << 10);//LED2开灯
                        break;
                case 2:
                        *vir2_odr |= (0x1 << 8);//LED3开灯
                        break;
                }
                break;
        case LED_OFF:
                switch (a)
                {
                case 0:
                        *vir_odr &= (~(0x1 << 10));//LED1开灯
                        break;
                case 1:
                        *vir1_odr &= (~(0x1 << 10));//LED2开灯
                        break;
                case 2:
                        *vir2_odr &= (~(0x1 << 8));//LED3开灯
                        break;
                }
                break;
        }
        return 0;
}



int mycdev_close(struct inode *inode, struct file *file)
{
     printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    return 0;
}
struct file_operations ops={
        .open=mycdev_open,
        .release=mycdev_close,
        .unlocked_ioctl=mycdev_ioctl,
};

static int __init mycdev_init(void)
{
    int ret;
    // 1.申请对象空间 cdev_alloc
    cdev = cdev_alloc();
    if (cdev == NULL)
    {
        printk("为驱动对象申请失败\n");
        ret = -EFAULT;
        goto out1;
    }
    // 2.初始化对象  cdev_init
    cdev_init(cdev, &ops);
    // 3.s申请设备号  register_chrdev_region()/alloc_chrdev_region()
    if (major == 0)
    {
        ret = alloc_chrdev_region(&dev, 0, 3, "myled");
        if (ret)
        {
            printk("动态申请设备号失败\n");
            goto out2;
        }
        major = MAJOR(dev);
    }
    else
    {
        ret = register_chrdev_region(MKDEV(major, minor), 3, "myled");
        if (ret)
        {
            printk("静态申请设备号失败\n");
            goto out2;
        }
    }
    // 4.注册驱动对象 cdev_add()
    ret = cdev_add(cdev, MKDEV(major, minor), 3);
    if (ret)
    {
        printk("注册设备驱动对象失败\n");
        goto out3;
    }
    // 5.向上提交目录  class_create()
    cls = class_create(THIS_MODULE, "myled");
    if (IS_ERR(cls))
    {
        printk("向上提交目录失败\n");
        ret = -PTR_ERR(cls);
        goto out4;
    }
    printk("向上提交目录成功\n");
    // 6.向上提交设备信息 device_create()
    int i;
    for (i = 0; i < 3; i++)
    {
        dev1 = device_create(cls, NULL, MKDEV(major, i), NULL, "myled%d", i);
        if (IS_ERR(dev1))
        {
            printk("向上提交设备结点信息失败\n");
            ret = -PTR_ERR(dev1);
            goto out5;
        }
    }
    printk("向上提交设备结点信息成功\n");

    // 进行led1寄存器地址的映射
    vir_moder = ioremap(PHY_LED1_MODER, 4);
    if (vir_moder == NULL)
    {
        printk("映射物理内存失败%d\n", __LINE__);
        return -EFAULT;
    }
    vir_odr = ioremap(PHY_LED1_ODR, 4);
    if (vir_odr == NULL)
    {
        printk("映射物理内存失败%d\n", __LINE__);
        return -EFAULT;
    }
    vir_rcc = ioremap(RCC_MP_AHB4ENSETR, 4);
    if (vir_rcc == NULL)
    {
        printk("映射物理内存失败%d\n", __LINE__);
        return -EFAULT;
    }
    printk("LED1映射物理内存成功\n");
    // 硬件寄存器的初始化
    (*vir_rcc) |= (0X1 << 4);       // rcc使能
    (*vir_moder) &= (~(0X3 << 20)); // 设置为输出
    (*vir_moder) |= (0X1 << 20);
    (*vir_odr) &= (~(0X1 << 10)); // 输出低电平
    printk("LED1硬件寄存器初始化成功\n");

    // 进行led2寄存器地址的映射
    vir1_moder = ioremap(PHY_LED2_MODER, 4);
    if (vir1_moder == NULL)
    {
        printk("2映射物理内存失败%d\n", __LINE__);
        return -EFAULT;
    }
    vir1_odr = ioremap(PHY_LED2_ODR, 4);
    if (vir1_odr == NULL)
    {
        printk("2映射物理内存失败%d\n", __LINE__);
        return -EFAULT;
    }
    vir1_rcc = ioremap(RCC_MP_AHB4ENSETR, 4);
    if (vir1_rcc == NULL)
    {
        printk("2映射物理内存失败%d\n", __LINE__);
        return -EFAULT;
    }
    printk("LED2映射物理内存成功\n");
    // 硬件寄存器的初始化
    (*vir1_rcc) |= (0X1 << 5);       // rcc使能
    (*vir1_moder) &= (~(0X3 << 20)); // 设置为输出
    (*vir1_moder) |= (0X1 << 20);
    (*vir1_odr) &= (~(0X1 << 10)); // 输出低电平
    printk("LED2硬件寄存器初始化成功\n");

    // 进行led3寄存器地址的映射
    vir2_moder = ioremap(PHY_LED3_MODER, 4);
    if (vir2_moder == NULL)
    {
        printk("3映射物理内存失败%d\n", __LINE__);
        return -EFAULT;
    }
    vir2_odr = ioremap(PHY_LED3_ODR, 4);
    if (vir2_odr == NULL)
    {
        printk("3映射物理内存失败%d\n", __LINE__);
        return -EFAULT;
    }
    vir2_rcc = ioremap(RCC_MP_AHB4ENSETR, 4);
    if (vir2_rcc == NULL)
    {
        printk("3映射物理内存失败%d\n", __LINE__);
        return -EFAULT;
    }
    printk("LED3映射物理内存成功\n");
    // 硬件寄存器的初始化
    (*vir2_rcc) |= (0X1 << 4);       // rcc使能
    (*vir2_moder) &= (~(0X3 << 16)); // 设置为输出
    (*vir2_moder) |= (0X1 << 16);
    (*vir2_odr) &= (~(0X1 << 8)); // 输出低电平
    printk("LED3硬件寄存器初始化成功\n");

    return 0;
out5:
    for (--i; i >= 0; i--) // 将提交成功的设备信息销毁
    {
        device_destroy(cls, MKDEV(major, i));
    }
    class_destroy(cls);
out4:
    cdev_del(cdev);
out3:
    unregister_chrdev_region(MKDEV(major, minor), 3);
out2:
    kfree(cdev);
out1:
    return ret;
}

static void __exit mycdev_exit(void)
{
    // 取消地址映射
    iounmap(vir_moder);
    iounmap(vir_odr);
    iounmap(vir_rcc);
    iounmap(vir1_moder);
    iounmap(vir1_odr);
    iounmap(vir1_rcc);
    iounmap(vir2_moder);
    iounmap(vir2_odr);
    iounmap(vir2_rcc);
 
     // 1.销毁设备信息  device_destroy
    int i;
    for (i = 0; i < 3; i++)
    {
        device_destroy(cls, MKDEV(major, i));
    }
    // 2.销毁目录    class_destroy
    class_destroy(cls);
    // 3.注销驱动对象  cdev_del
    cdev_del(cdev);
    // 4.释放设备号   unregister_chrdev_region()
    unregister_chrdev_region(MKDEV(major, minor), 3);
    // 5.释放对象空间   kfree()
    kfree(cdev);
}

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