通过ioctl实现驱动控制硬件

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

bee

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/device.h>
#include <linux/io.h>
#include "head.h"
// PB6

struct class *cls;
struct device *dev;
int major;
unsigned int *vir_rcc;
gpio_t *vir_bee;
int bee_open(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}
long bee_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
    //使用不带参数版本
    
      switch (cmd)
    {

    case BEE_ON: // 开
        vir_bee->ODR |= (0x1 << 6);
        break;

    case LED_OFF: // 关
        vir_bee->ODR &= (~(0X1 << 6));
        break;
    }
    return 0;
}
int bee_close(struct inode *inode, struct file *file)
{
    return 0;
}
// 操作方法结构体变量赋值 用于赋予应用层用户交互底层的能力
struct file_operations fops =
    {
        .open = bee_open,
        .unlocked_ioctl = bee_ioctl,
        .release = bee_close,
};

static int __init mycdev_init(void)
{
    // 进行对字符设备的驱动注册
    major = register_chrdev(0, "beedev", &fops);
    if (major < 0)
    {
        printk("字符设备注册失败\n");
        return major;
    }
    printk("字符设备注册成功：major=%d\n", major);

    // 通过udev创建字符设备文件
    // 1. 向上提交目录
    cls = class_create(THIS_MODULE, "beedev");
    if (IS_ERR(cls))
    {
        // 说明返回的地址在顶层 是个错误地址
        printk("向上提交目录失败\n");
        return -PTR_ERR(cls);
    }
    printk("提交目录成功\n");


    //向上提交设备节点信息
    dev = device_create(cls,NULL,MKDEV(major,0),NULL,"beedev");
    if (IS_ERR(dev))
        {
            printk("向上提交设备节点信息失败\n");
            return -PTR_ERR(dev);
        }
     printk("提交节点信息成功\n");


    //蜂鸣器进行初始化 pb6
    // 寄存器地址映射
    //1.rcc地址的映射
    vir_rcc = ioremap(PHY_RCC_ADDR, 4);
     if (vir_rcc == NULL)
    {
        printk("ioremap filed：%d\n", __LINE__);
        return -ENOMEM;
    }
   
    vir_bee = ioremap(PHY_BEE_ADDR, sizeof(gpio_t));
    if (vir_bee == NULL)
    {
        printk("ioremap filed：%d\n", __LINE__);
        return -ENOMEM;
    }

    //寄存器初始化
    // rcc使能
    *(vir_rcc) |= (0X1 << 1);
    //蜂鸣器初始化
    vir_bee->MODER &= (~(0X3<<12));   
    vir_bee->MODER |= (0X1<<12);
    vir_bee->ODR &= (~(1 << 6));
    printk("寄存器初始化成功");

    return 0;
}

static void __exit mycdev_exit(void)
{
    //结束时地址需要取消映射
    iounmap(vir_bee);
    iounmap(vir_rcc);

    //销毁节点信息
    device_destroy(cls,MKDEV(major,0));

    //销毁目录信息
    class_destroy(cls);

    //注销设备驱动
    unregister_chrdev(major,"beedev");
}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");

fans

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/device.h>
#include <linux/io.h>
#include "head.h"
// PE9

struct class *cls;
struct device *dev;
int major;
unsigned int *vir_rcc;
gpio_t *vir_fans;
int bee_open(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}
long bee_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
    //使用不带参数版本
    
      switch (cmd)
    {

    case FANS_ON: // 开
        vir_fans->ODR |= (0x1 << 9);
        break;

    case FANS_OFF: // 关
        vir_fans->ODR &= (~(0X1 << 9));
        break;
    }
    return 0;
}
int bee_close(struct inode *inode, struct file *file)
{
    return 0;
}
// 操作方法结构体变量赋值 用于赋予应用层用户交互底层的能力
struct file_operations fops =
    {
        .open = bee_open,
        .unlocked_ioctl = bee_ioctl,
        .release = bee_close,
};

