驱动 字符驱动

最新推荐文章于 2024-05-18 22:44:17 发布
最新推荐文章于 2024-05-18 22:44:17 发布
阅读量223 收藏
点赞数
文章标签： linux 运维 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yayyy4/article/details/127293008
版权

.h文件

#ifndef __MYLED_H__
#define __MYLED_H__
 
//PE10 PF10 PE8
 
#define PHY_LED_RCC   0x50000A28
 
#define PHY_LED1_MODER 0x50006000
#define PHY_LED1_ORD   0x50006014
 
#define PHY_LED2_MODER 0x50007000
#define PHY_LED2_ORD   0x50007014
 
#define PHY_LED3_MODER 0x50006000
#define PHY_LED3_ORD   0x50006014
 
#define LedON _IOW('a',1,int)
#define LedOFF _IOW('a',0,int)
 
#endif

.c文件

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/io.h>
#include <linux/cdev.h>
#include <linux/ioctl.h>
#include <linux/device.h>
#include <linux/uaccess.h>
#include <linux/slab.h>
#include "myled.h"
 
#define CNAME  "mycdev"
//设备驱动名
#define name "myled"
 
struct cdev *cdev;
struct class *cls;
struct device *dev;
 
//次设备号开始值
unsigned int baseminor = 0;
//次设备数量
unsigned int count = 3;
 
#if 0
unsigned int major = 0;//动态申请
#else
unsigned int major = 500;//静态指定设备号
#endif
char kbuf[128] = "";//定义数组用于存放和用户之间拷贝的数据
 
unsigned int *vir_rcc;
unsigned int *vir_moder_led1;
unsigned int *vir_odr_led1;
 
unsigned int *vir_moder_led2;
unsigned int *vir_odr_led2;
 
unsigned int *vir_moder_led3;
unsigned int *vir_odr_led3;
 
//对应的是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)
{
    int ret;
    if (size > sizeof(kbuf))
    {
        size = sizeof(kbuf);
    }
    ret = copy_to_user(ubuf,kbuf,size);
    if (ret)
    {
        /* code */
        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))
    {
        /* code */
        size = sizeof(kbuf);
    }
    ret = copy_from_user(kbuf,ubuf,size);
    if (ret)
    {
        /* code */
        printk("数据从内核向用户拷贝失败\n");
        return -EIO;
    }
 
 
    return size;
}
//close()
int mycdev_close(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    return 0;
}
 
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 1:
                        (*vir_odr_led1) |= (1 << 10);
                        break;
                    case 2:
                        (*vir_odr_led2) |= (1 << 10);
                        break;
                    case 3:
                        (*vir_odr_led3) |= (1 << 8);
                        break;
                    default:
                        break;
                }
            break;
        //关
        case LedOFF:
                ret=copy_from_user(&which,(void *)arg,sizeof(int));
                if (ret)
                {
                    printk("用户向内核拷贝数据失败\n");
                    return -EIO;
                }
                switch (which)
                {
                    case 1:
                        (*vir_odr_led1) &= ~(1 << 10);
                        break;
                    case 2:
                        (*vir_odr_led2) &= ~(1 << 10);
                        break;
                    case 3:
                        (*vir_odr_led3) &= ~(1 << 8);
                        break;
                    default:
                        printk("功能码错误\n");
                        break;
                }
            break;
 
        default:
            printk("功能码错误\n");
            break;
    }
    return 0;
}
 
 
//操作方法结构体的初始化
struct file_operations fops=
{
    .open=mycdev_open,
    .read=mycdev_read,
    .write=mycdev_write,
    .release=mycdev_close,
    .unlocked_ioctl=ioctl,
};
 
