linux驱动：（21）ioctl接口（二）驱动与应用程序传递ioctl命令

于 2024-10-04 17:57:28 发布
阅读量385 收藏 4
点赞数 1
分类专栏： linux驱动 文章标签： linux 运维 服务器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_59669309/article/details/142705025
版权

目录

copy_from_user改为用ioctl接口

修改为ioctl读取无参数命令

测试.c

驱动.c

效果

修改为ioctl读取有参数命令

测试.c

驱动.c

效果

修改为ioctl发送有参数命令

测试.c

驱动.c

效果

copy_from_user改为用ioctl接口

将以前的beep杂项设备中的copy_from_user改为用ioctl接口，修改的代码是   linux驱动：（8）实战：用杂项设备完成蜂鸣器驱动   中的代码

#include <linux/init.h>
#include <linux/module.h>
#include <linux/miscdevice.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/io.h>
 
#define GPIO5_DR 0x020AC00
unsigned int *vir_gpio5_dr;
 
int misc_open(struct inode * inode,struct file * file)
{
    printk("hello misc_open\n");
    return 0;
}
int misc_read(struct file *file,char _user *ubuf,size_t size,loff_t *loff_t)
{
    char kbuf[64] = "heheh";
    if( copy_to_user(ubuf,kbuf,strlen(kbuf))!=0)
    {
        printk("copy_to_user error\n");
        return -1;
    }
    return 0;
}
int misc_write(struct file *file,const char _user *ubuf,size_t size,loff_t *loff_t)
{
    char kbuf[64] = {0};
    if( copy_from_user(kbuf,ubuf,size)!=0)
    {
        printk("copy_from_user error\n");
        return -1;
    }
    printk("kbuf is %s\n",kbuf);
    if(kbuf[0]==1)
    {
        *vir_gpio5_dr |= (1<<1);
    }
    else if
    {
        *vir_gpio5_dr &= ~(1<<1);
    }
    return 0;
}
struct const file_operation misc_fops = {
    .owner = THIS_MODULE,
    .open = misc_open，
    .write= misc_write，
    .read = misc_read
};
struct miscdevice misc_dev = {
    .minor = MISC_DYNAMIC_MINOR,//动态分配
    .name ="hellomisc",//设备节点名字
    .fops =&misc_fops 
};
 
static int misc_init(void)
{
    int ret;
    ret = misc_register(&misc_dev);
    if(ret<0)
    {
        printk("misc registe is error\n");
        return -1;
    }
    vir_gpio5_dr = ioremap(GPIO5_DR,4);
    if(vir_gpio5_dr ==NULL)
    {
        printk("GPIO5_DR ioremap error\n");
        return -EBUSY;
    }
    printk("GPIO5_DR ioremap ok\n");
    return 0;
}
 
static void misc_exit(void)
{
    misc_deregister(&misc_dev);
    iounmap(vir_gpio5_dr );
    printk("misc goodbye");
}
 
module_init(misc_init);
module_exit(misc_exit);
 
MODULE_LICENSE("GPL");

修改为ioctl读取无参数命令

  • 先把关于GPIO5_DR 的部分删掉
  • 编写测试.c，定义发送两个无参数命令
    • ioctl函数中的参数对应驱动中的函数中的参数
  • 在驱动.c中也要定义两个一样的无参数命令
  • 在文件操作集中定义unlocked_ioctl函数
    • 在函数中判断cmd命令是否等于我们自己定义的两个命令

测试.c

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

#define CMD_TEST0 _IO('L',0)
#define CMD_TEST1 _IO('L',1)

int main(int argc,char *argv[])
{
    int fd;
    // 读取设备节点
    fd = open("/dev/hello_misc",O_RDWR);
    if (fd < 0)
    {
        perror("open error\n");
        return fd;
    }
    while (1)
    {
        ioctl(fd,CMD_TEST0);
        sleep(2);
        ioctl(fd,CMD_TEST1);
        sleep(2);
    }
    
    return 0;
}

驱动.c

#include <linux/init.h>
#include <linux/module.h>
#include <linux/miscdevice.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/io.h>
#include <sys/ioctl.h>
 
