混杂设备记录

参考文章  https://www.jianshu.com/p/1b3bf498ff82

                linux设备驱动之混杂设备misc-蒲公英云

在linux系统中，存在一类特殊的字符设备，它们共享同一个主设备号（10），但次设备号不同，我们称此类设备为混杂设备（miscdevice）。所有的混杂设备形成一个链表，对设备访问时内核根据次设备号查找相应的miscdevice设备。

（一个知识点补充） 

include/linux/下miscdevice.h中存在混杂设备结构体定义，各种次设备号定义以及注册注销函数。

linux内核使用struct miscdevice来描述一个混杂设备。

struct miscdevice {
int minor; /* 次设备号*/
const char *name; /* 设备名*/
const struct file_operations *fops; /*文件操作*/
struct list_head list;
struct device *parent;
struct device *this_device;
};

linux内核使用misc_register函数来注册一个混杂设备驱动。

int misc_register(struct miscdevice * misc)

linux内核使用misc_deregister函数来注销一个混杂设备驱动。

int misc_deregister(struct miscdevice * misc)

通常情况下，一个字符设备都不得不在初始化的过程中进行下面的步骤：
1 通过alloc_chrdev_region()分配主/次设备号。
2 使用cdev_init()和cdev_add()来以一个字符设备注册自己。

而一个misc驱动，则可以只用一个调用misc_register()来完成这所有的步骤。

如果一个字符设备驱动要驱动多个设备，那么它就不应该用misc设备来实现。（这里后续需要加强理解？）

minor是这个混杂设备的次设备号，若由系统自动配置，则可以设置为MISC_DYNANIC_MINOR，

name是设备名。

mdev.minor = MISC_DYNAMIC_MINOR;
mdev.name  = "DEVICE_NAME"

每一个misc驱动会自动出现在/sys/class/misc下，而不需要驱动程序作者明确的去做。

2 混杂设备的API

包含头文件

#include<linux/miscdevice.h>

建一个miscdevice结构体

static struct miscdevice misc = {
       .minor = MISC_DYNAMIC_MINOR,
       .name = DEVICE_NAME,
       .fops = &dev_fops,
};

在驱动函数初始化中注册这个混杂设备
misc_register(&misc);
驱动卸载时，注销这个设备
misc_deregister(&misc);

混杂设备miscdevice说明
miscdevice结构体

struct miscdevice  {
       int minor;
       const char *name;
       const struct file_operations *fops;
       struct list_head list;
       struct device *parent;
       struct device *this_device;
       const char *nodename;
       mode_t mode;
};

设备注册和注销
extern int misc_register(struct miscdevice * misc);
extern int misc_deregister(struct miscdevice *misc);
函数具体实现在/drivers/char/misc.c
在misc_init()函数中
调用class_create()函数创建了一个名misc的类，注册了一个主设备号为10，设备名为misc的字符设备。
misc_register()函数用于注册一个混杂设备，其主设备号为10，如果次设备号指定为MISC_DYNAMIC_MINOR将由系统去指定一个次设备号，调用device_create创建设备节点。
misc_deregister用于注销这个混杂设备，其中调用了device_destroy删除设备节点。

混杂设备驱动实例

/*
 *  ioctl 控制 LED
 *  使用库函数，非操作寄存器，没有重映射地址
 *  使用混杂设备驱动
 */
#include <linux/miscdevice.h>
#include <linux/delay.h>
#include <asm/irq.h>
#include <mach/regs-gpio.h>
#include <mach/hardware.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/mm.h>
#include <linux/fs.h>
#include <linux/types.h>
#include <linux/delay.h>
#include <linux/moduleparam.h>
#include <linux/slab.h>
#include <linux/errno.h>
#include <linux/ioctl.h>
#include <linux/cdev.h>
#include <linux/string.h>
#include <linux/list.h>
#include <linux/pci.h>
#include <asm/uaccess.h>
#include <asm/atomic.h>
#include <asm/unistd.h>
 
 
#define DEVICE_NAME "GPIO_Control_LED"
#define LED_NUM 4
 
/* 定义幻数 */
#define LED_IOC_MAGIC  'L'
 