int all_led_init(void)
{
    //物理地址映射
    //1 RCC映射
    vir_rcc=ioremap(PHY_LED_RCC,4);
    if (vir_rcc == NULL)
    {
        /* code */
        printk("vir_rcc 映射失败\n");
        return -EIO;
    }
    printk("vir_rcc 映射成功\n");
 
    //2 LED1 映射
    vir_moder_led1=ioremap(PHY_LED1_MODER,4);
    if (vir_moder_led1 == NULL)
    {
        /* led1 moder 映射 */
        printk("vir_mode_led1 映射失败\n");
        return -EIO;
    }
    printk("vir_mode_led1 映射成功\n");
 
    vir_odr_led1=ioremap(PHY_LED1_ORD,4);
    if (vir_odr_led1 == NULL)
    {
        /* led1 odr 映射 */
        printk("vir_odr_led1 映射失败\n");
        return -EIO;
    }
    printk("vir_odr_led1 映射成功\n");
 
     //2 LED2 映射
    vir_moder_led2=ioremap(PHY_LED2_MODER,4);
    if (vir_moder_led2 == NULL)
    {
        printk("vir_mode_led2 映射失败\n");
        return -EIO;
    }
    printk("vir_mode_led2 映射成功\n");
 
    vir_odr_led2=ioremap(PHY_LED2_ORD,4);
    if (vir_odr_led2 == NULL)
    {
        printk("vir_odr_led2 映射失败\n");
        return -EIO;
    }
    printk("vir_odr_led2 映射成功\n");   
 
    //2 LED3 映射
    vir_moder_led3=ioremap(PHY_LED3_MODER,4);
    if (vir_moder_led3 == NULL)
    {
        printk("vir_mode_led3 映射失败\n");
        return -EIO;
    }
    printk("vir_mode_led3 映射成功\n");
 
    vir_odr_led3=ioremap(PHY_LED3_ORD,4);
    if (vir_odr_led3 == NULL)
    {
        printk("vir_odr_led3 映射失败\n");
        return -EIO;
    }
    printk("vir_odr_led3 映射成功\n");
 
 
    //寄存器初始化 //PE10 PF10 PE8
    /* rcc寄存器GPIOE GPIOF使能 */
    (*vir_rcc) |= (3 << 4);
    
    /* led1 moder odr寄存器初始化 */
    (*vir_moder_led1) &= ~(3 << 20);
    (*vir_moder_led1) |=  (1 << 20);
    (*vir_odr_led1) &= ~(1 << 10);
    
    /* led2 moder odr寄存器初始化 */
    (*vir_moder_led2) &= ~(3 << 20);
    (*vir_moder_led2) |=  (1 << 20);
    (*vir_odr_led2) &= ~(1 << 10);
    
    /* led3 moder odr寄存器初始化 */
    (*vir_moder_led3) &= ~(3 << 16);
    (*vir_moder_led3) |=  (1 << 16);
    (*vir_odr_led3) &= ~(1 << 8);
 
    return 0;
}
 
static int __init mycdev_init(void)
{
    int ret,i;
    //给动态申请使用 设备号
    dev_t devno;
    //1.分配设备驱动对象
    cdev=cdev_alloc();
    if (cdev == NULL)
    {
        printk("分配设备驱动对象失败\n");
        ret = -ENOMEM;
        goto ERR1;
    }
    printk("分配设备驱动对象成功\n");
    
    //2.初始化对象
    cdev_init(cdev,&fops);
 
    //3.设备号的申请
    if(major==0)//动态申请
    {
        ret = alloc_chrdev_region(&devno,baseminor,count,name);
        if(ret)
        {
            printk("动态设备号申请失败\n");
            goto ERR2;
        }
        major = MAJOR(devno);
        baseminor = MINOR(devno);
        printk("动态设备号申请成功\n");
    }
    else
    {
        ret = register_chrdev_region(MKDEV(major,baseminor),count,name);
        if (ret)
        {
            printk("静态设备号申请失败\n");
            goto ERR2;
        }
        printk("静态设备号申请成功\n");
    }
 
    //4.注册字符设备驱动
    ret = cdev_add(cdev,MKDEV(major,baseminor),count);
    if(ret)
    {
        printk("字符设备驱动注册失败\n");
        goto ERR3;
    }
    printk("字符设备驱动注册成功");
 
    //5.自动创建设备节点
    cls = class_create(THIS_MODULE,"LED");
    if (IS_ERR(cls))
    {
        printk("向上提交目录失败\n");
        ret=PTR_ERR(cls);
        goto ERR4;
    }
    printk("向上提供目录成功");
 
    //创建设备节点
    for(i=0;i<3;i++)
    {
        dev = device_create(cls,NULL,MKDEV(major,i),NULL,"myled%d",i+1);
        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,baseminor),count);
ERR2:
    kfree(cdev);
ERR1:
    return ret;
}
static void __exit mycdev_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,baseminor),count);
    
    //4.释放动态申请的空间
    kfree(cdev);
 
}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");

test.c文件


#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/ioctl.h>
#include "myled.h"
 
