杂项设备，是字符设备中的特殊，它的主设备号，是 10，不同的杂项设备，通过次设备号进行区分。

1、注册与注销

int misc_register(struct miscdevice * misc)

完成杂项设备的注册，

int misc_deregister(struct miscdevice *misc)

可见，设备的注册和注销，都是设置到 struct miscdevice  结构体

2、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;
    const char *nodename;
    mode_t mode;
};

结构体中，name 是注册的名字，以后将会在 /dev 目录下，进行显示的 name，里面最主要的是 struct file_operations ，在注册杂项设备的时候，字符设备的结构体与杂项设备进行绑定，

minor 为 MISC_DYNAMIC_MINOR 的时候，miscdevice 核心层会自动寻找一个空闲的次设备号，

3、杂项设备与字符设备驱动

杂项设备，本质上就是字符设备驱动，只不过是一个特殊一点的。杂项设备的主设备号，被固定在 10，通过次设备号进行区分设备。杂项设备注册之后，在 /dev/ 目录下就有 name 设备节点，在 /sys/clas/misc 下面，也会自动生成的类信息，因此，一定程度上，比标准的的字符设备驱动简单了一丢丢。

4、流程

    struct const file_operations xxxx_fops = {

    .unlock_ioctl = xxx_ioctl,

     xxxx

};

    struct miscdevice xxx_dev = {

    .minor = MISC_DYNAMIC_MINOR,

    .name = “xxx”,

    .fops = xxxx_fops

};

static int __init xxx_init()

{

    return misc_register(&xxx_dev );

}

void __exit xxx_exit()

{

    return misc_deregister(&xxx_dev) ;

}

当调用 misc_register(&xxx_dev ); 的时候，会在 misc_open 的帮助下，实现将 xxx_dev 成为 file 的private_data，也就是 系统会帮助我们实现 file->private_data = xxx_dev .

二、总线平、设备、驱动

在实际的编程中，最希望的是，一套支持，可以支持一类所有的设备，比如 同一套 DM9000 驱动，可最好是满足在不同板子上运行，所以为了达到目标，就提出了总线、设备、驱动软件架构。

驱动编写代码中，有一些信息是关于设备的相关信息，比如 IO 地址，内存资源地址，其余的是对这些设备的操作，所以，就将这些对应的设备的信息进行提取到一个文件，设备文件，它只做对不同设备的资源进行定义，不同的平台就单独设置不同的设备文件。

驱动则只管对设备的操作。

总线，主要是完成 设备 与 驱动的配合。总线、设备、驱动 的 软件架构，就可以使得驱动四海皆准了。

在系统注册设备的时候，总线就会根据设备的信息去匹配对应的设备；同理，驱动注册的时候，总线也会根据驱动的信息进行运行匹配的设备，当找到对应的驱动或者设备的时候，就会调用驱动文件的 probe 函数。

2.1、platform_device 与 platform_driver

因为提出了总线、设备、驱动这种软件架构，Linux就虚构了虚拟的总线，称之为 platform 总线，设备称之为 platform_device,驱动则成为 platform_driver。

platform_device  有对应的结构体，

struct platform_device {
    const char    * name;     // 设备名字
    int        id;
    struct device    dev;    // 设备
    u32        num_resources;
    struct resource    * resource;   // 资源

    const struct platform_device_id    *id_entry;

    /* MFD cell pointer */
    struct mfd_cell *mfd_cell;

    /* arch specific additions */
    struct pdev_archdata    archdata;
};

platform_driver  结构体，我们只需要注意的是 设备的名字，以及设备的资源。

struct platform_driver {
    int (*probe)(struct platform_device *);     // probe
    int (*remove)(struct platform_device *);   // 删除
    void (*shutdown)(struct platform_device *);
    int (*suspend)(struct platform_device *, pm_message_t state);
    int (*resume)(struct platform_device *);
    struct device_driver driver;
    const struct platform_device_id *id_table;     // 平台设备的 ID，
};