/* 定义命令 */
#define IOCTL_GPIO_ON       _IOR(LED_IOC_MAGIC,1,int)  //从用户空间读
#define IOCTL_GPIO_OFF      _IOR(LED_IOC_MAGIC,2,int)  
#define IOCTL_GPIO_GET_STATE    _IOWR(LED_IOC_MAGIC,3,int)  //向用户空间写
 
//最大命令数
#define LED_IOC_MAXNR 3
 
 
//IO 口
static unsigned long gpio_table [] =
{
    S3C2410_GPB5,
    S3C2410_GPB6,
    S3C2410_GPB7,
    S3C2410_GPB8,
};
 
//IO口 配置
static unsigned int gpio_cfg_table [] =
{
    S3C2410_GPB5_OUTP,
    S3C2410_GPB6_OUTP,
    S3C2410_GPB7_OUTP,
    S3C2410_GPB8_OUTP,
};
 
static int tq2440_gpio_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
{
    static int pin_state=0;
    static int ret = 0;
    static int ioarg = 0;
    static int err = 0;
     
        /* 检测命令的有效性 */
    if (_IOC_TYPE(cmd) != LED_IOC_MAGIC) 
        return -EINVAL;
    if (_IOC_NR(cmd) > LED_IOC_MAXNR) 
        return -EINVAL;
     
        /* 根据命令类型，检测参数空间是否可以访问 */
    if (_IOC_DIR(cmd) & _IOC_READ)  //如果是读命令，则判断是否可以向用户空间 写
        err = !access_ok(VERIFY_WRITE, (void *)arg, _IOC_SIZE(cmd));
    else if (_IOC_DIR(cmd) & _IOC_WRITE)
        err = !access_ok(VERIFY_READ, (void *)arg, _IOC_SIZE(cmd));
        if (err) 
        return -EFAULT;

    /* 根据命令，来选择执行哪个分支，并根据传入的参数打开、关闭或得到某个灯的状态 */
    switch(cmd)
    {
        case IOCTL_GPIO_ON:
            ret = __get_user(ioarg, (int *)arg);
             
            printk("SET the LED  %d  to ON  \n",ioarg);
            s3c2410_gpio_setpin(gpio_table[ioarg], 0);
            return 0;
 
        case IOCTL_GPIO_OFF:
            ret = __get_user(ioarg, (int *)arg);
             
            printk("SET the LED  %d  to OFF  \n",ioarg);
            s3c2410_gpio_setpin(gpio_table[ioarg], 1);
            return 0;
             
        case IOCTL_GPIO_GET_STATE:
            ret = __get_user(ioarg, (int *)arg);
             
            pin_state=s3c2410_gpio_getpin(gpio_table[ioarg]);
                ret = __put_user(pin_state, (int *)arg);
                printk("IN KERNEL ---===>>>  I got the stat of pin is  %d   \n",pin_state);
                return 0;
                 
        default:
            return -EINVAL;
    }
}
 
static struct file_operations dev_fops = {
    .owner  =   THIS_MODULE,
    .ioctl  =   tq2440_gpio_ioctl, 
};
  /* 这个函数是混杂设备的关键函数，用以注册混杂设备 */
static struct miscdevice misc = {
    .minor = MISC_DYNAMIC_MINOR,   //自动分配次设备号
    .name  = DEVICE_NAME,
    .fops  = &dev_fops,  //关联你的操作函数
};
 
static int __init dev_init(void)
{
    int ret;
    int i;
     
    for (i = 0; i < LED_NUM; i++)
    {
        s3c2410_gpio_cfgpin(gpio_table[i], gpio_cfg_table[i]);
        s3c2410_gpio_setpin(gpio_table[i], 1);   //开始时LED全亮
    }
 
    ret = misc_register(&misc);  //混杂设备驱动注册
         
    printk ("%s initialized    ---===>>>\n",DEVICE_NAME);
 
    return ret;
}
 
static void __exit dev_exit(void)
{
    misc_deregister(&misc);
    printk ("%s UNloaded  ---===>>>\n",DEVICE_NAME);
 
}
 
module_init(dev_init);
module_exit(dev_exit);
 
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("GPIO control for  My 2440 Board");