1 /* drivers/input/sensors/sensor-dev.c - handle all gsensor in this file
\r
3 * Copyright (C) 2012-2015 ROCKCHIP.
\r
4 * Author: luowei <lw@rock-chips.com>
\r
6 * This software is licensed under the terms of the GNU General Public
\r
7 * License version 2, as published by the Free Software Foundation, and
\r
8 * may be copied, distributed, and modified under those terms.
\r
10 * This program is distributed in the hope that it will be useful,
\r
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
\r
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
\r
13 * GNU General Public License for more details.
\r
17 #include <linux/interrupt.h>
\r
18 #include <linux/i2c.h>
\r
19 #include <linux/slab.h>
\r
20 #include <linux/irq.h>
\r
21 #include <linux/miscdevice.h>
\r
22 #include <linux/gpio.h>
\r
23 #include <asm/uaccess.h>
\r
24 #include <asm/atomic.h>
\r
25 #include <linux/delay.h>
\r
26 #include <linux/input.h>
\r
27 #include <linux/workqueue.h>
\r
28 #include <linux/freezer.h>
\r
29 #include <mach/gpio.h>
\r
30 #include <mach/board.h>
\r
31 #ifdef CONFIG_HAS_EARLYSUSPEND
\r
32 #include <linux/earlysuspend.h>
\r
34 #include <linux/akm8975.h>
\r
35 #include <linux/l3g4200d.h>
\r
36 #include <linux/sensor-dev.h>
\r
40 #define SENSOR_DEBUG_TYPE SENSOR_TYPE_ACCEL
\r
41 #define DBG(x...) if(sensor->pdata->type == SENSOR_DEBUG_TYPE) printk(x)
\r
46 struct sensor_private_data *g_sensor[SENSOR_NUM_TYPES];
\r
47 static struct sensor_operate *sensor_ops[SENSOR_NUM_ID];
\r
48 static struct class *g_sensor_class[SENSOR_NUM_TYPES];
\r
51 static int sensor_get_id(struct i2c_client *client, int *value)
\r
53 struct sensor_private_data *sensor =
\r
54 (struct sensor_private_data *) i2c_get_clientdata(client);
\r
56 char temp = sensor->ops->id_reg;
\r
59 if(sensor->ops->id_reg >= 0)
\r
63 result = sensor_rx_data(client, &temp, 1);
\r
72 if(*value != sensor->ops->id_data)
\r
74 printk("%s:id=0x%x is not 0x%x\n",__func__,*value, sensor->ops->id_data);
\r
78 DBG("%s:devid=0x%x\n",__func__,*value);
\r
84 static int sensor_initial(struct i2c_client *client)
\r
86 struct sensor_private_data *sensor =
\r
87 (struct sensor_private_data *) i2c_get_clientdata(client);
\r
90 //register setting according to chip datasheet
\r
91 result = sensor->ops->init(client);
\r
94 printk("%s:fail to init sensor\n",__func__);
\r
99 DBG("%s:ctrl_data=0x%x\n",__func__,sensor->ops->ctrl_data);
\r
105 static int sensor_chip_init(struct i2c_client *client)
\r
107 struct sensor_private_data *sensor =
\r
108 (struct sensor_private_data *) i2c_get_clientdata(client);
\r
109 struct sensor_operate *ops = sensor_ops[(int)sensor->i2c_id->driver_data];
\r
118 printk("%s:ops is null,sensor name is %s\n",__func__,sensor->i2c_id->name);
\r
123 if((sensor->type != ops->type) || ((int)sensor->i2c_id->driver_data != ops->id_i2c))
\r
125 printk("%s:type or id is different:type=%d,%d,id=%d,%d\n",__func__,sensor->type, ops->type, (int)sensor->i2c_id->driver_data, ops->id_i2c);
\r
130 if(!ops->init || !ops->active || !ops->report)
\r
132 printk("%s:error:some function is needed\n",__func__);
\r
137 result = sensor_get_id(sensor->client, &sensor->devid);//get id
\r
140 printk("%s:fail to read %s devid:0x%x\n",__func__, sensor->i2c_id->name, sensor->devid);
\r
144 printk("%s:%s:devid=0x%x,ops=0x%p\n",__func__, sensor->i2c_id->name, sensor->devid,sensor->ops);
\r
146 result = sensor_initial(sensor->client); //init sensor
\r
149 printk("%s:fail to init sensor\n",__func__);
\r
160 static int sensor_reset_rate(struct i2c_client *client, int rate)
\r
162 struct sensor_private_data *sensor =
\r
163 (struct sensor_private_data *) i2c_get_clientdata(client);
\r
166 result = sensor->ops->active(client,SENSOR_OFF,rate);
\r
167 sensor->ops->init(client);
\r
168 result = sensor->ops->active(client,SENSOR_ON,rate);
\r
173 static int sensor_get_data(struct i2c_client *client)
\r
175 struct sensor_private_data *sensor =
\r
176 (struct sensor_private_data *) i2c_get_clientdata(client);
\r
179 result = sensor->ops->report(client);
\r
183 /* set data_ready */
\r
184 atomic_set(&sensor->data_ready, 1);
\r
185 /*wake up data_ready work queue*/
\r
186 wake_up(&sensor->data_ready_wq);
\r
193 int sensor_get_cached_data(struct i2c_client* client, char *buffer, int length, struct sensor_axis *axis)
\r
195 struct sensor_private_data* sensor = (struct sensor_private_data *)i2c_get_clientdata(client);
\r
196 wait_event_interruptible_timeout(sensor->data_ready_wq,
\r
197 atomic_read(&(sensor->data_ready) ),
\r
198 msecs_to_jiffies(1000) );
\r
199 if ( 0 == atomic_read(&(sensor->data_ready) ) ) {
\r
200 printk("waiting 'data_ready_wq' timed out.");
\r
205 mutex_lock(&sensor->data_mutex);
\r
207 switch(sensor->type)
\r
209 case SENSOR_TYPE_ACCEL:
\r
210 *axis = sensor->axis;
\r
213 case SENSOR_TYPE_COMPASS:
\r
214 memcpy(buffer, sensor->sensor_data, length);
\r
218 mutex_unlock(&sensor->data_mutex);
\r
227 static void sensor_delaywork_func(struct work_struct *work)
\r
229 struct delayed_work *delaywork = container_of(work, struct delayed_work, work);
\r
230 struct sensor_private_data *sensor = container_of(delaywork, struct sensor_private_data, delaywork);
\r
231 struct i2c_client *client = sensor->client;
\r
233 mutex_lock(&sensor->sensor_mutex);
\r
234 if (sensor_get_data(client) < 0)
\r
235 DBG(KERN_ERR "%s: Get data failed\n",__func__);
\r
237 if(!sensor->pdata->irq_enable)//restart work while polling
\r
238 schedule_delayed_work(&sensor->delaywork, msecs_to_jiffies(sensor->pdata->poll_delay_ms));
\r
241 //if((sensor->ops->trig == IRQF_TRIGGER_LOW) || (sensor->ops->trig == IRQF_TRIGGER_HIGH))
\r
242 //enable_irq(sensor->client->irq);
\r
244 mutex_unlock(&sensor->sensor_mutex);
\r
246 DBG("%s:%s\n",__func__,sensor->i2c_id->name);
\r
250 * This is a threaded IRQ handler so can access I2C/SPI. Since all
\r
251 * interrupts are clear on read the IRQ line will be reasserted and
\r
252 * the physical IRQ will be handled again if another interrupt is
\r
253 * asserted while we run - in the normal course of events this is a
\r
254 * rare occurrence so we save I2C/SPI reads. We're also assuming that
\r
255 * it's rare to get lots of interrupts firing simultaneously so try to
\r
258 static irqreturn_t sensor_interrupt(int irq, void *dev_id)
\r
260 struct sensor_private_data *sensor = (struct sensor_private_data *)dev_id;
\r
263 if (sensor_get_data(sensor->client) < 0)
\r
264 DBG(KERN_ERR "%s: Get data failed\n",__func__);
\r
265 msleep(sensor->pdata->poll_delay_ms);
\r
268 //if((sensor->ops->trig == IRQF_TRIGGER_LOW) || (sensor->ops->trig == IRQF_TRIGGER_HIGH))
\r
269 //disable_irq_nosync(irq);
\r
270 //schedule_delayed_work(&sensor->delaywork, msecs_to_jiffies(sensor->pdata->poll_delay_ms));
\r
271 DBG("%s:irq=%d\n",__func__,irq);
\r
272 return IRQ_HANDLED;
\r
276 static int sensor_irq_init(struct i2c_client *client)
\r
278 struct sensor_private_data *sensor =
\r
279 (struct sensor_private_data *) i2c_get_clientdata(client);
\r
282 if((sensor->pdata->irq_enable)&&(sensor->ops->trig != SENSOR_UNKNOW_DATA))
\r
284 //INIT_DELAYED_WORK(&sensor->delaywork, sensor_delaywork_func);
\r
285 if(sensor->pdata->poll_delay_ms < 0)
\r
286 sensor->pdata->poll_delay_ms = 30;
\r
288 result = gpio_request(client->irq, sensor->i2c_id->name);
\r
291 printk("%s:fail to request gpio :%d\n",__func__,client->irq);
\r
294 gpio_pull_updown(client->irq, PullEnable);
\r
295 irq = gpio_to_irq(client->irq);
\r
296 //result = request_irq(irq, sensor_interrupt, sensor->ops->trig, sensor->ops->name, sensor);
\r
297 result = request_threaded_irq(irq, NULL, sensor_interrupt, sensor->ops->trig, sensor->ops->name, sensor);
\r
299 printk(KERN_ERR "%s:fail to request irq = %d, ret = 0x%x\n",__func__, irq, result);
\r
303 if((sensor->pdata->type == SENSOR_TYPE_GYROSCOPE) || (sensor->pdata->type == SENSOR_TYPE_ACCEL))
\r
304 disable_irq_nosync(client->irq);//disable irq
\r
305 printk("%s:use irq=%d\n",__func__,irq);
\r
307 else if(!sensor->pdata->irq_enable)
\r
309 INIT_DELAYED_WORK(&sensor->delaywork, sensor_delaywork_func);
\r
310 if(sensor->pdata->poll_delay_ms < 0)
\r
311 sensor->pdata->poll_delay_ms = 30;
\r
313 printk("%s:use polling,delay=%d ms\n",__func__,sensor->pdata->poll_delay_ms);
\r
320 #ifdef CONFIG_HAS_EARLYSUSPEND
\r
321 static void sensor_suspend(struct early_suspend *h)
\r
323 struct sensor_private_data *sensor =
\r
324 container_of(h, struct sensor_private_data, early_suspend);
\r
326 if(sensor->ops->suspend)
\r
327 sensor->ops->suspend(sensor->client);
\r
331 static void sensor_resume(struct early_suspend *h)
\r
333 struct sensor_private_data *sensor =
\r
334 container_of(h, struct sensor_private_data, early_suspend);
\r
336 if(sensor->ops->resume)
\r
337 sensor->ops->resume(sensor->client);
\r
341 static int gsensor_dev_open(struct inode *inode, struct file *file)
\r
343 //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_ACCEL];
\r
344 //struct i2c_client *client = sensor->client;
\r
353 static int gsensor_dev_release(struct inode *inode, struct file *file)
\r
355 //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_ACCEL];
\r
356 //struct i2c_client *client = sensor->client;
\r
364 /* ioctl - I/O control */
\r
365 static long gsensor_dev_ioctl(struct file *file,
\r
366 unsigned int cmd, unsigned long arg)
\r
368 struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_ACCEL];
\r
369 struct i2c_client *client = sensor->client;
\r
370 void __user *argp = (void __user *)arg;
\r
371 struct sensor_axis axis = {0};
\r
376 case GSENSOR_IOCTL_APP_SET_RATE:
\r
377 if (copy_from_user(&rate, argp, sizeof(rate)))
\r
388 case GSENSOR_IOCTL_START:
\r
389 DBG("%s:GSENSOR_IOCTL_START start,status=%d\n", __func__,sensor->status_cur);
\r
390 mutex_lock(&sensor->operation_mutex);
\r
391 if(++sensor->start_count == 1)
\r
393 if(sensor->status_cur == SENSOR_OFF)
\r
395 atomic_set(&(sensor->data_ready), 0);
\r
396 if ( (result = sensor->ops->active(client, 1, 0) ) < 0 ) {
\r
397 mutex_unlock(&sensor->operation_mutex);
\r
398 printk("%s:fail to active sensor,ret=%d\n",__func__,result);
\r
401 if(sensor->pdata->irq_enable)
\r
403 DBG("%s:enable irq,irq=%d\n",__func__,client->irq);
\r
404 enable_irq(client->irq); //enable irq
\r
408 PREPARE_DELAYED_WORK(&sensor->delaywork, sensor_delaywork_func);
\r
409 schedule_delayed_work(&sensor->delaywork, msecs_to_jiffies(sensor->pdata->poll_delay_ms));
\r
411 sensor->status_cur = SENSOR_ON;
\r
414 mutex_unlock(&sensor->operation_mutex);
\r
415 DBG("%s:GSENSOR_IOCTL_START OK\n", __func__);
\r
418 case GSENSOR_IOCTL_CLOSE:
\r
419 DBG("%s:GSENSOR_IOCTL_CLOSE start,status=%d\n", __func__,sensor->status_cur);
\r
420 mutex_lock(&sensor->operation_mutex);
\r
421 if(--sensor->start_count == 0)
\r
423 if(sensor->status_cur == SENSOR_ON)
\r
425 atomic_set(&(sensor->data_ready), 0);
\r
426 if ( (result = sensor->ops->active(client, 0, 0) ) < 0 ) {
\r
427 mutex_unlock(&sensor->operation_mutex);
\r
431 if(sensor->pdata->irq_enable)
\r
433 DBG("%s:disable irq,irq=%d\n",__func__,client->irq);
\r
434 disable_irq_nosync(client->irq);//disable irq
\r
437 cancel_delayed_work_sync(&sensor->delaywork);
\r
438 sensor->status_cur = SENSOR_OFF;
\r
441 DBG("%s:GSENSOR_IOCTL_CLOSE OK\n", __func__);
\r
444 mutex_unlock(&sensor->operation_mutex);
\r
447 case GSENSOR_IOCTL_APP_SET_RATE:
\r
448 DBG("%s:GSENSOR_IOCTL_APP_SET_RATE start\n", __func__);
\r
449 mutex_lock(&sensor->operation_mutex);
\r
450 result = sensor_reset_rate(client, rate);
\r
452 mutex_unlock(&sensor->operation_mutex);
\r
456 sensor->status_cur = SENSOR_ON;
\r
457 mutex_unlock(&sensor->operation_mutex);
\r
458 DBG("%s:GSENSOR_IOCTL_APP_SET_RATE OK\n", __func__);
\r
461 case GSENSOR_IOCTL_GETDATA:
\r
462 mutex_lock(&sensor->data_mutex);
\r
463 memcpy(&axis, &sensor->axis, sizeof(sensor->axis)); //get data from buffer
\r
464 mutex_unlock(&sensor->data_mutex);
\r
472 case GSENSOR_IOCTL_GETDATA:
\r
473 if ( copy_to_user(argp, &axis, sizeof(axis) ) ) {
\r
474 printk("failed to copy sense data to user space.");
\r
478 DBG("%s:GSENSOR_IOCTL_GETDATA OK\n", __func__);
\r
488 static ssize_t gsensor_set_orientation_online(struct class *class,
\r
489 struct class_attribute *attr, const char *buf, size_t count)
\r
492 char orientation[20];
\r
495 struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_ACCEL];
\r
496 struct sensor_platform_data *pdata = sensor->pdata;
\r
499 char *p = strstr(buf,"gsensor_class");
\r
500 int start = strcspn(p,"{");
\r
501 int end = strcspn(p,"}");
\r
503 strncpy(orientation,p+start,end-start+1);
\r
507 while(strncmp(tmp,"}",1)!=0)
\r
509 if((strncmp(tmp,",",1)==0)||(strncmp(tmp,"{",1)==0))
\r
515 else if(strncmp(tmp,"-",1)==0)
\r
517 pdata->orientation[i++]=-1;
\r
518 DBG("i=%d,data=%d\n",i,pdata->orientation[i]);
\r
523 pdata->orientation[i++]=tmp[0]-48;
\r
524 DBG("----i=%d,data=%d\n",i,pdata->orientation[i]);
\r
532 DBG("i=%d gsensor_info=%d\n",i,pdata->orientation[i]);
\r
537 static CLASS_ATTR(orientation, 0660, NULL, gsensor_set_orientation_online);
\r
539 static int gsensor_class_init(void)
\r
542 struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_ACCEL];
\r
543 g_sensor_class[SENSOR_TYPE_ACCEL] = class_create(THIS_MODULE, "gsensor_class");
\r
544 ret = class_create_file(g_sensor_class[SENSOR_TYPE_ACCEL], &class_attr_orientation);
\r
547 printk("%s:Fail to creat class\n",__func__);
\r
550 printk("%s:%s\n",__func__,sensor->i2c_id->name);
\r
556 static int compass_dev_open(struct inode *inode, struct file *file)
\r
558 //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_COMPASS];
\r
559 //struct i2c_client *client = sensor->client;
\r
567 static int compass_dev_release(struct inode *inode, struct file *file)
\r
569 //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_COMPASS];
\r
570 //struct i2c_client *client = sensor->client;
\r
578 /* ioctl - I/O control */
\r
579 static long compass_dev_ioctl(struct file *file,
\r
580 unsigned int cmd, unsigned long arg)
\r
582 //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_COMPASS];
\r
583 //struct i2c_client *client = sensor->client;
\r
584 //void __user *argp = (void __user *)arg;
\r
591 static int gyro_dev_open(struct inode *inode, struct file *file)
\r
593 //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_GYROSCOPE];
\r
594 //struct i2c_client *client = sensor->client;
\r
603 static int gyro_dev_release(struct inode *inode, struct file *file)
\r
605 //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_GYROSCOPE];
\r
606 //struct i2c_client *client = sensor->client;
\r
615 /* ioctl - I/O control */
\r
616 static long gyro_dev_ioctl(struct file *file,
\r
617 unsigned int cmd, unsigned long arg)
\r
619 struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_GYROSCOPE];
\r
620 struct i2c_client *client = sensor->client;
\r
621 void __user *argp = (void __user *)arg;
\r
625 case L3G4200D_IOCTL_GET_ENABLE:
\r
626 result = !sensor->status_cur;
\r
627 if (copy_to_user(argp, &result, sizeof(result)))
\r
629 printk("%s:failed to copy status to user space.\n",__FUNCTION__);
\r
633 DBG("%s :L3G4200D_IOCTL_GET_ENABLE,status=%d\n",__FUNCTION__,result);
\r
635 case L3G4200D_IOCTL_SET_ENABLE:
\r
636 DBG("%s :L3G4200D_IOCTL_SET_ENABLE,flag=%d\n",__FUNCTION__,*(unsigned int *)argp);
\r
637 mutex_lock(&sensor->operation_mutex);
\r
638 if(*(unsigned int *)argp)
\r
640 if(sensor->status_cur == SENSOR_OFF)
\r
642 if ( (result = sensor->ops->active(client, 1, ODR100_BW12_5) ) < 0 ) {
\r
643 mutex_unlock(&sensor->operation_mutex);
\r
644 printk("%s:fail to active sensor,ret=%d\n",__func__,result);
\r
647 if(sensor->pdata->irq_enable)
\r
649 DBG("%s:enable irq,irq=%d\n",__func__,client->irq);
\r
650 enable_irq(client->irq); //enable irq
\r
654 PREPARE_DELAYED_WORK(&sensor->delaywork, sensor_delaywork_func);
\r
655 schedule_delayed_work(&sensor->delaywork, msecs_to_jiffies(sensor->pdata->poll_delay_ms));
\r
657 sensor->status_cur = SENSOR_ON;
\r
662 if(sensor->status_cur == SENSOR_ON)
\r
664 if ( (result = sensor->ops->active(client, 0, 0) ) < 0 ) {
\r
665 mutex_unlock(&sensor->operation_mutex);
\r
669 if(sensor->pdata->irq_enable)
\r
671 DBG("%s:disable irq,irq=%d\n",__func__,client->irq);
\r
672 disable_irq_nosync(client->irq);//disable irq
\r
675 cancel_delayed_work_sync(&sensor->delaywork);
\r
676 sensor->status_cur = SENSOR_OFF;
\r
680 result = sensor->status_cur;
\r
681 if (copy_to_user(argp, &result, sizeof(result)))
\r
683 printk("%s:failed to copy sense data to user space.\n",__FUNCTION__);
\r
687 mutex_unlock(&sensor->operation_mutex);
\r
688 DBG("%s:L3G4200D_IOCTL_SET_ENABLE OK\n", __func__);
\r
690 case L3G4200D_IOCTL_SET_DELAY:
\r
691 mutex_lock(&sensor->operation_mutex);
\r
692 if (copy_from_user(&rate, argp, sizeof(rate)))
\r
694 if(sensor->status_cur == SENSOR_OFF)
\r
696 if ( (result = sensor->ops->active(client, 1, rate) ) < 0 ) {
\r
697 mutex_unlock(&sensor->operation_mutex);
\r
698 printk("%s:fail to active sensor,ret=%d\n",__func__,result);
\r
702 if(sensor->pdata->irq_enable)
\r
704 DBG("%s:enable irq,irq=%d\n",__func__,client->irq);
\r
705 enable_irq(client->irq); //enable irq
\r
709 PREPARE_DELAYED_WORK(&sensor->delaywork, sensor_delaywork_func);
\r
710 schedule_delayed_work(&sensor->delaywork, msecs_to_jiffies(sensor->pdata->poll_delay_ms));
\r
712 sensor->status_cur = SENSOR_ON;
\r
715 mutex_unlock(&sensor->operation_mutex);
\r
716 DBG("%s :L3G4200D_IOCTL_SET_DELAY,rate=%d\n",__FUNCTION__,rate);
\r
720 printk("%s:error,cmd=0x%x\n",__func__,cmd);
\r
724 DBG("%s:line=%d,cmd=0x%x\n",__func__,__LINE__,cmd);
\r
730 static int light_dev_open(struct inode *inode, struct file *file)
\r
732 //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_LIGHT];
\r
733 //struct i2c_client *client = sensor->client;
\r
743 static int light_dev_release(struct inode *inode, struct file *file)
\r
745 //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_LIGHT];
\r
746 //struct i2c_client *client = sensor->client;
\r
754 /* ioctl - I/O control */
\r
755 static long light_dev_ioctl(struct file *file,
\r
756 unsigned int cmd, unsigned long arg)
\r
758 struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_LIGHT];
\r
759 struct i2c_client *client = sensor->client;
\r
760 unsigned int *argp = (unsigned int *)arg;
\r
765 case LIGHTSENSOR_IOCTL_GET_ENABLED:
\r
766 *argp = sensor->status_cur;
\r
768 case LIGHTSENSOR_IOCTL_ENABLE:
\r
769 DBG("%s:LIGHTSENSOR_IOCTL_ENABLE start\n", __func__);
\r
770 mutex_lock(&sensor->operation_mutex);
\r
771 if(*(unsigned int *)argp)
\r
773 if(sensor->status_cur == SENSOR_OFF)
\r
775 if ( (result = sensor->ops->active(client, SENSOR_ON, 0) ) < 0 ) {
\r
776 mutex_unlock(&sensor->operation_mutex);
\r
777 printk("%s:fail to active sensor,ret=%d\n",__func__,result);
\r
781 if(!sensor->pdata->irq_enable)
\r
783 PREPARE_DELAYED_WORK(&sensor->delaywork, sensor_delaywork_func);
\r
784 schedule_delayed_work(&sensor->delaywork, msecs_to_jiffies(sensor->pdata->poll_delay_ms));
\r
786 sensor->status_cur = SENSOR_ON;
\r
791 if(sensor->status_cur == SENSOR_ON)
\r
793 if ( (result = sensor->ops->active(client, SENSOR_OFF, 0) ) < 0 ) {
\r
794 mutex_unlock(&sensor->operation_mutex);
\r
798 if(!sensor->pdata->irq_enable)
\r
799 cancel_delayed_work_sync(&sensor->delaywork);
\r
800 sensor->status_cur = SENSOR_OFF;
\r
803 mutex_unlock(&sensor->operation_mutex);
\r
804 DBG("%s:LIGHTSENSOR_IOCTL_ENABLE OK\n", __func__);
\r
816 static int proximity_dev_open(struct inode *inode, struct file *file)
\r
818 //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_PROXIMITY];
\r
819 //struct i2c_client *client = sensor->client;
\r
827 static int proximity_dev_release(struct inode *inode, struct file *file)
\r
829 //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_PROXIMITY];
\r
830 //struct i2c_client *client = sensor->client;
\r
838 /* ioctl - I/O control */
\r
839 static long proximity_dev_ioctl(struct file *file,
\r
840 unsigned int cmd, unsigned long arg)
\r
842 struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_PROXIMITY];
\r
843 struct i2c_client *client = sensor->client;
\r
844 unsigned int *argp = (unsigned int *)arg;
\r
848 case PSENSOR_IOCTL_GET_ENABLED:
\r
849 *argp = sensor->status_cur;
\r
851 case PSENSOR_IOCTL_ENABLE:
\r
852 DBG("%s:PSENSOR_IOCTL_ENABLE start\n", __func__);
\r
853 mutex_lock(&sensor->operation_mutex);
\r
854 if(*(unsigned int *)argp)
\r
856 if(sensor->status_cur == SENSOR_OFF)
\r
858 if ( (result = sensor->ops->active(client, SENSOR_ON, 0) ) < 0 ) {
\r
859 mutex_unlock(&sensor->operation_mutex);
\r
860 printk("%s:fail to active sensor,ret=%d\n",__func__,result);
\r
864 if(!sensor->pdata->irq_enable)
\r
866 PREPARE_DELAYED_WORK(&sensor->delaywork, sensor_delaywork_func);
\r
867 schedule_delayed_work(&sensor->delaywork, msecs_to_jiffies(sensor->pdata->poll_delay_ms));
\r
869 sensor->status_cur = SENSOR_ON;
\r
874 if(sensor->status_cur == SENSOR_ON)
\r
876 if ( (result = sensor->ops->active(client, SENSOR_OFF, 0) ) < 0 ) {
\r
877 mutex_unlock(&sensor->operation_mutex);
\r
880 if(!sensor->pdata->irq_enable)
\r
881 cancel_delayed_work_sync(&sensor->delaywork);
\r
882 sensor->status_cur = SENSOR_OFF;
\r
885 mutex_unlock(&sensor->operation_mutex);
\r
886 DBG("%s:PSENSOR_IOCTL_ENABLE OK\n", __func__);
\r
897 static int temperature_dev_open(struct inode *inode, struct file *file)
\r
899 //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_TEMPERATURE];
\r
900 //struct i2c_client *client = sensor->client;
\r
909 static int temperature_dev_release(struct inode *inode, struct file *file)
\r
911 //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_TEMPERATURE];
\r
912 //struct i2c_client *client = sensor->client;
\r
921 /* ioctl - I/O control */
\r
922 static long temperature_dev_ioctl(struct file *file,
\r
923 unsigned int cmd, unsigned long arg)
\r
925 //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_TEMPERATURE];
\r
926 //struct i2c_client *client = sensor->client;
\r
927 //void __user *argp = (void __user *)arg;
\r
935 static int sensor_misc_device_register(struct sensor_private_data *sensor, int type)
\r
941 case SENSOR_TYPE_ACCEL:
\r
942 if(!sensor->ops->misc_dev)
\r
944 sensor->fops.owner = THIS_MODULE;
\r
945 sensor->fops.unlocked_ioctl = gsensor_dev_ioctl;
\r
946 sensor->fops.open = gsensor_dev_open;
\r
947 sensor->fops.release = gsensor_dev_release;
\r
949 sensor->miscdev.minor = MISC_DYNAMIC_MINOR;
\r
950 sensor->miscdev.name = "mma8452_daemon";
\r
951 sensor->miscdev.fops = &sensor->fops;
\r
955 memcpy(&sensor->miscdev, sensor->ops->misc_dev, sizeof(*sensor->ops->misc_dev));
\r
961 case SENSOR_TYPE_COMPASS:
\r
962 if(!sensor->ops->misc_dev)
\r
964 sensor->fops.owner = THIS_MODULE;
\r
965 sensor->fops.unlocked_ioctl = compass_dev_ioctl;
\r
966 sensor->fops.open = compass_dev_open;
\r
967 sensor->fops.release = compass_dev_release;
\r
969 sensor->miscdev.minor = MISC_DYNAMIC_MINOR;
\r
970 sensor->miscdev.name = "compass";
\r
971 sensor->miscdev.fops = &sensor->fops;
\r
975 memcpy(&sensor->miscdev, sensor->ops->misc_dev, sizeof(*sensor->ops->misc_dev));
\r
981 case SENSOR_TYPE_GYROSCOPE:
\r
982 if(!sensor->ops->misc_dev)
\r
984 sensor->fops.owner = THIS_MODULE;
\r
985 sensor->fops.unlocked_ioctl = gyro_dev_ioctl;
\r
986 sensor->fops.open = gyro_dev_open;
\r
987 sensor->fops.release = gyro_dev_release;
\r
989 sensor->miscdev.minor = MISC_DYNAMIC_MINOR;
\r
990 sensor->miscdev.name = "gyrosensor";
\r
991 sensor->miscdev.fops = &sensor->fops;
\r
995 memcpy(&sensor->miscdev, sensor->ops->misc_dev, sizeof(*sensor->ops->misc_dev));
\r
1001 case SENSOR_TYPE_LIGHT:
\r
1002 if(!sensor->ops->misc_dev)
\r
1004 sensor->fops.owner = THIS_MODULE;
\r
1005 sensor->fops.unlocked_ioctl = light_dev_ioctl;
\r
1006 sensor->fops.open = light_dev_open;
\r
1007 sensor->fops.release = light_dev_release;
\r
1009 sensor->miscdev.minor = MISC_DYNAMIC_MINOR;
\r
1010 sensor->miscdev.name = "lightsensor";
\r
1011 sensor->miscdev.fops = &sensor->fops;
\r
1015 memcpy(&sensor->miscdev, sensor->ops->misc_dev, sizeof(*sensor->ops->misc_dev));
\r
1020 case SENSOR_TYPE_PROXIMITY:
\r
1021 if(!sensor->ops->misc_dev)
\r
1023 sensor->fops.owner = THIS_MODULE;
\r
1024 sensor->fops.unlocked_ioctl = proximity_dev_ioctl;
\r
1025 sensor->fops.open = proximity_dev_open;
\r
1026 sensor->fops.release = proximity_dev_release;
\r
1028 sensor->miscdev.minor = MISC_DYNAMIC_MINOR;
\r
1029 sensor->miscdev.name = "psensor";
\r
1030 sensor->miscdev.fops = &sensor->fops;
\r
1034 memcpy(&sensor->miscdev, sensor->ops->misc_dev, sizeof(*sensor->ops->misc_dev));
\r
1039 case SENSOR_TYPE_TEMPERATURE:
\r
1040 if(!sensor->ops->misc_dev)
\r
1042 sensor->fops.owner = THIS_MODULE;
\r
1043 sensor->fops.unlocked_ioctl = temperature_dev_ioctl;
\r
1044 sensor->fops.open = temperature_dev_open;
\r
1045 sensor->fops.release = temperature_dev_release;
\r
1047 sensor->miscdev.minor = MISC_DYNAMIC_MINOR;
\r
1048 sensor->miscdev.name = "temperature";
\r
1049 sensor->miscdev.fops = &sensor->fops;
\r
1053 memcpy(&sensor->miscdev, sensor->ops->misc_dev, sizeof(*sensor->ops->misc_dev));
\r
1060 printk("%s:unknow sensor type=%d\n",__func__,type);
\r
1065 sensor->miscdev.parent = &sensor->client->dev;
\r
1066 result = misc_register(&sensor->miscdev);
\r
1068 dev_err(&sensor->client->dev,
\r
1069 "fail to register misc device %s\n", sensor->miscdev.name);
\r
1073 printk("%s:miscdevice: %s\n",__func__,sensor->miscdev.name);
\r
1081 int sensor_register_slave(int type,struct i2c_client *client,
\r
1082 struct sensor_platform_data *slave_pdata,
\r
1083 struct sensor_operate *(*get_sensor_ops)(void))
\r
1086 struct sensor_operate *ops = get_sensor_ops();
\r
1087 if((ops->id_i2c >= SENSOR_NUM_ID) || (ops->id_i2c <= ID_INVALID))
\r
1089 printk("%s:%s id is error %d\n", __func__, ops->name, ops->id_i2c);
\r
1092 sensor_ops[ops->id_i2c] = ops;
\r
1093 printk("%s:%s,id=%d\n",__func__,sensor_ops[ops->id_i2c]->name, ops->id_i2c);
\r
1098 int sensor_unregister_slave(int type,struct i2c_client *client,
\r
1099 struct sensor_platform_data *slave_pdata,
\r
1100 struct sensor_operate *(*get_sensor_ops)(void))
\r
1103 struct sensor_operate *ops = get_sensor_ops();
\r
1104 if((ops->id_i2c >= SENSOR_NUM_ID) || (ops->id_i2c <= ID_INVALID))
\r
1106 printk("%s:%s id is error %d\n", __func__, ops->name, ops->id_i2c);
\r
1109 printk("%s:%s,id=%d\n",__func__,sensor_ops[ops->id_i2c]->name, ops->id_i2c);
\r
1110 sensor_ops[ops->id_i2c] = NULL;
\r
1115 int sensor_probe(struct i2c_client *client, const struct i2c_device_id *devid)
\r
1117 struct sensor_private_data *sensor =
\r
1118 (struct sensor_private_data *) i2c_get_clientdata(client);
\r
1119 struct sensor_platform_data *pdata;
\r
1122 dev_info(&client->adapter->dev, "%s: %s,0x%x\n", __func__, devid->name,(unsigned int)client);
\r
1124 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
\r
1129 pdata = client->dev.platform_data;
\r
1131 dev_err(&client->adapter->dev,
\r
1132 "Missing platform data for slave %s\n", devid->name);
\r
1137 sensor = kzalloc(sizeof(*sensor), GFP_KERNEL);
\r
1143 type= pdata->type;
\r
1145 if((type >= SENSOR_NUM_TYPES) || (type <= SENSOR_TYPE_NULL))
\r
1147 dev_err(&client->adapter->dev, "sensor type is error %d\n", pdata->type);
\r
1149 goto out_no_free;
\r
1152 if(((int)devid->driver_data >= SENSOR_NUM_ID) || ((int)devid->driver_data <= ID_INVALID))
\r
1154 dev_err(&client->adapter->dev, "sensor id is error %d\n", (int)devid->driver_data);
\r
1156 goto out_no_free;
\r
1159 i2c_set_clientdata(client, sensor);
\r
1160 sensor->client = client;
\r
1161 sensor->pdata = pdata;
\r
1162 sensor->type = type;
\r
1163 sensor->i2c_id = (struct i2c_device_id *)devid;
\r
1165 if (pdata->init_platform_hw) {
\r
1166 result = pdata->init_platform_hw();
\r
1168 goto out_free_memory;
\r
1171 memset(&(sensor->axis), 0, sizeof(struct sensor_axis) );
\r
1172 atomic_set(&(sensor->data_ready), 0);
\r
1173 init_waitqueue_head(&(sensor->data_ready_wq));
\r
1174 mutex_init(&sensor->data_mutex);
\r
1175 mutex_init(&sensor->operation_mutex);
\r
1176 mutex_init(&sensor->sensor_mutex);
\r
1177 mutex_init(&sensor->i2c_mutex);
\r
1179 sensor->status_cur = SENSOR_OFF;
\r
1180 sensor->axis.x = 0;
\r
1181 sensor->axis.y = 0;
\r
1182 sensor->axis.z = 0;
\r
1184 result = sensor_chip_init(sensor->client);
\r
1186 goto out_free_memory;
\r
1188 sensor->input_dev = input_allocate_device();
\r
1189 if (!sensor->input_dev) {
\r
1191 dev_err(&client->dev,
\r
1192 "Failed to allocate input device %s\n", sensor->input_dev->name);
\r
1193 goto out_free_memory;
\r
1198 case SENSOR_TYPE_ACCEL:
\r
1199 sensor->input_dev->name = "gsensor";
\r
1200 set_bit(EV_ABS, sensor->input_dev->evbit);
\r
1201 /* x-axis acceleration */
\r
1202 input_set_abs_params(sensor->input_dev, ABS_X, sensor->ops->range[0], sensor->ops->range[1], 0, 0); //2g full scale range
\r
1203 /* y-axis acceleration */
\r
1204 input_set_abs_params(sensor->input_dev, ABS_Y, sensor->ops->range[0], sensor->ops->range[1], 0, 0); //2g full scale range
\r
1205 /* z-axis acceleration */
\r
1206 input_set_abs_params(sensor->input_dev, ABS_Z, sensor->ops->range[0], sensor->ops->range[1], 0, 0); //2g full scale range
\r
1208 case SENSOR_TYPE_COMPASS:
\r
1209 sensor->input_dev->name = "compass";
\r
1210 /* Setup input device */
\r
1211 set_bit(EV_ABS, sensor->input_dev->evbit);
\r
1212 /* yaw (0, 360) */
\r
1213 input_set_abs_params(sensor->input_dev, ABS_RX, 0, 23040, 0, 0);
\r
1214 /* pitch (-180, 180) */
\r
1215 input_set_abs_params(sensor->input_dev, ABS_RY, -11520, 11520, 0, 0);
\r
1216 /* roll (-90, 90) */
\r
1217 input_set_abs_params(sensor->input_dev, ABS_RZ, -5760, 5760, 0, 0);
\r
1218 /* x-axis acceleration (720 x 8G) */
\r
1219 input_set_abs_params(sensor->input_dev, ABS_X, -5760, 5760, 0, 0);
\r
1220 /* y-axis acceleration (720 x 8G) */
\r
1221 input_set_abs_params(sensor->input_dev, ABS_Y, -5760, 5760, 0, 0);
\r
1222 /* z-axis acceleration (720 x 8G) */
\r
1223 input_set_abs_params(sensor->input_dev, ABS_Z, -5760, 5760, 0, 0);
\r
1224 /* status of magnetic sensor */
\r
1225 input_set_abs_params(sensor->input_dev, ABS_RUDDER, -32768, 3, 0, 0);
\r
1226 /* status of acceleration sensor */
\r
1227 input_set_abs_params(sensor->input_dev, ABS_WHEEL, -32768, 3, 0, 0);
\r
1228 /* x-axis of raw magnetic vector (-4096, 4095) */
\r
1229 input_set_abs_params(sensor->input_dev, ABS_HAT0X, -20480, 20479, 0, 0);
\r
1230 /* y-axis of raw magnetic vector (-4096, 4095) */
\r
1231 input_set_abs_params(sensor->input_dev, ABS_HAT0Y, -20480, 20479, 0, 0);
\r
1232 /* z-axis of raw magnetic vector (-4096, 4095) */
\r
1233 input_set_abs_params(sensor->input_dev, ABS_BRAKE, -20480, 20479, 0, 0);
\r
1235 case SENSOR_TYPE_GYROSCOPE:
\r
1236 sensor->input_dev->name = "gyro";
\r
1237 /* x-axis acceleration */
\r
1238 input_set_capability(sensor->input_dev, EV_REL, REL_RX);
\r
1239 input_set_abs_params(sensor->input_dev, ABS_RX, sensor->ops->range[0], sensor->ops->range[1], 0, 0);
\r
1240 /* y-axis acceleration */
\r
1241 input_set_capability(sensor->input_dev, EV_REL, REL_RY);
\r
1242 input_set_abs_params(sensor->input_dev, ABS_RY, sensor->ops->range[0], sensor->ops->range[1], 0, 0);
\r
1243 /* z-axis acceleration */
\r
1244 input_set_capability(sensor->input_dev, EV_REL, REL_RZ);
\r
1245 input_set_abs_params(sensor->input_dev, ABS_RZ, sensor->ops->range[0], sensor->ops->range[1], 0, 0);
\r
1247 case SENSOR_TYPE_LIGHT:
\r
1248 sensor->input_dev->name = "lightsensor-level";
\r
1249 set_bit(EV_ABS, sensor->input_dev->evbit);
\r
1250 input_set_abs_params(sensor->input_dev, ABS_MISC, sensor->ops->range[0], sensor->ops->range[1], 0, 0);
\r
1251 input_set_abs_params(sensor->input_dev, ABS_TOOL_WIDTH , sensor->ops->brightness[0],sensor->ops->brightness[1], 0, 0);
\r
1253 case SENSOR_TYPE_PROXIMITY:
\r
1254 sensor->input_dev->name = "proximity";
\r
1255 set_bit(EV_ABS, sensor->input_dev->evbit);
\r
1256 input_set_abs_params(sensor->input_dev, ABS_DISTANCE, sensor->ops->range[0], sensor->ops->range[1], 0, 0);
\r
1258 case SENSOR_TYPE_TEMPERATURE:
\r
1259 sensor->input_dev->name = "temperature";
\r
1260 set_bit(EV_ABS, sensor->input_dev->evbit);
\r
1261 input_set_abs_params(sensor->input_dev, ABS_THROTTLE, sensor->ops->range[0], sensor->ops->range[1], 0, 0);
\r
1264 printk("%s:unknow sensor type=%d\n",__func__,type);
\r
1268 sensor->input_dev->dev.parent = &client->dev;
\r
1270 result = input_register_device(sensor->input_dev);
\r
1272 dev_err(&client->dev,
\r
1273 "Unable to register input device %s\n", sensor->input_dev->name);
\r
1274 goto out_input_register_device_failed;
\r
1277 result = sensor_irq_init(sensor->client);
\r
1279 dev_err(&client->dev,
\r
1280 "fail to init sensor irq,ret=%d\n",result);
\r
1281 goto out_input_register_device_failed;
\r
1285 sensor->miscdev.parent = &client->dev;
\r
1286 result = sensor_misc_device_register(sensor, type);
\r
1288 dev_err(&client->dev,
\r
1289 "fail to register misc device %s\n", sensor->miscdev.name);
\r
1290 goto out_misc_device_register_device_failed;
\r
1293 g_sensor[type] = sensor;
\r
1295 if((type == SENSOR_TYPE_ACCEL) && (sensor->pdata->factory)) //only support setting gsensor orientation online now
\r
1297 result = gsensor_class_init();
\r
1299 dev_err(&client->dev,
\r
1300 "fail to register misc device %s\n", sensor->i2c_id->name);
\r
1301 goto out_misc_device_register_device_failed;
\r
1305 #ifdef CONFIG_HAS_EARLYSUSPEND
\r
1306 if((sensor->ops->suspend) && (sensor->ops->resume))
\r
1308 sensor->early_suspend.suspend = sensor_suspend;
\r
1309 sensor->early_suspend.resume = sensor_resume;
\r
1310 sensor->early_suspend.level = 0x02;
\r
1311 register_early_suspend(&sensor->early_suspend);
\r
1315 printk("%s:initialized ok,sensor name:%s,type:%d,id=%d\n\n",__func__,sensor->ops->name,type,(int)sensor->i2c_id->driver_data);
\r
1319 out_misc_device_register_device_failed:
\r
1320 input_unregister_device(sensor->input_dev);
\r
1321 out_input_register_device_failed:
\r
1322 input_free_device(sensor->input_dev);
\r
1326 dev_err(&client->adapter->dev, "%s failed %d\n", __func__, result);
\r
1331 static void sensor_shut_down(struct i2c_client *client)
\r
1333 #ifdef CONFIG_HAS_EARLYSUSPEND
\r
1334 struct sensor_private_data *sensor =
\r
1335 (struct sensor_private_data *) i2c_get_clientdata(client);
\r
1336 if((sensor->ops->suspend) && (sensor->ops->resume))
\r
1337 unregister_early_suspend(&sensor->early_suspend);
\r
1338 DBG("%s:%s\n",__func__,sensor->i2c_id->name);
\r
1342 static int sensor_remove(struct i2c_client *client)
\r
1344 struct sensor_private_data *sensor =
\r
1345 (struct sensor_private_data *) i2c_get_clientdata(client);
\r
1348 cancel_delayed_work_sync(&sensor->delaywork);
\r
1349 misc_deregister(&sensor->miscdev);
\r
1350 input_unregister_device(sensor->input_dev);
\r
1351 input_free_device(sensor->input_dev);
\r
1353 #ifdef CONFIG_HAS_EARLYSUSPEND
\r
1354 if((sensor->ops->suspend) && (sensor->ops->resume))
\r
1355 unregister_early_suspend(&sensor->early_suspend);
\r
1360 static const struct i2c_device_id sensor_id[] = {
\r
1362 {"gsensor", ACCEL_ID_ALL},
\r
1363 {"gs_mma8452", ACCEL_ID_MMA845X},
\r
1364 {"gs_kxtik", ACCEL_ID_KXTIK},
\r
1365 {"gs_lis3dh", ACCEL_ID_LIS3DH},
\r
1366 {"gs_mma7660", ACCEL_ID_MMA7660},
\r
1368 {"compass", COMPASS_ID_ALL},
\r
1369 {"ak8975", COMPASS_ID_AK8975},
\r
1370 {"mmc314x", COMPASS_ID_MMC314X},
\r
1372 {"gyro", GYRO_ID_ALL},
\r
1373 {"l3g4200d_gryo", GYRO_ID_L3G4200D},
\r
1374 {"k3g", GYRO_ID_K3G},
\r
1376 {"lightsensor", LIGHT_ID_ALL},
\r
1377 {"light_cm3217", LIGHT_ID_CM3217},
\r
1378 {"light_al3006", LIGHT_ID_AL3006},
\r
1379 {"ls_stk3171", LIGHT_ID_STK3171},
\r
1380 /*proximity sensor*/
\r
1381 {"psensor", PROXIMITY_ID_ALL},
\r
1382 {"proximity_al3006", PROXIMITY_ID_AL3006},
\r
1383 {"ps_stk3171", PROXIMITY_ID_STK3171},
\r
1385 {"temperature", TEMPERATURE_ID_ALL},
\r
1390 static struct i2c_driver sensor_driver = {
\r
1391 .probe = sensor_probe,
\r
1392 .remove = sensor_remove,
\r
1393 .shutdown = sensor_shut_down,
\r
1394 .id_table = sensor_id,
\r
1396 .owner = THIS_MODULE,
\r
1397 .name = "sensors",
\r
1401 static int __init sensor_init(void)
\r
1403 int res = i2c_add_driver(&sensor_driver);
\r
1404 pr_info("%s: Probe name %s\n", __func__, sensor_driver.driver.name);
\r
1406 pr_err("%s failed\n", __func__);
\r
1410 static void __exit sensor_exit(void)
\r
1412 pr_info("%s\n", __func__);
\r
1413 i2c_del_driver(&sensor_driver);
\r
1416 late_initcall(sensor_init);
\r
1417 module_exit(sensor_exit);
\r
1419 MODULE_AUTHOR("ROCKCHIP Corporation:lw@rock-chips.com");
\r
1420 MODULE_DESCRIPTION("User space character device interface for sensors");
\r
1421 MODULE_LICENSE("GPL");
\r