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

int __init demo_init(void){
    printk(KERN_INFO,"----%s---%s---%d---",__FILE__,__func__,__LINE__);
    return 0;
}

void __exit demo_exit(void){
 printk("----%s---%s---%d---",__FILE__,__func__,__LINE__);
}

module_init(demo_init);
module_exit(demo_exit);
MODULE_LICENSE("GPL");

struct cdev{
   struct module *owner;//THIS_MODULE
   const struct file_operations *ops;
   dev_t dev;  //设备号
   unsigned int count;  //设备个数
   struct list_head list;  
}

#define Demo_RETURN_SUCCESS 0
#define Demo_RETURN_FAILED 1 
#define Demo_DEV_NAME "Demo"
#define Demo_CLASS_NAME "Demo_class"
#define Demo_COUNT 1

struct Demo_Dev {
    dev_t DemoDevId;
    struct cdev DemoCdev;
    struct class *DemoClass;
    struct device *DemoDevice;
    int major;
    int minor;
};

struct Demo_Dev DemoDev; 

static ssize_t Demo_read  (struct file *filp, char __user *buf, size_t cnt, loff_t * offet) {

    return Demo_RETURN_SUCCESS;
}
static ssize_t Demo_write (struct file *filp, const char __user *buf, size_t cnt, loff_t *offet){

    return Demo_RETURN_SUCCESS;
}
static int Demo_open (struct inode *inodep, struct file *filep){

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

    return Demo_RETURN_SUCCESS;
}
static int Demo_release (struct inode *inodep, struct file *filep){
    
    printk("%s %s line %d\r\n",__FILE__,__func__,__LINE__);

    return Demo_RETURN_SUCCESS;
}

struct file_operations DemoFops ={
    .owner = THIS_MODULE,
    .open = Demo_open,
    .read = Demo_read,
    .write = Demo_write,
    .release = Demo_release,
};