int main(int argc, char const *argv[])
{
    system("rmmod chdev");
    system("insmod chdev.ko");
 
    char buf[128] = "";
    int which;
 
    int fd1 = open("/dev/myled1",O_RDWR);
    if(fd1 < 0)
    {
        printf("打开设备文件myled1失败\n");
        return -1;
    }
    printf("打开设备文件myled1成功\n");
 
    int fd2 = open("/dev/myled2",O_RDWR);
    if(fd2 < 0)
    {
        printf("打开设备文件myled2失败\n");
        return -1;
    }
    printf("打开设备文件myled2成功\n");
 
    int fd3 = open("/dev/myled3",O_RDWR);
    if(fd3 < 0)
    {
        printf("打开设备文件myled3失败\n");
        return -1;
    }
    printf("打开设备文件myled3成功\n");
    
    //终端输入
    while (1)
    {
        printf("请输入要开或者关(开 1 关 0):");
        fgets(buf,sizeof(buf),stdin);
        printf("请输入要控制的灯:");
        scanf("%d",&which);
        getchar();
        
        //吃掉换行
        buf[strlen(buf)-1]='\0';
 
        switch (which)
        {
            case 1:
                if(buf[0]=='1')
                    ioctl(fd1,LedON,&which);
                else
                    ioctl(fd1,LedOFF,&which);
                break;
            case 2:
                if(buf[0]=='1')
                    ioctl(fd2,LedON,&which);
                else
                    ioctl(fd2,LedOFF,&which);
                break;
            case 3:
                if(buf[0]=='1')
                    ioctl(fd3,LedON,&which);
                else
                    ioctl(fd3,LedOFF,&which);
                break;
 
            default:
                break;
        }
        //清空buf
        memset(buf,0,sizeof(buf));
    }
    return 0;
}