platform_driver  结构体的地位 和 i2c_driver、spi_driver 、usb_driver, pci_driver 相等。所以说，在实现 I2C 驱动的时候，就可以使用 i2c_driver，当然可以是 platform_driver 。

设备与驱动的匹配主要是通过设备名字的方式实现的：

struct platform_device  里面的注册一个 一个 name，指定的是 device 的名字；struct platform_driver 里面的const struct platform_device_id *id_table 表，则是注册了驱动支持的不同设备的名字，正是对两个名字进行了匹配，匹配成功之后，就会调用 driver 端 的probe 函数。一般是在里面是  probe 里面，完成新的字符设备驱动的操作。

2.2、device 的注册

当 新建了platform_device  结构体（也可以是新建了一个指针， 再通过platform_device_alloc 接口实现 ），完成了资源和名字的设置之后，需要将这个 device 注册到内核。

设备注册进内核：

platform_device_add(struct platform_device *pdev)

设备从内核取消：

 platform_device_unregister(struct platform_device * pdev)

2.3、driver 的注册

struct platform_driver  里面的 id_table 指定了设备的名字，当总线完成名字的匹配之后，就会调用 driver 端的 probe 函数，一般是在 probe 函数里面完成注册，注册的实现，一般也是注册为字符设备驱动，或者杂项设备。

3.、device 资源、driver 获取资源

struct resource {
    resource_size_t start;
    resource_size_t end;
    const char *name;
    unsigned long flags;
    struct resource *parent, *sibling, *child;
};

device 结构体 里面，的resource 结构体实现了对设备资源的描述。一般上，只需要关心 start、end、flags。

start： 设备资源的开始值

end ： 设备资源的结束值

flags ： 设备资源类型的标志。IORESOURCE_IO   IORESOURCE_MEM IORESOURCE_IRQ IORESOURCE_DMA

当 flag 是 IORESOURCE_MEM  的时候，start 就是内存的开始地址，end 就是内存资源的结束地址。

flag 是 IORESOURCE_IRQ  的时候，start 和 end 就是中断号的开始值和结束值。如果只是一个中断的话，那么开始值和结束值就是相同的。

device 定了硬件相关的板级资源，所以 driver 端，就应该在需要获取板级资源的时候，去获取相关的设备资源，driver 是通过这个接口去实现 相匹配的 device 端的资源：

 platform_get_resource(struct platform_device * dev,unsigned int type,unsigned int num)

去 device 获取 type 类型指定的资源。

如果是获取 irq 的资源的话，也可以使用直接封装的接口：

  platform_get_irq(struct platform_device * dev,unsigned int num) 

4、代码

借助宋宝华的 Linux设备驱动开发详解的代码，

4.1、device

static struct platform_device *globalfifo_pdev;     // 指针

static int __init globalfifodev_init(void)
{
    int ret;

    globalfifo_pdev = platform_device_alloc("globalfifo", -1);   // 分配一个  device ，指定了名字
    if (!globalfifo_pdev)
        return -ENOMEM;

    ret = platform_device_add(globalfifo_pdev);   // 将 device 注册进 总线
    if (ret) {
        platform_device_put(globalfifo_pdev);
        return ret;
    }

    return 0;

}
module_init(globalfifodev_init);

static void __exit globalfifodev_exit(void)
{
    platform_device_unregister(globalfifo_pdev);      // 将 device 从总线进行注销

}
module_exit(globalfifodev_exit);

4.3、driver

static int globalfifo_probe(struct platform_device *pdev)
{

    ret = misc_register(miscdev);    // 杂项设备的注册
    if (ret < 0)
        goto err;
}

static int globalfifo_remove(struct platform_device *pdev)
{ 

    misc_deregister(miscdev);   // 注销

    return 0;
}

static struct platform_driver globalfifo_driver = {
    .driver = {
        .name = "globalfifo",   // 名字
        .owner = THIS_MODULE,
    },
    .probe = globalfifo_probe,   // 名字匹配成功，就调用 probe 函数
    .remove = globalfifo_remove,
};

module_platform_driver(globalfifo_driver);   // 平台设备 driver 入口