static int __init DemoDev_init(void){
    int ret;
    printk("%s %s line %d\r\n",__FILE__,__func__,__LINE__);

    if(DemoDev.major){
        DemoDev.DemoDevId = MKDEV(DemoDev.major,0);
        if((ret = register_chrdev_region(DemoDev.DemoDevId,Demo_COUNT,Demo_DEV_NAME)) < 0)
            {
                printk("%s %s line %d\r\n",__FILE__,__func__,__LINE__);
                printk("faled to get dev_id\r\n");
                ret = Demo_RETURN_FAILED;
                goto err1;
            }
    }
    else{
        
        if((ret = alloc_chrdev_region(&DemoDev.DemoDevId,0,Demo_COUNT,Demo_DEV_NAME)) < 0)
            {
                printk("%s %s line %d\r\n",__FILE__,__func__,__LINE__);
                printk("faled to allocate dev_id\r\n");
                ret = Demo_RETURN_FAILED;
                goto err1;
            }
            DemoDev.major = MAJOR(DemoDev.DemoDevId);
            DemoDev.minor = MINOR(DemoDev.DemoDevId);
        printk("major id is %d, minor id is %d\r\n",DemoDev.major,DemoDev.minor);
    }

    DemoDev.DemoCdev.owner = THIS_MODULE;
    
    cdev_init(&DemoDev.DemoCdev,&DemoFops);
    cdev_add(&DemoDev.DemoCdev,DemoDev.DemoDevId,Demo_COUNT);

    DemoDev.DemoClass = class_create(THIS_MODULE,Demo_CLASS_NAME);
    if(IS_ERR(DemoDev.DemoClass)){
        ret = PTR_ERR(DemoDev.DemoClass);
        goto err2;
    }

    DemoDev.DemoDevice = device_create( DemoDev.DemoClass, NULL , DemoDev.DemoDevId, NULL ,Demo_DEV_NAME);
    if(IS_ERR(DemoDev.DemoDevice)){
        ret = PTR_ERR(DemoDev.DemoDevice);
        goto err3;
    }

    printk("HELLO Demo TEST DRIVER\r\n");
    return Demo_RETURN_SUCCESS;

err3:
    class_destroy(DemoDev.DemoClass);
err2:
    cdev_del(&DemoDev.DemoCdev);
    unregister_chrdev_region(DemoDev.DemoDevId,Demo_COUNT);
err1:
    printk("Demo TEST DRIVER FAILED\r\n");
    return ret;
}
static void __exit DemoDev_exit(void){
    printk("%s %s line %d\r\n",__FILE__,__func__,__LINE__);
    
    cdev_del(&DemoDev.DemoCdev);
    
    unregister_chrdev_region(DemoDev.DemoDevId,Demo_COUNT);
    
    device_destroy(DemoDev.DemoClass,DemoDev.DemoDevId);
    
    class_destroy(DemoDev.DemoClass);

    printk("BYE Demo TEST DRIVER\r\n");
}
module_init(DemoDev_init);
module_exit(DemoDev_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Jiang Di");
MODULE_DESCRIPTION("Demo Test Driver Module");

unsigned long copy_from_user(void *to, const void __user *from, unsigned long count);

unsigned long copy_to_user(void __user *to,const void *from,unsigned long count);

int  val;
get_user(val, (int *)arg);

put_user(val,(int *)arg)

dev_t devid;
struct cdev cdev;
struct class *class;
struct device *device;
int major;
int minor;
/*
创建设备结构体
*/
struct test_dev{
   dev_t devid;
   struct cdev cdev;
   struct class *class;
   struct device *device;
   int major;
   int miror;
};
struct test_dev testdev;
static int test_open(struct inode *inode,struct file *filep){
   filp->private_data = &testdev;
}

struct device_node *nd;
struct property *ppro;
char *str;
u32 def_value;

nd = of_find_node_by_path("/");
if(nd  == NULL){
   ret = -EINVAL;
   goto fail_findnd;
}

ppro = of_find_property(nd,"compatible",NULL);
if(ppro  == NULL){
   ret = -EINVAL;
   goto fail_findpro;
}
else{

   printk("compitable value is %s",ppro->values);
}

ret = of_property_read_string(nd,"status",str);
if(ret < 0){
   goto fail_rs;
}

ret = of_property_read_u32(nd,"",&def_value);
if(ret < 0){
   goto faile_read32;
}
   return 0;


fail_read32:
fail_rs:
fail_findppro:
fail_findnd:
   return ret;

/*request irq*/
int request_irq(unsigned int irq, irq_handler_t handler,unsigned long flags, const char *name , void *dev);

/*free irq*/
void free_irq(unsigned int irp, void *dev_id);

void xxx_do_tasklet(unsigned long);
DECLARE_TASKLET(xxx_tasklet , xxx_do_tasklet , 0);

void xxx_do_tasklet(unsigned long){

}
/* */
irqreturn_t xxx_interrupt(int irq, void *dev_id){
      tasklet_schedule(&xxx_tasklet);
}

int __init xxx_init(void){

   result = request_irq(xxx_irq, xxx_interrupt,0,"xxx",NULL);

   return IRQ_HANDLED;
}
void __exit xxx_exit(void){

   free_irq(xxx_irq,xxx_interrupt);
}

struct work_struct xxx_wq;
void xxx_do_work(struct work_struct *work);

void xxx_do_work(struct work_struct *work){

}
irqreturn_t xxx_interrupt(int irq , void *dev_id){
   schedule_work(&xxx_wq);

   return IRQ_HANDLED;
}
__init int xxx_init(void){
   result = request_irq(xxx_irq,xxx_interrupt,0,"xxx",NULL);

   INIT_WORK(&xxx_wq,xxx_do_work);

}

__exit void xxx_exit(void){
   free_irq(xxx_irq,xxx_interrupt);
}

static int xxx_probe(struct platform_devie *pdev){

}
static int xxx_remove(struct platform_device *pdev){

}
static struct platform_driver xxx_driver = {
   .driver = {
      .name = "xxx"
      .owner = THIS_MODULE,
   }
   .probe = xxx_probe,
   .remove = xxx_remove,
};
module_platform_driver(xxx_driver);

/**/
static struct platform_device xxx_device = {
   .name = "xxx",
   .id   = -1.
};

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

struct input_dev *inputdev;
static int __init xxx_init(void){
   inputdev = input_allocate_device();
   inputdev->name = "test_inputdev";
   /*设置时间和时间值*/
   /*ops*/
   /******/


   input_register_device(inputdev);
   return 0;
}
static void __exit xxx_exit(void){
   input_unregister_device(inputdev);
   input_free_device(inputdev);
}

input_events(struct input_dev *dev, unsigned type , unsigned int code,int value);
/*
type  -  上报的事件类型(EV_KEY)  u16
code  -  事件码（KEY_0 KEY1 KEY_2) u16
value -  事件值( 1 /0)  u32
*/
input_sync(struct input_dev *dev);

#inlucde <linux/input.h>
static struct input_event inputevent;

int fd;
fd = open("filename",O_RDWD);
while(1){
   err = read(fd, &inputevent, sizeof(inputevent));
   if(err > 0){
      switch (inputevent.type){
         case EV_KEY:
            if(inputevent.code < BTN_MISC){
               printf("key %d %s \r\n",inputevent.code,inputevent.value ? "perss" : "release");
            }
            else {
               printf("button %d %s \r\n" inputevent.code,inputevent.value ? "perss : "release");
            }
            break;

            case EV_REL:
               break;
            case EV_ABS :
               break;
            case EV_MSC :
               break;
      }
   }
   else {
      printf("failed read\r\n");
   }
   return 0;
}

#define MISCxxx_Name    "xxx"

#define MISCxxx_MINOR   x

static int xxxx_open(struct inode *inode, struct file *filp){
   return 0;
}

static ssize_t xxxx_write(struct file *filp,const char __user *buf, size_t cnt, loff_t *offt){
   return 0;
}

static struct file_operations miscxxx_fops = {
   .owner = THIS_MODULE,
   .open = miscxxx_open,
   .write = miscxxx_write,
}
static struct miscdevice xxx_miscdev =  {
   .minor = MISCxxx_MINOR,
   .name = MISCxxx_NAME,
   .fops = &miscxxx_fops,
}
static int miscxxx_probe(struct platform_device *dev){
   int ret = 0;

   ret = misc_register(xxx_miscdev);
   if(ret < 0){
      printk("misc device register failed\r\n");
      return -EFAULT;
   }

   return 0;
}
static int miscxxx_remove(struct platform_device *dev){
   misc_deregister(&xxx_miscdev);
   return 0;
}
static const struct of_device_id xxx_of_match[] = {
   {  .compatible = "xxxxxxxx"},
   {  /* Sentinel */},
}

static struct platform_driver xxx_driver = {
   .driver = {
      .name = "driver_xxxx",
      .of_match_table = xxx_of_match,
   },
   .probe = miscxxx_probe,
   .remobe = miscxxx_remove,
}
static int __init miscxxx_init(void){
   
   return platform_driver_register(&xxx_driver);

}
static void __exit miscxxx_exit(void){
   platform_driver_unregister(&xxx_driver);
}

module_init(miscxxx_init);
module_exit(miscxxx_exit);
MODULE_LICENSE("GPL");
MODULE_AUTHOR("JiangDi");

static int xxx_probe(struct i2c_client *client, const struct i2c_device_id *id)
{
   /*ops*/

   return 0;
}

static int xxx_remove(struct i2c_client *client){
   /*ops*/

   retrun 0;
}

static const struct i2c_device_id xxx_id[] = {
   {"xxx",0},
   {  }
}
static const struct of_device_id xxx_of_match[] = {
   {  .compatible = ""},
   {  /* Sentinel */}
}
static struct i2c_driver xxx_driver = {
   .probe = xxx_probe,
   .remove = xxx_remove,
   .driver = {
      .owner = THIS_MODULE,
      .name = "xxx",
      .of_match_table = xxx_of_match,
   },
   .id_table = xxx_id,
}

static int __init xxx_init(void){
   int ret = 0;

   ret = i2c_add_driver(&xxx_driver);

   return ret;
}
static void __exit xxx_exit(void){
   i2c_del_driver(&xxx_driver);
}
module_init(xxx_init);
module_exit(xxx_exit);

static int xxx_probe(struct spi_device *spi){
   return 0;
}

static int xxx_remove(struct spi_device *spi){

   /*ops*/

   return 0;
}

static const struct spi_device_id xxx_id[] = {
   {"xxx",0},
   {}

};
static const struct of_device_id xxx_of_match [] = {
   {.compatible = "xxxx"},
   {  /* Sentinel */}
};

static struct spi_driver xxx_driver = {
   .probe = xxx_probem,
   .remove = xxx_remove,
   .driver = {
      .owner = THIS_MODULE,
      .name = "xxx",
      .of_match_table = xxx_of_match,
   },
   .id_table = xxx_id,
};

static int __init xxx_init(void){
   return spi_register_driver(&xxx_driver);

}

static void __exit xxx_exit(void){
   spi_unregister_driver(&xxx_driver);
}
module_init(xxx_init);
module_exit(xxx_exit);

void main(void){
   int ret , fd;
   fd_set readfds;
   struct timeval teimout;
   fd = open("dev_xxx", O_RDWR | O_NONBLOCK);
   FD_ZERO(&readfds);
   FD_SET(fd, &readfds);

   timeout.tv_set  = 0;
   timeout.tv_usec = 500000;

   ret = select (fd + 1 ， &readfds,NULL,NULL,&timeout);
   switch(ret){
      case 0 :
         printf("timeout \r\n");
         break;
      case -1 :
         printf("error\r\n");
      default :
         if(FD_ISSET(fd,&readfds)){
            /*ops*/
         }
         break;
   }
}

void main(void){
   int ret;
   int fd;
   struct pollfd fds;

   fd = open(filename , O_RDWR | O_NONBLOCK);
   fds.fd = fd;
   fds.events = POLLIN;
   ret = poll(&fds , 1 ,500);
   if(ret){
      /*read ops*/
   }
   else if(ret == 0){
      /* time out*/
   }
   else if(ret < 0){
      /* error */
   }
}