#define CMD_TEST0 _IO('L',0)
#define CMD_TEST1 _IO('L',1)
int misc_open(struct inode * inode,struct file * file)
{
    printk("hello misc_open\n");
    return 0;
}
int misc_read(struct file *file,char _user *ubuf,size_t size,loff_t *loff_t)
{
    char kbuf[64] = "heheh";
    if( copy_to_user(ubuf,kbuf,strlen(kbuf))!=0)
    {
        printk("copy_to_user error\n");
        return -1;
    }
    return 0;
}
int misc_write(struct file *file,const char _user *ubuf,size_t size,loff_t *loff_t)
{
    char kbuf[64] = {0};
    if( copy_from_user(kbuf,ubuf,size)!=0)
    {
        printk("copy_from_user error\n");
        return -1;
    }
    printk("kbuf is %s\n",kbuf);

    return 0;
}

long misc_ioctl(struct file *file,unsigned int cmd, unsigned long value)
{
    switch (cmd)
    {
    case CMD_TEST0:
        printk("led on\n");
        break;
    case CMD_TEST1:
        printk("led off\n");
        break;
    default:
        break;
    }
    return 0;
}

struct const file_operation misc_fops = {
    .owner = THIS_MODULE,
    .open = misc_open，
    .write= misc_write，
    .unlocked_ioctl= misc_ioctl，
    .read = misc_read
};
struct miscdevice misc_dev = {
    .minor = MISC_DYNAMIC_MINOR,//动态分配
    .name ="hellomisc",//设备节点名字
    .fops =&misc_fops 
};
 
static int misc_init(void)
{
    int ret;
    ret = misc_register(&misc_dev);
    if(ret<0)
    {
        printk("misc registe is error\n");
        return -1;
    }
    vir_gpio5_dr = ioremap(GPIO5_DR,4);

    return 0;
}
 
static void misc_exit(void)
{
    misc_deregister(&misc_dev);
    printk("misc goodbye");
}
 
module_init(misc_init);
module_exit(misc_exit);
 
MODULE_LICENSE("GPL");

效果

  • 编译成模块，烧录到开发板中，加载驱动，运行测试.c
  • 每隔两秒打印led on或者led off

修改为ioctl读取有参数命令

  • 先把关于GPIO5_DR 的部分删掉
  • 编写测试.c，定义发送两个有参数命令
    • ioctl函数中的参数对应驱动中的函数中的参数
  • 在驱动.c中也要定义两个一样的有参数命令
  • 在文件操作集中定义unlocked_ioctl函数
    • 在函数中判断cmd命令是否等于我们自己定义的两个命令

测试.c

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

#define CMD_TEST0 _IOW('L',0,int)
#define CMD_TEST1 _IOW('L',1,int)

int main(int argc,char *argv[])
{
    int fd;
    // 读取设备节点
    fd = open("/dev/hello_misc",O_RDWR);
    if (fd < 0)
    {
        perror("open error\n");
        return fd;
    }
    while (1)
    {
        ioctl(fd,CMD_TEST0,1);
        sleep(2);
        ioctl(fd,CMD_TEST1,0);
        sleep(2);
    }
    
    return 0;
}

驱动.c

#include <linux/init.h>
#include <linux/module.h>
#include <linux/miscdevice.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/io.h>
#include <sys/ioctl.h>
 
#define CMD_TEST0 _IOW('L',0,int)
#define CMD_TEST1 _IOW('L',1,int)
int misc_open(struct inode * inode,struct file * file)
{
    printk("hello misc_open\n");
    return 0;
}
int misc_read(struct file *file,char _user *ubuf,size_t size,loff_t *loff_t)
{
    char kbuf[64] = "heheh";
    if( copy_to_user(ubuf,kbuf,strlen(kbuf))!=0)
    {
        printk("copy_to_user error\n");
        return -1;
    }
    return 0;
}
int misc_write(struct file *file,const char _user *ubuf,size_t size,loff_t *loff_t)
{
    char kbuf[64] = {0};
    if( copy_from_user(kbuf,ubuf,size)!=0)
    {
        printk("copy_from_user error\n");
        return -1;
    }
    printk("kbuf is %s\n",kbuf);

    return 0;
}

long misc_ioctl(struct file *file,unsigned int cmd, unsigned long value)
{
    switch (cmd)
    {
    case CMD_TEST0:
        printk("led on\n");
        printk("value is %d\n",value);
        break;
    case CMD_TEST1:
        printk("led off\n");
        printk("value is %d\n",value);
        break;
    default:
        break;
    }
    return 0;
}

