linux驱动开发之字符设备--内核和用户空间数据的交换（ioctl）

时间：2021-03-24 17:55:12

前言

在驱动中，除了需要具备读写能力外，还需要对硬件设备进行控制。ioctl就常用户底层的一些操作。

正文

linux中，建议使用下边的方式，进行进行ioctl命令

设备类型 序列号 方向 数据尺寸
8bit 8bit 2bit 13/14bit

命令码的设备类型为一个 “幻数”，可以是在 0 ~0xff 之间值，内核中的 ioctl-number.txt 给出了一些推荐的和已经被使用的 “幻数”。

命令码列号也是 8 位宽 。

命令码的方向字节也是 2 位宽，该字端表示出具传送的方向，可能的值是 _IO_NONE(无数据传输)、_IOC_READ(读)、_IOC_WRITE(写)、_IOC_READ|_IOC_WRITE(双向)。数据传输的方向是从应用程序的角度来看的。

命令码的数据长度字节表示涉及的用户数据的大小，这个成员的宽度依赖于体系结构，通常为 13 或 14 位。

内核中定义了 _IO()、_IOR()、_IOW()、_IOWR()这4个宏来辅助生成命令。

#define _IOC(dir,type,nr,size) \
        (((dir)  << _IOC_DIRSHIFT) | \
         ((type) << _IOC_TYPESHIFT) | \
         ((nr)   << _IOC_NRSHIFT) | \
         ((size) << _IOC_SIZESHIFT))
#define _IO(type,nr) _IOC(_IOC_NONE,(type),(nr),0)
#define _IOR(type,nr,size) _IOC(_IOC_READ,(type),(nr),sizeof(size))
#define _IOW(type,nr,size) _IOC(_IOC_WRITE,(type),(nr),sizeof(size))
#define _IOWR(type,nr,size) _IOC(_IOC_READ|_IOC_WRITE,(type),(nr),sizeof(size))

以上宏的作用是根据输入的type（设备类型）、nr(序列号)、size(数据长度) 和宏中的位移来生成相应的 命令码。

#define _IOC_SIZE(nr) \
 ((((((nr) >> _IOC_DIRSHIFT) & _IOC_DIRMASK) & (_IOC_WRITE|_IOC_READ)) == 0)?    \
0: (((nr) >> _IOC_SIZESHIFT) & _IOC_XSIZEMASK))

获得数据域的大小。

应用API

  #include <sys/ioctl.h>
  int ioctl(int d, int request, ...)

参数:fd : 打开的文件描述符
request:命令码
可变参数：可以用来表示，写时用来传入驱动的数据，读时用来接收驱动的数据

内核

    long (*unlocked_ioctl) (struct file *filp , unsigned int, cmd .unsigned long arg);

参数:filp 应用打开的文件在内核的表示
cmd: 对应应用程序传入的命令码
arg ： 对于应用程序 传入或者接收的数据

实例

#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>

#include <linux/cdev.h>
#include <linux/fs.h>

#include <linux/uaccess.h>
//幻数
#define IOCTL_TYPE 'b'

#define COUNT 32

struct  ioctl_arg {
int val;
char buf[COUNT];
};
//定义的命令码
#define CMDCTL _IO(IOCTL_TYPE,0)
#define CMDR _IOR(IOCTL_TYPE,1,struct ioctl_arg)
#define CMDW _IOW(IOCTL_TYPE,2,struct ioctl_arg)

#define DEVICE_NAME "cdev_demo"

static struct cdev *pdev = NULL;
static int major = 0;
static int minor = 0;
static int count = 2;


#define BUF_SIZE (1024)
static char kbuf[BUF_SIZE];
static int  buf_count = 0;

static int cdev_demo_open(struct inode * inode, struct file * file)
{
    printk("%s,%d\n",__func__,__LINE__);
return 0;
}
static int cdev_demo_release(struct inode *inode, struct file * file)
{
    printk("%s,%d\n",__func__,__LINE__);
return 0;
}
static ssize_t cdev_demo_read(struct file * file, char __user * buffer, size_t size, loff_t * loff)
{
    printk("%s,%d\n",__func__,__LINE__);

if(0 == buf_count){
return -EAGAIN;
    }

if(buf_count < size){
        size = buf_count;
    }

if(size == copy_to_user(buffer,kbuf,size)){
return -EAGAIN;
    }

    buf_count  = 0;

return size;

}

