4 static struct alsps_context
*alsps_context_obj
= NULL
;
7 static struct alsps_init_info
* alsps_init_list
[MAX_CHOOSE_ALSPS_NUM
]= {0}; //modified
8 static void alsps_early_suspend(struct early_suspend
*h
);
9 static void alsps_late_resume(struct early_suspend
*h
);
12 int als_data_report(struct input_dev
*dev
, int value
, int status
)
14 //ALSPS_LOG("+als_data_report! %d, %d\n",value,status);
15 input_report_abs(dev
, EVENT_TYPE_ALS_VALUE
, value
);
16 input_report_abs(dev
, EVENT_TYPE_ALS_STATUS
, status
);
21 int ps_data_report(struct input_dev
*dev
, int value
,int status
)
23 //ALSPS_LOG("+ps_data_report! %d, %d\n",value,status);
24 input_report_abs(dev
, EVENT_TYPE_PS_VALUE
, value
);
25 input_report_abs(dev
, EVENT_TYPE_PS_STATUS
, status
);
30 static void als_work_func(struct work_struct
*work
)
33 struct alsps_context
*cxt
= NULL
;
35 //hwm_sensor_data sensor_data;
41 cxt
= alsps_context_obj
;
43 if(NULL
== cxt
->als_data
.get_data
)
45 ALSPS_LOG("alsps driver not register data path\n");
49 time
.tv_sec
= time
.tv_nsec
= 0;
50 time
= get_monotonic_coarse();
51 nt
= time
.tv_sec
*1000000000LL+time
.tv_nsec
;
53 //add wake lock to make sure data can be read before system suspend
54 err
= cxt
->als_data
.get_data(&value
,&status
);
58 ALSPS_ERR("get alsps data fails!!\n" );
64 cxt
->drv_data
.als_data
.values
[0] = value
;
65 cxt
->drv_data
.als_data
.status
= status
;
66 cxt
->drv_data
.als_data
.time
= nt
;
71 if(true == cxt
->is_als_first_data_after_enable
)
73 cxt
->is_als_first_data_after_enable
= false;
75 if(ALSPS_INVALID_VALUE
== cxt
->drv_data
.als_data
.values
[0] )
77 ALSPS_LOG(" read invalid data \n");
82 //report data to input device
83 //printk("new alsps work run....\n");
84 //ALSPS_LOG("als data[%d] \n" ,cxt->drv_data.als_data.values[0]);
86 als_data_report(cxt
->idev
,
87 cxt
->drv_data
.als_data
.values
[0],
88 cxt
->drv_data
.als_data
.status
);
91 if(true == cxt
->is_als_polling_run
)
94 mod_timer(&cxt
->timer_als
, jiffies
+ atomic_read(&cxt
->delay_als
)/(1000/HZ
));
100 static void ps_work_func(struct work_struct
*work
)
103 struct alsps_context
*cxt
= NULL
;
105 //hwm_sensor_data sensor_data;
106 int value
,status
,div
;
108 struct timespec time
;
111 cxt
= alsps_context_obj
;
113 if(NULL
== cxt
->ps_data
.get_data
)
115 ALSPS_LOG("alsps driver not register data path\n");
119 time
.tv_sec
= time
.tv_nsec
= 0;
120 time
= get_monotonic_coarse();
121 nt
= time
.tv_sec
*1000000000LL+time
.tv_nsec
;
123 //add wake lock to make sure data can be read before system suspend
124 err
= cxt
->ps_data
.get_data(&value
,&status
);
128 ALSPS_ERR("get alsps data fails!!\n" );
134 cxt
->drv_data
.ps_data
.values
[0] = value
;
135 cxt
->drv_data
.ps_data
.status
= status
;
136 cxt
->drv_data
.ps_data
.time
= nt
;
141 if(true == cxt
->is_ps_first_data_after_enable
)
143 cxt
->is_ps_first_data_after_enable
= false;
145 if(ALSPS_INVALID_VALUE
== cxt
->drv_data
.ps_data
.values
[0])
147 ALSPS_LOG(" read invalid data \n");
152 //report data to input device
153 //printk("new alsps work run....\n");
154 //ALSPS_LOG("alsps data[%d,%d,%d] \n" ,cxt->drv_data.alsps_data.values[0],
155 //cxt->drv_data.alsps_data.values[1],cxt->drv_data.alsps_data.values[2]);
157 ps_data_report(cxt
->idev
,
158 cxt
->drv_data
.ps_data
.values
[0],
159 cxt
->drv_data
.ps_data
.status
);
162 if(true == cxt
->is_ps_polling_run
)
165 mod_timer(&cxt
->timer_ps
, jiffies
+ atomic_read(&cxt
->delay_ps
)/(1000/HZ
));
171 static void als_poll(unsigned long data
)
173 struct alsps_context
*obj
= (struct alsps_context
*)data
;
176 schedule_work(&obj
->report_als
);
180 static void ps_poll(unsigned long data
)
182 struct alsps_context
*obj
= (struct alsps_context
*)data
;
185 if(obj
->ps_ctl
.is_polling_mode
)
186 schedule_work(&obj
->report_ps
);
190 static struct alsps_context
*alsps_context_alloc_object(void)
193 struct alsps_context
*obj
= kzalloc(sizeof(*obj
), GFP_KERNEL
);
194 ALSPS_LOG("alsps_context_alloc_object++++\n");
197 ALSPS_ERR("Alloc alsps object error!\n");
200 atomic_set(&obj
->delay_als
, 200); /*5Hz*/// set work queue delay time
200ms
201 atomic_set(&obj
->delay_ps
, 200); /*5Hz*/// set work queue delay time
200ms
202 atomic_set(&obj
->wake
, 0);
203 INIT_WORK(&obj
->report_als
, als_work_func
);
204 INIT_WORK(&obj
->report_ps
, ps_work_func
);
205 init_timer(&obj
->timer_als
);
206 init_timer(&obj
->timer_ps
);
207 obj
->timer_als
.expires
= jiffies
+ atomic_read(&obj
->delay_als
)/(1000/HZ
);
208 obj
->timer_als
.function
= als_poll
;
209 obj
->timer_als
.data
= (unsigned long)obj
;
211 obj
->timer_ps
.expires
= jiffies
+ atomic_read(&obj
->delay_ps
)/(1000/HZ
);
212 obj
->timer_ps
.function
= ps_poll
;
213 obj
->timer_ps
.data
= (unsigned long)obj
;
215 obj
->is_als_first_data_after_enable
= false;
216 obj
->is_als_polling_run
= false;
217 obj
->is_ps_first_data_after_enable
= false;
218 obj
->is_ps_polling_run
= false;
219 mutex_init(&obj
->alsps_op_mutex
);
220 obj
->is_als_batch_enable
= false;//for batch mode init
221 obj
->is_ps_batch_enable
= false;//for batch mode init
223 ALSPS_LOG("alsps_context_alloc_object----\n");
227 static int als_real_enable(int enable
)
230 struct alsps_context
*cxt
= NULL
;
231 cxt
= alsps_context_obj
;
235 if(true==cxt
->is_als_active_data
|| true ==cxt
->is_als_active_nodata
)
237 err
= cxt
->als_ctl
.enable_nodata(1);
240 err
= cxt
->als_ctl
.enable_nodata(1);
243 err
= cxt
->als_ctl
.enable_nodata(1);
245 ALSPS_ERR("alsps enable(%d) err 3 timers = %d\n", enable
, err
);
248 ALSPS_LOG("alsps real enable \n" );
254 if(false==cxt
->is_als_active_data
&& false ==cxt
->is_als_active_nodata
)
256 err
= cxt
->als_ctl
.enable_nodata(0);
259 ALSPS_ERR("alsps enable(%d) err = %d\n", enable
, err
);
261 ALSPS_LOG("alsps real disable \n" );
268 static int als_enable_data(int enable
)
270 struct alsps_context
*cxt
= NULL
;
272 cxt
= alsps_context_obj
;
273 if(NULL
== cxt
->als_ctl
.open_report_data
)
275 ALSPS_ERR("no als control path\n");
281 ALSPS_LOG("ALSPS enable data\n");
282 cxt
->is_als_active_data
=true;
283 cxt
->is_als_first_data_after_enable
= true;
284 cxt
->als_ctl
.open_report_data(1);
285 if(false == cxt
->is_als_polling_run
&& cxt
->is_als_batch_enable
== false)
287 if(false == cxt
->als_ctl
.is_report_input_direct
)
289 mod_timer(&cxt
->timer_als
, jiffies
+ atomic_read(&cxt
->delay_als
)/(1000/HZ
));
290 cxt
->is_als_polling_run
= true;
296 ALSPS_LOG("ALSPS disable \n");
297 cxt
->is_als_active_data
=false;
298 cxt
->als_ctl
.open_report_data(0);
299 if(true == cxt
->is_als_polling_run
)
301 if(false == cxt
->als_ctl
.is_report_input_direct
)
303 cxt
->is_als_polling_run
= false;
304 del_timer_sync(&cxt
->timer_als
);
305 cancel_work_sync(&cxt
->report_als
);
306 cxt
->drv_data
.als_data
.values
[0] = ALSPS_INVALID_VALUE
;
310 als_real_enable(enable
);
314 static int ps_real_enable(int enable
)
317 struct alsps_context
*cxt
= NULL
;
318 cxt
= alsps_context_obj
;
322 if(true==cxt
->is_ps_active_data
|| true ==cxt
->is_ps_active_nodata
)
324 err
= cxt
->ps_ctl
.enable_nodata(1);
327 err
= cxt
->ps_ctl
.enable_nodata(1);
330 err
= cxt
->ps_ctl
.enable_nodata(1);
332 ALSPS_ERR("ps enable(%d) err 3 timers = %d\n", enable
, err
);
335 ALSPS_LOG("ps real enable \n" );
341 if(false==cxt
->is_ps_active_data
&& false ==cxt
->is_ps_active_nodata
)
343 err
= cxt
->ps_ctl
.enable_nodata(0);
346 ALSPS_ERR("ps enable(%d) err = %d\n", enable
, err
);
348 ALSPS_LOG("ps real disable \n" );
355 static int ps_enable_data(int enable
)
357 struct alsps_context
*cxt
= NULL
;
359 cxt
= alsps_context_obj
;
360 if(NULL
== cxt
->ps_ctl
.open_report_data
)
362 ALSPS_ERR("no ps control path\n");
368 ALSPS_LOG("PS enable data\n");
369 cxt
->is_ps_active_data
=true;
370 cxt
->is_ps_first_data_after_enable
= true;
371 cxt
->ps_ctl
.open_report_data(1);
372 if(false == cxt
->is_ps_polling_run
&& cxt
->is_ps_batch_enable
== false)
374 if(false == cxt
->ps_ctl
.is_report_input_direct
)
376 mod_timer(&cxt
->timer_ps
, jiffies
+ atomic_read(&cxt
->delay_ps
)/(1000/HZ
));
377 cxt
->is_ps_polling_run
= true;
383 ALSPS_LOG("PS disable \n");
384 cxt
->is_ps_active_data
=false;
385 cxt
->ps_ctl
.open_report_data(0);
386 if(true == cxt
->is_ps_polling_run
)
388 if(false == cxt
->ps_ctl
.is_report_input_direct
)
390 cxt
->is_ps_polling_run
= false;
391 del_timer_sync(&cxt
->timer_ps
);
392 cancel_work_sync(&cxt
->report_ps
);
393 cxt
->drv_data
.ps_data
.values
[0] = ALSPS_INVALID_VALUE
;
397 ps_real_enable(enable
);
401 static ssize_t
als_store_active(struct device
* dev
, struct device_attribute
*attr
,
402 const char *buf
, size_t count
)
404 ALSPS_LOG("als_store_active buf=%s\n",buf
);
405 mutex_lock(&alsps_context_obj
->alsps_op_mutex
);
406 struct alsps_context
*cxt
= NULL
;
408 cxt
= alsps_context_obj
;
410 if (!strncmp(buf
, "1", 1))
414 else if (!strncmp(buf
, "0", 1))
420 ALSPS_ERR(" alsps_store_active error !!\n");
422 mutex_unlock(&alsps_context_obj
->alsps_op_mutex
);
423 ALSPS_LOG(" alsps_store_active done\n");
426 /*----------------------------------------------------------------------------*/
427 static ssize_t
als_show_active(struct device
* dev
,
428 struct device_attribute
*attr
, char *buf
)
430 struct alsps_context
*cxt
= NULL
;
431 cxt
= alsps_context_obj
;
432 int div
=cxt
->als_data
.vender_div
;
433 ALSPS_LOG("als vender_div value: %d\n", div
);
434 return snprintf(buf
, PAGE_SIZE
, "%d\n", div
);
437 static ssize_t
als_store_delay(struct device
* dev
, struct device_attribute
*attr
,
438 const char *buf
, size_t count
)
441 mutex_lock(&alsps_context_obj
->alsps_op_mutex
);
442 struct alsps_context
*devobj
= (struct alsps_context
*)dev_get_drvdata(dev
);
445 struct alsps_context
*cxt
= NULL
;
447 cxt
= alsps_context_obj
;
448 if(NULL
== cxt
->als_ctl
.set_delay
)
450 ALSPS_LOG("als_ctl set_delay NULL\n");
451 mutex_unlock(&alsps_context_obj
->alsps_op_mutex
);
455 if (1 != sscanf(buf
, "%d", &delay
)) {
456 ALSPS_ERR("invalid format!!\n");
457 mutex_unlock(&alsps_context_obj
->alsps_op_mutex
);
461 if(false == cxt
->als_ctl
.is_report_input_direct
)
463 mdelay
= (int)delay
/1000/1000;
464 atomic_set(&alsps_context_obj
->delay_als
, mdelay
);
466 cxt
->als_ctl
.set_delay(delay
);
467 ALSPS_LOG(" als_delay %d ns\n",delay
);
468 mutex_unlock(&alsps_context_obj
->alsps_op_mutex
);
473 static ssize_t
als_show_delay(struct device
* dev
,
474 struct device_attribute
*attr
, char *buf
)
477 ALSPS_LOG(" not support now\n");
482 static ssize_t
als_store_batch(struct device
* dev
, struct device_attribute
*attr
,
483 const char *buf
, size_t count
)
485 ALSPS_LOG("als_store_batch buf=%s\n",buf
);
486 mutex_lock(&alsps_context_obj
->alsps_op_mutex
);
487 struct alsps_context
*cxt
= NULL
;
489 cxt
= alsps_context_obj
;
490 if(cxt
->als_ctl
.is_support_batch
){
491 if (!strncmp(buf
, "1", 1))
493 cxt
->is_als_batch_enable
= true;
495 else if (!strncmp(buf
, "0", 1))
497 cxt
->is_als_batch_enable
= false;
501 ALSPS_ERR(" als_store_batch error !!\n");
504 ALSPS_LOG(" als_store_batch not supported\n");
506 mutex_unlock(&alsps_context_obj
->alsps_op_mutex
);
507 ALSPS_LOG(" als_store_batch done: %d\n", cxt
->is_als_batch_enable
);
512 static ssize_t
als_show_batch(struct device
* dev
,
513 struct device_attribute
*attr
, char *buf
)
515 return snprintf(buf
, PAGE_SIZE
, "%d\n", 0);
518 static ssize_t
als_store_flush(struct device
* dev
, struct device_attribute
*attr
,
519 const char *buf
, size_t count
)
521 mutex_lock(&alsps_context_obj
->alsps_op_mutex
);
522 struct alsps_context
*devobj
= (struct alsps_context
*)dev_get_drvdata(dev
);
523 //do read FIFO data function and report data immediately
524 mutex_unlock(&alsps_context_obj
->alsps_op_mutex
);
528 static ssize_t
als_show_flush(struct device
* dev
,
529 struct device_attribute
*attr
, char *buf
)
531 return snprintf(buf
, PAGE_SIZE
, "%d\n", 0);
534 static ssize_t
als_show_devnum(struct device
* dev
,
535 struct device_attribute
*attr
, char *buf
)
538 devname
= dev_name(&alsps_context_obj
->idev
->dev
);
539 return snprintf(buf
, PAGE_SIZE
, "%s\n", devname
+5);
541 static ssize_t
ps_store_active(struct device
* dev
, struct device_attribute
*attr
,
542 const char *buf
, size_t count
)
544 ALSPS_LOG("ps_store_active buf=%s\n",buf
);
545 mutex_lock(&alsps_context_obj
->alsps_op_mutex
);
546 struct alsps_context
*cxt
= NULL
;
548 cxt
= alsps_context_obj
;
550 if (!strncmp(buf
, "1", 1))
554 else if (!strncmp(buf
, "0", 1))
560 ALSPS_ERR(" ps_store_active error !!\n");
562 mutex_unlock(&alsps_context_obj
->alsps_op_mutex
);
563 ALSPS_LOG(" ps_store_active done\n");
566 /*----------------------------------------------------------------------------*/
567 static ssize_t
ps_show_active(struct device
* dev
,
568 struct device_attribute
*attr
, char *buf
)
570 struct alsps_context
*cxt
= NULL
;
571 cxt
= alsps_context_obj
;
572 int div
=cxt
->ps_data
.vender_div
;
573 ALSPS_LOG("ps vender_div value: %d\n", div
);
574 return snprintf(buf
, PAGE_SIZE
, "%d\n", div
);
577 static ssize_t
ps_store_delay(struct device
* dev
, struct device_attribute
*attr
,
578 const char *buf
, size_t count
)
581 mutex_lock(&alsps_context_obj
->alsps_op_mutex
);
582 struct alsps_context
*devobj
= (struct alsps_context
*)dev_get_drvdata(dev
);
585 struct alsps_context
*cxt
= NULL
;
587 cxt
= alsps_context_obj
;
588 if(NULL
== cxt
->ps_ctl
.set_delay
)
590 ALSPS_LOG("ps_ctl set_delay NULL\n");
591 mutex_unlock(&alsps_context_obj
->alsps_op_mutex
);
595 if (1 != sscanf(buf
, "%d", &delay
)) {
596 ALSPS_ERR("invalid format!!\n");
597 mutex_unlock(&alsps_context_obj
->alsps_op_mutex
);
601 if(false == cxt
->ps_ctl
.is_report_input_direct
)
603 mdelay
= (int)delay
/1000/1000;
604 atomic_set(&alsps_context_obj
->delay_ps
, mdelay
);
606 cxt
->ps_ctl
.set_delay(delay
);
607 ALSPS_LOG(" ps_delay %d ns\n",delay
);
608 mutex_unlock(&alsps_context_obj
->alsps_op_mutex
);
613 static ssize_t
ps_show_delay(struct device
* dev
,
614 struct device_attribute
*attr
, char *buf
)
617 ALSPS_LOG(" not support now\n");
622 static ssize_t
ps_store_batch(struct device
* dev
, struct device_attribute
*attr
,
623 const char *buf
, size_t count
)
625 ALSPS_LOG("ps_store_batch buf=%s\n",buf
);
626 mutex_lock(&alsps_context_obj
->alsps_op_mutex
);
627 struct alsps_context
*cxt
= NULL
;
629 cxt
= alsps_context_obj
;
630 if(cxt
->ps_ctl
.is_support_batch
){
631 if (!strncmp(buf
, "1", 1))
633 cxt
->is_ps_batch_enable
= true;
635 else if (!strncmp(buf
, "0", 1))
637 cxt
->is_ps_batch_enable
= false;
641 ALSPS_ERR(" ps_store_batch error !!\n");
644 ALSPS_LOG(" ps_store_batch not supported\n");
646 mutex_unlock(&alsps_context_obj
->alsps_op_mutex
);
647 ALSPS_LOG(" ps_store_batch done: %d\n", cxt
->is_ps_batch_enable
);
652 static ssize_t
ps_show_batch(struct device
* dev
,
653 struct device_attribute
*attr
, char *buf
)
655 return snprintf(buf
, PAGE_SIZE
, "%d\n", 0);
658 static ssize_t
ps_store_flush(struct device
* dev
, struct device_attribute
*attr
,
659 const char *buf
, size_t count
)
661 mutex_lock(&alsps_context_obj
->alsps_op_mutex
);
662 struct alsps_context
*devobj
= (struct alsps_context
*)dev_get_drvdata(dev
);
663 //do read FIFO data function and report data immediately
664 mutex_unlock(&alsps_context_obj
->alsps_op_mutex
);
668 static ssize_t
ps_show_flush(struct device
* dev
,
669 struct device_attribute
*attr
, char *buf
)
671 return snprintf(buf
, PAGE_SIZE
, "%d\n", 0);
674 static ssize_t
ps_show_devnum(struct device
* dev
,
675 struct device_attribute
*attr
, char *buf
)
678 devname
= dev_name(&alsps_context_obj
->idev
->dev
);
679 return snprintf(buf
, PAGE_SIZE
, "%s\n", devname
+5);
681 static int als_ps_remove(struct platform_device
*pdev
)
683 ALSPS_LOG("als_ps_remove\n");
687 static int als_ps_probe(struct platform_device
*pdev
)
689 ALSPS_LOG("als_ps_probe\n");
693 static struct platform_driver als_ps_driver
= {
694 .probe
= als_ps_probe
,
695 .remove
= als_ps_remove
,
702 static int alsps_real_driver_init(void)
706 ALSPS_LOG(" alsps_real_driver_init +\n");
707 for(i
= 0; i
< MAX_CHOOSE_ALSPS_NUM
; i
++)
709 ALSPS_LOG("alsps_real_driver_init i=%d\n",i
);
710 if(0 != alsps_init_list
[i
])
712 ALSPS_LOG(" alsps try to init driver %s\n", alsps_init_list
[i
]->name
);
713 err
= alsps_init_list
[i
]->init();
716 ALSPS_LOG(" alsps real driver %s probe ok\n", alsps_init_list
[i
]->name
);
722 if(i
== MAX_CHOOSE_ALSPS_NUM
)
724 ALSPS_LOG(" alsps_real_driver_init fail\n");
730 int alsps_driver_add(struct alsps_init_info
* obj
)
737 for(i
=0; i
< MAX_CHOOSE_ALSPS_NUM
; i
++ )
740 ALSPS_LOG("register alsps driver for the first time\n");
741 if(platform_driver_register(&als_ps_driver
))
743 ALSPS_ERR("failed to register gensor driver already exist\n");
747 if(NULL
== alsps_init_list
[i
])
749 obj
->platform_diver_addr
= &als_ps_driver
;
750 alsps_init_list
[i
] = obj
;
754 if(NULL
==alsps_init_list
[i
])
756 ALSPS_ERR("ALSPS driver add err \n");
762 EXPORT_SYMBOL_GPL(alsps_driver_add
);
764 int ps_report_interrupt_data(int value
)
766 struct alsps_context
*cxt
= NULL
;
768 cxt
= alsps_context_obj
;
769 ps_data_report(cxt
->idev
,value
,3);
773 /*----------------------------------------------------------------------------*/
774 EXPORT_SYMBOL_GPL(ps_report_interrupt_data
);
776 static int alsps_misc_init(struct alsps_context
*cxt
)
780 cxt
->mdev
.minor
= MISC_DYNAMIC_MINOR
;
781 cxt
->mdev
.name
= ALSPS_MISC_DEV_NAME
;
782 if((err
= misc_register(&cxt
->mdev
)))
784 ALSPS_ERR("unable to register alsps misc device!!\n");
789 static void alsps_input_destroy(struct alsps_context
*cxt
)
791 struct input_dev
*dev
= cxt
->idev
;
793 input_unregister_device(dev
);
794 input_free_device(dev
);
797 static int alsps_input_init(struct alsps_context
*cxt
)
799 struct input_dev
*dev
;
802 dev
= input_allocate_device();
806 dev
->name
= ALSPS_INPUTDEV_NAME
;
808 input_set_capability(dev
, EV_ABS
, EVENT_TYPE_ALS_VALUE
);
809 input_set_capability(dev
, EV_ABS
, EVENT_TYPE_PS_VALUE
);
810 input_set_capability(dev
, EV_ABS
, EVENT_TYPE_ALS_STATUS
);
811 input_set_capability(dev
, EV_ABS
, EVENT_TYPE_PS_STATUS
);
813 input_set_abs_params(dev
, EVENT_TYPE_ALS_VALUE
, ALSPS_VALUE_MIN
, ALSPS_VALUE_MAX
, 0, 0);
814 input_set_abs_params(dev
, EVENT_TYPE_PS_VALUE
, ALSPS_VALUE_MIN
, ALSPS_VALUE_MAX
, 0, 0);
815 input_set_abs_params(dev
, EVENT_TYPE_ALS_STATUS
, ALSPS_STATUS_MIN
, ALSPS_STATUS_MAX
, 0, 0);
816 input_set_abs_params(dev
, EVENT_TYPE_PS_STATUS
, ALSPS_STATUS_MIN
, ALSPS_STATUS_MAX
, 0, 0);
817 input_set_drvdata(dev
, cxt
);
819 err
= input_register_device(dev
);
821 input_free_device(dev
);
830 DEVICE_ATTR(alsactive
, S_IWUSR
| S_IRUGO
, als_show_active
, als_store_active
);
831 DEVICE_ATTR(alsdelay
, S_IWUSR
| S_IRUGO
, als_show_delay
, als_store_delay
);
832 DEVICE_ATTR(alsbatch
, S_IWUSR
| S_IRUGO
, als_show_batch
, als_store_batch
);
833 DEVICE_ATTR(alsflush
, S_IWUSR
| S_IRUGO
, als_show_flush
, als_store_flush
);
834 DEVICE_ATTR(alsdevnum
, S_IWUSR
| S_IRUGO
, als_show_devnum
, NULL
);
835 DEVICE_ATTR(psactive
, S_IWUSR
| S_IRUGO
, ps_show_active
, ps_store_active
);
836 DEVICE_ATTR(psdelay
, S_IWUSR
| S_IRUGO
, ps_show_delay
, ps_store_delay
);
837 DEVICE_ATTR(psbatch
, S_IWUSR
| S_IRUGO
, ps_show_batch
, ps_store_batch
);
838 DEVICE_ATTR(psflush
, S_IWUSR
| S_IRUGO
, ps_show_flush
, ps_store_flush
);
839 DEVICE_ATTR(psdevnum
, S_IWUSR
| S_IRUGO
, ps_show_devnum
, NULL
);
842 static struct attribute
*alsps_attributes
[] = {
843 &dev_attr_alsactive
.attr
,
844 &dev_attr_alsdelay
.attr
,
845 &dev_attr_alsbatch
.attr
,
846 &dev_attr_alsflush
.attr
,
847 &dev_attr_alsdevnum
.attr
,
848 &dev_attr_psactive
.attr
,
849 &dev_attr_psdelay
.attr
,
850 &dev_attr_psbatch
.attr
,
851 &dev_attr_psflush
.attr
,
852 &dev_attr_psdevnum
.attr
,
856 static struct attribute_group alsps_attribute_group
= {
857 .attrs
= alsps_attributes
860 int als_register_data_path(struct als_data_path
*data
)
862 struct alsps_context
*cxt
= NULL
;
864 cxt
= alsps_context_obj
;
865 cxt
->als_data
.get_data
= data
->get_data
;
866 cxt
->als_data
.vender_div
= data
->vender_div
;
867 ALSPS_LOG("alsps register data path vender_div: %d\n", cxt
->als_data
.vender_div
);
868 if(NULL
== cxt
->als_data
.get_data
)
870 ALSPS_LOG("alsps register data path fail \n");
876 int ps_register_data_path(struct ps_data_path
*data
)
878 struct alsps_context
*cxt
= NULL
;
880 cxt
= alsps_context_obj
;
881 cxt
->ps_data
.get_data
= data
->get_data
;
882 cxt
->ps_data
.vender_div
= data
->vender_div
;
883 ALSPS_LOG("alsps register data path vender_div: %d\n", cxt
->ps_data
.vender_div
);
884 if(NULL
== cxt
->ps_data
.get_data
)
886 ALSPS_LOG("alsps register data path fail \n");
892 int als_register_control_path(struct als_control_path
*ctl
)
894 struct alsps_context
*cxt
= NULL
;
896 cxt
= alsps_context_obj
;
897 cxt
->als_ctl
.set_delay
= ctl
->set_delay
;
898 cxt
->als_ctl
.open_report_data
= ctl
->open_report_data
;
899 cxt
->als_ctl
.enable_nodata
= ctl
->enable_nodata
;
900 cxt
->als_ctl
.is_support_batch
= ctl
->is_support_batch
;
901 cxt
->als_ctl
.is_report_input_direct
= ctl
->is_report_input_direct
;
903 if(NULL
==cxt
->als_ctl
.set_delay
|| NULL
==cxt
->als_ctl
.open_report_data
904 || NULL
==cxt
->als_ctl
.enable_nodata
)
906 ALSPS_LOG("alsps register control path fail \n");
913 int ps_register_control_path(struct ps_control_path
*ctl
)
915 struct alsps_context
*cxt
= NULL
;
917 cxt
= alsps_context_obj
;
918 cxt
->ps_ctl
.set_delay
= ctl
->set_delay
;
919 cxt
->ps_ctl
.open_report_data
= ctl
->open_report_data
;
920 cxt
->ps_ctl
.enable_nodata
= ctl
->enable_nodata
;
921 cxt
->ps_ctl
.is_support_batch
= ctl
->is_support_batch
;
922 cxt
->ps_ctl
.is_report_input_direct
= ctl
->is_report_input_direct
;
924 if(NULL
==cxt
->ps_ctl
.set_delay
|| NULL
==cxt
->ps_ctl
.open_report_data
925 || NULL
==cxt
->ps_ctl
.enable_nodata
)
927 ALSPS_LOG("ps register control path fail \n");
931 //add misc dev for sensor hal control cmd
932 err
= alsps_misc_init(alsps_context_obj
);
935 ALSPS_ERR("unable to register alsps misc device!!\n");
938 err
= sysfs_create_group(&alsps_context_obj
->mdev
.this_device
->kobj
,
939 &alsps_attribute_group
);
942 ALSPS_ERR("unable to create alsps attribute file\n");
947 kobject_uevent(&alsps_context_obj
->mdev
.this_device
->kobj
, KOBJ_ADD
);
952 static int alsps_probe(struct platform_device
*pdev
)
956 ALSPS_LOG("+++++++++++++alsps_probe!!\n");
958 alsps_context_obj
= alsps_context_alloc_object();
959 if (!alsps_context_obj
)
962 ALSPS_ERR("unable to allocate devobj!\n");
963 goto exit_alloc_data_failed
;
966 //init real alspseleration driver
967 err
= alsps_real_driver_init();
970 ALSPS_ERR("alsps real driver init fail\n");
971 goto real_driver_init_fail
;
975 err
= alsps_input_init(alsps_context_obj
);
978 ALSPS_ERR("unable to register alsps input device!\n");
979 goto exit_alloc_input_dev_failed
;
982 atomic_set(&(alsps_context_obj
->early_suspend
), 0);
983 alsps_context_obj
->early_drv
.level
= EARLY_SUSPEND_LEVEL_STOP_DRAWING
- 1,
984 alsps_context_obj
->early_drv
.suspend
= alsps_early_suspend
,
985 alsps_context_obj
->early_drv
.resume
= alsps_late_resume
,
986 register_early_suspend(&alsps_context_obj
->early_drv
);
989 ALSPS_LOG("----alsps_probe OK !!\n");
992 exit_hwmsen_create_attr_failed
:
993 exit_misc_register_failed
:
999 ALSPS_ERR("sysfs node creation error \n");
1000 alsps_input_destroy(alsps_context_obj
);
1003 real_driver_init_fail
:
1004 exit_alloc_input_dev_failed
:
1005 kfree(alsps_context_obj
);
1007 exit_alloc_data_failed
:
1010 ALSPS_LOG("----alsps_probe fail !!!\n");
1016 static int alsps_remove(struct platform_device
*pdev
)
1020 input_unregister_device(alsps_context_obj
->idev
);
1021 sysfs_remove_group(&alsps_context_obj
->idev
->dev
.kobj
,
1022 &alsps_attribute_group
);
1024 if((err
= misc_deregister(&alsps_context_obj
->mdev
)))
1026 ALSPS_ERR("misc_deregister fail: %d\n", err
);
1028 kfree(alsps_context_obj
);
1033 static void alsps_early_suspend(struct early_suspend
*h
)
1035 atomic_set(&(alsps_context_obj
->early_suspend
), 1);
1036 ALSPS_LOG(" alsps_early_suspend ok------->hwm_obj->early_suspend=%d \n",atomic_read(&(alsps_context_obj
->early_suspend
)));
1039 /*----------------------------------------------------------------------------*/
1040 static void alsps_late_resume(struct early_suspend
*h
)
1042 atomic_set(&(alsps_context_obj
->early_suspend
), 0);
1043 ALSPS_LOG(" alsps_late_resume ok------->hwm_obj->early_suspend=%d \n",atomic_read(&(alsps_context_obj
->early_suspend
)));
1047 static int alsps_suspend(struct platform_device
*dev
, pm_message_t state
)
1051 /*----------------------------------------------------------------------------*/
1052 static int alsps_resume(struct platform_device
*dev
)
1057 static struct platform_driver alsps_driver
=
1059 .probe
= alsps_probe
,
1060 .remove
= alsps_remove
,
1061 .suspend
= alsps_suspend
,
1062 .resume
= alsps_resume
,
1065 .name
= ALSPS_PL_DEV_NAME
,
1069 static int __init
alsps_init(void)
1073 if(platform_driver_register(&alsps_driver
))
1075 ALSPS_ERR("failed to register alsps driver\n");
1082 static void __exit
alsps_exit(void)
1084 platform_driver_unregister(&alsps_driver
);
1085 platform_driver_unregister(&als_ps_driver
);
1089 module_init(alsps_init
);
1090 module_exit(alsps_exit
);
1091 MODULE_LICENSE("GPL");
1092 MODULE_DESCRIPTION("ALSPS device driver");
1093 MODULE_AUTHOR("Mediatek");