struct const file_operation misc_fops = {
    .owner = THIS_MODULE,
    .open = misc_open，
    .write= misc_write，
    .unlocked_ioctl= misc_ioctl，
    .read = misc_read
};
struct miscdevice misc_dev = {
    .minor = MISC_DYNAMIC_MINOR,//动态分配
    .name ="hellomisc",//设备节点名字
    .fops =&misc_fops 
};
 
static int misc_init(void)
{
    int ret;
    ret = misc_register(&misc_dev);
    if(ret<0)
    {
        printk("misc registe is error\n");
        return -1;
    }
    vir_gpio5_dr = ioremap(GPIO5_DR,4);

    return 0;
}
 
static void misc_exit(void)
{
    misc_deregister(&misc_dev);
    printk("misc goodbye");
}
 
module_init(misc_init);
module_exit(misc_exit);
 
MODULE_LICENSE("GPL");

效果

  • 编译成模块，烧录到开发板中，加载驱动，运行测试.c
  • 每隔两秒打印led on或者led off，并会打印出value的值(0和1)

修改为ioctl发送有参数命令

  • 先把关于GPIO5_DR 的部分删掉
  • 编写测试.c，定义接收一个有参数命令
    • ioctl函数中的参数对应驱动中的函数中的参数
  • 在驱动.c中也要定义一个一样的有参数命令
  • 在文件操作集中定义unlocked_ioctl函数
    • 在函数中判断cmd命令是否等于我们自己定义的一个命令，是就通过copy_to_user进行发送

测试.c

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

#define CMD_TEST0 _IOR('L',0,int)

int main(int argc,char *argv[])
{
    int fd;
    int value;
    // 读取设备节点
    fd = open("/dev/hello_misc",O_RDWR);
    if (fd < 0)
    {
        perror("open error\n");
        return fd;
    }
    while (1)
    {
        ioctl(fd,CMD_TEST0,&value);
        printf("value is %d\n",value);
        sleep(2);
    }
    
    return 0;
}

驱动.c

#include <linux/init.h>
#include <linux/module.h>
#include <linux/miscdevice.h>
#include <linux/fs.h>
#include <linux/uaccess.h>
#include <linux/io.h>
#include <sys/ioctl.h>
 
#define CMD_TEST0 _IOR('L',0,int)
int misc_open(struct inode * inode,struct file * file)
{
    printk("hello misc_open\n");
    return 0;
}
int misc_read(struct file *file,char _user *ubuf,size_t size,loff_t *loff_t)
{
    char kbuf[64] = "heheh";
    if( copy_to_user(ubuf,kbuf,strlen(kbuf))!=0)
    {
        printk("copy_to_user error\n");
        return -1;
    }
    return 0;
}
int misc_write(struct file *file,const char _user *ubuf,size_t size,loff_t *loff_t)
{
    char kbuf[64] = {0};
    if( copy_from_user(kbuf,ubuf,size)!=0)
    {
        printk("copy_from_user error\n");
        return -1;
    }
    printk("kbuf is %s\n",kbuf);

    return 0;
}

long misc_ioctl(struct file *file,unsigned int cmd, unsigned long value)
{
    int val;
    switch (cmd)
    {
    case CMD_TEST0:
        val = 12 ;
        if( copy_to_user((int *)value,&val,sizeof(val))!=0)
        {
            printk("copy_to_user error\n");
            return -1;
        }
        break;
    default:
        break;
    }
    return 0;
}

struct const file_operation misc_fops = {
    .owner = THIS_MODULE,
    .open = misc_open，
    .write= misc_write，
    .unlocked_ioctl= misc_ioctl，
    .read = misc_read
};
struct miscdevice misc_dev = {
    .minor = MISC_DYNAMIC_MINOR,//动态分配
    .name ="hellomisc",//设备节点名字
    .fops =&misc_fops 
};
 
static int misc_init(void)
{
    int ret;
    ret = misc_register(&misc_dev);
    if(ret<0)
    {
        printk("misc registe is error\n");
        return -1;
    }
    vir_gpio5_dr = ioremap(GPIO5_DR,4);

    return 0;
}
 