static int __init mycdev_init(void)
{
    // 进行对字符设备的驱动注册
    major = register_chrdev(0, "fansdev", &fops);
    if (major < 0)
    {
        printk("字符设备注册失败\n");
        return major;
    }
    printk("字符设备注册成功：major=%d\n", major);

    // 通过udev创建字符设备文件
    // 1. 向上提交目录
    cls = class_create(THIS_MODULE, "fansdev");
    if (IS_ERR(cls))
    {
        // 说明返回的地址在顶层 是个错误地址
        printk("向上提交目录失败\n");
        return -PTR_ERR(cls);
    }
    printk("提交目录成功\n");


    //向上提交设备节点信息
    dev = device_create(cls,NULL,MKDEV(major,0),NULL,"fansdev");
    if (IS_ERR(dev))
        {
            printk("向上提交设备节点信息失败\n");
            return -PTR_ERR(dev);
        }
     printk("提交节点信息成功\n");


    //蜂鸣器进行初始化 pb6
    // 寄存器地址映射
    //1.rcc地址的映射
    vir_rcc = ioremap(PHY_RCC_ADDR, 4);
     if (vir_rcc == NULL)
    {
        printk("ioremap filed：%d\n", __LINE__);
        return -ENOMEM;
    }
   
    vir_fans = ioremap(PHY_FANS_ADDR, sizeof(gpio_t));
    if (vir_fans == NULL)
    {
        printk("ioremap filed：%d\n", __LINE__);
        return -ENOMEM;
    }

    //寄存器初始化
    // rcc使能
    *(vir_rcc) |= (0X1 << 4);
    //蜂鸣器初始化
    vir_fans->MODER &= (~(0X3<<18));   
    vir_fans->MODER |= (0X1<<18);
    vir_fans->ODR &= (~(1 << 9));
    printk("寄存器初始化成功");

    return 0;
}

static void __exit mycdev_exit(void)
{
    //结束时地址需要取消映射
    iounmap(vir_fans);
    iounmap(vir_rcc);

    //销毁节点信息
    device_destroy(cls,MKDEV(major,0));

    //销毁目录信息
    class_destroy(cls);

    //注销设备驱动
    unregister_chrdev(major,"fansdev");
}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");

led

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/io.h>
#include <linux/device.h>
#include "head.h"

