内核设备控制三个文件节点控制三个灯

已于 2022-10-12 23:21:52 修改
阅读量182 收藏
点赞数
文章标签： servlet java 开发语言
于 2022-10-12 23:20:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_47440242/article/details/127292748
版权

#include <stdio.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <fcntl.h>

#include <unistd.h>

#include <stdlib.h>

#include <sys/ioctl.h>

#include "myled.h"

#include <string.h>

int main(int argc, char const *argv[])

{

    char buf[128] = {};

    int which,off;

    int fd = open("/dev/my_led0", O_RDWR);

    if (fd < 0)

    {

        printf("打开设备文件失败\n");

        exit(-1);

    }

    printf("打开设备成功\n");

    //在终端输入

    int fd1 = open("/dev/my_led1", O_RDWR);

    if (fd1 < 0)

    {

        printf("打开设备文件失败\n");

        exit(-1);

    }

    printf("打开设备成功\n");

    //在终端输入

    int fd2 = open("/dev/my_led2", O_RDWR);

    if (fd2 < 0)

    {

        printf("打开设备文件失败\n");

        exit(-1);

    }

    printf("打开设备成功\n"); //在终端输入

    //在终端输入

    while (1)

    {

        printf("请输入控制命令 1开灯 0：关灯\n");

        fgets(buf, sizeof(buf), stdin);

        //吃掉换行符

        buf[strlen(buf) - 1] = '\0';

        printf("请输入要操作的灯1-->led1,2-->led2,3-->led3\n");

        scanf("%d", &which);

        getchar();

        if (which == 1)

        {

            ioctl(fd, led_ON, &which);

           

        }

        else if (which == 2)

        {

            ioctl(fd1, led_ON, &which);

           

        }

        else if (which == 3)

        {

            ioctl(fd2, led_ON, &which);

           

        }

         else if (which == 4)

        {

            ioctl(fd2, led_ON, &which);

           

        }

         else if (which == 5)

        {

            ioctl(fd2, led_ON, &which);

           

        }

         else if (which == 6)

        {

            ioctl(fd2, led_ON, &which);

        }

         else if (which == 11)

        {

            ioctl(fd2, led_OFF, &which);

        }

        else if (which == 12)

        {

            ioctl(fd2, led_OFF, &which);

        }

        else if (which == 13)

        {

            ioctl(fd2, led_OFF, &which);

        }

        else if (which == 14)

        {

            ioctl(fd2, led_OFF, &which);

        }

        else if (which == 15)

        {

            ioctl(fd2, led_OFF, &which);

        }

        else if (which == 16)

        {

            ioctl(fd2, led_OFF, &which);

        }

    }

    close(fd);

    close(fd1);

    close(fd2);

    return 0;

}

myled.c文件

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


int minor=0;//次设备号从0开始
#if 0
unsigned int major = 0;//动态申请
#else
unsigned int major = 500;//静态指定设备号
#endif
char kbuf[128] = {}; //定义数组用于存放和用户之间拷贝的数据
gpio_t *vir_led1;
gpio_t *vir_led2;
gpio_t *vir_led3;
gpio_t *vir_fan1;
gpio_t *vir_sp1;
gpio_t *vir_m1;
unsigned int *vir_rcc_apb1;
unsigned int *vir_rcc_apb2;
unsigned int *vir_rcc;
struct class *cls; //句柄
struct device *dev;

struct cdev *cdev;//分配字符设备对象
const int count=3;//设备节点个数为3
//对应的是open()
int mycdev_open(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}
// read()
ssize_t mycdev_read(struct file *file, char __user *ubuf, size_t size, loff_t *loff)
{
    // size参数是用户期待读到的字节长度
    int ret;
    if (size > sizeof(kbuf))
        size = sizeof(kbuf);
    ret = copy_to_user(ubuf, kbuf, size);
    if (ret)
    {
        printk("数据从内核向用户拷贝失败\n");
        return -EIO;
    }

    return size;
}
// write()
ssize_t mycdev_write(struct file *file, const char __user *ubuf, size_t size, loff_t *loff)
{
    int ret;
    if (size > sizeof(kbuf))
        size = sizeof(kbuf);
    ret = copy_from_user(kbuf, ubuf, size);
    if (ret)
    {
        printk("数据从内核向用户拷贝失败\n");
        return -EIO;
    }
    /*if(kbuf[0]=='1')//开灯
        vir_led1->ODR |= (1<<10);
    else if(kbuf[0]=='2')
        vir_led2->ODR |= (1 << 10);
    else if(kbuf[0]=='3')
       vir_led3->ODR |= (1 << 8);
    else//关灯
    {
        vir_led1->ODR &= ~(1<<10);
        vir_led2->ODR&= ~(1 << 10);
       vir_led3->ODR &= ~(1 << 8);
    }*/
    return size;
}