static void misc_exit(void)
{
    misc_deregister(&misc_dev);
    printk("misc goodbye");
}
 
module_init(misc_init);
module_exit(misc_exit);
 
MODULE_LICENSE("GPL");

效果

  • 编译成模块，烧录到开发板中，加载驱动，运行测试.c
  • 每隔两秒打印驱动传出来的value值12

码农小白
关注
专栏目录
linux设备驱动归纳总结（三）：4.ioctl的实现
12-24
本篇文章将深入探讨Linux设备驱动中的一个重要特性——ioctl接口的实现，这是设备驱动程序与用户空间进行复杂交互的主要手段。 ioctl（Input/Output Control）是一种特殊的I/O控制命令，允许用户空间程序对设备进行...
zynq的linux驱动10-ioctl架构来控制led灯
01-31
本篇将详细讨论如何利用ioctl架构来控制LED灯，这是在Zynq Linux驱动开发中的一个基础但关键的应用。 ioctl（Input/Output Control）是Linux内核提供的一种机制，允许用户空间程序对设备进行特定的控制操作，这些...
Linux驱动开发—ioctl命令构成，设备驱动基础使用ioctl详解
weixin_46999174的博客
08-04 2034
ioctl（输入/输出控制）是一种系统调用，用于设备驱动程序与用户空间应用程序之间进行设备特定的输入/输出操作。它通常用于对设备执行标准文件操作（如读取、写入、打开和关闭）之外的特殊操作。ioctl提供了一种通用的机制，通过文件描述符与设备进行交互，支持各种类型的设备操作和控制。ioctl定义命令和参数：设备驱动程序和用户空间应用程序之间的交互是通过命令和参数来实现的。命令通常是一个宏，表示特定的操作，而参数则是传递给驱动程序的数据。调用ioctl系统调用：用户空间应用程序通过文件描述符调用ioctl。
linux驱动开发(一)：ioctl()函数
DYR20010308的博客
06-03 1095
一、应用程序中的ioctl接口首先，我们需要规定一些命令码，这些命令码在应用程序和驱动程序中需要保持一致。应用程序只需向驱动程序下发一条指令码，用来通知它执行哪条命令。如何解读这条指令和怎么实现相关操作，就是驱动程序自己要做的事。应用程序的接口函数为ioctl，参考，函数原型为下面我们解释各个参数的含义。1）fd是文件描述符。当我们的设备作为特殊文件被open()函数打开后，会返回一个文件描述符，通过操作这个文件描述符达到操作设备文件的目的。
驱动程序开发：Linux内核定时器与应用层ioctl的使用
morecrazylove的博客
07-14 810
Linux驱动之Linux内核定时器与应用层ioctl的应用
Linux内核编程（五）ioctl驱动编写
qq_1033275663的博客
06-16 979
ioctl主要用于实现对硬件设备控制类操作，实现 write 和 read 不太好实现的功能。ioctl是一个强大的工具，可以用于实现复杂的设备控制和状态查询。尽管它的使用有时被认为不太优雅，因为它打破了标准的读写接口模型，但在许多情况下，它提供了一种有效的方法来与设备驱动程序进行高级交互。开发者在使用 ioctl 时需要小心设计和实现命令码，以确保与设备的交互是清晰且安全的。
linux ioctl 应用程序,ioctl使用（驱动层和应用层）简介
weixin_30476083的博客
05-03 936
在用户空间，ioctl系调用具有如下原型：intioctl(intfd,unsignedlongcmd,...);这里的第三个参数，...在unix系统中一般代表可变参数， 但是这里代表可选参数。在驱动空间，ioctl方法的原型如下：long(*unlocked_ioctl)(structfile*,unsignedint,unsignedlong);定义ioctl命令...
linux设备驱动标准ioctl接口
仗劍走天涯
08-04 842
ioctl的驱动接口一般是作用在一些标准接口无法实现的功能。如和主控芯片链接的很多外设ic，主控对这些芯片的功能设置以及状态的获取等。所以 ioctl 接口可以看成是系统给我们进行功能扩展的的专用接口。 系统调用接口原型： int ioctl(int d, int request, ...); 这个函数是一个可变参数函数，最少需要2个参数 参数： d: 是文件描述符号 reque...
Linux内核之宏_IOWR：如何生成ioctl控制命令(六十)
Android系统攻城狮
04-24 1417
本篇目的：Linux内核之宏_IOWR：如何生成ioctl控制命令在Linux内核中，_IOWR是一个宏，用于生成系统调用中ioctl命令代码的一部分。ioctl（“input/output control”）系统调用是Linux中用于与设备文件交互的接口，它允许用户空间程序向设备驱动发送控制命令，并可能传递或接收数据。_IOWR宏用于构造一个ioctl命令，该命令支持双向数据传输，即可以同时从用户空间读取数据和向用户空间写入数据。
linux驱动ioctl数据传递机制
万波的技术博客
06-06 2796
ioctl是linux中一种除read和write之外的数据传递机制， 通信双方是应用层和内核层。 简单描述这个机制就是， 应用程序调用ioctl函数发送一个数字给内核层驱动程序 驱动程序接收到数字， 执行对应的操作。 难点： ioctl所发送的数字， 是有一定规则的， 必须符合这个规则， 驱动层才能正确解析这个数字指令。 这个数字也叫指令码 应用层的ioctl是个变参函数， 但是变参并不意味着它可以传任意多个参数进去，它的意思是第三个参数可传可不传。 既然是机制， 那么ioctl的机制如下 //
linux驱动：（20）ioctl接口（一）
weixin_59669309的博客
09-24 374
【代码】linux驱动：（20）ioctl接口（一）
linux驱动开发(五)：ioctl()函数使用实例——地址传参
baidu_38797690的博客
03-24 5372
介绍了Linux系统设备驱动中ioctl接口的进一步使用方法，这一次我们使用ioctl传递复杂的参数，因此只能传递参数的地址，同时借用copy_from_user和copy_to_user两个函数完成用户空间与内核空间之间的数据拷贝。
linux3.16驱动unlocked_ioctl
05-18
在Linux内核开发中，`ioctl`（Input/Output Control）是用于设备驱动程序与用户空间应用程序之间通信的一种机制。`unlocked_ioctl`是Linux 3.16版本引入的一个新特性，它改进了传统的`ioctl`调用，提高了并发性能和...
Linux设备驱动程序学习（4）-高级字符驱动程序操作［（1）ioctl and llseek］ - Linux设备驱动程序
05-16
在Linux系统中，设备驱动程序是操作系统与硬件设备之间的桥梁，它们负责管理和控制硬件设备，使得上层的应用程序可以通过标准的系统调用来访问硬件。本文将深入探讨Linux设备驱动程序中的两个关键操作：ioctl和...
Linux 再入门整理：详解 /etc/fstab 文件
最新发布
一只奋斗的猪
10-01 1166
`/etc/fstab` 文件是 Linux 系统中用于定义和管理文件系统的挂载信息的配置文件。它的作用是告诉系统在启动时，应该如何自动挂载各种文件系统。挂载是 Linux 操作系统中一种将存储设备与目录树关联的操作。通过挂载，存储设备中的文件可以通过目录访问。
linux 网络序
CodeHouse的博客
09-30 442
在将ip字符串转网络序存储时。根据整形二进制显示判断。
在 Kali Linux 中安装 Impacket
weixin_44023460的博客
09-30 302
在安装 Impacket 之前，你需要确保安装了 Python 和一些必要的依赖。通常，Kali 已经预装了 Python。步骤 3：克隆 Impacket 仓库。步骤 4：进入 Impacket 目录。如果你看到帮助信息，说明安装成功。步骤 5：安装 Impacket。
Linux的基本指令（2）
shylyly_的博客
10-01 969
Linux的基本指令（2） man nano cp mv which 自制指令 alias echo cat tac > >> < more less head tail |（管道）
使用Python实现在 Linux 和 Windows 之间的双向文件传输
2301_80892630的博客
09-29 692
在 Linux 和 Windows 之间可以用python程序实现双向文件传输，通过创建一个简单的文件传输程序来实现。该程序将使用套接字socket通信，允许任意一端发送或接收文件。这是在我的那篇实现python两个进程之间相互通信的基础上拓展的（不过只看这一篇文章也行），那篇文章传输的数据是字符串类型，今天我来实现文件的传输。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

码农小白

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值