static ssize_t cdev_demo_write(struct file * file, const char __user * buffer, size_t size, loff_t * loff)
{
    printk("%s,%d\n",__func__,__LINE__);
    printk("buffer=%s size=%d\n",buffer,size);
if(size >BUF_SIZE){
return -ENOMEM;
    }
if(size == copy_from_user(kbuf,buffer,size)){
return -EAGAIN;
    }

    buf_count = size;
return size;
}
//ioctl
static long cdev_demo_ioctl (struct file *filep, unsigned int cmd, unsigned long arg)
{
static struct ioctl_arg buf;
    printk("%s,%d\n",__func__,__LINE__);
//分辨不同命令码
switch(cmd){
case CMDCTL:
                printk("do CMDCTL\n");
break;
case CMDR:
//使用 _IOC_SIZE()获得命令码中的数据长度
if(sizeof(buf) != _IOC_SIZE(cmd)){
return -EINVAL;
            }

if(sizeof(buf) == copy_to_user((struct ioctl_arg*)arg,&buf,sizeof(struct ioctl_arg))){
return -EAGAIN;
            }
            printk("do CMDR\n");
break;
case CMDW:
if(sizeof(buf)!= _IOC_SIZE(cmd)){
return -EINVAL;
            }

if(sizeof(buf) == copy_from_user(&buf,(struct ioctl_arg*)arg,sizeof(buf))){
return -EAGAIN;
            }
            printk("do CMDW\n");
            printk("%d,%s \n",buf.val,buf.buf);
break;

default:
break;

    }

return 0;
}
static struct file_operations fops ={
    .owner   = THIS_MODULE,
    .open    = cdev_demo_open,
    .release = cdev_demo_release,
    .read    = cdev_demo_read,
    .write   = cdev_demo_write,
    .unlocked_ioctl = cdev_demo_ioctl,
};

static int __init cdev_demo_init(void)
{
    dev_t dev;
int ret;

    printk("%s,%d\n",__func__,__LINE__);

    pdev = cdev_alloc();
if(NULL == pdev){
        printk("cdev_alloc failed.\n");
return -ENOMEM;
    }

    cdev_init(pdev,&fops);

    ret = alloc_chrdev_region(&dev,minor,count,DEVICE_NAME);
if(ret){
        printk("alloc_chrdev_region failed.\n");
goto ERROR_CDEV;
    }
    major = MAJOR(dev);
    ret = cdev_add(pdev, dev,count);
if(ret) {
        printk("cdev_add failed.\n");
goto  ERROR_ADD;
    }

return 0;
ERROR_ADD:
    unregister_chrdev_region(dev,count);
ERROR_CDEV:
    cdev_del(pdev);
return ret;
}
static void __exit cdev_demo_exit(void)
{
    printk("%s,%d\n",__func__,__LINE__);
    unregister_chrdev_region(MKDEV(major,minor),count);

    cdev_del(pdev);
}

module_init(cdev_demo_init);
module_exit(cdev_demo_exit);
MODULE_LICENSE("GPL");

APP:

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

#include <errno.h>

#include <sys/ioctl.h>


#define IOCTL_TYPE 'b'

#define COUNT 32

struct  ioctl_arg {
int val;
char buf[COUNT];
};

#define CMDCTL _IO(IOCTL_TYPE,0)
#define CMDR _IOR(IOCTL_TYPE,1,struct ioctl_arg)
#define CMDW _IOW(IOCTL_TYPE,2,struct ioctl_arg)




#define BUFFER_SIZE (1024)
int main(int argc,char* argv[])
{
char *dev = "/dev/cdev_demo";
int fd = open(dev,O_RDWR);
    if(0 > fd){
        perror("open\n");
return -1;
    }
//先构造数据，然后调用ioctl进行写操作
        printf("begin write\n");
struct ioctl_arg arg = {
            .val = 123,
            .buf = "address",
        };

        if( 0 > ioctl(fd,CMDW,&arg)){
            perror(" write ");
return -1;
        }

//调用ioctl进行读取内核数据
        printf("begin read\n");
struct ioctl_arg args;
        if(0 > ioctl(fd,CMDR,&args)){
            perror("read");
return -1;
        }
        printf("read args.val = %d args.buf = %s\n",args.val,args.buf);

    close(fd);
return  0;
}

运行结果：

shell@tiny4412:/mnt # ./test 
[  777.455766] cdev_demo_open,39
[  777.457120] do CMDW
[  777.457192] 123,address 
[  777.457238] cdev_demo_ioctl,87
[  777.457334] do CMDR
[  777.457441] cdev_demo_release,44
begin write
begin read
read args.val = 123 args.buf = address

注： [ xx] 表示tiny4412打印的信息，不带的表示app 打印出的信息。

总结

在ioctl中，可以根据命令码对硬件进行功能的操作，即可以进行写操作也可以进行读操作。这样就比read()、write()更加灵活。
标签：

相关文章