struct class *cls;
struct device *dev;
int major;
char kbuf[128] = {0};
gpio_t *vir_led1;
gpio_t *vir_led2;
gpio_t *vir_led3;
unsigned int *vir_rcc;
int mycdev_open(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}
long mycdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
    int which;
    //通过拷贝函数获取ioctl第三个参数对应空间的数值
    int ret=copy_from_user(&which,(void *)arg,4);
    if(ret)
    {
        printk("拷贝用户空间数据失败\n");
        return -EIO;
    }
    //进行功能控制
    switch (cmd)
    {
    case LED_ON: // 开灯
        switch (which)
        {
        case 1: // LED1
            vir_led1->ODR |= (0x1 << 10);
            break;
        case 2: // LED2
            vir_led2->ODR |= (0x1 << 10);
            break;
        case 3: // LED3
            vir_led3->ODR |= (0x1 << 8);
            break;
        }
        break;
    case LED_OFF: // 关灯
        switch (which)
        {
        case 1:
            vir_led1->ODR &= (~(0X1 << 10));
            break;
        case 2:
            vir_led2->ODR &= (~(0X1 << 10));
            break;
        case 3:
            vir_led3->ODR &= (~(0X1 << 8));
            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 fops = {

    .open = mycdev_open,
    .unlocked_ioctl = mycdev_ioctl,
    .release = mycdev_close,
};

int all_led_init(void)
{
    // 寄存器地址的映射
    vir_led1 = ioremap(PHY_LED1_ADDR, sizeof(gpio_t));
    if (vir_led1 == NULL)
    {
        printk("ioremap filed：%d\n", __LINE__);
        return -ENOMEM;
    }
    vir_led2 = ioremap(PHY_LED2_ADDR, sizeof(gpio_t));
    if (vir_led2 == NULL)
    {
        printk("ioremap filed：%d\n", __LINE__);
        return -ENOMEM;
    }
    vir_led3 = vir_led1;
    vir_rcc = ioremap(PHY_RCC_ADDR, 4);
    if (vir_rcc == NULL)
    {
        printk("ioremap filed：%d\n", __LINE__);
        return -ENOMEM;
    }
    printk("物理地址映射成功\n");
    // 寄存器的初始化
    // rcc
    (*vir_rcc) |= (3 << 4);
    // 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_led1->MODER |= (1 << 16);
    vir_led1->ODR &= (~(1 << 8));
    printk("寄存器初始化成功\n");

    return 0;
}

static int __init mycdev_init(void)
{
    int i;
    // 字符设备驱动注册
    major = register_chrdev(0, "mychrdev", &fops);
    if (major < 0)
    {
        printk("字符设备驱动注册失败\n");
        return major;
    }
    printk("字符设备驱动注册成功:major=%d\n", major);
    // 向上提交目录
    cls = class_create(THIS_MODULE, "mychrdev");
    if (IS_ERR(cls))
    {
        printk("向上提交目录失败\n");
        return -PTR_ERR(cls);
    }
    // 向上提交设备节点信息
    // 为三盏灯创建三个设备文件
    for (i = 0; i < 3; i++)
    {
        dev = device_create(cls, NULL, MKDEV(major, i), NULL, "mychrdev%d", i);
        if (IS_ERR(dev))
        {
            printk("向上提交设备节点信息失败\n");
            return -PTR_ERR(dev);
        }
    }
    // 寄存器映射以及初始化
    all_led_init();

    return 0;
}
static void __exit mycdev_exit(void)
{
    int i;
    // 取消地址映射
    iounmap(vir_led1);
    iounmap(vir_led2);
    iounmap(vir_rcc);
    // 销毁设备节点信息
    for (i = 0; i < 3; i++)
    {
        device_destroy(cls, MKDEV(major, i));
    }
    // 销毁目录信息
    class_destroy(cls);
    // 注销字符设备驱动
    unregister_chrdev(major, "mychrdev");
}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");

motor

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include <linux/device.h>
#include <linux/io.h>
#include "head.h"
// PF6

struct class *cls;
struct device *dev;
int major;
unsigned int *vir_rcc;
gpio_t *vir_motor;
int bee_open(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n", __FILE__, __func__, __LINE__);
    return 0;
}
long bee_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
{
    //使用不带参数版本
    
      switch (cmd)
    {

    case BEE_ON: // 开
        vir_motor->ODR |= (0x1 << 6);
        break;

    case LED_OFF: // 关
        vir_motor->ODR &= (~(0X1 << 6));
        break;
    }
    return 0;
}
int bee_close(struct inode *inode, struct file *file)
{
    return 0;
}
// 操作方法结构体变量赋值 用于赋予应用层用户交互底层的能力
struct file_operations fops =
    {
        .open = bee_open,
        .unlocked_ioctl = bee_ioctl,
        .release = bee_close,
};

static int __init mycdev_init(void)
{
    // 进行对字符设备的驱动注册
    major = register_chrdev(0, "motordev", &fops);
    if (major < 0)
    {
        printk("字符设备注册失败\n");
        return major;
    }
    printk("字符设备注册成功：major=%d\n", major);

    // 通过udev创建字符设备文件
    // 1. 向上提交目录
    cls = class_create(THIS_MODULE, "motordev");
    if (IS_ERR(cls))
    {
        // 说明返回的地址在顶层 是个错误地址
        printk("向上提交目录失败\n");
        return -PTR_ERR(cls);
    }
    printk("提交目录成功\n");


    //向上提交设备节点信息
    dev = device_create(cls,NULL,MKDEV(major,0),NULL,"motordev");
    if (IS_ERR(dev))
        {
            printk("向上提交设备节点信息失败\n");
            return -PTR_ERR(dev);
        }
     printk("提交节点信息成功\n");


    //蜂鸣器进行初始化 pb6
    // 寄存器地址映射
    //1.rcc地址的映射
    vir_rcc = ioremap(PHY_RCC_ADDR, 4);
     if (vir_rcc == NULL)
    {
        printk("ioremap filed：%d\n", __LINE__);
        return -ENOMEM;
    }
   
    vir_motor = ioremap(PHY_BEE_ADDR, sizeof(gpio_t));
    if (vir_motor == NULL)
    {
        printk("ioremap filed：%d\n", __LINE__);
        return -ENOMEM;
    }

    //寄存器初始化
    // rcc使能
    *(vir_rcc) |= (0X1 << 5);
    //蜂鸣器初始化
    vir_motor->MODER &= (~(0X3<<12));   
    vir_motor->MODER |= (0X1<<12);
    vir_motor->ODR &= (~(1 << 6));
    printk("寄存器初始化成功");

    return 0;
}

static void __exit mycdev_exit(void)
{
    //结束时地址需要取消映射
    iounmap(vir_motor);
    iounmap(vir_rcc);

    //销毁节点信息
    device_destroy(cls,MKDEV(major,0));

    //销毁目录信息
    class_destroy(cls);

    //注销设备驱动
    unregister_chrdev(major,"motordev");
}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");

test

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

int main(int argc, char const *argv[])
{
    int a, b, c;
    char buf[128] = {0};
    int fd_led = open("/dev/mychrdev0", O_RDWR);
    if (fd_led < 0)
    {
        printf("打开设备文件失败\n");
        exit(-1);
    }
    int fd_bee = open("/dev/beedev", O_RDWR);
    if (fd_bee < 0)
    {
        printf("打开设备文件失败\n");
        exit(-1);
    }
    int fd_fans = open("/dev/fansdev", O_RDWR);
    if (fd_fans < 0)
    {
        printf("打开设备文件失败\n");
        exit(-1);
    }
    int fd_motor = open("/dev/motordev", O_RDWR);
    if (fd_motor < 0)
    {
        printf("打开设备文件失败\n");
        exit(-1);
    }
    while (1)
    {
        // 从终端读取
        printf("请输入要控制的硬件\n");
        printf("0(灯) 1(蜂鸣器) 2(风扇) 3（马达）>");
        scanf("%d", &c);
        if (c == 0)
        {
            printf("请选择要实现的功能\n");
            printf("0(关灯) 1(开灯)>");
            scanf("%d", &a);
            printf("请输入要控制的灯\n");
            printf("1(LED1) 2(LED2) 3(LED3)>");
            scanf("%d", &b);
            if (a == 1) // 开灯
            {
                ioctl(fd_led, LED_ON, &b);
            }
            else if (a == 0) // 关灯
            {
                ioctl(fd_led, LED_OFF, &b);
            }
        }
        else if (c == 1)
        {
            printf("请选择要实现的功能\n");
            printf("0(关灯) 1(开灯)>");
            scanf("%d", &a);
            if (a == 1) // 开灯
            {
                ioctl(fd_bee, BEE_ON);
            }
            else if (a == 0) // 关灯
            {
                ioctl(fd_bee, BEE_OFF);
            }
        }
        else if (c == 2)
        {
            printf("请选择要实现的功能\n");
            printf("0(关灯) 1(开灯)>");
            scanf("%d", &a);
            if (a == 1) // 开灯
            {
                ioctl(fd_fans, FANS_ON);
            }
            else if (a == 0) // 关灯
            {
                ioctl(fd_fans, FANS_OFF);
            }
        }
        else
        {
            printf("请选择要实现的功能\n");
            printf("0(关灯) 1(开灯)>");
            scanf("%d", &a);
            if (a == 1) // 开灯
            {
                ioctl(fd_motor, MOTOR_ON);
            }
            else if (a == 0) // 关灯
            {
                ioctl(fd_motor, MOTOR_ON);
            }
        }
    }

    close(fd_bee);
    close(fd_led);
    close(fd_fans);
    close(fd_motor);

    return 0;
}

head.h

#ifndef __HEAD_H__
#define __HEAD_H__ 
typedef struct{
    unsigned int MODER;
    unsigned int OTYPER;
    unsigned int OSPEEDR;
    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_FANS_ADDR   0X50006000
#define PHY_RCC_ADDR    0X50000A28
#define PHY_BEE_ADDR    0x50003000
#define PHY_MOTOR_ADDR    0X50007000
//风扇 PE9 蜂鸣器PB6 马达PF6 
#define LED_ON _IOW('l',1,int)  //开灯
#define LED_OFF _IOW('l',0,int)//关灯
#define BEE_ON _IO('b',1)  //开灯
#define BEE_OFF _IO('b',0)//关灯
#define MOTOR_ON _IO('m',1)  //开灯
#define MOTOR_OFF _IO('m',0)//关灯
#define FANS_ON _IO('f',1)  //开灯
#define FANS_OFF _IO('f',0)//关灯

#endif

 

night76
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Linux设备驱动：Ioctl控制
m0_74282605的博客
06-28 997
在驱动程序中实现的ioctl函数体内，实际上是有一个switch {case}结构，每一个case对应一个命令码，做出一些相应的操作。但是命令码非常的不直观，所以Linux Kernel中提供了一些宏，这些宏可根据便于理解的字符串生成命令码，或者是从命令码得到一些用户可以理解的字符串以标明这个命令对应的设备类型、设备序列号、数据传送方向和数据传输尺寸。ioctl函数的实现是根据命令执行的一个switch语句，但是，当命令不能匹配任何一个设备所支持的命令时，通常返回-EINVAL(非法参数)；
ioctl的控制方法，学习其控制内核
12-14
ioctl提供了一种灵活的方法，使得开发者可以通过标准的文件描述符来控制硬件设备，而无需编写复杂的内核模块。在本文中，我们将深入探讨ioctl的工作原理、使用方法以及在实际应用中的重要性。 首先，理解ioctl的...
linux驱动学习加强版-5（ioctl的使用）
永不秃头的程序员的博客
04-10 653
ioctl是用户空间和内核空间相互交流时候用的比较多的一种手段。我们也可以在HAL层通过ioctl调到驱动里面。
（八）linux驱动之ioctl的使用
水枂的博客
04-01 2770
这篇文章给大家讲解一下ioctl的简单使用，关于ioctl更详细的教程后面有机会单独写出来 （一）什么是ioctl ioctl是设备驱动程序中对设备的I/O通道进行管理的函数。所谓对I/O通道进行管理，就是对设备的一些特性进行控制，例如串口的传输波特率、马达的转速、网卡速率等等。它的调用方式如下： //在应用调用 int ioctl(int fd, int cmd, …)； 其中fd是用户程...
zynq的linux驱动10-ioctl架构来控制led灯
01-31
在Zynq平台上，通过ioctl接口，我们可以编写用户空间应用程序来控制硬件资源，比如LED灯。 首先，我们需要在驱动程序中定义ioctl命令。在C语言中，ioctl命令通常用`#define`来定义，例如： ```c #define MY_LED_ON...
imx6ul gpio ioctl简单驱动
06-15
ioctl是一种在用户空间与内核空间之间进行低级别通信的系统调用，常用于设备驱动中的控制操作。对于GPIO驱动，ioctl可以用来设置GPIO的方向（输入或输出）、读取或设置GPIO的值、使能或禁用中断等。 例如，我们可以...
linux设备驱动归纳总结（三）：4.ioctl的实现
12-24
在实际的设备驱动开发中，理解并正确实现ioctl接口对于提供灵活的设备控制至关重要。通过ioctl，开发者能够定制设备的行为，实现设备驱动与应用程序之间的高效通信。记住，每个设备驱动都是独特的，因此ioctl的使用...
linux3.16驱动unlocked_ioctl
05-18
`memdev3.16_ioctl`可能是内存设备驱动的例子，它可能包含一个或多个`ioctl`命令来控制内存区域的分配、释放或查询。在`unlocked_ioctl`的上下文中，这个驱动可能实现了自己的锁机制，使得多个进程可以并发地对内存...
IOCTL 助手（Windows驱动开发工具）
08-12
IOCTL助手。前几次上传，都有问题，因为是使用7-zip解压的。唉，看来还是要用WINRAR或者WinZip比较好啊。
内核与用户空间的通信实现——ioctl（驱动+用户程序）
ljl113的博客
09-24 5230
本文主要介绍内核空间与用户空间通信的一种方式----ioctl，用户程序可以通过调用ioctl函数来实现将一个cmd传给内核，而内核驱动根据switch case来实现预先设定好cmd对应执行的相关程序。学习ioctl是一个字符设备，所以在我们学习ioctl之前需要先了解一下linux设备驱动中的字符设备。
驱动设备的IOCTL
m0_74936872的博客
07-16 331
已知成员的地址获得所在结构体变量的地址：container_of(成员地址,结构体类型名，成员在结构体中的名称)cmd组成dir（direction），ioctl 命令访问模式（属性数据传输方向），占据 2 bit，可以为IOC_NONE、IOC_READ、IOC_WRITE、IOC_READ | _IOC_WRITE，分别指示了四种访问模式：无数据、读数据、写数据、读写数据；
Ioctl()方式实现与驱动交互简洁框架
weixin_42271802的博客
06-14 1606
ioctl是linux中一种除read和write之外的数据传递机制以上函数参数的含义如下。inode和fp用来确定被操作的设备。request就是用户程序下发的命令。args就是用户程序在必要时传递的参数。在2.6.36以后ioctl函数已经不存在了，用unlocked_ioctl和compat_ioctl两个函数代替。参数去除了原来ioctl中的structinode参数，返回值也发生了改变。新的代码。
Linux驱动开发：9、驱动-控制接口的实现(ioctl)
最新发布
遇雪长安的博客
03-06 6308
以字符设备为例。一般情况下，一个字符设备的驱动，除了读取和写入设备之外，大部分的驱动程序都需要通过设备驱动程序来执行各种类型的硬件控制。例如，针对串口设备，驱动层除了需要提供对串口的读写，还需要提供对串口波特率、校验位、以及流控等配置信息的控制。这些配置信息需要从应用层传递一些基本数据，相比普通的读写数据，控制数据仅仅也只是数据类型不同。同时传输的控制信息，数据量一般情况下也不会太大。
设备驱动中的ioctl函数详解
jinking01的专栏
10-09 1万+
ioctl是iocontrol的缩写，就是IO控制。 行为上 简单来说，如果你在写驱动程序时候，碰到一些IO操作，在逻辑上不能归类到read，不能归类到write，那就可以认为是ioctl的部分。 read和write应该是写入和读出数据的，应该是作为单纯的数据交换的方式来处理。而ioctl则是控制read和write一些选项的。 比如：你做了一个通用的读写IO端口的驱动模块。read和write是从端口读写数据的，但是...
驱动--ioctl
weixin_44240433的博客
02-08 199
驱动--ioctl
linux驱动之ioctl详解
qq_40684669的博客
11-13 2424
字符设备驱动中ioctl的使用
ioctl()分析——从用户空间到设备驱动
热门推荐
zifehng的专栏
03-02 2万+
　　一个字符设备驱动通常会实现常规的打开、关闭、读、写等功能，但在一些细分的情境下，如果需要扩展新的功能，通常以增设ioctl()命令的方式实现，其作用类似于“拾遗补漏”。在文件I/O中，ioctl扮演着重要角色，本文将以驱动开发为侧重点，从用户空间到内核空间纵向分析ioctl函数。 用户空间的ioctl() #include &lt;sys/ioctl.h&gt; int i...
Linux驱动开发基础：从HelloWorld到网络相关 ioctl 实现
2. **驱动开发实践**：从简单的字符设备驱动（char device）开始，编写一个可以编译并加载到内核的驱动，通过`insmod`、`lsmod`、`rmmod`命令控制驱动的加载和卸载。在这个阶段，你需要理解如何在驱动的初始化函数中...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值