struct input_dev{ //代表输入设备,会加到全局input_dev队列
  const char *name;
}
struct input_handler{//代表输入设备的处理方法,会加到全局input_handler队列

}
struct input_handle{//用来关联某个input_dev和某个input_handler

}
//一个input_dev可有多个input_handler:鼠标可有按键事件evdev和移动事件mousedev
//一个input_handler可以用于多个输入设备：比如按键evdev可用于鼠标和键盘

input_table[8]
input_handler_list

input_register_handler(&evdev_handler->handler)
  INIT_LIST_HEAD(&handler->h_list)
  input_table[handler->minor>>5] = handler
  list_add_tail(&handler->node,&input_handler_list)
  list_for_each_entry(dev,&input_dev_list, node)
    input_attach_handler(dev,handler)//遍历执行
      input_match_device(handler,dev)
        if handler->id_table[i].flag & xx
          handler->id_table[i].bustype == dev->id.bustype
          handler..evbit[] == dev..evbit[]
          ...
          return id->struct input_device_id *id
      handler->connect(handler,dev,id) //evdev_connect

evdev_connect(struct input_handler *handler,struct input_dev *dev, const struct input_device_id *id)
  //找evdev_table[]中首个未使用的下标minor
  evdev = kzmalloc()
  INIT_LIST_HEAD(&evdev->client_list)
  dev_set_name(&evdev->dev,"event%d",minor)
  evdev->exist=true
  evdev->minor=minor
  evdev->handle.dev=input_get_device(dev)
  evdev->handle.name=dev_name(&evdev->dev)
  evdev->handle.handler=handler
  evdev->handle.private=evdev
  evdev->dev.devt=MKDEV(INPUT_MAJOR,EVDEV_MINOR_BASE+minor)
  evdev->dev.class=&input_class
  evdev->dev.parent=&dev->dev
  evdev->dev.release=evdev_free
  device_initialize(&evdev->dev)
  input_register_handle(&evdev->handle)
    struct input_handler *handler=handle->handler
    struct input_dev *dev=handle->dev
    list_add_tail_rcu(&handle->d_node,&dev->h_list)
    list_add_tail_rcu(&handle->h_node,&handler->h_list)
    if(handler->start) handler->start(handle)
  evdev_install_chrdev(evdev)
    evdev_table[evdev->minor]=evdev
  device_add(&evdev->dev)//创建设备节点

应用层对设备节点读，就会调用到
evdev_read(struct file *file,char __user *buffer, size_t count, loff_t *ppos)
  struct evdev_client *client = file->private_data;
  struct evdev *evdev = client->evdev;
  struct input_event event;
  if(BLOCK) wait_event_interruptible(evdev->wait,client->packet_head!=client->tail||!evdev->exist)
  while ... evdev_fetch_next_event(client,&event)
    input_event_to_user(buffer+retval,&event)
    retval+=input_event_size()


evdev_open(struct inode *inode,struct file *file)

struct device platform_bus = {
    .init_name = "platform",
};
struct bus_type platform_bus_type = {
    .name = "platform",
    .dev_attrs=platform_dev_attrs,
    .match = platform_match,
    .uevent = platform_uevent,
    .pm = &platform_dev_pm_ops,
};
stat_kernel()
  rest_init()
    kernel_thread(kernel_init...)
    kernel_init
      do_basic_setup()
        driver_init()
          platform_bus_init()
            device_register(&platform_bus) //注册总线设备
            bus_register(&platform_bus_type) //注册总线
            //至此虚拟总线已经注册成功，可以用它来管理设备和驱动了

struct resources{
  resource_size start;//资源起始地址
  resource_size end;//资源结束地址
  const char *name;
  ulong flags; //IO资源还是内存资源还是中断资源
  struct resources *parent, *sibling, *child;
}
struct platform_device{
    const char *name;
    int id;
    struct device dev;//描述设备的基类
    u32 num_resources;//资源数组长度
    struct resources *resources;//资源数组
    const struct platform_device_id *id_entry;//某种匹配方式用到的
    ...
}

struct platform_driver{
  int (*probe)(struct platform_device *);
  int (*remove)(struct platform_device* );
  shutdown,suspend,resume
  struct device_driver driver;
  const struct platform_device_id *id_table;//某种匹配方式用到的
}

