android sensors 总结(三)

3 sensor driver

 

相关结构体

//Sensor device 抽象

struct hwmdev_object {

         structinput_dev   *idev;

         structmiscdevice   mdev;

         structdev_context *dc;

         structwork_struct  report;

         atomic_t            delay; /*polling period for reportinginput event*/

         atomic_t            wake;  /*user-space request to wake-up, used withstop*/

         structtimer_list   timer;  /* polling timer */

         atomic_t            trace;

         uint32_t                     active_sensor;                            // Active, buthwmsen don't need data sensor.                                                                                         //Maybeother need it's data.

         uint32_t                     active_data_sensor;                 // Active and hwmsen need datasensor.

         //addfor fix resume issue

         structearly_suspend    early_drv;

         structwake_lock        read_data_wake_lock;

         atomic_t                early_suspend;

         //addfor fix resume end

};

 

struct dev_context {

   int              polling_running;

   struct mutex lock;

   struct hwmsen_context* cxt[MAX_ANDROID_SENSOR_NUM+1];

};

 

struct hwmsen_context { /*sensor context*/

         atomic_t                enable;

         atomic_tdelay;

         uint32_tdelayCountSet;

         uint32_tdelayCount;

        

         structhwmsen_object    obj;

};

 

/*------------sensorsdata----------------------------------------------------*/

typedef struct {

         /*sensor identifier */

         int  sensor;

         /*sensor values */

         int    values[3];

         /*sensor values divide */

         uint32_tvalue_divide;

         /*sensor accuracy*/

         int8_tstatus;

         /*whether updata? */

         int    update;

         /*time is in nanosecond */

         int64_t     time;

 

         uint32_t   reserved;

}hwm_sensor_data;

 

typedef struct {

         hwm_sensor_datadata[MAX_ANDROID_SENSOR_NUM];

         intdate_type;

}hwm_trans_data;

 

 

static int hwmsen_probe(structplatform_device *pdev)

{

 

         interr;

         //HWM_LOG("+++++++++++++++++hwmsen_probe!!\n");

 

         HWM_FUN(f);

         init_static_data();  

         hwm_obj= hwmsen_alloc_object();        //alloc& init hwmsensor obj

         if(!hwm_obj)

         {

                   err= -ENOMEM;

                   HWM_ERR("unableto allocate devobj!\n");

                   gotoexit_alloc_data_failed;

         }

 

         hwm_obj->idev= input_allocate_device();      //alloc inputdevice

         if(!hwm_obj->idev)

         {

                   err= -ENOMEM;

                   HWM_ERR("unableto allocate input device!\n");

                   gotoexit_alloc_input_dev_failed;

         }

 

         set_bit(EV_REL,hwm_obj->idev->evbit);

         set_bit(EV_SYN,hwm_obj->idev->evbit);

 

         input_set_capability(hwm_obj->idev,EV_REL, EVENT_TYPE_SENSOR);         ///setevent type

         hwm_obj->idev->name= HWM_INPUTDEV_NAME;

         if((err= input_register_device(hwm_obj->idev)))                      ///

         {

                   HWM_ERR("unableto register input device!\n");

                   gotoexit_input_register_device_failed;

         }

         input_set_drvdata(hwm_obj->idev,hwm_obj);

 

         hwm_obj->mdev.minor= MISC_DYNAMIC_MINOR;

         hwm_obj->mdev.name  = HWM_SENSOR_DEV_NAME;

         hwm_obj->mdev.fops  = &hwmsen_fops;

         if((err= misc_register(&hwm_obj->mdev)))                      //注册为一个杂项设备，提供ops

         {

                   HWM_ERR("unableto register sensor device!!\n");

                   gotoexit_misc_register_failed;

         }

         dev_set_drvdata(hwm_obj->mdev.this_device,hwm_obj);

 

         //add for fix resume bug

   atomic_set(&(hwm_obj->early_suspend), 0);

         hwm_obj->early_drv.level    = EARLY_SUSPEND_LEVEL_STOP_DRAWING - 1,

         hwm_obj->early_drv.suspend  = hwmsen_early_suspend,

         hwm_obj->early_drv.resume   = hwmsen_late_resume,   

         register_early_suspend(&hwm_obj->early_drv);

         wake_lock_init(&(hwm_obj->read_data_wake_lock),WAKE_LOCK_SUSPEND,"read_data_wake_lock");

         //add for fix resume bug end

         return0;

 

         exit_hwmsen_create_attr_failed:

         exit_misc_register_failed:   

//      exit_get_hwmsen_info_failed:

         exit_input_register_device_failed:

         input_free_device(hwm_obj->idev);

        

         exit_alloc_input_dev_failed:   

         kfree(hwm_obj);

        

         exit_alloc_data_failed:

         returnerr;

}

 

static void hwmsen_poll(unsigned long data)

{

         structhwmdev_object *obj = (struct hwmdev_object *)data;

         if(obj!= NULL)

         {

                   queue_work(sensor_workqueue,&obj->report);

         }

}

 

static struct hwmdev_object*hwmsen_alloc_object(void)

{

        

         structhwmdev_object *obj = kzalloc(sizeof(*obj), GFP_KERNEL);

         HWM_FUN(f);

        

         if(!obj)

         {

                   HWM_ERR("Allochwmsen object error!\n");

                   returnNULL;

         }       

 

         obj->dc= &dev_cxt;

         obj->active_data_sensor= 0;

         obj->active_sensor= 0;

         atomic_set(&obj->delay,200); /*5Hz*/// set work queue delay time 200ms

         atomic_set(&obj->wake,0);

         sensor_workqueue= create_singlethread_workqueue("sensor_polling");

         INIT_WORK(&obj->report,hwmsen_work_func);

         init_timer(&obj->timer);

         obj->timer.expires   = jiffies + atomic_read(&obj->delay)/(1000/HZ);

         obj->timer.function = hwmsen_poll;

         obj->timer.d