yayyy4
关注
Android内核驱动
07-10
Android内核驱动,该书主要介绍android内核驱动以及电源管理，内存管理
内核驱动
kuangreng的专栏
09-12 532
Linux内核驱动
ChrisKevin0221的博客
05-22 2587
最近一直在学习偏理论的东西，内核编译，文件管理系统，虚拟文件系统，感觉挺枯燥的，也没有写笔记来记录，估计也就听着了个耳熟，过后用到了不会，我再回头看看这些吧。 今天开始终于学到驱动部分了，开始好好记记笔记，总结一下。 文章目录内核驱动框架内核编译 内核驱动框架 #include <linux/fs.h> //file_operations声明 #include <linux/module.h> //module_init module_exit声明 #include &l
《驱动开发》开启电灯、风扇和蜂鸣器
qq_60071225的博客
10-11 455
开启电灯、风扇和蜂鸣器。
字符驱动程序及应用程序.zip_字符驱动_字符驱动设计
09-20
字符驱动程序是操作系统内核与硬件设备之间的重要接口，它负责管理和控制硬件设备，使得上层应用程序能够方便地访问和操作这些设备。字符驱动通常应用于简单、低级别的I/O设备，如串行端口、键盘、鼠标等，它们通常...
Linux字符设备驱动实现
11-06
在Linux操作系统中，字符设备驱动是内核与硬件之间交互的关键接口，用于处理特定硬件的输入和输出。本文将深入探讨如何实现一个简单的字符设备驱动，并利用它来设计一个聊天程序，实现进程间的同步通信。 首先，...
linux驱动详解，字符驱动、总线驱动
08-08
Linux 驱动详解、字符驱动、总线驱动 Linux 驱动是指在 Linux 操作系统中管理和控制硬件设备的软件组件。 Linux 驱动的主要作用是向应用层提供能够访问硬件的函数接口，使得应用层可以使用硬件设备的功能。 Linux ...
Linux内核设备驱动之字符设备驱动笔记整理
09-15
【字符设备驱动详解】 字符设备驱动是Linux内核设备驱动的一部分，主要负责处理那些以字节流方式访问的硬件设备，如串口、并口打印机等。这些设备可以通过在Linux文件系统下的/dev目录创建设备文件来访问。用户通过...
字符型驱动的过程总结及驱动和测试相关源码
06-03
字符驱动主要用于处理简单的、基于字符流的设备，如串口、键盘、鼠标等。本篇文章将深入探讨字符型驱动的开发过程，并结合测试源码进行分析，旨在帮助初学者快速理解这一领域。 首先，我们来看字符驱动的基本结构。...
内核必须懂(四): 撰写内核驱动
weixin_33937778的博客
03-28 264
前言 之前的文章里面说了简单的.ko文件编译. 这里继续深入下去. 当然, 还是从驱动的Hello, world!开始. 驱动模块里的Hello, world! 首先是源码部分, 这里由于是内核, 所以c库的函数就不能用了, 比如printf这样的, 要用printk替代, 这里的k就是指kernel. 然后**__init和__exit意味着只有初始化和卸载才会执行函数, 也就是都只执行...
linux内核驱动
嵌入式与人工智能
01-04 791
linux内核驱动模块linux/drivers 驱动模块常用的驱动 linux/drivers 驱动模块 驱动模块大概有30-50个，但是常用的就10来种，搞懂常用的几个，项目基本够用。 常用的驱动 GPIO UART I2C SPI USB LCD WIFI/bluetooth ETH Power 大多数驱动设备都用了2个以上的驱动模块， 摄像头就用了 MIPI+I2C两种驱动。 4/5G 用了USB+虚拟串口驱动. ...
Linux——Linux驱动之内核基础概览（Linux体系结构、内核结构、内核源码目录结构）
数字世界 万物互联
04-24 1613
0 引言 学习嵌入式Linux，之前也说过，包括几部分：应用开发、驱动开发、内核开发，我们后面的大部分博文都会围绕在Linux驱动开发展开，但是Linux内核有和驱动开发相关联的东西，所以，本博文主要对Linux内核进行提纲挈领，有个总体的认知，内容包括：Linux体系结构、Linux内核结构、Linux内核源码目录结构。 1 Linux体系结构 Linux体系分为两大块：内核空间（系统调用接口、内核、平台支持代码、硬件支持）、用户空间（用户应用、C库），之所以这样划分是有一定道理的。原因如下：...
linux驱动开发(一)：一个最简单的内核驱动程序
baidu_38797690的博客
12-23 5729
编写一个最简单的Linux内核驱动程序，可以在加载和移除模块时打印字符串。
AMD GPU 内核驱动分析(一)总览
tugouxp的专栏
09-11 4352
和CPU相比，GPU中包含了大量的并行计算单元，适合处理像素，矩阵，坐标等大量同类型的数据，因此，很多LINUX上的应用程序为了能够利用GPU的加速功能，都试图和GPU直接打交道，因此，系统中可能有多个组件或者程序同时使用GPU，比如桌面系统中OpenGL的实现MESA。
linux 内核驱动开发
颇锐克
03-06 3651
一、为什么要学习内核？ 有些人要学习内核，而有些人则可以不学习它。你如果以后要从事系统研发或驱动开发的话，就要学习内核。 刚刚接触内核，主要学习内核的接口函数。不要深入的去读内核，因为你读也读不懂，内核代码庞大如野兽一般不可驾驭。 学习内核主要掌握层次学习法，即从头开始学习，一环紧扣一环。 内核学习的四步学习法：1、核心理论学习-概念与函数原型2、范例程序分析3、思维导图设计4、亲自编写代
【基础篇】1.1 内核驱动简介
最新发布
从0到1，突破自己
05-18 1365
内核驱动，也称为内核模块或设备驱动，是一段可以加载到操作系统内核中的代码，通常用于管理硬件设备和提供操作系统与硬件之间的接口。这些驱动为操作系统提供了与硬件设备进行交互的能力，使得操作系统能够识别、管理和控制硬件设备。在Linux系统中，内核驱动通常以模块的形式存在，可以被动态地加载到内核中或从内核中卸载。这种模块化设计使得Linux系统能够灵活地支持各种硬件设备，而无需在每次添加或更换硬件时都重新编译整个内核。
驱动与内核模块
m0_53887937的博客
12-28 421
简单的学习记录
内核与驱动_00_内核编程基础知识
hskull的博客
02-02 956
内核编程环境 概述 在Windows下，32为系统中每个进程都有其自身享有的4GB内存空间，每个进程的内存空间都是相互隔离的。其中低2GB是用户空间，高2GB是内核空间。原则上，每个进程的高2GB内核空间内的数据是共享的，即绝大部分都是一样的。 而内核空间是受到硬件保护的，比如在x86架构下R0层（Ring0）的代码才可以访问内核空间，普通的应用程序编译出来后都运行在R3层，R3层程序要调用R0...
Linux字符设备驱动模型详解
"这篇文档是关于Linux环境下字符设备驱动开发的概述，主要讲解了字符驱动的基本概念、分类以及注册注销的流程。" 在Linux操作系统中，字符设备驱动扮演着连接内核与用户空间应用程序的关键角色。字符驱动通常相对...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值