//在你的驱动内初始化struct platform_device *pdev，调用该函数
platform_device_register(struct platform_device *pdev)
  platform_device_add(pdev);
    pdev->dev.parent = &platform_bus;//设置其父类为
    pdev->dev.bus = &platform_bus_type;//设置其所属总线
    //至此pdev已经挂到虚拟总线上了
    device_add(&pdev->dev); //把pdev注册到内核

//在你的驱动内初始化struct platform_driver *drv，调用该函数
platform_driver_register(struct platform_driver *drv)
  drv->driver.bus = &platform_bus_type;//设置其所属总线
  drv->driver.probe = platform_drv_probe;
  drv->driver.remove = platform_drv_remove;
  dirver_register(&drv->dirver);//把drv注册到内核
    bus_add_driver(&drv->dirver)
      dirver_attach(&drv->dirver)
        bus_for_each_dev(drv->bus, NULL, &drv->driver, __driver_attach)//遍历全部dev，执行__driver_attach(dev,&drv->driver)
          __driver_attach(dev, drv)
            if(!driver_match_device(drv,dev)) return 0; //调用platform_match,失败就返回
            driver_probe_device(drv, dev)
              really_probe(dev,drv)
                dev->driver = drv;
                drv->probe(dev) //platform_drv_probe(struct device *_dev)


platform_match(struct device *dev, struct device_driver *drv)
  struct platform_device *pdev = to_platform_device(dev);
  struct platform_driver *pdrv = to_platform_driver(drv);
  if(pdrv->id_table){ return platform_match_id(pdrv->id_table, pdev); }
  return (strcmp(pdev->name, drv->name) == 0);

platform_drv_probe(struct device *_dev)
  struct platform_driver *drv = to_platform_ddriver(_dev->driver);
  struct platform_device *dev = to_platform_device(_dev);
  drv->probe(dev);



//驱动代码

int charDrvInit(void)
{
  platform_device_register(&s3c_device_lcd);
  platform_driver_register(&s3c2410led_driver);
}
void __exit charDrvExit(void)
{
  platform_device_unregister(&s3c_device_lcd);
  platform_driver_unregister(&s3c2410led_driver);
}

extern void asm_irq(void);
void irq_init(void){
#if 0    //方案1：直接把指令内容放到寄存器，中断来之后cpu直接执行该指令(无法工作)
    unsigned int tmp;
    tmp = *((unsigned int *)asm_irq); //把asm_irq地址的4字节内容赋值给tmp（也就是把指令赋值给tmp）
    pEXECEPTION_IRQ = tmp; //把指令赋值给该寄存器，当发生中断，该寄存器内的指令被cpu执行
#else   //方案2：把地址放到寄存器，中断来之后cpu读出该地址的指令来执行
    pEXECEPTION_IRQ = (unsigned int)asm_irq;
#endif
}

void irq_c_handler(void){
    myputs("irq_c_handler\n");
    if(VIC0IRQSTATU|VIC1IRQSTATUS|VIC2IRQSTATUS|SVIC3IRQSTATUS){ }
    void (*handler)(void) = NULL;
    handler = (void (*)(void))VIC0ADDRESS; //handler的值应该就是key1_handler
    if(handler) handler();
}
void key1_handler(void){
    myputs("key1_handler\n");
    set EXT_INT_2_PENDING[0] = 1; //清除中断源控制器的pending位EXT_INT[16]。pending:用于多个中断源同时发生，pending寄存器就暂存中断信号，等cpu处理完一个之后将其取消，接着处理下一个中断源
    set VIC0ADDRESS = 0; //清除中断主控制器的pending
}

void key_init(void)
{
    //1.对引脚进行功能选择，把GPH2.0引脚配置为中断 EXT_INT[16]
    set GPH2.CON[3:0] = 1111;

    //配置中断源(extern)控制器 extern interrupt controller register
    set EXT_INT_2_CON[2:0] = 0b010; //上升沿触发EXT_INT[16]
    set EXT_INT_2_MASK[0] = 0b0; //取消屏蔽EXT_INT[16]，让中断可以去到主中断控制器

    //配置中断主控制器
    set VIC0INTENABLE[16] = 1; //使能接受中断EXT_INT[16],若想禁用 set VIC0INTENCLEAR[16] = 1;
    VIC0VECTORADDR16 = key1_handler; //把处理函数的地址放到寄存器里面,当发生中断时，该地址会被cpu写到VIC0ADDRESS里面
}

int main(void)
{
    irq_init();
    key_init();
    while(1);
    return 0;
}