// close()
long ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
    // cmd是传输过来的功能模块，arg是传递过来的第三个参数，选择是哪个灯的
    // file对应着文件描述符文件
    int which, ret;
    switch (cmd)
    {
    case led_ON:
    {
        ret = copy_from_user(&which, (void *)arg, sizeof(int)); //获取发送的数据是否成功
        if (ret)
        {
            printk("数据向内核拷贝失败\n");
            return -EIO;
        }
        switch (which)
        {
        case 11:
            vir_led1->ODR |= (1 << 10);
            break;
        case 12:
            vir_led2->ODR |= (1 << 10);
            break;
        case 13:
            vir_led3->ODR |= (1 << 8);
            break;
        case 14:
            vir_m1->ODR |= (1 << 6);
            break;
        case 15:
            vir_fan1->ODR |= (1 << 9);
            break;
        case 16:
            vir_sp1->ODR |= (1 << 6);
            break;
        }
        break;
    }

    case led_OFF:
    {
        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;
        case M1:
            vir_m1->ODR &= ~(1 << 6);
            break;
        case FAN1:
            vir_fan1->ODR &= ~(1 << 9);
            break;
        case SP1:
            vir_sp1->ODR &= ~(1 << 6);
            break;
        }
        break;
    }
    default:
        printk("功能码错误\n");
        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 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;
    }
    //apb1
    vir_rcc_apb1 = ioremap(PHY_RCC_APB1, 4);
    if (vir_rcc_apb1 == NULL)
    {
        printk("vir_rcc_apb1 映射失败\n");
        return -ENOMEM;
    }
    printk("vir_rcc_apb1 映射成功\n");
    //apb2
    vir_rcc_apb2 = ioremap(PHY_RCC_APB2, 4);
    if (vir_rcc_apb2 == NULL)
    {
        printk("vir_rcc_apb2 映射失败\n");
        return -ENOMEM;
    }
    printk("vir_rcc_apb2 映射成功\n");
    //风扇
    vir_fan1 = ioremap(PHY_FAN1_ADDR, sizeof(gpio_t));
    if (vir_fan1 == NULL)
    {
        printk("vir_fan1 映射失败\n");
        return -ENOMEM;
    }
    printk("vir_fan1 映射成功\n");
    // m1
    vir_m1 = ioremap(PHY_M1_ADDR, sizeof(gpio_t));
    if (vir_m1 == NULL)
    {
        printk("vir_m1 映射失败\n");
        return -ENOMEM;
    }
    printk("vir_m1 映射成功\n");
    // sp1
    vir_sp1 = ioremap(PHY_SP1_ADDR, sizeof(gpio_t));
    if (vir_sp1 == NULL)
    {
        printk("vir_sp1 映射失败\n");
        return -ENOMEM;
    }
    printk("vir_sp1 映射成功\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);
    // fan1
    vir_fan1->MODER &= ~(3 << 18);
    vir_fan1->MODER |= (1 << 18);
    vir_fan1->ODR &= ~(1 << 9);
    // sp1
    vir_sp1->MODER &= ~(3 << 12);
    vir_sp1->MODER |= (1 << 12);
    vir_sp1->ODR &= ~(1 << 6);
    // m1
    vir_m1->MODER &= ~(3 << 12);
    vir_m1->MODER |= (1 << 12);
    vir_m1->ODR &= ~(1 << 6);
    //使能TIM寄存器
    (*vir_rcc) |= (3 << 4);
    (*vir_rcc_apb1) |= (1 << 2); //使能TIM4
    (*vir_rcc_apb2) |= (1 << 0); //使能TIM1
    (*vir_rcc_apb2) |= (1 << 3); //使能TIM16
    (*vir_rcc) |= (1 << 1);      //使能gpiob
    return 0;
}
//入口函数，当驱动安装的时候执行
static int __init demo_init(void)
{

    //动态注册字符设备驱动
   /*/ major = register_chrdev(0, CNAME, &fops);
    if (major < 0)
    {
        printk("字符设备驱动注册失败\n");
        return major;
    }
    printk("字符设备驱动注册成功major=%d\n", major);*/
    //分配设备对象空间
    int ret,i;
    //分配对象
    dev_t devno;
    cdev=cdev_alloc();
    if(cdev==NULL)
    {
        printk("cdev alloc memory err\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=0;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>=0;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 demo_exit(void)
{
    ///1.销毁设备节点
    int i;
    for(i=0;i<count;i++)
    {
         device_destroy(cls,MKDEV(major,i));
    }
     class_destroy(cls);
     //2.注销字符设备驱动
    cdev_del(cdev);
    //3.释放设备号
    unregister_chrdev_region(MKDEV(major,minor),count);
    
    //取消映射
    iounmap(vir_led1);
    iounmap(vir_led2);
    iounmap(vir_led3);
    iounmap(vir_rcc);
    iounmap(vir_m1);
    iounmap(vir_fan1);
    iounmap(vir_sp1);
    iounmap(vir_rcc_apb1);
    iounmap(vir_rcc_apb2);
   
    //4.释放动态申请的空间
    kfree(cdev);
}
module_init(demo_init);
module_exit(demo_exit);
MODULE_LICENSE("GPL");
 

weixin_47440242
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
重庆理工大学操作系统基于Linux0.11内核的实践
06-29
在Linux0.11的环境下完成基于内核栈切换的进程切换、地址映射与共享、终端设备的控制、proc文件系统的实现中的三个及以上实验项目。 在Linux四项任务中成功完成了四项：基于内核栈切换的进程切换，终端设备的控制，...
Linux内核源代码情景分析 (上下册 高清非扫描 )
03-27
8.11设备文件系统devfs 第9章多处理器SMP系统结构 9.1概述 9.2SMP结构中的互斥问题 9.3高速缓存与内存的一致性 9.4SMP结构中的中断机制 9.5SMP结构中的进程调度 9.6SMP系统的引导 第10章系统引导和初始化 ...
Linux驱动开发--通过按键控制led灯
yasinEmb的专栏
06-10 5418
/*说明：通过OK6410开发板自带的user key 的前四个控制led的开关，对应的，按key1,led1亮，亲自验证无误*/#include #include #include #include #include /*包含struct file_operations,MAJOR等*/ #include /*kmalloc*/ #include /*class_creat,
十、Linux开发板控制LED灯设备
qq_43940175的博客
02-26 1698
控制LED灯设备 驱动程序 本质：为硬件设备创建相应的设备节点文件 创建设备文件时，规定好设备文件的使用方式。 应用程序 根据驱动程序规定的设备文件使用方式去控制硬件 控制硬件设备步骤 1、找出硬件设备所对应的设备节点文件 两个地方： /dev目录下 对驱动程序熟悉的工程师可以使用，一个设备节点文件控制硬件全部特性 /sys目录下 业余工程师使用，一个设备节点文件只控制硬件的一个特性 严格来说，它下面的文件是Linux内核导出到用户空间的硬件操作接口 2、找出驱动程序规定的设备文件使用方式 LE
设备文件节点的生成
云计算?
03-01 212
http://blog.csdn.net/broadview2006/article/details/7281061 设备文件节点的生成 在Linux系统下，设备文件是种特殊的文件类型，其存在的主要意义是沟通用户空间程序和内核空间驱动程序。换句话说，用户空间的应用程序要想使用驱动程序提供的服务，需要经过设备文件来达成。当然，如果你的驱动程序只是为内核中的其他模块提供服务，则没有必要生成对应的设...
linux内核驱动---创建设备节点文件
勤能补拙，孰能生巧
09-15 3707
Linux下生成驱动设备节点文件的方法有3个：1、手动mknod；2、利用devfs；3、利用udev 在刚开始写Linux设备驱动程序的时候，很多时候都是利用mknod命令手动创建设备节点，实际上Linux内核为我们提供了一组函数，可以用来在模块加载的时候自动在/dev目录下创建相应设备节点，并在卸载模块时删除该节点。在2.6.17以前，在/dev目录下生成设备文件很容易devfs_mk_bdev
linux 设备文件节点的创建（三）/dev设备节点的创建及打开
oqqYuJi12345678的博客
11-16 5235
继续上一篇的分析，应用层udev或者mdev获取到内核的事件，来创建设备文件的时候，实际就是调用mknod命令进行节点创建。我们可以模仿udev或者mdev，来手动创建这个节点。 1 /dev设备节点创建 我们在使用命令： mknod /dev/iTestDevice c $major 0 创建设备文件的时候，内核做了哪些事呢？可以肯定的一点是，内核肯定创建了一个 dentry，inode 结...
第三课:linux内核对设备树的处理
热门推荐
韦东山嵌入式专栏
11-22 1万+
这一课是设备树中最重要的一课。 前面我们从内核文档了解到，对于设备树，它里面描述的信息可以分为这三部分： Linux uses DT data for three major purposes: platform identification, runtime configuration, and device population. 事实上，内核对设备树的处理，也会分为与其对应的三部分： 对于...
Linux字符设备驱动注册三种方法以及内核分析
nswcszmdfj的博客
10-07 7908
Linux驱动是用户访问底层硬件的桥梁，驱动有可以简单分成三类：字符设备、块设备、网络设备。其中最多的是字符设备，其中字符设备的注册方法主要有三种：杂项设备注册、早期字符设备注册、标准字符设备注册。以及详细介绍各类方法注册。 开发环境： PC：VMworkstation 12 运行Ubuntu12 32位虚拟机 开发板：友善之臂Tiny4412 （EXYNOS4412 Cor...
3.8内核对设备树的处理——在根文件系统中查看设备树
一个嵌入式软件工程师的博客
10-26 3093
当内核启动完成后，会进入根文件系统，本节说明如何。
Android 获得对一个设备节点的访问权限
随心所记
06-04 5171
Android 获得对设备节点的访问权限       Android 5.0 下，因为采取了 SEAndroid/SElinux 的安全机制，即使拥有 root权限，或者对某内核节点设置为 777 的权限，仍然无法在 JNI 层访问。        本文将以用户自定义的内核节点 /dev/wf_bt 为例，手把手教会读者如何在 JNI 层获得对该节点的访问权限。可分为以下四个步骤： 第一步：找到
USB总线-Linux内核USB3.0控制器初始化代码分析（三）
非专业业余程序员
07-25 7264
1.概述 RK33999使用synopsys dwc3的USB3.0控制器IP。早期的初始化需要在两个模块中进行，一个在rockchip官方提供的驱动中初始化，位于drivers/usb/dwc3/dwc3-rockchip.c文件中，主要初始化和CPU紧密相关的内容，如时钟、复位、电源、extcon（用于USB模式切换），另一个在synopsys提供的驱动中初始化，位于drivers/usb/dwc3/core.c文件中，这部分和USB3.0控制器密切相关，如USB3.0控制器内部寄存器地址、USB3.0
手写了卷积神经网络内核，来处理图上的节点分类与链路预测任务，在三个数据集cora,citeseer,ppi上进行试验.zip
03-03
人工智能-项目实践-数据预处理
人工智能项目资料-手写了卷积神经网络内核，来处理图上的节点分类与链路预测任.zip
02-08
人工智能项目资料-手写了卷积神经网络内核，来处理图上的节点分类与链路预测任务，在三个数据集cora,citeseer,ppi上进行试验 【探索人工智能的宝藏之地】 无论您是计算机相关专业的在校学生、老师，还是企业界的探索...
第三代移动WEB内核小程序风口-逐浪CMS2 x3.9.3全面发布
01-31
■扩展:优化了AJAX单文件上传组件,支持一个页面放置多个上传组件 ■增加:BIS模块 ■扩展:LED设计模块,支持动画等效果 ■修改:Boot4标签解析,增加font字体，基于逐浪字库的高端字体图标技术。 ■增加:Bis增加订单...
jdk8新特性----Lambda表达式
w_t_y_y的博客
05-11 442
Java的Lambda表达式是Java 8引入的一个特性，它支持函数式编程，允许将函数作为方法的参数或返回值，从而简化了匿名内部类的使用，并提供了对并行编程的更好支持。
jar包增量更新分析
最新发布
junlaiyan的专栏
05-16 138
借助jdeps分析出jar包的增量文件
CMS垃圾回收器为什么被移除
m0_54187478的博客
05-10 521
由于上述缺点，加上需要将资源投入到更现代垃圾回收器的开发和优化上，Oracle决定从Java 9开始标记CMS为废弃，并在后续版本中完全移除CMS。这些新的收集器旨在提供更低的停顿时间和更高的性能，同时减少配置和维护的复杂性。当它在垃圾收集周期内无法足够快地回收内存时，会退回到一种需要完全暂停所有应用线程的老年代收集模式，这与它设计的初衷相违背。：CMS使用的标记-清除算法会导致较多的内存碎片。：CMS需要更多的CPU资源来执行垃圾回收的并发阶段，而且它在运行时对系统资源的利用也较为激进。
java导出excel动态加载多sheet多复杂表头
weixin_43931108的博客
05-14 204
java导出excel动态加载多sheet多复杂表头
device_create_file创建设备文件
05-19
`device_create_file()`函数需要三个参数：设备结构体（struct device *）、指向属性结构体（struct attribute *）的指针，以及sysfs文件节点名字的字符串。 以下是使用`device_create_file()`函数创建设备文件的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值