-/* drivers/input/sensors/sensor-dev.c - handle all gsensor in this file\r
- *\r
- * Copyright (C) 2012-2015 ROCKCHIP.\r
- * Author: luowei <lw@rock-chips.com>\r
- *\r
- * This software is licensed under the terms of the GNU General Public\r
- * License version 2, as published by the Free Software Foundation, and\r
- * may be copied, distributed, and modified under those terms.\r
- *\r
- * This program is distributed in the hope that it will be useful,\r
- * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\r
- * GNU General Public License for more details.\r
- *\r
- */\r
-\r
-#include <linux/interrupt.h>\r
-#include <linux/i2c.h>\r
-#include <linux/slab.h>\r
-#include <linux/irq.h>\r
-#include <linux/miscdevice.h>\r
-#include <linux/gpio.h>\r
-#include <asm/uaccess.h>\r
-#include <asm/atomic.h>\r
-#include <linux/delay.h>\r
-#include <linux/input.h>\r
-#include <linux/workqueue.h>\r
-#include <linux/freezer.h>\r
-#include <linux/proc_fs.h>\r
-#include <linux/gpio.h>\r
-#include <linux/of_gpio.h>\r
-#include <linux/of.h>\r
-#ifdef CONFIG_HAS_EARLYSUSPEND\r
-#include <linux/earlysuspend.h>\r
-#endif\r
-#include <linux/l3g4200d.h>\r
-#include <linux/sensor-dev.h>\r
-#include <linux/module.h>\r
+/* drivers/input/sensors/sensor-dev.c - handle all gsensor in this file
+ *
+ * Copyright (C) 2012-2015 ROCKCHIP.
+ * Author: luowei <lw@rock-chips.com>
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ */
+
+#include <linux/interrupt.h>
+#include <linux/i2c.h>
+#include <linux/slab.h>
+#include <linux/irq.h>
+#include <linux/miscdevice.h>
+#include <linux/gpio.h>
+#include <asm/uaccess.h>
+#include <asm/atomic.h>
+#include <linux/delay.h>
+#include <linux/input.h>
+#include <linux/workqueue.h>
+#include <linux/freezer.h>
+#include <linux/proc_fs.h>
+#include <linux/gpio.h>
+#include <linux/of_gpio.h>
+#include <linux/of.h>
+#ifdef CONFIG_HAS_EARLYSUSPEND
+#include <linux/earlysuspend.h>
+#endif
+#include <linux/l3g4200d.h>
+#include <linux/sensor-dev.h>
+#include <linux/module.h>
#ifdef CONFIG_COMPAT
#include <linux/compat.h>
#endif
-\r
-\r
-/*\r
-sensor-dev.c v1.1 add pressure and temperature support 2013-2-27\r
-sensor-dev.c v1.2 add akm8963 support 2013-3-10\r
-sensor-dev.c v1.3 add sensor debug support 2013-3-15\r
-sensor-dev.c v1.4 add angle calculation support between two gsensors 2013-09-01\r
-*/\r
-\r
-#define SENSOR_VERSION_AND_TIME "sensor-dev.c v1.4 add angle calculation support between two gsensors 2013-09-01"\r
-\r
-\r
-struct sensor_private_data *g_sensor[SENSOR_NUM_TYPES];\r
-static struct sensor_operate *sensor_ops[SENSOR_NUM_ID]; \r
-static struct class *g_sensor_class[SENSOR_NUM_TYPES];\r
-\r
-static ssize_t sensor_proc_write(struct file *file, const char __user *buffer,\r
- size_t count, loff_t *data)\r
-{\r
- char c;\r
- int rc;\r
- int i = 0, num = 0;\r
- \r
- rc = get_user(c, buffer);\r
- if (rc)\r
- {\r
- for(i=SENSOR_TYPE_NULL+1; i<SENSOR_NUM_TYPES; i++)\r
- atomic_set(&g_sensor[i]->flags.debug_flag, SENSOR_TYPE_NULL);\r
- return rc; \r
- }\r
-\r
- \r
- num = c - '0';\r
-\r
- printk("%s command list:close:%d,angle:%d accel:%d, compass:%d, gyro:%d, light:%d, psensor:%d, temp:%d, pressure:%d,total:%d,num=%d\n",__func__,\r
- \r
- SENSOR_TYPE_NULL, SENSOR_TYPE_ANGLE, SENSOR_TYPE_ACCEL,SENSOR_TYPE_COMPASS,SENSOR_TYPE_GYROSCOPE,SENSOR_TYPE_LIGHT,SENSOR_TYPE_PROXIMITY,\r
-\r
- SENSOR_TYPE_TEMPERATURE,SENSOR_TYPE_PRESSURE,SENSOR_NUM_TYPES,num);\r
-\r
- if((num > SENSOR_NUM_TYPES) || (num < SENSOR_TYPE_NULL))\r
- {\r
- printk("%s:error! only support %d to %d\n",__func__, SENSOR_TYPE_NULL,SENSOR_NUM_TYPES);\r
- return -1;\r
- }\r
-\r
- for(i=SENSOR_TYPE_NULL+1; i<SENSOR_NUM_TYPES; i++)\r
- {\r
- if(g_sensor[i])\r
- atomic_set(&g_sensor[i]->flags.debug_flag, num);\r
- }\r
- \r
- return count; \r
-}\r
-\r
-static const struct file_operations sensor_proc_fops = {\r
- .owner = THIS_MODULE, \r
- .write = sensor_proc_write,\r
-};\r
-\r
-\r
-\r
-static int sensor_get_id(struct i2c_client *client, int *value)\r
-{\r
- struct sensor_private_data *sensor =\r
- (struct sensor_private_data *) i2c_get_clientdata(client); \r
- int result = 0;\r
- char temp = sensor->ops->id_reg;\r
- int i = 0;\r
-\r
- if(sensor->ops->id_reg >= 0)\r
- {\r
- for(i=0; i<3; i++)\r
- {\r
- result = sensor_rx_data(client, &temp, 1);\r
- *value = temp;\r
- if(!result)\r
- break;\r
- }\r
-\r
- if(result)\r
- return result;\r
-\r
- if(*value != sensor->ops->id_data)\r
- {\r
- printk("%s:id=0x%x is not 0x%x\n",__func__,*value, sensor->ops->id_data);\r
- result = -1;\r
- }\r
- \r
- DBG("%s:devid=0x%x\n",__func__,*value);\r
- }\r
- \r
- return result;\r
-}\r
-\r
-static int sensor_initial(struct i2c_client *client)\r
-{\r
- struct sensor_private_data *sensor =\r
- (struct sensor_private_data *) i2c_get_clientdata(client); \r
- int result = 0;\r
-\r
- //register setting according to chip datasheet \r
- result = sensor->ops->init(client);\r
- if(result < 0)\r
- {\r
- printk("%s:fail to init sensor\n",__func__);\r
- return result;\r
- }\r
-\r
-\r
- DBG("%s:ctrl_data=0x%x\n",__func__,sensor->ops->ctrl_data);\r
- \r
- return result;\r
-\r
-}\r
-\r
-static int sensor_chip_init(struct i2c_client *client)\r
-{\r
- struct sensor_private_data *sensor =\r
- (struct sensor_private_data *) i2c_get_clientdata(client); \r
- struct sensor_operate *ops = sensor_ops[(int)sensor->i2c_id->driver_data];\r
- int result = 0;\r
- \r
- if(ops)\r
- {\r
- sensor->ops = ops;\r
- }\r
- else\r
- {\r
- printk("%s:ops is null,sensor name is %s\n",__func__,sensor->i2c_id->name);\r
- result = -1;\r
- goto error;\r
- }\r
-\r
- if((sensor->type != ops->type) || ((int)sensor->i2c_id->driver_data != ops->id_i2c))\r
- {\r
- 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
- result = -1;\r
- goto error;\r
- }\r
- \r
- if(!ops->init || !ops->active || !ops->report)\r
- {\r
- printk("%s:error:some function is needed\n",__func__); \r
- result = -1;\r
- goto error;\r
- }\r
-\r
- result = sensor_get_id(sensor->client, &sensor->devid);//get id\r
- if(result < 0)\r
- { \r
- printk("%s:fail to read %s devid:0x%x\n",__func__, sensor->i2c_id->name, sensor->devid); \r
- goto error;\r
- }\r
- \r
- printk("%s:%s:devid=0x%x,ops=0x%p\n",__func__, sensor->i2c_id->name, sensor->devid,sensor->ops);\r
-\r
- result = sensor_initial(sensor->client); //init sensor\r
- if(result < 0)\r
- { \r
- printk("%s:fail to init sensor\n",__func__); \r
- goto error;\r
- }\r
-\r
- return 0;\r
-\r
-error:\r
- \r
- return result;\r
-}\r
-\r
-static int sensor_reset_rate(struct i2c_client *client, int rate)\r
-{\r
- struct sensor_private_data *sensor =\r
- (struct sensor_private_data *) i2c_get_clientdata(client); \r
- int result = 0; \r
- \r
- result = sensor->ops->active(client,SENSOR_OFF,rate);\r
- sensor->ops->init(client);\r
- result = sensor->ops->active(client,SENSOR_ON,rate);\r
-\r
- return result;\r
-}\r
-\r
-static int sensor_get_data(struct i2c_client *client)\r
-{\r
- struct sensor_private_data *sensor =\r
- (struct sensor_private_data *) i2c_get_clientdata(client); \r
- int result = 0;\r
- \r
- result = sensor->ops->report(client);\r
- if(result)\r
- goto error;\r
-\r
- /* set data_ready */\r
- atomic_set(&sensor->data_ready, 1);\r
- /*wake up data_ready work queue*/\r
- wake_up(&sensor->data_ready_wq);\r
- \r
-error: \r
- return result;\r
-}\r
-\r
-#if 0\r
-int sensor_get_cached_data(struct i2c_client* client, char *buffer, int length, struct sensor_axis *axis)\r
-{\r
- struct sensor_private_data* sensor = (struct sensor_private_data *)i2c_get_clientdata(client); \r
- wait_event_interruptible_timeout(sensor->data_ready_wq, \r
- atomic_read(&(sensor->data_ready) ),\r
- msecs_to_jiffies(1000) );\r
- if ( 0 == atomic_read(&(sensor->data_ready) ) ) {\r
- printk("waiting 'data_ready_wq' timed out.");\r
- goto error;\r
- }\r
-\r
- \r
- mutex_lock(&sensor->data_mutex);\r
-\r
- switch(sensor->type)\r
- {\r
- case SENSOR_TYPE_ACCEL:\r
- *axis = sensor->axis;\r
- break;\r
-\r
- case SENSOR_TYPE_COMPASS:\r
- memcpy(buffer, sensor->sensor_data, length);\r
- break;\r
- }\r
- \r
- mutex_unlock(&sensor->data_mutex);\r
- \r
- return 0;\r
- \r
-error:\r
- return -1;\r
-}\r
-#endif\r
-\r
-static void sensor_delaywork_func(struct work_struct *work)\r
-{\r
- struct delayed_work *delaywork = container_of(work, struct delayed_work, work);\r
- struct sensor_private_data *sensor = container_of(delaywork, struct sensor_private_data, delaywork);\r
- struct i2c_client *client = sensor->client;\r
-\r
- mutex_lock(&sensor->sensor_mutex); \r
- if (sensor_get_data(client) < 0) \r
- DBG(KERN_ERR "%s: Get data failed\n",__func__);\r
- \r
- if(!sensor->pdata->irq_enable)//restart work while polling\r
- schedule_delayed_work(&sensor->delaywork, msecs_to_jiffies(sensor->pdata->poll_delay_ms));\r
- //else\r
- //{\r
- //if((sensor->ops->trig == IRQF_TRIGGER_LOW) || (sensor->ops->trig == IRQF_TRIGGER_HIGH))\r
- //enable_irq(sensor->client->irq);\r
- //}\r
- mutex_unlock(&sensor->sensor_mutex);\r
- \r
- DBG("%s:%s\n",__func__,sensor->i2c_id->name);\r
-}\r
-\r
-/*\r
- * This is a threaded IRQ handler so can access I2C/SPI. Since all\r
- * interrupts are clear on read the IRQ line will be reasserted and\r
- * the physical IRQ will be handled again if another interrupt is\r
- * asserted while we run - in the normal course of events this is a\r
- * rare occurrence so we save I2C/SPI reads. We're also assuming that\r
- * it's rare to get lots of interrupts firing simultaneously so try to\r
- * minimise I/O.\r
- */\r
-static irqreturn_t sensor_interrupt(int irq, void *dev_id)\r
-{\r
- struct sensor_private_data *sensor = (struct sensor_private_data *)dev_id;\r
-\r
- //use threaded IRQ\r
- if (sensor_get_data(sensor->client) < 0) \r
- DBG(KERN_ERR "%s: Get data failed\n",__func__);\r
- msleep(sensor->pdata->poll_delay_ms);\r
-\r
- \r
- //if((sensor->ops->trig == IRQF_TRIGGER_LOW) || (sensor->ops->trig == IRQF_TRIGGER_HIGH))\r
- //disable_irq_nosync(irq);\r
- //schedule_delayed_work(&sensor->delaywork, msecs_to_jiffies(sensor->pdata->poll_delay_ms));\r
- DBG("%s:irq=%d\n",__func__,irq);\r
- return IRQ_HANDLED;\r
-}\r
-\r
-\r
-static int sensor_irq_init(struct i2c_client *client)\r
-{\r
- struct sensor_private_data *sensor =\r
- (struct sensor_private_data *) i2c_get_clientdata(client); \r
- int result = 0;\r
- int irq;\r
- if((sensor->pdata->irq_enable)&&(sensor->pdata->irq_flags!= SENSOR_UNKNOW_DATA))\r
- {\r
- //INIT_DELAYED_WORK(&sensor->delaywork, sensor_delaywork_func);\r
- if(sensor->pdata->poll_delay_ms < 0)\r
- sensor->pdata->poll_delay_ms = 30;\r
- result = gpio_request(client->irq, sensor->i2c_id->name);\r
- if (result)\r
- {\r
- printk("%s:fail to request gpio :%d\n",__func__,client->irq);\r
- }\r
- \r
- //gpio_pull_updown(client->irq, PullEnable);\r
- irq = gpio_to_irq(client->irq);\r
- //result = request_irq(irq, sensor_interrupt, sensor->ops->trig, sensor->ops->name, sensor);\r
- //result = request_threaded_irq(irq, NULL, sensor_interrupt, sensor->ops->trig, sensor->ops->name, sensor);\r
- result = devm_request_threaded_irq(&client->dev, irq, NULL, sensor_interrupt, sensor->pdata->irq_flags | IRQF_ONESHOT, sensor->ops->name, sensor);\r
- if (result) {\r
- printk(KERN_ERR "%s:fail to request irq = %d, ret = 0x%x\n",__func__, irq, result); \r
- goto error; \r
- }\r
- client->irq = irq;\r
- if((sensor->pdata->type == SENSOR_TYPE_GYROSCOPE) || (sensor->pdata->type == SENSOR_TYPE_ACCEL) || (sensor->pdata->type == SENSOR_TYPE_ANGLE))\r
- disable_irq_nosync(client->irq);//disable irq\r
- if(((sensor->pdata->type == SENSOR_TYPE_LIGHT) || (sensor->pdata->type == SENSOR_TYPE_PROXIMITY))&& (!(sensor->ops->trig & IRQF_SHARED))) \r
- disable_irq_nosync(client->irq);//disable irq \r
- if(((sensor->pdata->type == SENSOR_TYPE_TEMPERATURE) || (sensor->pdata->type == SENSOR_TYPE_PRESSURE))&& (!(sensor->ops->trig & IRQF_SHARED))) \r
- disable_irq_nosync(client->irq);//disable irq\r
- DBG("%s:use irq=%d\n",__func__,irq);\r
- }\r
- else if(!sensor->pdata->irq_enable)\r
- { \r
- INIT_DELAYED_WORK(&sensor->delaywork, sensor_delaywork_func);\r
- if(sensor->pdata->poll_delay_ms < 0)\r
- sensor->pdata->poll_delay_ms = 30;\r
- \r
- DBG("%s:use polling,delay=%d ms\n",__func__,sensor->pdata->poll_delay_ms);\r
- }\r
-\r
-error: \r
- return result;\r
-}\r
-\r
-#ifdef CONFIG_HAS_EARLYSUSPEND\r
-static void sensor_suspend(struct early_suspend *h)\r
-{\r
- struct sensor_private_data *sensor = \r
- container_of(h, struct sensor_private_data, early_suspend);\r
- \r
- if(sensor->ops->suspend)\r
- sensor->ops->suspend(sensor->client);\r
-\r
-}\r
-\r
-static void sensor_resume(struct early_suspend *h)\r
-{\r
- struct sensor_private_data *sensor = \r
- container_of(h, struct sensor_private_data, early_suspend);\r
-\r
- if(sensor->ops->resume)\r
- sensor->ops->resume(sensor->client);\r
-}\r
-#endif\r
+
+
+/*
+sensor-dev.c v1.1 add pressure and temperature support 2013-2-27
+sensor-dev.c v1.2 add akm8963 support 2013-3-10
+sensor-dev.c v1.3 add sensor debug support 2013-3-15
+sensor-dev.c v1.4 add angle calculation support between two gsensors 2013-09-01
+*/
+
+#define SENSOR_VERSION_AND_TIME "sensor-dev.c v1.4 add angle calculation support between two gsensors 2013-09-01"
+
+
+struct sensor_private_data *g_sensor[SENSOR_NUM_TYPES];
+static struct sensor_operate *sensor_ops[SENSOR_NUM_ID];
+static struct class *g_sensor_class[SENSOR_NUM_TYPES];
+
+static ssize_t sensor_proc_write(struct file *file, const char __user *buffer,
+ size_t count, loff_t *data)
+{
+ char c;
+ int rc;
+ int i = 0, num = 0;
+
+ rc = get_user(c, buffer);
+ if (rc)
+ {
+ for(i=SENSOR_TYPE_NULL+1; i<SENSOR_NUM_TYPES; i++)
+ atomic_set(&g_sensor[i]->flags.debug_flag, SENSOR_TYPE_NULL);
+ return rc;
+ }
+
+
+ num = c - '0';
+
+ printk("%s command list:close:%d,angle:%d accel:%d, compass:%d, gyro:%d, light:%d, psensor:%d, temp:%d, pressure:%d,total:%d,num=%d\n",__func__,
+
+ SENSOR_TYPE_NULL, SENSOR_TYPE_ANGLE, SENSOR_TYPE_ACCEL,SENSOR_TYPE_COMPASS,SENSOR_TYPE_GYROSCOPE,SENSOR_TYPE_LIGHT,SENSOR_TYPE_PROXIMITY,
+
+ SENSOR_TYPE_TEMPERATURE,SENSOR_TYPE_PRESSURE,SENSOR_NUM_TYPES,num);
+
+ if((num > SENSOR_NUM_TYPES) || (num < SENSOR_TYPE_NULL))
+ {
+ printk("%s:error! only support %d to %d\n",__func__, SENSOR_TYPE_NULL,SENSOR_NUM_TYPES);
+ return -1;
+ }
+
+ for(i=SENSOR_TYPE_NULL+1; i<SENSOR_NUM_TYPES; i++)
+ {
+ if(g_sensor[i])
+ atomic_set(&g_sensor[i]->flags.debug_flag, num);
+ }
+
+ return count;
+}
+
+static const struct file_operations sensor_proc_fops = {
+ .owner = THIS_MODULE,
+ .write = sensor_proc_write,
+};
+
+
+
+static int sensor_get_id(struct i2c_client *client, int *value)
+{
+ struct sensor_private_data *sensor =
+ (struct sensor_private_data *) i2c_get_clientdata(client);
+ int result = 0;
+ char temp = sensor->ops->id_reg;
+ int i = 0;
+
+ if(sensor->ops->id_reg >= 0)
+ {
+ for(i=0; i<3; i++)
+ {
+ result = sensor_rx_data(client, &temp, 1);
+ *value = temp;
+ if(!result)
+ break;
+ }
+
+ if(result)
+ return result;
+
+ if(*value != sensor->ops->id_data)
+ {
+ printk("%s:id=0x%x is not 0x%x\n",__func__,*value, sensor->ops->id_data);
+ result = -1;
+ }
+
+ DBG("%s:devid=0x%x\n",__func__,*value);
+ }
+
+ return result;
+}
+
+static int sensor_initial(struct i2c_client *client)
+{
+ struct sensor_private_data *sensor =
+ (struct sensor_private_data *) i2c_get_clientdata(client);
+ int result = 0;
+
+ //register setting according to chip datasheet
+ result = sensor->ops->init(client);
+ if(result < 0)
+ {
+ printk("%s:fail to init sensor\n",__func__);
+ return result;
+ }
+
+
+ DBG("%s:ctrl_data=0x%x\n",__func__,sensor->ops->ctrl_data);
+
+ return result;
+
+}
+
+static int sensor_chip_init(struct i2c_client *client)
+{
+ struct sensor_private_data *sensor =
+ (struct sensor_private_data *) i2c_get_clientdata(client);
+ struct sensor_operate *ops = sensor_ops[(int)sensor->i2c_id->driver_data];
+ int result = 0;
+
+ if(ops)
+ {
+ sensor->ops = ops;
+ }
+ else
+ {
+ printk("%s:ops is null,sensor name is %s\n",__func__,sensor->i2c_id->name);
+ result = -1;
+ goto error;
+ }
+
+ if((sensor->type != ops->type) || ((int)sensor->i2c_id->driver_data != ops->id_i2c))
+ {
+ 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);
+ result = -1;
+ goto error;
+ }
+
+ if(!ops->init || !ops->active || !ops->report)
+ {
+ printk("%s:error:some function is needed\n",__func__);
+ result = -1;
+ goto error;
+ }
+
+ result = sensor_get_id(sensor->client, &sensor->devid);//get id
+ if(result < 0)
+ {
+ printk("%s:fail to read %s devid:0x%x\n",__func__, sensor->i2c_id->name, sensor->devid);
+ goto error;
+ }
+
+ printk("%s:%s:devid=0x%x,ops=0x%p\n",__func__, sensor->i2c_id->name, sensor->devid,sensor->ops);
+
+ result = sensor_initial(sensor->client); //init sensor
+ if(result < 0)
+ {
+ printk("%s:fail to init sensor\n",__func__);
+ goto error;
+ }
+
+ return 0;
+
+error:
+
+ return result;
+}
+
+static int sensor_reset_rate(struct i2c_client *client, int rate)
+{
+ struct sensor_private_data *sensor =
+ (struct sensor_private_data *) i2c_get_clientdata(client);
+ int result = 0;
+
+ result = sensor->ops->active(client,SENSOR_OFF,rate);
+ sensor->ops->init(client);
+ result = sensor->ops->active(client,SENSOR_ON,rate);
+
+ return result;
+}
+
+static int sensor_get_data(struct i2c_client *client)
+{
+ struct sensor_private_data *sensor =
+ (struct sensor_private_data *) i2c_get_clientdata(client);
+ int result = 0;
+
+ result = sensor->ops->report(client);
+ if(result)
+ goto error;
+
+ /* set data_ready */
+ atomic_set(&sensor->data_ready, 1);
+ /*wake up data_ready work queue*/
+ wake_up(&sensor->data_ready_wq);
+
+error:
+ return result;
+}
+
+#if 0
+int sensor_get_cached_data(struct i2c_client* client, char *buffer, int length, struct sensor_axis *axis)
+{
+ struct sensor_private_data* sensor = (struct sensor_private_data *)i2c_get_clientdata(client);
+ wait_event_interruptible_timeout(sensor->data_ready_wq,
+ atomic_read(&(sensor->data_ready) ),
+ msecs_to_jiffies(1000) );
+ if ( 0 == atomic_read(&(sensor->data_ready) ) ) {
+ printk("waiting 'data_ready_wq' timed out.");
+ goto error;
+ }
+
+
+ mutex_lock(&sensor->data_mutex);
+
+ switch(sensor->type)
+ {
+ case SENSOR_TYPE_ACCEL:
+ *axis = sensor->axis;
+ break;
+
+ case SENSOR_TYPE_COMPASS:
+ memcpy(buffer, sensor->sensor_data, length);
+ break;
+ }
+
+ mutex_unlock(&sensor->data_mutex);
+
+ return 0;
+
+error:
+ return -1;
+}
+#endif
+
+static void sensor_delaywork_func(struct work_struct *work)
+{
+ struct delayed_work *delaywork = container_of(work, struct delayed_work, work);
+ struct sensor_private_data *sensor = container_of(delaywork, struct sensor_private_data, delaywork);
+ struct i2c_client *client = sensor->client;
+
+ mutex_lock(&sensor->sensor_mutex);
+ if (sensor_get_data(client) < 0)
+ DBG(KERN_ERR "%s: Get data failed\n",__func__);
+
+ if(!sensor->pdata->irq_enable)//restart work while polling
+ schedule_delayed_work(&sensor->delaywork, msecs_to_jiffies(sensor->pdata->poll_delay_ms));
+ //else
+ //{
+ //if((sensor->ops->trig == IRQF_TRIGGER_LOW) || (sensor->ops->trig == IRQF_TRIGGER_HIGH))
+ //enable_irq(sensor->client->irq);
+ //}
+ mutex_unlock(&sensor->sensor_mutex);
+
+ DBG("%s:%s\n",__func__,sensor->i2c_id->name);
+}
+
+/*
+ * This is a threaded IRQ handler so can access I2C/SPI. Since all
+ * interrupts are clear on read the IRQ line will be reasserted and
+ * the physical IRQ will be handled again if another interrupt is
+ * asserted while we run - in the normal course of events this is a
+ * rare occurrence so we save I2C/SPI reads. We're also assuming that
+ * it's rare to get lots of interrupts firing simultaneously so try to
+ * minimise I/O.
+ */
+static irqreturn_t sensor_interrupt(int irq, void *dev_id)
+{
+ struct sensor_private_data *sensor = (struct sensor_private_data *)dev_id;
+
+ //use threaded IRQ
+ if (sensor_get_data(sensor->client) < 0)
+ DBG(KERN_ERR "%s: Get data failed\n",__func__);
+ msleep(sensor->pdata->poll_delay_ms);
+
+
+ //if((sensor->ops->trig == IRQF_TRIGGER_LOW) || (sensor->ops->trig == IRQF_TRIGGER_HIGH))
+ //disable_irq_nosync(irq);
+ //schedule_delayed_work(&sensor->delaywork, msecs_to_jiffies(sensor->pdata->poll_delay_ms));
+ DBG("%s:irq=%d\n",__func__,irq);
+ return IRQ_HANDLED;
+}
+
+
+static int sensor_irq_init(struct i2c_client *client)
+{
+ struct sensor_private_data *sensor =
+ (struct sensor_private_data *) i2c_get_clientdata(client);
+ int result = 0;
+ int irq;
+ if((sensor->pdata->irq_enable)&&(sensor->pdata->irq_flags!= SENSOR_UNKNOW_DATA))
+ {
+ //INIT_DELAYED_WORK(&sensor->delaywork, sensor_delaywork_func);
+ if(sensor->pdata->poll_delay_ms < 0)
+ sensor->pdata->poll_delay_ms = 30;
+ result = gpio_request(client->irq, sensor->i2c_id->name);
+ if (result)
+ {
+ printk("%s:fail to request gpio :%d\n",__func__,client->irq);
+ }
+
+ //gpio_pull_updown(client->irq, PullEnable);
+ irq = gpio_to_irq(client->irq);
+ //result = request_irq(irq, sensor_interrupt, sensor->ops->trig, sensor->ops->name, sensor);
+ //result = request_threaded_irq(irq, NULL, sensor_interrupt, sensor->ops->trig, sensor->ops->name, sensor);
+ result = devm_request_threaded_irq(&client->dev, irq, NULL, sensor_interrupt, sensor->pdata->irq_flags | IRQF_ONESHOT, sensor->ops->name, sensor);
+ if (result) {
+ printk(KERN_ERR "%s:fail to request irq = %d, ret = 0x%x\n",__func__, irq, result);
+ goto error;
+ }
+ client->irq = irq;
+ if((sensor->pdata->type == SENSOR_TYPE_GYROSCOPE) || (sensor->pdata->type == SENSOR_TYPE_ACCEL) || (sensor->pdata->type == SENSOR_TYPE_ANGLE))
+ disable_irq_nosync(client->irq);//disable irq
+ if(((sensor->pdata->type == SENSOR_TYPE_LIGHT) || (sensor->pdata->type == SENSOR_TYPE_PROXIMITY))&& (!(sensor->ops->trig & IRQF_SHARED)))
+ disable_irq_nosync(client->irq);//disable irq
+ if(((sensor->pdata->type == SENSOR_TYPE_TEMPERATURE) || (sensor->pdata->type == SENSOR_TYPE_PRESSURE))&& (!(sensor->ops->trig & IRQF_SHARED)))
+ disable_irq_nosync(client->irq);//disable irq
+ DBG("%s:use irq=%d\n",__func__,irq);
+ }
+ else if(!sensor->pdata->irq_enable)
+ {
+ INIT_DELAYED_WORK(&sensor->delaywork, sensor_delaywork_func);
+ if(sensor->pdata->poll_delay_ms < 0)
+ sensor->pdata->poll_delay_ms = 30;
+
+ DBG("%s:use polling,delay=%d ms\n",__func__,sensor->pdata->poll_delay_ms);
+ }
+
+error:
+ return result;
+}
+
+#ifdef CONFIG_HAS_EARLYSUSPEND
+static void sensor_suspend(struct early_suspend *h)
+{
+ struct sensor_private_data *sensor =
+ container_of(h, struct sensor_private_data, early_suspend);
+
+ if(sensor->ops->suspend)
+ sensor->ops->suspend(sensor->client);
+
+}
+
+static void sensor_resume(struct early_suspend *h)
+{
+ struct sensor_private_data *sensor =
+ container_of(h, struct sensor_private_data, early_suspend);
+
+ if(sensor->ops->resume)
+ sensor->ops->resume(sensor->client);
+}
+#endif
#ifdef CONFIG_PM
static int sensor_of_suspend(struct device *dev)
#define SENSOR_PM_OPS NULL
#endif
-static int angle_dev_open(struct inode *inode, struct file *file)\r
-{\r
- //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_ACCEL]; \r
- //struct i2c_client *client = sensor->client;\r
-\r
- int result = 0;\r
-\r
-\r
- return result;\r
-}\r
-\r
-\r
-static int angle_dev_release(struct inode *inode, struct file *file)\r
-{\r
- //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_ANGLE]; \r
- //struct i2c_client *client = sensor->client;\r
-\r
- int result = 0;\r
-\r
-\r
- return result;\r
-}\r
-\r
-/* ioctl - I/O control */\r
-static long angle_dev_ioctl(struct file *file,\r
- unsigned int cmd, unsigned long arg)\r
-{\r
- struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_ANGLE];\r
- struct i2c_client *client = sensor->client;\r
- void __user *argp = (void __user *)arg;\r
- struct sensor_axis axis = {0};\r
- char rate;\r
- int result = 0;\r
-\r
- switch (cmd) {\r
- case GSENSOR_IOCTL_APP_SET_RATE:\r
- if (copy_from_user(&rate, argp, sizeof(rate)))\r
- {\r
- result = -EFAULT;\r
- goto error;\r
- }\r
- break;\r
- default:\r
- break;\r
- }\r
-\r
- switch (cmd) {\r
- case GSENSOR_IOCTL_START: \r
- DBG("%s:GSENSOR_IOCTL_START start,status=%d\n", __func__,sensor->status_cur);\r
- mutex_lock(&sensor->operation_mutex); \r
- if(++sensor->start_count == 1)\r
- {\r
- if(sensor->status_cur == SENSOR_OFF)\r
- {\r
- atomic_set(&(sensor->data_ready), 0);\r
- if ( (result = sensor->ops->active(client, 1, 0) ) < 0 ) {\r
- mutex_unlock(&sensor->operation_mutex);\r
- printk("%s:fail to active sensor,ret=%d\n",__func__,result); \r
- goto error; \r
- } \r
- if(sensor->pdata->irq_enable)\r
- {\r
- DBG("%s:enable irq,irq=%d\n",__func__,client->irq);\r
- enable_irq(client->irq); //enable irq\r
- } \r
- else\r
- {\r
- schedule_delayed_work(&sensor->delaywork, msecs_to_jiffies(sensor->pdata->poll_delay_ms));\r
- }\r
- sensor->status_cur = SENSOR_ON;\r
- } \r
- }\r
- mutex_unlock(&sensor->operation_mutex);\r
- DBG("%s:GSENSOR_IOCTL_START OK\n", __func__);\r
- break;\r
-\r
- case GSENSOR_IOCTL_CLOSE: \r
- DBG("%s:GSENSOR_IOCTL_CLOSE start,status=%d\n", __func__,sensor->status_cur);\r
- mutex_lock(&sensor->operation_mutex); \r
- if(--sensor->start_count == 0)\r
- {\r
- if(sensor->status_cur == SENSOR_ON)\r
- {\r
- atomic_set(&(sensor->data_ready), 0);\r
- if ( (result = sensor->ops->active(client, 0, 0) ) < 0 ) {\r
- mutex_unlock(&sensor->operation_mutex); \r
- goto error;\r
- }\r
- \r
- if(sensor->pdata->irq_enable)\r
- { \r
- DBG("%s:disable irq,irq=%d\n",__func__,client->irq);\r
- disable_irq_nosync(client->irq);//disable irq\r
- }\r
- else\r
- cancel_delayed_work_sync(&sensor->delaywork); \r
- sensor->status_cur = SENSOR_OFF;\r
- }\r
- \r
- DBG("%s:GSENSOR_IOCTL_CLOSE OK\n", __func__);\r
- }\r
- \r
- mutex_unlock(&sensor->operation_mutex); \r
- break;\r
-\r
- case GSENSOR_IOCTL_APP_SET_RATE: \r
- DBG("%s:GSENSOR_IOCTL_APP_SET_RATE start\n", __func__); \r
- mutex_lock(&sensor->operation_mutex); \r
- result = sensor_reset_rate(client, rate);\r
- if (result < 0){\r
- mutex_unlock(&sensor->operation_mutex);\r
- goto error;\r
- }\r
-\r
- sensor->status_cur = SENSOR_ON;\r
- mutex_unlock(&sensor->operation_mutex); \r
- DBG("%s:GSENSOR_IOCTL_APP_SET_RATE OK\n", __func__);\r
- break;\r
- \r
- case GSENSOR_IOCTL_GETDATA:\r
- mutex_lock(&sensor->data_mutex);\r
- memcpy(&axis, &sensor->axis, sizeof(sensor->axis)); //get data from buffer\r
- mutex_unlock(&sensor->data_mutex); \r
- break;\r
- default:\r
- result = -ENOTTY;\r
- goto error;\r
- }\r
-\r
- switch (cmd) {\r
- case GSENSOR_IOCTL_GETDATA:\r
- if ( copy_to_user(argp, &axis, sizeof(axis) ) ) {\r
- printk("failed to copy sense data to user space.");\r
- result = -EFAULT; \r
- goto error;\r
- } \r
- DBG("%s:GSENSOR_IOCTL_GETDATA OK\n", __func__);\r
- break;\r
- default:\r
- break;\r
- }\r
- \r
-error:\r
- return result;\r
-}\r
-\r
-\r
-static int gsensor_dev_open(struct inode *inode, struct file *file)\r
-{\r
- //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_ACCEL]; \r
- //struct i2c_client *client = sensor->client;\r
-\r
- int result = 0;\r
-\r
-\r
- return result;\r
-}\r
-\r
-\r
-static int gsensor_dev_release(struct inode *inode, struct file *file)\r
-{\r
- //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_ACCEL]; \r
- //struct i2c_client *client = sensor->client;\r
-\r
- int result = 0;\r
-\r
-\r
- return result;\r
-}\r
-\r
-/* ioctl - I/O control */\r
-static long gsensor_dev_ioctl(struct file *file,\r
- unsigned int cmd, unsigned long arg)\r
-{\r
- struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_ACCEL];\r
- struct i2c_client *client = sensor->client;\r
- void __user *argp = (void __user *)arg;\r
- struct sensor_axis axis = {0};\r
- char rate;\r
- int result = 0;\r
-\r
- switch (cmd) {\r
- case GSENSOR_IOCTL_APP_SET_RATE:\r
- if (copy_from_user(&rate, argp, sizeof(rate)))\r
- {\r
- result = -EFAULT;\r
- goto error;\r
- }\r
- break;\r
- default:\r
- break;\r
- }\r
-\r
- switch (cmd) {\r
- case GSENSOR_IOCTL_START: \r
- DBG("%s:GSENSOR_IOCTL_START start,status=%d\n", __func__,sensor->status_cur);\r
- mutex_lock(&sensor->operation_mutex); \r
- if(++sensor->start_count == 1)\r
- {\r
- if(sensor->status_cur == SENSOR_OFF)\r
- {\r
- atomic_set(&(sensor->data_ready), 0);\r
- if ( (result = sensor->ops->active(client, 1, 0) ) < 0 ) {\r
- mutex_unlock(&sensor->operation_mutex);\r
- printk("%s:fail to active sensor,ret=%d\n",__func__,result); \r
- goto error; \r
- } \r
- if(sensor->pdata->irq_enable)\r
- {\r
- DBG("%s:enable irq,irq=%d\n",__func__,client->irq);\r
- enable_irq(client->irq); //enable irq\r
- } \r
- else\r
- {\r
- schedule_delayed_work(&sensor->delaywork, msecs_to_jiffies(sensor->pdata->poll_delay_ms));\r
- }\r
- sensor->status_cur = SENSOR_ON;\r
- } \r
- }\r
- mutex_unlock(&sensor->operation_mutex);\r
- DBG("%s:GSENSOR_IOCTL_START OK\n", __func__);\r
- break;\r
-\r
- case GSENSOR_IOCTL_CLOSE: \r
- DBG("%s:GSENSOR_IOCTL_CLOSE start,status=%d\n", __func__,sensor->status_cur);\r
- mutex_lock(&sensor->operation_mutex); \r
- if(--sensor->start_count == 0)\r
- {\r
- if(sensor->status_cur == SENSOR_ON)\r
- {\r
- atomic_set(&(sensor->data_ready), 0);\r
- if ( (result = sensor->ops->active(client, 0, 0) ) < 0 ) {\r
- mutex_unlock(&sensor->operation_mutex); \r
- goto error;\r
- }\r
- \r
- if(sensor->pdata->irq_enable)\r
- { \r
- DBG("%s:disable irq,irq=%d\n",__func__,client->irq);\r
- disable_irq_nosync(client->irq);//disable irq\r
- }\r
- else\r
- cancel_delayed_work_sync(&sensor->delaywork); \r
- sensor->status_cur = SENSOR_OFF;\r
- }\r
- \r
- DBG("%s:GSENSOR_IOCTL_CLOSE OK\n", __func__);\r
- }\r
- \r
- mutex_unlock(&sensor->operation_mutex); \r
- break;\r
-\r
- case GSENSOR_IOCTL_APP_SET_RATE: \r
- DBG("%s:GSENSOR_IOCTL_APP_SET_RATE start\n", __func__); \r
- mutex_lock(&sensor->operation_mutex); \r
- result = sensor_reset_rate(client, rate);\r
- if (result < 0){\r
- mutex_unlock(&sensor->operation_mutex);\r
- goto error;\r
- }\r
-\r
- sensor->status_cur = SENSOR_ON;\r
- mutex_unlock(&sensor->operation_mutex); \r
- DBG("%s:GSENSOR_IOCTL_APP_SET_RATE OK\n", __func__);\r
- break;\r
- \r
- case GSENSOR_IOCTL_GETDATA:\r
- mutex_lock(&sensor->data_mutex);\r
- memcpy(&axis, &sensor->axis, sizeof(sensor->axis)); //get data from buffer\r
- mutex_unlock(&sensor->data_mutex); \r
- break;\r
- default:\r
- result = -ENOTTY;\r
- goto error;\r
- }\r
-\r
- switch (cmd) {\r
- case GSENSOR_IOCTL_GETDATA:\r
- if ( copy_to_user(argp, &axis, sizeof(axis) ) ) {\r
- printk("failed to copy sense data to user space.");\r
- result = -EFAULT; \r
- goto error;\r
- } \r
- DBG("%s:GSENSOR_IOCTL_GETDATA OK\n", __func__);\r
- break;\r
- default:\r
- break;\r
- }\r
- \r
-error:\r
- return result;\r
-}\r
-\r
-static ssize_t gsensor_set_orientation_online(struct class *class,\r
- struct class_attribute *attr, const char *buf, size_t count)\r
-{\r
- int i=0;\r
- char orientation[20];\r
- char *tmp;\r
- \r
- struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_ACCEL];\r
- struct sensor_platform_data *pdata = sensor->pdata;\r
-\r
- \r
- char *p = strstr(buf,"gsensor_class");\r
- int start = strcspn(p,"{");\r
- int end = strcspn(p,"}");\r
- \r
- strncpy(orientation,p+start,end-start+1);\r
- tmp = orientation;\r
- \r
-\r
- while(strncmp(tmp,"}",1)!=0)\r
- {\r
- if((strncmp(tmp,",",1)==0)||(strncmp(tmp,"{",1)==0))\r
- {\r
- \r
- tmp++; \r
- continue;\r
- } \r
- else if(strncmp(tmp,"-",1)==0)\r
- {\r
- pdata->orientation[i++]=-1;\r
- DBG("i=%d,data=%d\n",i,pdata->orientation[i]);\r
- tmp++;\r
- } \r
- else\r
- {\r
- pdata->orientation[i++]=tmp[0]-48; \r
- DBG("----i=%d,data=%d\n",i,pdata->orientation[i]); \r
- } \r
- tmp++;\r
- \r
- \r
- }\r
-\r
- for(i=0;i<9;i++)\r
- DBG("i=%d gsensor_info=%d\n",i,pdata->orientation[i]);\r
- return 0;\r
-\r
-}\r
-\r
-static CLASS_ATTR(orientation, 0660, NULL, gsensor_set_orientation_online);\r
-\r
-static int gsensor_class_init(void)\r
-{\r
- int ret ;\r
- struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_ACCEL]; \r
- g_sensor_class[SENSOR_TYPE_ACCEL] = class_create(THIS_MODULE, "gsensor_class");\r
- ret = class_create_file(g_sensor_class[SENSOR_TYPE_ACCEL], &class_attr_orientation);\r
- if (ret)\r
- {\r
- printk("%s:Fail to creat class\n",__func__);\r
- return ret;\r
- }\r
- printk("%s:%s\n",__func__,sensor->i2c_id->name);\r
- return 0;\r
-}\r
-\r
-\r
-\r
-static int compass_dev_open(struct inode *inode, struct file *file)\r
-{\r
- struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_COMPASS];\r
- //struct i2c_client *client = sensor->client; \r
-\r
- int result = 0;\r
- int flag = 0;\r
- flag = atomic_read(&sensor->flags.open_flag);\r
- if(!flag)\r
- { \r
- atomic_set(&sensor->flags.open_flag, 1);\r
- wake_up(&sensor->flags.open_wq);\r
- }\r
-\r
- DBG("%s\n", __func__);\r
- return result;\r
-}\r
-\r
-\r
-\r
-static int compass_dev_release(struct inode *inode, struct file *file)\r
-{\r
- struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_COMPASS];\r
- //struct i2c_client *client = sensor->client;\r
- //void __user *argp = (void __user *)arg;\r
- int result = 0;\r
- int flag = 0;\r
- flag = atomic_read(&sensor->flags.open_flag);\r
- if(flag)\r
- {\r
- atomic_set(&sensor->flags.open_flag, 0);\r
- wake_up(&sensor->flags.open_wq); \r
- }\r
- \r
- DBG("%s\n", __func__);\r
- return result;\r
-}\r
-\r
-#ifdef CONFIG_COMPAT
-/* ioctl - I/O control */
-static long compass_dev_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+static int angle_dev_open(struct inode *inode, struct file *file)
{
- void __user *arg64 = compat_ptr(arg);
+ //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_ACCEL];
+ //struct i2c_client *client = sensor->client;
+
int result = 0;
- if (!file->f_op || !file->f_op->unlocked_ioctl) {
- pr_err("file->f_op or file->f_op->unlocked_ioctl is null\n");
- return -ENOTTY;
- }
+
+ return result;
+}
+
+
+static int angle_dev_release(struct inode *inode, struct file *file)
+{
+ //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_ANGLE];
+ //struct i2c_client *client = sensor->client;
+
+ int result = 0;
+
+
+ return result;
+}
+
+/* ioctl - I/O control */
+static long angle_dev_ioctl(struct file *file,
+ unsigned int cmd, unsigned long arg)
+{
+ struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_ANGLE];
+ struct i2c_client *client = sensor->client;
+ void __user *argp = (void __user *)arg;
+ struct sensor_axis axis = {0};
+ char rate;
+ int result = 0;
switch (cmd) {
- case COMPAT_ECS_IOCTL_APP_SET_MFLAG:
- if (file->f_op->unlocked_ioctl)
- result = file->f_op->unlocked_ioctl(file, ECS_IOCTL_APP_SET_MFLAG, (unsigned long)arg64);
- break;
- case COMPAT_ECS_IOCTL_APP_GET_MFLAG:
- if (file->f_op->unlocked_ioctl)
- result = file->f_op->unlocked_ioctl(file, ECS_IOCTL_APP_GET_MFLAG, (unsigned long)arg64);
- break;
- case COMPAT_ECS_IOCTL_APP_SET_AFLAG:
- if (file->f_op->unlocked_ioctl)
- result = file->f_op->unlocked_ioctl(file, ECS_IOCTL_APP_SET_AFLAG, (unsigned long)arg64);
- break;
- case COMPAT_ECS_IOCTL_APP_GET_AFLAG:
- if (file->f_op->unlocked_ioctl)
- result = file->f_op->unlocked_ioctl(file, ECS_IOCTL_APP_GET_AFLAG, (unsigned long)arg64);
+ case GSENSOR_IOCTL_APP_SET_RATE:
+ if (copy_from_user(&rate, argp, sizeof(rate)))
+ {
+ result = -EFAULT;
+ goto error;
+ }
break;
- case COMPAT_ECS_IOCTL_APP_SET_MVFLAG:
- if (file->f_op->unlocked_ioctl)
- result = file->f_op->unlocked_ioctl(file, ECS_IOCTL_APP_SET_MVFLAG, (unsigned long)arg64);
+ default:
break;
- case COMPAT_ECS_IOCTL_APP_GET_MVFLAG:
- if (file->f_op->unlocked_ioctl)
- result = file->f_op->unlocked_ioctl(file, ECS_IOCTL_APP_GET_MVFLAG, (unsigned long)arg64);
+ }
+
+ switch (cmd) {
+ case GSENSOR_IOCTL_START:
+ DBG("%s:GSENSOR_IOCTL_START start,status=%d\n", __func__,sensor->status_cur);
+ mutex_lock(&sensor->operation_mutex);
+ if(++sensor->start_count == 1)
+ {
+ if(sensor->status_cur == SENSOR_OFF)
+ {
+ atomic_set(&(sensor->data_ready), 0);
+ if ( (result = sensor->ops->active(client, 1, 0) ) < 0 ) {
+ mutex_unlock(&sensor->operation_mutex);
+ printk("%s:fail to active sensor,ret=%d\n",__func__,result);
+ goto error;
+ }
+ if(sensor->pdata->irq_enable)
+ {
+ DBG("%s:enable irq,irq=%d\n",__func__,client->irq);
+ enable_irq(client->irq); //enable irq
+ }
+ else
+ {
+ schedule_delayed_work(&sensor->delaywork, msecs_to_jiffies(sensor->pdata->poll_delay_ms));
+ }
+ sensor->status_cur = SENSOR_ON;
+ }
+ }
+ mutex_unlock(&sensor->operation_mutex);
+ DBG("%s:GSENSOR_IOCTL_START OK\n", __func__);
+ break;
+
+ case GSENSOR_IOCTL_CLOSE:
+ DBG("%s:GSENSOR_IOCTL_CLOSE start,status=%d\n", __func__,sensor->status_cur);
+ mutex_lock(&sensor->operation_mutex);
+ if(--sensor->start_count == 0)
+ {
+ if(sensor->status_cur == SENSOR_ON)
+ {
+ atomic_set(&(sensor->data_ready), 0);
+ if ( (result = sensor->ops->active(client, 0, 0) ) < 0 ) {
+ mutex_unlock(&sensor->operation_mutex);
+ goto error;
+ }
+
+ if(sensor->pdata->irq_enable)
+ {
+ DBG("%s:disable irq,irq=%d\n",__func__,client->irq);
+ disable_irq_nosync(client->irq);//disable irq
+ }
+ else
+ cancel_delayed_work_sync(&sensor->delaywork);
+ sensor->status_cur = SENSOR_OFF;
+ }
+
+ DBG("%s:GSENSOR_IOCTL_CLOSE OK\n", __func__);
+ }
+
+ mutex_unlock(&sensor->operation_mutex);
+ break;
+
+ case GSENSOR_IOCTL_APP_SET_RATE:
+ DBG("%s:GSENSOR_IOCTL_APP_SET_RATE start\n", __func__);
+ mutex_lock(&sensor->operation_mutex);
+ result = sensor_reset_rate(client, rate);
+ if (result < 0){
+ mutex_unlock(&sensor->operation_mutex);
+ goto error;
+ }
+
+ sensor->status_cur = SENSOR_ON;
+ mutex_unlock(&sensor->operation_mutex);
+ DBG("%s:GSENSOR_IOCTL_APP_SET_RATE OK\n", __func__);
break;
- case COMPAT_ECS_IOCTL_APP_SET_DELAY:
- if (file->f_op->unlocked_ioctl)
- result = file->f_op->unlocked_ioctl(file, ECS_IOCTL_APP_SET_DELAY, (unsigned long)arg64);
+
+ case GSENSOR_IOCTL_GETDATA:
+ mutex_lock(&sensor->data_mutex);
+ memcpy(&axis, &sensor->axis, sizeof(sensor->axis)); //get data from buffer
+ mutex_unlock(&sensor->data_mutex);
break;
- case COMPAT_ECS_IOCTL_APP_GET_DELAY:
- if (file->f_op->unlocked_ioctl)
- result = file->f_op->unlocked_ioctl(file, ECS_IOCTL_APP_GET_DELAY, (unsigned long)arg64);
+ default:
+ result = -ENOTTY;
+ goto error;
+ }
+
+ switch (cmd) {
+ case GSENSOR_IOCTL_GETDATA:
+ if ( copy_to_user(argp, &axis, sizeof(axis) ) ) {
+ printk("failed to copy sense data to user space.");
+ result = -EFAULT;
+ goto error;
+ }
+ DBG("%s:GSENSOR_IOCTL_GETDATA OK\n", __func__);
break;
default:
break;
}
+error:
return result;
}
-#endif
-\r
-/* ioctl - I/O control */\r
-static long compass_dev_ioctl(struct file *file,\r
- unsigned int cmd, unsigned long arg)\r
-{\r
- struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_COMPASS];\r
- //struct i2c_client *client = sensor->client;\r
- void __user *argp = (void __user *)arg;\r
- int result = 0;\r
- short flag;\r
- \r
- switch (cmd) {\r
- case ECS_IOCTL_APP_SET_MFLAG:\r
- case ECS_IOCTL_APP_SET_AFLAG:\r
- case ECS_IOCTL_APP_SET_MVFLAG:\r
- if (copy_from_user(&flag, argp, sizeof(flag))) {\r
- return -EFAULT;\r
- }\r
- if (flag < 0 || flag > 1) {\r
- return -EINVAL;\r
- }\r
- break;\r
- case ECS_IOCTL_APP_SET_DELAY:\r
- if (copy_from_user(&flag, argp, sizeof(flag))) {\r
- return -EFAULT;\r
- }\r
- break;\r
- default:\r
- break;\r
- }\r
- \r
- switch (cmd) {\r
- case ECS_IOCTL_APP_SET_MFLAG: \r
- atomic_set(&sensor->flags.m_flag, flag); \r
- DBG("%s:ECS_IOCTL_APP_SET_MFLAG,flag=%d\n", __func__,flag);\r
- break;\r
- case ECS_IOCTL_APP_GET_MFLAG: \r
- flag = atomic_read(&sensor->flags.m_flag);\r
- DBG("%s:ECS_IOCTL_APP_GET_MFLAG,flag=%d\n", __func__,flag);\r
- break;\r
- case ECS_IOCTL_APP_SET_AFLAG: \r
- atomic_set(&sensor->flags.a_flag, flag); \r
- DBG("%s:ECS_IOCTL_APP_SET_AFLAG,flag=%d\n", __func__,flag);\r
- break;\r
- case ECS_IOCTL_APP_GET_AFLAG:\r
- flag = atomic_read(&sensor->flags.a_flag); \r
- DBG("%s:ECS_IOCTL_APP_GET_AFLAG,flag=%d\n", __func__,flag);\r
- break;\r
- case ECS_IOCTL_APP_SET_MVFLAG: \r
- atomic_set(&sensor->flags.mv_flag, flag); \r
- DBG("%s:ECS_IOCTL_APP_SET_MVFLAG,flag=%d\n", __func__,flag);\r
- break;\r
- case ECS_IOCTL_APP_GET_MVFLAG: \r
- flag = atomic_read(&sensor->flags.mv_flag); \r
- DBG("%s:ECS_IOCTL_APP_GET_MVFLAG,flag=%d\n", __func__,flag);\r
- break;\r
- case ECS_IOCTL_APP_SET_DELAY:\r
- sensor->flags.delay = flag;\r
- break;\r
- case ECS_IOCTL_APP_GET_DELAY:\r
- flag = sensor->flags.delay;\r
- break;\r
- default:\r
- return -ENOTTY;\r
- }\r
- \r
- switch (cmd) {\r
- case ECS_IOCTL_APP_GET_MFLAG:\r
- case ECS_IOCTL_APP_GET_AFLAG:\r
- case ECS_IOCTL_APP_GET_MVFLAG:\r
- case ECS_IOCTL_APP_GET_DELAY:\r
- if (copy_to_user(argp, &flag, sizeof(flag))) {\r
- return -EFAULT;\r
- }\r
- break;\r
- default:\r
- break;\r
- }\r
-\r
- return result;\r
-}\r
-\r
-static int gyro_dev_open(struct inode *inode, struct file *file)\r
-{\r
- //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_GYROSCOPE];\r
- //struct i2c_client *client = sensor->client;\r
-\r
- int result = 0;\r
-\r
-\r
- return result;\r
-}\r
-\r
-\r
-static int gyro_dev_release(struct inode *inode, struct file *file)\r
-{\r
- //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_GYROSCOPE];\r
- //struct i2c_client *client = sensor->client;\r
-\r
- int result = 0;\r
-\r
-\r
- return result;\r
-}\r
-\r
-\r
-/* ioctl - I/O control */\r
-static long gyro_dev_ioctl(struct file *file,\r
- unsigned int cmd, unsigned long arg)\r
-{\r
- struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_GYROSCOPE]; \r
- struct i2c_client *client = sensor->client; \r
- void __user *argp = (void __user *)arg;\r
- int result = 0;\r
- char rate;\r
- switch (cmd) {\r
- case L3G4200D_IOCTL_GET_ENABLE: \r
- result = !sensor->status_cur;\r
- if (copy_to_user(argp, &result, sizeof(result)))\r
- {\r
- printk("%s:failed to copy status to user space.\n",__FUNCTION__);\r
- return -EFAULT;\r
- }\r
- \r
- DBG("%s :L3G4200D_IOCTL_GET_ENABLE,status=%d\n",__FUNCTION__,result); \r
- break;\r
- case L3G4200D_IOCTL_SET_ENABLE: \r
- DBG("%s :L3G4200D_IOCTL_SET_ENABLE,flag=%d\n",__FUNCTION__,*(unsigned int *)argp);\r
- mutex_lock(&sensor->operation_mutex); \r
- if(*(unsigned int *)argp)\r
- {\r
- if(sensor->status_cur == SENSOR_OFF)\r
- {\r
- if ( (result = sensor->ops->active(client, 1, ODR100_BW12_5) ) < 0 ) {\r
- mutex_unlock(&sensor->operation_mutex);\r
- printk("%s:fail to active sensor,ret=%d\n",__func__,result); \r
- goto error; \r
- } \r
- if(sensor->pdata->irq_enable)\r
- {\r
- DBG("%s:enable irq,irq=%d\n",__func__,client->irq);\r
- enable_irq(client->irq); //enable irq\r
- } \r
- else\r
- {\r
- schedule_delayed_work(&sensor->delaywork, msecs_to_jiffies(sensor->pdata->poll_delay_ms));\r
- }\r
- sensor->status_cur = SENSOR_ON;\r
- } \r
- }\r
- else\r
- {\r
- if(sensor->status_cur == SENSOR_ON)\r
- {\r
- if ( (result = sensor->ops->active(client, 0, 0) ) < 0 ) {\r
- mutex_unlock(&sensor->operation_mutex); \r
- goto error;\r
- }\r
- \r
- if(sensor->pdata->irq_enable)\r
- { \r
- DBG("%s:disable irq,irq=%d\n",__func__,client->irq);\r
- disable_irq_nosync(client->irq);//disable irq\r
- }\r
- else\r
- cancel_delayed_work_sync(&sensor->delaywork); \r
- sensor->status_cur = SENSOR_OFF;\r
- }\r
- }\r
- \r
- result = sensor->status_cur;\r
- if (copy_to_user(argp, &result, sizeof(result)))\r
- {\r
- mutex_unlock(&sensor->operation_mutex);\r
- printk("%s:failed to copy sense data to user space.\n",__FUNCTION__);\r
- return -EFAULT;\r
- }\r
-\r
- mutex_unlock(&sensor->operation_mutex);\r
- DBG("%s:L3G4200D_IOCTL_SET_ENABLE OK\n", __func__);\r
- break;\r
- case L3G4200D_IOCTL_SET_DELAY: \r
- if (copy_from_user(&rate, argp, sizeof(rate)))\r
- return -EFAULT;\r
- mutex_lock(&sensor->operation_mutex);\r
- if(sensor->status_cur == SENSOR_OFF)\r
- {\r
- if ( (result = sensor->ops->active(client, 1, rate) ) < 0 ) {\r
- mutex_unlock(&sensor->operation_mutex);\r
- printk("%s:fail to active sensor,ret=%d\n",__func__,result); \r
- goto error; \r
- }\r
- \r
- if(sensor->pdata->irq_enable)\r
- {\r
- DBG("%s:enable irq,irq=%d\n",__func__,client->irq);\r
- enable_irq(client->irq); //enable irq\r
- } \r
- else\r
- {\r
- schedule_delayed_work(&sensor->delaywork, msecs_to_jiffies(sensor->pdata->poll_delay_ms));\r
- }\r
- sensor->status_cur = SENSOR_ON;\r
- } \r
- \r
- mutex_unlock(&sensor->operation_mutex);\r
- DBG("%s :L3G4200D_IOCTL_SET_DELAY,rate=%d\n",__FUNCTION__,rate);\r
- break;\r
-\r
- default:\r
- printk("%s:error,cmd=0x%x\n",__func__,cmd);\r
- return -ENOTTY;\r
- }\r
- \r
- DBG("%s:line=%d,cmd=0x%x\n",__func__,__LINE__,cmd);\r
-\r
-error:\r
- return result;\r
-}\r
-\r
-static int light_dev_open(struct inode *inode, struct file *file)\r
-{\r
- //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_LIGHT];\r
- //struct i2c_client *client = sensor->client; \r
- int result = 0; \r
-\r
-\r
- return result;\r
-}\r
-\r
-\r
-\r
-\r
-static int light_dev_release(struct inode *inode, struct file *file)\r
-{\r
- //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_LIGHT];\r
- //struct i2c_client *client = sensor->client; \r
- int result = 0;\r
-\r
-\r
- return result;\r
-}\r
-\r
-#ifdef CONFIG_COMPAT
-static long light_dev_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+
+static int gsensor_dev_open(struct inode *inode, struct file *file)
{
- long ret = 0;
- void __user *arg64 = compat_ptr(arg);
+ //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_ACCEL];
+ //struct i2c_client *client = sensor->client;
- if (!file->f_op || !file->f_op->unlocked_ioctl) {
- pr_err("[DEBUG] file->f_op or file->f_op->unlocked_ioctl is null\n");
- return -ENOTTY;
- }
+ int result = 0;
- switch (cmd) {
- case COMPAT_LIGHTSENSOR_IOCTL_GET_ENABLED:
- if (file->f_op->unlocked_ioctl)
- ret = file->f_op->unlocked_ioctl(file, LIGHTSENSOR_IOCTL_GET_ENABLED, (unsigned long)arg64);
- break;
- case COMPAT_LIGHTSENSOR_IOCTL_ENABLE:
- if (file->f_op->unlocked_ioctl)
- ret = file->f_op->unlocked_ioctl(file, LIGHTSENSOR_IOCTL_ENABLE, (unsigned long)arg64);
- break;
- default:
- break;
- }
- return ret;
+ return result;
}
-#endif
-\r
-/* ioctl - I/O control */\r
-static long light_dev_ioctl(struct file *file,\r
- unsigned int cmd, unsigned long arg)\r
-{\r
- struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_LIGHT];\r
- struct i2c_client *client = sensor->client;\r
- unsigned int *argp = (unsigned int *)arg; \r
- int result = 0;\r
-\r
- switch(cmd)\r
- {\r
- case LIGHTSENSOR_IOCTL_GET_ENABLED:\r
- *argp = sensor->status_cur;\r
- break;\r
- case LIGHTSENSOR_IOCTL_ENABLE: \r
- DBG("%s:LIGHTSENSOR_IOCTL_ENABLE start\n", __func__);\r
- mutex_lock(&sensor->operation_mutex); \r
- if(*(unsigned int *)argp)\r
- {\r
- if(sensor->status_cur == SENSOR_OFF)\r
- {\r
- if ( (result = sensor->ops->active(client, SENSOR_ON, 0) ) < 0 ) {\r
- mutex_unlock(&sensor->operation_mutex);\r
- printk("%s:fail to active sensor,ret=%d\n",__func__,result); \r
- goto error; \r
- } \r
- if(sensor->pdata->irq_enable)\r
- {\r
- if(!(sensor->ops->trig & IRQF_SHARED))\r
- {\r
- DBG("%s:enable irq,irq=%d\n",__func__,client->irq);\r
- enable_irq(client->irq); //enable irq\r
- }\r
- } \r
- else\r
- {\r
- schedule_delayed_work(&sensor->delaywork, msecs_to_jiffies(sensor->pdata->poll_delay_ms));\r
- }\r
- \r
- sensor->status_cur = SENSOR_ON;\r
- } \r
- }\r
- else\r
- {\r
- if(sensor->status_cur == SENSOR_ON)\r
- {\r
- if ( (result = sensor->ops->active(client, SENSOR_OFF, 0) ) < 0 ) {\r
- mutex_unlock(&sensor->operation_mutex); \r
- goto error;\r
- }\r
- \r
- if(sensor->pdata->irq_enable)\r
- { \r
- if(!(sensor->ops->trig & IRQF_SHARED))\r
- {\r
- DBG("%s:disable irq,irq=%d\n",__func__,client->irq);\r
- disable_irq_nosync(client->irq);//disable irq\r
- }\r
- }\r
- else\r
- cancel_delayed_work_sync(&sensor->delaywork); \r
- \r
- sensor->status_cur = SENSOR_OFF;\r
- }\r
- }\r
- mutex_unlock(&sensor->operation_mutex);\r
- DBG("%s:LIGHTSENSOR_IOCTL_ENABLE OK\n", __func__);\r
- break;\r
- \r
- default:\r
- break;\r
- }\r
- \r
-error:\r
- return result;\r
-}\r
-\r
-\r
-static int proximity_dev_open(struct inode *inode, struct file *file)\r
-{\r
- //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_PROXIMITY];\r
- //struct i2c_client *client = sensor->client; \r
- int result = 0;\r
-\r
-\r
- return result;\r
-}\r
-\r
-\r
-static int proximity_dev_release(struct inode *inode, struct file *file)\r
-{\r
- //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_PROXIMITY];\r
- //struct i2c_client *client = sensor->client; \r
- int result = 0;\r
-\r
-\r
- return result;\r
-}\r
-\r
-#ifdef CONFIG_COMPAT
-static long proximity_dev_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+
+
+static int gsensor_dev_release(struct inode *inode, struct file *file)
{
- long ret = 0;
- void __user *arg64 = compat_ptr(arg);
+ //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_ACCEL];
+ //struct i2c_client *client = sensor->client;
- if (!file->f_op || !file->f_op->unlocked_ioctl) {
- pr_err("file->f_op or file->f_op->unlocked_ioctl is null\n");
- return -ENOTTY;
- }
+ int result = 0;
+
+
+ return result;
+}
+
+/* ioctl - I/O control */
+static long gsensor_dev_ioctl(struct file *file,
+ unsigned int cmd, unsigned long arg)
+{
+ struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_ACCEL];
+ struct i2c_client *client = sensor->client;
+ void __user *argp = (void __user *)arg;
+ struct sensor_axis axis = {0};
+ char rate;
+ int result = 0;
switch (cmd) {
- case COMPAT_PSENSOR_IOCTL_GET_ENABLED:
- if (file->f_op->unlocked_ioctl)
- ret = file->f_op->unlocked_ioctl(file, PSENSOR_IOCTL_GET_ENABLED, (unsigned long)arg64);
- break;
- case COMPAT_PSENSOR_IOCTL_ENABLE:
- if (file->f_op->unlocked_ioctl)
- ret = file->f_op->unlocked_ioctl(file, PSENSOR_IOCTL_ENABLE, (unsigned long)arg64);
+ case GSENSOR_IOCTL_APP_SET_RATE:
+ if (copy_from_user(&rate, argp, sizeof(rate)))
+ {
+ result = -EFAULT;
+ goto error;
+ }
break;
default:
break;
}
- return ret;
-}
-#endif
-\r
-/* ioctl - I/O control */\r
-static long proximity_dev_ioctl(struct file *file,\r
- unsigned int cmd, unsigned long arg)\r
-{\r
- struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_PROXIMITY];\r
- struct i2c_client *client = sensor->client; \r
- unsigned int *argp = (unsigned int *)arg; \r
- int result = 0;\r
- switch(cmd)\r
- {\r
- case PSENSOR_IOCTL_GET_ENABLED:\r
- *argp = sensor->status_cur;\r
- break;\r
- case PSENSOR_IOCTL_ENABLE: \r
- DBG("%s:PSENSOR_IOCTL_ENABLE start\n", __func__);\r
- mutex_lock(&sensor->operation_mutex); \r
- if(*(unsigned int *)argp)\r
- {\r
- if(sensor->status_cur == SENSOR_OFF)\r
- {\r
- if ( (result = sensor->ops->active(client, SENSOR_ON, 0) ) < 0 ) {\r
- mutex_unlock(&sensor->operation_mutex);\r
- printk("%s:fail to active sensor,ret=%d\n",__func__,result); \r
- goto error; \r
- }\r
- \r
- if(sensor->pdata->irq_enable)\r
- {\r
- if(!(sensor->ops->trig & IRQF_SHARED))\r
- {\r
- DBG("%s:enable irq,irq=%d\n",__func__,client->irq);\r
- enable_irq(client->irq); //enable irq\r
- }\r
- } \r
- else\r
- {\r
- schedule_delayed_work(&sensor->delaywork, msecs_to_jiffies(sensor->pdata->poll_delay_ms));\r
- }\r
- \r
- sensor->status_cur = SENSOR_ON;\r
- } \r
- }\r
- else\r
- {\r
- if(sensor->status_cur == SENSOR_ON)\r
- {\r
- if ( (result = sensor->ops->active(client, SENSOR_OFF, 0) ) < 0 ) {\r
- mutex_unlock(&sensor->operation_mutex); \r
- goto error;\r
- }\r
- if(sensor->pdata->irq_enable)\r
- { \r
- if(!(sensor->ops->trig & IRQF_SHARED))\r
- {\r
- DBG("%s:disable irq,irq=%d\n",__func__,client->irq);\r
- disable_irq_nosync(client->irq);//disable irq\r
- }\r
- }\r
- else\r
- cancel_delayed_work_sync(&sensor->delaywork); \r
- sensor->status_cur = SENSOR_OFF;\r
- }\r
- }\r
- mutex_unlock(&sensor->operation_mutex);\r
- DBG("%s:PSENSOR_IOCTL_ENABLE OK\n", __func__);\r
- break;\r
- \r
- default:\r
- break;\r
- }\r
- \r
-error:\r
- return result;\r
-}\r
-\r
-static int temperature_dev_open(struct inode *inode, struct file *file)\r
-{\r
- //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_TEMPERATURE];\r
- //struct i2c_client *client = sensor->client;\r
-\r
- int result = 0;\r
-\r
-\r
- return result;\r
-}\r
-\r
-\r
-static int temperature_dev_release(struct inode *inode, struct file *file)\r
-{\r
- //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_TEMPERATURE];\r
- //struct i2c_client *client = sensor->client;\r
-\r
- int result = 0;\r
-\r
-\r
- return result;\r
-}\r
-\r
-\r
-/* ioctl - I/O control */\r
-static long temperature_dev_ioctl(struct file *file,\r
- unsigned int cmd, unsigned long arg)\r
-{\r
- struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_TEMPERATURE];\r
- struct i2c_client *client = sensor->client;\r
- unsigned int *argp = (unsigned int *)arg; \r
- int result = 0;\r
-\r
- switch(cmd)\r
- {\r
- case TEMPERATURE_IOCTL_GET_ENABLED:\r
- *argp = sensor->status_cur;\r
- break;\r
- case TEMPERATURE_IOCTL_ENABLE: \r
- DBG("%s:LIGHTSENSOR_IOCTL_ENABLE start\n", __func__);\r
- mutex_lock(&sensor->operation_mutex); \r
- if(*(unsigned int *)argp)\r
- {\r
- if(sensor->status_cur == SENSOR_OFF)\r
- {\r
- if ( (result = sensor->ops->active(client, SENSOR_ON, 0) ) < 0 ) {\r
- mutex_unlock(&sensor->operation_mutex);\r
- printk("%s:fail to active sensor,ret=%d\n",__func__,result); \r
- goto error; \r
- } \r
- if(sensor->pdata->irq_enable)\r
- {\r
- if(!(sensor->ops->trig & IRQF_SHARED))\r
- {\r
- DBG("%s:enable irq,irq=%d\n",__func__,client->irq);\r
- enable_irq(client->irq); //enable irq\r
- }\r
- } \r
- else\r
- {\r
- schedule_delayed_work(&sensor->delaywork, msecs_to_jiffies(sensor->pdata->poll_delay_ms));\r
- }\r
- \r
- sensor->status_cur = SENSOR_ON;\r
- } \r
- }\r
- else\r
- {\r
- if(sensor->status_cur == SENSOR_ON)\r
- {\r
- if ( (result = sensor->ops->active(client, SENSOR_OFF, 0) ) < 0 ) {\r
- mutex_unlock(&sensor->operation_mutex); \r
- goto error;\r
- }\r
- \r
- if(sensor->pdata->irq_enable)\r
- { \r
- if(!(sensor->ops->trig & IRQF_SHARED))\r
- {\r
- DBG("%s:disable irq,irq=%d\n",__func__,client->irq);\r
- disable_irq_nosync(client->irq);//disable irq\r
- }\r
- }\r
- else\r
- cancel_delayed_work_sync(&sensor->delaywork); \r
- \r
- sensor->status_cur = SENSOR_OFF;\r
- }\r
- }\r
- mutex_unlock(&sensor->operation_mutex);\r
- DBG("%s:LIGHTSENSOR_IOCTL_ENABLE OK\n", __func__);\r
- break;\r
- \r
- default:\r
- break;\r
- }\r
- \r
-error:\r
- return result;\r
-}\r
-\r
-\r
-static int pressure_dev_open(struct inode *inode, struct file *file)\r
-{\r
- //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_PRESSURE];\r
- //struct i2c_client *client = sensor->client;\r
-\r
- int result = 0;\r
-\r
-\r
- return result;\r
-}\r
-\r
-\r
-static int pressure_dev_release(struct inode *inode, struct file *file)\r
-{\r
- //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_PRESSURE];\r
- //struct i2c_client *client = sensor->client;\r
-\r
- int result = 0;\r
-\r
-\r
- return result;\r
-}\r
-\r
-\r
-/* ioctl - I/O control */\r
-static long pressure_dev_ioctl(struct file *file,\r
- unsigned int cmd, unsigned long arg)\r
-{\r
- struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_PRESSURE];\r
- struct i2c_client *client = sensor->client;\r
- unsigned int *argp = (unsigned int *)arg; \r
- int result = 0;\r
-\r
- switch(cmd)\r
- {\r
- case PRESSURE_IOCTL_GET_ENABLED:\r
- *argp = sensor->status_cur;\r
- break;\r
- case PRESSURE_IOCTL_ENABLE: \r
- DBG("%s:LIGHTSENSOR_IOCTL_ENABLE start\n", __func__);\r
- mutex_lock(&sensor->operation_mutex); \r
- if(*(unsigned int *)argp)\r
- {\r
- if(sensor->status_cur == SENSOR_OFF)\r
- {\r
- if ( (result = sensor->ops->active(client, SENSOR_ON, 0) ) < 0 ) {\r
- mutex_unlock(&sensor->operation_mutex);\r
- printk("%s:fail to active sensor,ret=%d\n",__func__,result); \r
- goto error; \r
- } \r
- if(sensor->pdata->irq_enable)\r
- {\r
- if(!(sensor->ops->trig & IRQF_SHARED))\r
- {\r
- DBG("%s:enable irq,irq=%d\n",__func__,client->irq);\r
- enable_irq(client->irq); //enable irq\r
- }\r
- } \r
- else\r
- {\r
- schedule_delayed_work(&sensor->delaywork, msecs_to_jiffies(sensor->pdata->poll_delay_ms));\r
- }\r
- \r
- sensor->status_cur = SENSOR_ON;\r
- } \r
- }\r
- else\r
- {\r
- if(sensor->status_cur == SENSOR_ON)\r
- {\r
- if ( (result = sensor->ops->active(client, SENSOR_OFF, 0) ) < 0 ) {\r
- mutex_unlock(&sensor->operation_mutex); \r
- goto error;\r
- }\r
- \r
- if(sensor->pdata->irq_enable)\r
- { \r
- if(!(sensor->ops->trig & IRQF_SHARED))\r
- {\r
- DBG("%s:disable irq,irq=%d\n",__func__,client->irq);\r
- disable_irq_nosync(client->irq);//disable irq\r
- }\r
- }\r
- else\r
- cancel_delayed_work_sync(&sensor->delaywork); \r
- \r
- sensor->status_cur = SENSOR_OFF;\r
- }\r
- }\r
- mutex_unlock(&sensor->operation_mutex);\r
- DBG("%s:LIGHTSENSOR_IOCTL_ENABLE OK\n", __func__);\r
- break;\r
- \r
- default:\r
- break;\r
- }\r
- \r
-error:\r
- return result;\r
-}\r
-\r
-\r
-\r
-\r
-static int sensor_misc_device_register(struct sensor_private_data *sensor, int type)\r
-{\r
- int result = 0;\r
- \r
- switch(type)\r
- {\r
- case SENSOR_TYPE_ANGLE:\r
- if(!sensor->ops->misc_dev)\r
- {\r
- sensor->fops.owner = THIS_MODULE;\r
- sensor->fops.unlocked_ioctl = angle_dev_ioctl;\r
- sensor->fops.open = angle_dev_open;\r
- sensor->fops.release = angle_dev_release;\r
-\r
- sensor->miscdev.minor = MISC_DYNAMIC_MINOR;\r
- sensor->miscdev.name = "angle";\r
- sensor->miscdev.fops = &sensor->fops;\r
- }\r
- else\r
- {\r
- memcpy(&sensor->miscdev, sensor->ops->misc_dev, sizeof(*sensor->ops->misc_dev));\r
-\r
- }\r
- \r
- break;\r
- \r
- case SENSOR_TYPE_ACCEL:\r
- if(!sensor->ops->misc_dev)\r
- {\r
- sensor->fops.owner = THIS_MODULE;\r
- sensor->fops.unlocked_ioctl = gsensor_dev_ioctl;\r
- #ifdef CONFIG_COMPAT\r
- sensor->fops.compat_ioctl = gsensor_dev_ioctl;\r
- #endif\r
- sensor->fops.open = gsensor_dev_open;\r
- sensor->fops.release = gsensor_dev_release;\r
-\r
- sensor->miscdev.minor = MISC_DYNAMIC_MINOR;\r
- sensor->miscdev.name = "mma8452_daemon";\r
- sensor->miscdev.fops = &sensor->fops;\r
- }\r
- else\r
- {\r
- memcpy(&sensor->miscdev, sensor->ops->misc_dev, sizeof(*sensor->ops->misc_dev));\r
-\r
- }\r
- \r
- break;\r
-\r
- case SENSOR_TYPE_COMPASS: \r
- if(!sensor->ops->misc_dev)\r
- {\r
- sensor->fops.owner = THIS_MODULE;\r
- sensor->fops.unlocked_ioctl = compass_dev_ioctl;\r
-#ifdef CONFIG_COMPAT
+ switch (cmd) {
+ case GSENSOR_IOCTL_START:
+ DBG("%s:GSENSOR_IOCTL_START start,status=%d\n", __func__,sensor->status_cur);
+ mutex_lock(&sensor->operation_mutex);
+ if(++sensor->start_count == 1)
+ {
+ if(sensor->status_cur == SENSOR_OFF)
+ {
+ atomic_set(&(sensor->data_ready), 0);
+ if ( (result = sensor->ops->active(client, 1, 0) ) < 0 ) {
+ mutex_unlock(&sensor->operation_mutex);
+ printk("%s:fail to active sensor,ret=%d\n",__func__,result);
+ goto error;
+ }
+ if(sensor->pdata->irq_enable)
+ {
+ DBG("%s:enable irq,irq=%d\n",__func__,client->irq);
+ enable_irq(client->irq); //enable irq
+ }
+ else
+ {
+ schedule_delayed_work(&sensor->delaywork, msecs_to_jiffies(sensor->pdata->poll_delay_ms));
+ }
+ sensor->status_cur = SENSOR_ON;
+ }
+ }
+ mutex_unlock(&sensor->operation_mutex);
+ DBG("%s:GSENSOR_IOCTL_START OK\n", __func__);
+ break;
+
+ case GSENSOR_IOCTL_CLOSE:
+ DBG("%s:GSENSOR_IOCTL_CLOSE start,status=%d\n", __func__,sensor->status_cur);
+ mutex_lock(&sensor->operation_mutex);
+ if(--sensor->start_count == 0)
+ {
+ if(sensor->status_cur == SENSOR_ON)
+ {
+ atomic_set(&(sensor->data_ready), 0);
+ if ( (result = sensor->ops->active(client, 0, 0) ) < 0 ) {
+ mutex_unlock(&sensor->operation_mutex);
+ goto error;
+ }
+
+ if(sensor->pdata->irq_enable)
+ {
+ DBG("%s:disable irq,irq=%d\n",__func__,client->irq);
+ disable_irq_nosync(client->irq);//disable irq
+ }
+ else
+ cancel_delayed_work_sync(&sensor->delaywork);
+ sensor->status_cur = SENSOR_OFF;
+ }
+
+ DBG("%s:GSENSOR_IOCTL_CLOSE OK\n", __func__);
+ }
+
+ mutex_unlock(&sensor->operation_mutex);
+ break;
+
+ case GSENSOR_IOCTL_APP_SET_RATE:
+ DBG("%s:GSENSOR_IOCTL_APP_SET_RATE start\n", __func__);
+ mutex_lock(&sensor->operation_mutex);
+ result = sensor_reset_rate(client, rate);
+ if (result < 0){
+ mutex_unlock(&sensor->operation_mutex);
+ goto error;
+ }
+
+ sensor->status_cur = SENSOR_ON;
+ mutex_unlock(&sensor->operation_mutex);
+ DBG("%s:GSENSOR_IOCTL_APP_SET_RATE OK\n", __func__);
+ break;
+
+ case GSENSOR_IOCTL_GETDATA:
+ mutex_lock(&sensor->data_mutex);
+ memcpy(&axis, &sensor->axis, sizeof(sensor->axis)); //get data from buffer
+ mutex_unlock(&sensor->data_mutex);
+ break;
+ default:
+ result = -ENOTTY;
+ goto error;
+ }
+
+ switch (cmd) {
+ case GSENSOR_IOCTL_GETDATA:
+ if ( copy_to_user(argp, &axis, sizeof(axis) ) ) {
+ printk("failed to copy sense data to user space.");
+ result = -EFAULT;
+ goto error;
+ }
+ DBG("%s:GSENSOR_IOCTL_GETDATA OK\n", __func__);
+ break;
+ default:
+ break;
+ }
+
+error:
+ return result;
+}
+
+static ssize_t gsensor_set_orientation_online(struct class *class,
+ struct class_attribute *attr, const char *buf, size_t count)
+{
+ int i=0;
+ char orientation[20];
+ char *tmp;
+
+ struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_ACCEL];
+ struct sensor_platform_data *pdata = sensor->pdata;
+
+
+ char *p = strstr(buf,"gsensor_class");
+ int start = strcspn(p,"{");
+ int end = strcspn(p,"}");
+
+ strncpy(orientation,p+start,end-start+1);
+ tmp = orientation;
+
+
+ while(strncmp(tmp,"}",1)!=0)
+ {
+ if((strncmp(tmp,",",1)==0)||(strncmp(tmp,"{",1)==0))
+ {
+
+ tmp++;
+ continue;
+ }
+ else if(strncmp(tmp,"-",1)==0)
+ {
+ pdata->orientation[i++]=-1;
+ DBG("i=%d,data=%d\n",i,pdata->orientation[i]);
+ tmp++;
+ }
+ else
+ {
+ pdata->orientation[i++]=tmp[0]-48;
+ DBG("----i=%d,data=%d\n",i,pdata->orientation[i]);
+ }
+ tmp++;
+
+
+ }
+
+ for(i=0;i<9;i++)
+ DBG("i=%d gsensor_info=%d\n",i,pdata->orientation[i]);
+ return 0;
+
+}
+
+static CLASS_ATTR(orientation, 0660, NULL, gsensor_set_orientation_online);
+
+static int gsensor_class_init(void)
+{
+ int ret ;
+ struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_ACCEL];
+ g_sensor_class[SENSOR_TYPE_ACCEL] = class_create(THIS_MODULE, "gsensor_class");
+ ret = class_create_file(g_sensor_class[SENSOR_TYPE_ACCEL], &class_attr_orientation);
+ if (ret)
+ {
+ printk("%s:Fail to creat class\n",__func__);
+ return ret;
+ }
+ printk("%s:%s\n",__func__,sensor->i2c_id->name);
+ return 0;
+}
+
+
+
+static int compass_dev_open(struct inode *inode, struct file *file)
+{
+ struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_COMPASS];
+ //struct i2c_client *client = sensor->client;
+
+ int result = 0;
+ int flag = 0;
+ flag = atomic_read(&sensor->flags.open_flag);
+ if(!flag)
+ {
+ atomic_set(&sensor->flags.open_flag, 1);
+ wake_up(&sensor->flags.open_wq);
+ }
+
+ DBG("%s\n", __func__);
+ return result;
+}
+
+
+
+static int compass_dev_release(struct inode *inode, struct file *file)
+{
+ struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_COMPASS];
+ //struct i2c_client *client = sensor->client;
+ //void __user *argp = (void __user *)arg;
+ int result = 0;
+ int flag = 0;
+ flag = atomic_read(&sensor->flags.open_flag);
+ if(flag)
+ {
+ atomic_set(&sensor->flags.open_flag, 0);
+ wake_up(&sensor->flags.open_wq);
+ }
+
+ DBG("%s\n", __func__);
+ return result;
+}
+
+#ifdef CONFIG_COMPAT
+/* ioctl - I/O control */
+static long compass_dev_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+{
+ void __user *arg64 = compat_ptr(arg);
+ int result = 0;
+
+ if (!file->f_op || !file->f_op->unlocked_ioctl) {
+ pr_err("file->f_op or file->f_op->unlocked_ioctl is null\n");
+ return -ENOTTY;
+ }
+
+ switch (cmd) {
+ case COMPAT_ECS_IOCTL_APP_SET_MFLAG:
+ if (file->f_op->unlocked_ioctl)
+ result = file->f_op->unlocked_ioctl(file, ECS_IOCTL_APP_SET_MFLAG, (unsigned long)arg64);
+ break;
+ case COMPAT_ECS_IOCTL_APP_GET_MFLAG:
+ if (file->f_op->unlocked_ioctl)
+ result = file->f_op->unlocked_ioctl(file, ECS_IOCTL_APP_GET_MFLAG, (unsigned long)arg64);
+ break;
+ case COMPAT_ECS_IOCTL_APP_SET_AFLAG:
+ if (file->f_op->unlocked_ioctl)
+ result = file->f_op->unlocked_ioctl(file, ECS_IOCTL_APP_SET_AFLAG, (unsigned long)arg64);
+ break;
+ case COMPAT_ECS_IOCTL_APP_GET_AFLAG:
+ if (file->f_op->unlocked_ioctl)
+ result = file->f_op->unlocked_ioctl(file, ECS_IOCTL_APP_GET_AFLAG, (unsigned long)arg64);
+ break;
+ case COMPAT_ECS_IOCTL_APP_SET_MVFLAG:
+ if (file->f_op->unlocked_ioctl)
+ result = file->f_op->unlocked_ioctl(file, ECS_IOCTL_APP_SET_MVFLAG, (unsigned long)arg64);
+ break;
+ case COMPAT_ECS_IOCTL_APP_GET_MVFLAG:
+ if (file->f_op->unlocked_ioctl)
+ result = file->f_op->unlocked_ioctl(file, ECS_IOCTL_APP_GET_MVFLAG, (unsigned long)arg64);
+ break;
+ case COMPAT_ECS_IOCTL_APP_SET_DELAY:
+ if (file->f_op->unlocked_ioctl)
+ result = file->f_op->unlocked_ioctl(file, ECS_IOCTL_APP_SET_DELAY, (unsigned long)arg64);
+ break;
+ case COMPAT_ECS_IOCTL_APP_GET_DELAY:
+ if (file->f_op->unlocked_ioctl)
+ result = file->f_op->unlocked_ioctl(file, ECS_IOCTL_APP_GET_DELAY, (unsigned long)arg64);
+ break;
+ default:
+ break;
+ }
+
+ return result;
+}
+#endif
+
+
+/* ioctl - I/O control */
+static long compass_dev_ioctl(struct file *file,
+ unsigned int cmd, unsigned long arg)
+{
+ struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_COMPASS];
+ //struct i2c_client *client = sensor->client;
+ void __user *argp = (void __user *)arg;
+ int result = 0;
+ short flag;
+
+ switch (cmd) {
+ case ECS_IOCTL_APP_SET_MFLAG:
+ case ECS_IOCTL_APP_SET_AFLAG:
+ case ECS_IOCTL_APP_SET_MVFLAG:
+ if (copy_from_user(&flag, argp, sizeof(flag))) {
+ return -EFAULT;
+ }
+ if (flag < 0 || flag > 1) {
+ return -EINVAL;
+ }
+ break;
+ case ECS_IOCTL_APP_SET_DELAY:
+ if (copy_from_user(&flag, argp, sizeof(flag))) {
+ return -EFAULT;
+ }
+ break;
+ default:
+ break;
+ }
+
+ switch (cmd) {
+ case ECS_IOCTL_APP_SET_MFLAG:
+ atomic_set(&sensor->flags.m_flag, flag);
+ DBG("%s:ECS_IOCTL_APP_SET_MFLAG,flag=%d\n", __func__,flag);
+ break;
+ case ECS_IOCTL_APP_GET_MFLAG:
+ flag = atomic_read(&sensor->flags.m_flag);
+ DBG("%s:ECS_IOCTL_APP_GET_MFLAG,flag=%d\n", __func__,flag);
+ break;
+ case ECS_IOCTL_APP_SET_AFLAG:
+ atomic_set(&sensor->flags.a_flag, flag);
+ DBG("%s:ECS_IOCTL_APP_SET_AFLAG,flag=%d\n", __func__,flag);
+ break;
+ case ECS_IOCTL_APP_GET_AFLAG:
+ flag = atomic_read(&sensor->flags.a_flag);
+ DBG("%s:ECS_IOCTL_APP_GET_AFLAG,flag=%d\n", __func__,flag);
+ break;
+ case ECS_IOCTL_APP_SET_MVFLAG:
+ atomic_set(&sensor->flags.mv_flag, flag);
+ DBG("%s:ECS_IOCTL_APP_SET_MVFLAG,flag=%d\n", __func__,flag);
+ break;
+ case ECS_IOCTL_APP_GET_MVFLAG:
+ flag = atomic_read(&sensor->flags.mv_flag);
+ DBG("%s:ECS_IOCTL_APP_GET_MVFLAG,flag=%d\n", __func__,flag);
+ break;
+ case ECS_IOCTL_APP_SET_DELAY:
+ sensor->flags.delay = flag;
+ break;
+ case ECS_IOCTL_APP_GET_DELAY:
+ flag = sensor->flags.delay;
+ break;
+ default:
+ return -ENOTTY;
+ }
+
+ switch (cmd) {
+ case ECS_IOCTL_APP_GET_MFLAG:
+ case ECS_IOCTL_APP_GET_AFLAG:
+ case ECS_IOCTL_APP_GET_MVFLAG:
+ case ECS_IOCTL_APP_GET_DELAY:
+ if (copy_to_user(argp, &flag, sizeof(flag))) {
+ return -EFAULT;
+ }
+ break;
+ default:
+ break;
+ }
+
+ return result;
+}
+
+static int gyro_dev_open(struct inode *inode, struct file *file)
+{
+ //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_GYROSCOPE];
+ //struct i2c_client *client = sensor->client;
+
+ int result = 0;
+
+
+ return result;
+}
+
+
+static int gyro_dev_release(struct inode *inode, struct file *file)
+{
+ //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_GYROSCOPE];
+ //struct i2c_client *client = sensor->client;
+
+ int result = 0;
+
+
+ return result;
+}
+
+
+/* ioctl - I/O control */
+static long gyro_dev_ioctl(struct file *file,
+ unsigned int cmd, unsigned long arg)
+{
+ struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_GYROSCOPE];
+ struct i2c_client *client = sensor->client;
+ void __user *argp = (void __user *)arg;
+ int result = 0;
+ char rate;
+ switch (cmd) {
+ case L3G4200D_IOCTL_GET_ENABLE:
+ result = !sensor->status_cur;
+ if (copy_to_user(argp, &result, sizeof(result)))
+ {
+ printk("%s:failed to copy status to user space.\n",__FUNCTION__);
+ return -EFAULT;
+ }
+
+ DBG("%s :L3G4200D_IOCTL_GET_ENABLE,status=%d\n",__FUNCTION__,result);
+ break;
+ case L3G4200D_IOCTL_SET_ENABLE:
+ DBG("%s :L3G4200D_IOCTL_SET_ENABLE,flag=%d\n",__FUNCTION__,*(unsigned int *)argp);
+ mutex_lock(&sensor->operation_mutex);
+ if(*(unsigned int *)argp)
+ {
+ if(sensor->status_cur == SENSOR_OFF)
+ {
+ if ( (result = sensor->ops->active(client, 1, ODR100_BW12_5) ) < 0 ) {
+ mutex_unlock(&sensor->operation_mutex);
+ printk("%s:fail to active sensor,ret=%d\n",__func__,result);
+ goto error;
+ }
+ if(sensor->pdata->irq_enable)
+ {
+ DBG("%s:enable irq,irq=%d\n",__func__,client->irq);
+ enable_irq(client->irq); //enable irq
+ }
+ else
+ {
+ schedule_delayed_work(&sensor->delaywork, msecs_to_jiffies(sensor->pdata->poll_delay_ms));
+ }
+ sensor->status_cur = SENSOR_ON;
+ }
+ }
+ else
+ {
+ if(sensor->status_cur == SENSOR_ON)
+ {
+ if ( (result = sensor->ops->active(client, 0, 0) ) < 0 ) {
+ mutex_unlock(&sensor->operation_mutex);
+ goto error;
+ }
+
+ if(sensor->pdata->irq_enable)
+ {
+ DBG("%s:disable irq,irq=%d\n",__func__,client->irq);
+ disable_irq_nosync(client->irq);//disable irq
+ }
+ else
+ cancel_delayed_work_sync(&sensor->delaywork);
+ sensor->status_cur = SENSOR_OFF;
+ }
+ }
+
+ result = sensor->status_cur;
+ if (copy_to_user(argp, &result, sizeof(result)))
+ {
+ mutex_unlock(&sensor->operation_mutex);
+ printk("%s:failed to copy sense data to user space.\n",__FUNCTION__);
+ return -EFAULT;
+ }
+
+ mutex_unlock(&sensor->operation_mutex);
+ DBG("%s:L3G4200D_IOCTL_SET_ENABLE OK\n", __func__);
+ break;
+ case L3G4200D_IOCTL_SET_DELAY:
+ if (copy_from_user(&rate, argp, sizeof(rate)))
+ return -EFAULT;
+ mutex_lock(&sensor->operation_mutex);
+ if(sensor->status_cur == SENSOR_OFF)
+ {
+ if ( (result = sensor->ops->active(client, 1, rate) ) < 0 ) {
+ mutex_unlock(&sensor->operation_mutex);
+ printk("%s:fail to active sensor,ret=%d\n",__func__,result);
+ goto error;
+ }
+
+ if(sensor->pdata->irq_enable)
+ {
+ DBG("%s:enable irq,irq=%d\n",__func__,client->irq);
+ enable_irq(client->irq); //enable irq
+ }
+ else
+ {
+ schedule_delayed_work(&sensor->delaywork, msecs_to_jiffies(sensor->pdata->poll_delay_ms));
+ }
+ sensor->status_cur = SENSOR_ON;
+ }
+
+ mutex_unlock(&sensor->operation_mutex);
+ DBG("%s :L3G4200D_IOCTL_SET_DELAY,rate=%d\n",__FUNCTION__,rate);
+ break;
+
+ default:
+ printk("%s:error,cmd=0x%x\n",__func__,cmd);
+ return -ENOTTY;
+ }
+
+ DBG("%s:line=%d,cmd=0x%x\n",__func__,__LINE__,cmd);
+
+error:
+ return result;
+}
+
+static int light_dev_open(struct inode *inode, struct file *file)
+{
+ //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_LIGHT];
+ //struct i2c_client *client = sensor->client;
+ int result = 0;
+
+
+ return result;
+}
+
+
+
+
+static int light_dev_release(struct inode *inode, struct file *file)
+{
+ //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_LIGHT];
+ //struct i2c_client *client = sensor->client;
+ int result = 0;
+
+
+ return result;
+}
+
+#ifdef CONFIG_COMPAT
+static long light_dev_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+{
+ long ret = 0;
+ void __user *arg64 = compat_ptr(arg);
+
+ if (!file->f_op || !file->f_op->unlocked_ioctl) {
+ pr_err("[DEBUG] file->f_op or file->f_op->unlocked_ioctl is null\n");
+ return -ENOTTY;
+ }
+
+ switch (cmd) {
+ case COMPAT_LIGHTSENSOR_IOCTL_GET_ENABLED:
+ if (file->f_op->unlocked_ioctl)
+ ret = file->f_op->unlocked_ioctl(file, LIGHTSENSOR_IOCTL_GET_ENABLED, (unsigned long)arg64);
+ break;
+ case COMPAT_LIGHTSENSOR_IOCTL_ENABLE:
+ if (file->f_op->unlocked_ioctl)
+ ret = file->f_op->unlocked_ioctl(file, LIGHTSENSOR_IOCTL_ENABLE, (unsigned long)arg64);
+ break;
+ default:
+ break;
+ }
+
+ return ret;
+}
+#endif
+
+/* ioctl - I/O control */
+static long light_dev_ioctl(struct file *file,
+ unsigned int cmd, unsigned long arg)
+{
+ struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_LIGHT];
+ struct i2c_client *client = sensor->client;
+ unsigned int *argp = (unsigned int *)arg;
+ int result = 0;
+
+ switch(cmd)
+ {
+ case LIGHTSENSOR_IOCTL_GET_ENABLED:
+ *argp = sensor->status_cur;
+ break;
+ case LIGHTSENSOR_IOCTL_ENABLE:
+ DBG("%s:LIGHTSENSOR_IOCTL_ENABLE start\n", __func__);
+ mutex_lock(&sensor->operation_mutex);
+ if(*(unsigned int *)argp)
+ {
+ if(sensor->status_cur == SENSOR_OFF)
+ {
+ if ( (result = sensor->ops->active(client, SENSOR_ON, 0) ) < 0 ) {
+ mutex_unlock(&sensor->operation_mutex);
+ printk("%s:fail to active sensor,ret=%d\n",__func__,result);
+ goto error;
+ }
+ if(sensor->pdata->irq_enable)
+ {
+ if(!(sensor->ops->trig & IRQF_SHARED))
+ {
+ DBG("%s:enable irq,irq=%d\n",__func__,client->irq);
+ enable_irq(client->irq); //enable irq
+ }
+ }
+ else
+ {
+ schedule_delayed_work(&sensor->delaywork, msecs_to_jiffies(sensor->pdata->poll_delay_ms));
+ }
+
+ sensor->status_cur = SENSOR_ON;
+ }
+ }
+ else
+ {
+ if(sensor->status_cur == SENSOR_ON)
+ {
+ if ( (result = sensor->ops->active(client, SENSOR_OFF, 0) ) < 0 ) {
+ mutex_unlock(&sensor->operation_mutex);
+ goto error;
+ }
+
+ if(sensor->pdata->irq_enable)
+ {
+ if(!(sensor->ops->trig & IRQF_SHARED))
+ {
+ DBG("%s:disable irq,irq=%d\n",__func__,client->irq);
+ disable_irq_nosync(client->irq);//disable irq
+ }
+ }
+ else
+ cancel_delayed_work_sync(&sensor->delaywork);
+
+ sensor->status_cur = SENSOR_OFF;
+ }
+ }
+ mutex_unlock(&sensor->operation_mutex);
+ DBG("%s:LIGHTSENSOR_IOCTL_ENABLE OK\n", __func__);
+ break;
+
+ default:
+ break;
+ }
+
+error:
+ return result;
+}
+
+
+static int proximity_dev_open(struct inode *inode, struct file *file)
+{
+ //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_PROXIMITY];
+ //struct i2c_client *client = sensor->client;
+ int result = 0;
+
+
+ return result;
+}
+
+
+static int proximity_dev_release(struct inode *inode, struct file *file)
+{
+ //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_PROXIMITY];
+ //struct i2c_client *client = sensor->client;
+ int result = 0;
+
+
+ return result;
+}
+
+#ifdef CONFIG_COMPAT
+static long proximity_dev_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
+{
+ long ret = 0;
+ void __user *arg64 = compat_ptr(arg);
+
+ if (!file->f_op || !file->f_op->unlocked_ioctl) {
+ pr_err("file->f_op or file->f_op->unlocked_ioctl is null\n");
+ return -ENOTTY;
+ }
+
+ switch (cmd) {
+ case COMPAT_PSENSOR_IOCTL_GET_ENABLED:
+ if (file->f_op->unlocked_ioctl)
+ ret = file->f_op->unlocked_ioctl(file, PSENSOR_IOCTL_GET_ENABLED, (unsigned long)arg64);
+ break;
+ case COMPAT_PSENSOR_IOCTL_ENABLE:
+ if (file->f_op->unlocked_ioctl)
+ ret = file->f_op->unlocked_ioctl(file, PSENSOR_IOCTL_ENABLE, (unsigned long)arg64);
+ break;
+ default:
+ break;
+ }
+
+ return ret;
+}
+#endif
+
+/* ioctl - I/O control */
+static long proximity_dev_ioctl(struct file *file,
+ unsigned int cmd, unsigned long arg)
+{
+ struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_PROXIMITY];
+ struct i2c_client *client = sensor->client;
+ unsigned int *argp = (unsigned int *)arg;
+ int result = 0;
+ switch(cmd)
+ {
+ case PSENSOR_IOCTL_GET_ENABLED:
+ *argp = sensor->status_cur;
+ break;
+ case PSENSOR_IOCTL_ENABLE:
+ DBG("%s:PSENSOR_IOCTL_ENABLE start\n", __func__);
+ mutex_lock(&sensor->operation_mutex);
+ if(*(unsigned int *)argp)
+ {
+ if(sensor->status_cur == SENSOR_OFF)
+ {
+ if ( (result = sensor->ops->active(client, SENSOR_ON, 0) ) < 0 ) {
+ mutex_unlock(&sensor->operation_mutex);
+ printk("%s:fail to active sensor,ret=%d\n",__func__,result);
+ goto error;
+ }
+
+ if(sensor->pdata->irq_enable)
+ {
+ if(!(sensor->ops->trig & IRQF_SHARED))
+ {
+ DBG("%s:enable irq,irq=%d\n",__func__,client->irq);
+ enable_irq(client->irq); //enable irq
+ }
+ }
+ else
+ {
+ schedule_delayed_work(&sensor->delaywork, msecs_to_jiffies(sensor->pdata->poll_delay_ms));
+ }
+
+ sensor->status_cur = SENSOR_ON;
+ }
+ }
+ else
+ {
+ if(sensor->status_cur == SENSOR_ON)
+ {
+ if ( (result = sensor->ops->active(client, SENSOR_OFF, 0) ) < 0 ) {
+ mutex_unlock(&sensor->operation_mutex);
+ goto error;
+ }
+ if(sensor->pdata->irq_enable)
+ {
+ if(!(sensor->ops->trig & IRQF_SHARED))
+ {
+ DBG("%s:disable irq,irq=%d\n",__func__,client->irq);
+ disable_irq_nosync(client->irq);//disable irq
+ }
+ }
+ else
+ cancel_delayed_work_sync(&sensor->delaywork);
+ sensor->status_cur = SENSOR_OFF;
+ }
+ }
+ mutex_unlock(&sensor->operation_mutex);
+ DBG("%s:PSENSOR_IOCTL_ENABLE OK\n", __func__);
+ break;
+
+ default:
+ break;
+ }
+
+error:
+ return result;
+}
+
+static int temperature_dev_open(struct inode *inode, struct file *file)
+{
+ //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_TEMPERATURE];
+ //struct i2c_client *client = sensor->client;
+
+ int result = 0;
+
+
+ return result;
+}
+
+
+static int temperature_dev_release(struct inode *inode, struct file *file)
+{
+ //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_TEMPERATURE];
+ //struct i2c_client *client = sensor->client;
+
+ int result = 0;
+
+
+ return result;
+}
+
+
+/* ioctl - I/O control */
+static long temperature_dev_ioctl(struct file *file,
+ unsigned int cmd, unsigned long arg)
+{
+ struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_TEMPERATURE];
+ struct i2c_client *client = sensor->client;
+ unsigned int *argp = (unsigned int *)arg;
+ int result = 0;
+
+ switch(cmd)
+ {
+ case TEMPERATURE_IOCTL_GET_ENABLED:
+ *argp = sensor->status_cur;
+ break;
+ case TEMPERATURE_IOCTL_ENABLE:
+ DBG("%s:LIGHTSENSOR_IOCTL_ENABLE start\n", __func__);
+ mutex_lock(&sensor->operation_mutex);
+ if(*(unsigned int *)argp)
+ {
+ if(sensor->status_cur == SENSOR_OFF)
+ {
+ if ( (result = sensor->ops->active(client, SENSOR_ON, 0) ) < 0 ) {
+ mutex_unlock(&sensor->operation_mutex);
+ printk("%s:fail to active sensor,ret=%d\n",__func__,result);
+ goto error;
+ }
+ if(sensor->pdata->irq_enable)
+ {
+ if(!(sensor->ops->trig & IRQF_SHARED))
+ {
+ DBG("%s:enable irq,irq=%d\n",__func__,client->irq);
+ enable_irq(client->irq); //enable irq
+ }
+ }
+ else
+ {
+ schedule_delayed_work(&sensor->delaywork, msecs_to_jiffies(sensor->pdata->poll_delay_ms));
+ }
+
+ sensor->status_cur = SENSOR_ON;
+ }
+ }
+ else
+ {
+ if(sensor->status_cur == SENSOR_ON)
+ {
+ if ( (result = sensor->ops->active(client, SENSOR_OFF, 0) ) < 0 ) {
+ mutex_unlock(&sensor->operation_mutex);
+ goto error;
+ }
+
+ if(sensor->pdata->irq_enable)
+ {
+ if(!(sensor->ops->trig & IRQF_SHARED))
+ {
+ DBG("%s:disable irq,irq=%d\n",__func__,client->irq);
+ disable_irq_nosync(client->irq);//disable irq
+ }
+ }
+ else
+ cancel_delayed_work_sync(&sensor->delaywork);
+
+ sensor->status_cur = SENSOR_OFF;
+ }
+ }
+ mutex_unlock(&sensor->operation_mutex);
+ DBG("%s:LIGHTSENSOR_IOCTL_ENABLE OK\n", __func__);
+ break;
+
+ default:
+ break;
+ }
+
+error:
+ return result;
+}
+
+
+static int pressure_dev_open(struct inode *inode, struct file *file)
+{
+ //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_PRESSURE];
+ //struct i2c_client *client = sensor->client;
+
+ int result = 0;
+
+
+ return result;
+}
+
+
+static int pressure_dev_release(struct inode *inode, struct file *file)
+{
+ //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_PRESSURE];
+ //struct i2c_client *client = sensor->client;
+
+ int result = 0;
+
+
+ return result;
+}
+
+
+/* ioctl - I/O control */
+static long pressure_dev_ioctl(struct file *file,
+ unsigned int cmd, unsigned long arg)
+{
+ struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_PRESSURE];
+ struct i2c_client *client = sensor->client;
+ unsigned int *argp = (unsigned int *)arg;
+ int result = 0;
+
+ switch(cmd)
+ {
+ case PRESSURE_IOCTL_GET_ENABLED:
+ *argp = sensor->status_cur;
+ break;
+ case PRESSURE_IOCTL_ENABLE:
+ DBG("%s:LIGHTSENSOR_IOCTL_ENABLE start\n", __func__);
+ mutex_lock(&sensor->operation_mutex);
+ if(*(unsigned int *)argp)
+ {
+ if(sensor->status_cur == SENSOR_OFF)
+ {
+ if ( (result = sensor->ops->active(client, SENSOR_ON, 0) ) < 0 ) {
+ mutex_unlock(&sensor->operation_mutex);
+ printk("%s:fail to active sensor,ret=%d\n",__func__,result);
+ goto error;
+ }
+ if(sensor->pdata->irq_enable)
+ {
+ if(!(sensor->ops->trig & IRQF_SHARED))
+ {
+ DBG("%s:enable irq,irq=%d\n",__func__,client->irq);
+ enable_irq(client->irq); //enable irq
+ }
+ }
+ else
+ {
+ schedule_delayed_work(&sensor->delaywork, msecs_to_jiffies(sensor->pdata->poll_delay_ms));
+ }
+
+ sensor->status_cur = SENSOR_ON;
+ }
+ }
+ else
+ {
+ if(sensor->status_cur == SENSOR_ON)
+ {
+ if ( (result = sensor->ops->active(client, SENSOR_OFF, 0) ) < 0 ) {
+ mutex_unlock(&sensor->operation_mutex);
+ goto error;
+ }
+
+ if(sensor->pdata->irq_enable)
+ {
+ if(!(sensor->ops->trig & IRQF_SHARED))
+ {
+ DBG("%s:disable irq,irq=%d\n",__func__,client->irq);
+ disable_irq_nosync(client->irq);//disable irq
+ }
+ }
+ else
+ cancel_delayed_work_sync(&sensor->delaywork);
+
+ sensor->status_cur = SENSOR_OFF;
+ }
+ }
+ mutex_unlock(&sensor->operation_mutex);
+ DBG("%s:LIGHTSENSOR_IOCTL_ENABLE OK\n", __func__);
+ break;
+
+ default:
+ break;
+ }
+
+error:
+ return result;
+}
+
+
+
+
+static int sensor_misc_device_register(struct sensor_private_data *sensor, int type)
+{
+ int result = 0;
+
+ switch(type)
+ {
+ case SENSOR_TYPE_ANGLE:
+ if(!sensor->ops->misc_dev)
+ {
+ sensor->fops.owner = THIS_MODULE;
+ sensor->fops.unlocked_ioctl = angle_dev_ioctl;
+ sensor->fops.open = angle_dev_open;
+ sensor->fops.release = angle_dev_release;
+
+ sensor->miscdev.minor = MISC_DYNAMIC_MINOR;
+ sensor->miscdev.name = "angle";
+ sensor->miscdev.fops = &sensor->fops;
+ }
+ else
+ {
+ memcpy(&sensor->miscdev, sensor->ops->misc_dev, sizeof(*sensor->ops->misc_dev));
+
+ }
+
+ break;
+
+ case SENSOR_TYPE_ACCEL:
+ if(!sensor->ops->misc_dev)
+ {
+ sensor->fops.owner = THIS_MODULE;
+ sensor->fops.unlocked_ioctl = gsensor_dev_ioctl;
+ #ifdef CONFIG_COMPAT
+ sensor->fops.compat_ioctl = gsensor_dev_ioctl;
+ #endif
+ sensor->fops.open = gsensor_dev_open;
+ sensor->fops.release = gsensor_dev_release;
+
+ sensor->miscdev.minor = MISC_DYNAMIC_MINOR;
+ sensor->miscdev.name = "mma8452_daemon";
+ sensor->miscdev.fops = &sensor->fops;
+ }
+ else
+ {
+ memcpy(&sensor->miscdev, sensor->ops->misc_dev, sizeof(*sensor->ops->misc_dev));
+
+ }
+
+ break;
+
+ case SENSOR_TYPE_COMPASS:
+ if(!sensor->ops->misc_dev)
+ {
+ sensor->fops.owner = THIS_MODULE;
+ sensor->fops.unlocked_ioctl = compass_dev_ioctl;
+#ifdef CONFIG_COMPAT
sensor->fops.compat_ioctl = compass_dev_compat_ioctl;
#endif
- sensor->fops.open = compass_dev_open;\r
- sensor->fops.release = compass_dev_release;\r
-\r
- sensor->miscdev.minor = MISC_DYNAMIC_MINOR;\r
- sensor->miscdev.name = "compass";\r
- sensor->miscdev.fops = &sensor->fops;\r
- }\r
- else\r
- {\r
- memcpy(&sensor->miscdev, sensor->ops->misc_dev, sizeof(*sensor->ops->misc_dev));\r
-\r
- }\r
-\r
- break;\r
-\r
- case SENSOR_TYPE_GYROSCOPE: \r
- if(!sensor->ops->misc_dev)\r
- {\r
- sensor->fops.owner = THIS_MODULE;\r
- sensor->fops.unlocked_ioctl = gyro_dev_ioctl;\r
- sensor->fops.open = gyro_dev_open;\r
- sensor->fops.release = gyro_dev_release;\r
-\r
- sensor->miscdev.minor = MISC_DYNAMIC_MINOR;\r
- sensor->miscdev.name = "gyrosensor";\r
- sensor->miscdev.fops = &sensor->fops;\r
- }\r
- else\r
- {\r
- memcpy(&sensor->miscdev, sensor->ops->misc_dev, sizeof(*sensor->ops->misc_dev));\r
-\r
- }\r
- \r
- break;\r
-\r
- case SENSOR_TYPE_LIGHT:\r
- if(!sensor->ops->misc_dev)\r
- {\r
- sensor->fops.owner = THIS_MODULE;\r
- sensor->fops.unlocked_ioctl = light_dev_ioctl;\r
+ sensor->fops.open = compass_dev_open;
+ sensor->fops.release = compass_dev_release;
+
+ sensor->miscdev.minor = MISC_DYNAMIC_MINOR;
+ sensor->miscdev.name = "compass";
+ sensor->miscdev.fops = &sensor->fops;
+ }
+ else
+ {
+ memcpy(&sensor->miscdev, sensor->ops->misc_dev, sizeof(*sensor->ops->misc_dev));
+
+ }
+
+ break;
+
+ case SENSOR_TYPE_GYROSCOPE:
+ if(!sensor->ops->misc_dev)
+ {
+ sensor->fops.owner = THIS_MODULE;
+ sensor->fops.unlocked_ioctl = gyro_dev_ioctl;
+ sensor->fops.open = gyro_dev_open;
+ sensor->fops.release = gyro_dev_release;
+
+ sensor->miscdev.minor = MISC_DYNAMIC_MINOR;
+ sensor->miscdev.name = "gyrosensor";
+ sensor->miscdev.fops = &sensor->fops;
+ }
+ else
+ {
+ memcpy(&sensor->miscdev, sensor->ops->misc_dev, sizeof(*sensor->ops->misc_dev));
+
+ }
+
+ break;
+
+ case SENSOR_TYPE_LIGHT:
+ if(!sensor->ops->misc_dev)
+ {
+ sensor->fops.owner = THIS_MODULE;
+ sensor->fops.unlocked_ioctl = light_dev_ioctl;
#ifdef CONFIG_COMPAT
sensor->fops.compat_ioctl = light_dev_compat_ioctl;
#endif
- sensor->fops.open = light_dev_open;\r
- sensor->fops.release = light_dev_release;\r
-\r
- sensor->miscdev.minor = MISC_DYNAMIC_MINOR;\r
- sensor->miscdev.name = "lightsensor";\r
- sensor->miscdev.fops = &sensor->fops;\r
- } \r
- else\r
- {\r
- memcpy(&sensor->miscdev, sensor->ops->misc_dev, sizeof(*sensor->ops->misc_dev));\r
-\r
- }\r
- break;\r
- \r
- case SENSOR_TYPE_PROXIMITY:\r
- if(!sensor->ops->misc_dev)\r
- {\r
- sensor->fops.owner = THIS_MODULE;\r
- sensor->fops.unlocked_ioctl = proximity_dev_ioctl;\r
+ sensor->fops.open = light_dev_open;
+ sensor->fops.release = light_dev_release;
+
+ sensor->miscdev.minor = MISC_DYNAMIC_MINOR;
+ sensor->miscdev.name = "lightsensor";
+ sensor->miscdev.fops = &sensor->fops;
+ }
+ else
+ {
+ memcpy(&sensor->miscdev, sensor->ops->misc_dev, sizeof(*sensor->ops->misc_dev));
+
+ }
+ break;
+
+ case SENSOR_TYPE_PROXIMITY:
+ if(!sensor->ops->misc_dev)
+ {
+ sensor->fops.owner = THIS_MODULE;
+ sensor->fops.unlocked_ioctl = proximity_dev_ioctl;
#ifdef CONFIG_COMPAT
sensor->fops.compat_ioctl = proximity_dev_compat_ioctl;
#endif
- sensor->fops.open = proximity_dev_open;\r
- sensor->fops.release = proximity_dev_release;\r
-\r
- sensor->miscdev.minor = MISC_DYNAMIC_MINOR;\r
- sensor->miscdev.name = "psensor";\r
- sensor->miscdev.fops = &sensor->fops;\r
- } \r
- else\r
- {\r
- memcpy(&sensor->miscdev, sensor->ops->misc_dev, sizeof(*sensor->ops->misc_dev));\r
-\r
- }\r
- break;\r
-\r
- case SENSOR_TYPE_TEMPERATURE:\r
- if(!sensor->ops->misc_dev)\r
- {\r
- sensor->fops.owner = THIS_MODULE;\r
- sensor->fops.unlocked_ioctl = temperature_dev_ioctl;\r
- sensor->fops.open = temperature_dev_open;\r
- sensor->fops.release = temperature_dev_release;\r
-\r
- sensor->miscdev.minor = MISC_DYNAMIC_MINOR;\r
- sensor->miscdev.name = "temperature";\r
- sensor->miscdev.fops = &sensor->fops;\r
- } \r
- else\r
- {\r
- memcpy(&sensor->miscdev, sensor->ops->misc_dev, sizeof(*sensor->ops->misc_dev));\r
-\r
- }\r
- \r
- break;\r
-\r
- case SENSOR_TYPE_PRESSURE:\r
- if(!sensor->ops->misc_dev)\r
- {\r
- sensor->fops.owner = THIS_MODULE;\r
- sensor->fops.unlocked_ioctl = pressure_dev_ioctl;\r
- sensor->fops.open = pressure_dev_open;\r
- sensor->fops.release = pressure_dev_release;\r
-\r
- sensor->miscdev.minor = MISC_DYNAMIC_MINOR;\r
- sensor->miscdev.name = "pressure";\r
- sensor->miscdev.fops = &sensor->fops;\r
- } \r
- else\r
- {\r
- memcpy(&sensor->miscdev, sensor->ops->misc_dev, sizeof(*sensor->ops->misc_dev));\r
-\r
- }\r
- \r
- break;\r
-\r
- default:\r
- printk("%s:unknow sensor type=%d\n",__func__,type);\r
- result = -1;\r
- goto error;\r
- }\r
- \r
- sensor->miscdev.parent = &sensor->client->dev;\r
- result = misc_register(&sensor->miscdev);\r
- if (result < 0) {\r
- dev_err(&sensor->client->dev,\r
- "fail to register misc device %s\n", sensor->miscdev.name);\r
- goto error;\r
- }\r
- \r
- printk("%s:miscdevice: %s\n",__func__,sensor->miscdev.name);\r
-\r
-error: \r
- \r
- return result;\r
-\r
-}\r
-\r
-int sensor_register_slave(int type,struct i2c_client *client,\r
- struct sensor_platform_data *slave_pdata,\r
- struct sensor_operate *(*get_sensor_ops)(void))\r
-{\r
- int result = 0;\r
- struct sensor_operate *ops = get_sensor_ops();\r
- if((ops->id_i2c >= SENSOR_NUM_ID) || (ops->id_i2c <= ID_INVALID))\r
- { \r
- printk("%s:%s id is error %d\n", __func__, ops->name, ops->id_i2c);\r
- return -1; \r
- }\r
- sensor_ops[ops->id_i2c] = ops;\r
- printk("%s:%s,id=%d\n",__func__,sensor_ops[ops->id_i2c]->name, ops->id_i2c);\r
- return result;\r
-}\r
-\r
-\r
-int sensor_unregister_slave(int type,struct i2c_client *client,\r
- struct sensor_platform_data *slave_pdata,\r
- struct sensor_operate *(*get_sensor_ops)(void))\r
-{\r
- int result = 0;\r
- struct sensor_operate *ops = get_sensor_ops();\r
- if((ops->id_i2c >= SENSOR_NUM_ID) || (ops->id_i2c <= ID_INVALID))\r
- { \r
- printk("%s:%s id is error %d\n", __func__, ops->name, ops->id_i2c);\r
- return -1; \r
- }\r
- printk("%s:%s,id=%d\n",__func__,sensor_ops[ops->id_i2c]->name, ops->id_i2c);\r
- sensor_ops[ops->id_i2c] = NULL; \r
- return result;\r
-}\r
-\r
-\r
-int sensor_probe(struct i2c_client *client, const struct i2c_device_id *devid)\r
-{\r
- struct sensor_private_data *sensor =\r
- (struct sensor_private_data *) i2c_get_clientdata(client);\r
- struct sensor_platform_data *pdata;\r
- struct device_node *np = client->dev.of_node;\r
- enum of_gpio_flags rst_flags, pwr_flags;\r
- unsigned long irq_flags;\r
- int result = 0;\r
- int type = 0;\r
- \r
- dev_info(&client->adapter->dev, "%s: %s,%p\n", __func__, devid->name, client);\r
-\r
- if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {\r
- result = -ENODEV;\r
- goto out_no_free;\r
- }\r
- if (!np) {\r
- dev_err(&client->dev, "no device tree\n");\r
- return -EINVAL;\r
- }\r
- pdata = devm_kzalloc(&client->dev,sizeof(*pdata), GFP_KERNEL);\r
- if (!pdata) {\r
- result = -ENOMEM;\r
- goto out_no_free;\r
- }\r
- sensor = devm_kzalloc(&client->dev,sizeof(*sensor), GFP_KERNEL);\r
- if (!sensor) {\r
- result = -ENOMEM;\r
- goto out_no_free;\r
- }\r
- \r
- of_property_read_u32(np,"type",&(pdata->type));\r
-\r
- pdata->irq_pin = of_get_named_gpio_flags(np, "irq-gpio", 0,(enum of_gpio_flags *)&irq_flags);\r
- pdata->reset_pin = of_get_named_gpio_flags(np, "reset-gpio",0,&rst_flags);\r
- pdata->power_pin = of_get_named_gpio_flags(np, "power-gpio",0,&pwr_flags);\r
- \r
- of_property_read_u32(np,"irq_enable",&(pdata->irq_enable));\r
- of_property_read_u32(np,"poll_delay_ms",&(pdata->poll_delay_ms));\r
-\r
- of_property_read_u32(np,"x_min",&(pdata->x_min));\r
- of_property_read_u32(np,"y_min",&(pdata->y_min));\r
- of_property_read_u32(np,"z_min",&(pdata->z_min));\r
- of_property_read_u32(np,"factory",&(pdata->factory));\r
- of_property_read_u32(np,"layout",&(pdata->layout));\r
-\r
- of_property_read_u8(np,"address",&(pdata->address));\r
- of_get_property(np, "project_name", pdata->project_name);\r
+ sensor->fops.open = proximity_dev_open;
+ sensor->fops.release = proximity_dev_release;
+
+ sensor->miscdev.minor = MISC_DYNAMIC_MINOR;
+ sensor->miscdev.name = "psensor";
+ sensor->miscdev.fops = &sensor->fops;
+ }
+ else
+ {
+ memcpy(&sensor->miscdev, sensor->ops->misc_dev, sizeof(*sensor->ops->misc_dev));
+
+ }
+ break;
+
+ case SENSOR_TYPE_TEMPERATURE:
+ if(!sensor->ops->misc_dev)
+ {
+ sensor->fops.owner = THIS_MODULE;
+ sensor->fops.unlocked_ioctl = temperature_dev_ioctl;
+ sensor->fops.open = temperature_dev_open;
+ sensor->fops.release = temperature_dev_release;
+
+ sensor->miscdev.minor = MISC_DYNAMIC_MINOR;
+ sensor->miscdev.name = "temperature";
+ sensor->miscdev.fops = &sensor->fops;
+ }
+ else
+ {
+ memcpy(&sensor->miscdev, sensor->ops->misc_dev, sizeof(*sensor->ops->misc_dev));
+
+ }
+
+ break;
+
+ case SENSOR_TYPE_PRESSURE:
+ if(!sensor->ops->misc_dev)
+ {
+ sensor->fops.owner = THIS_MODULE;
+ sensor->fops.unlocked_ioctl = pressure_dev_ioctl;
+ sensor->fops.open = pressure_dev_open;
+ sensor->fops.release = pressure_dev_release;
+
+ sensor->miscdev.minor = MISC_DYNAMIC_MINOR;
+ sensor->miscdev.name = "pressure";
+ sensor->miscdev.fops = &sensor->fops;
+ }
+ else
+ {
+ memcpy(&sensor->miscdev, sensor->ops->misc_dev, sizeof(*sensor->ops->misc_dev));
+
+ }
+
+ break;
+
+ default:
+ printk("%s:unknow sensor type=%d\n",__func__,type);
+ result = -1;
+ goto error;
+ }
+
+ sensor->miscdev.parent = &sensor->client->dev;
+ result = misc_register(&sensor->miscdev);
+ if (result < 0) {
+ dev_err(&sensor->client->dev,
+ "fail to register misc device %s\n", sensor->miscdev.name);
+ goto error;
+ }
+
+ printk("%s:miscdevice: %s\n",__func__,sensor->miscdev.name);
+
+error:
+
+ return result;
+
+}
+
+int sensor_register_slave(int type,struct i2c_client *client,
+ struct sensor_platform_data *slave_pdata,
+ struct sensor_operate *(*get_sensor_ops)(void))
+{
+ int result = 0;
+ struct sensor_operate *ops = get_sensor_ops();
+ if((ops->id_i2c >= SENSOR_NUM_ID) || (ops->id_i2c <= ID_INVALID))
+ {
+ printk("%s:%s id is error %d\n", __func__, ops->name, ops->id_i2c);
+ return -1;
+ }
+ sensor_ops[ops->id_i2c] = ops;
+ printk("%s:%s,id=%d\n",__func__,sensor_ops[ops->id_i2c]->name, ops->id_i2c);
+ return result;
+}
+
+
+int sensor_unregister_slave(int type,struct i2c_client *client,
+ struct sensor_platform_data *slave_pdata,
+ struct sensor_operate *(*get_sensor_ops)(void))
+{
+ int result = 0;
+ struct sensor_operate *ops = get_sensor_ops();
+ if((ops->id_i2c >= SENSOR_NUM_ID) || (ops->id_i2c <= ID_INVALID))
+ {
+ printk("%s:%s id is error %d\n", __func__, ops->name, ops->id_i2c);
+ return -1;
+ }
+ printk("%s:%s,id=%d\n",__func__,sensor_ops[ops->id_i2c]->name, ops->id_i2c);
+ sensor_ops[ops->id_i2c] = NULL;
+ return result;
+}
+
+
+int sensor_probe(struct i2c_client *client, const struct i2c_device_id *devid)
+{
+ struct sensor_private_data *sensor =
+ (struct sensor_private_data *) i2c_get_clientdata(client);
+ struct sensor_platform_data *pdata;
+ struct device_node *np = client->dev.of_node;
+ enum of_gpio_flags rst_flags, pwr_flags;
+ unsigned long irq_flags;
+ int result = 0;
+ int type = 0;
+
+ dev_info(&client->adapter->dev, "%s: %s,%p\n", __func__, devid->name, client);
+
+ if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
+ result = -ENODEV;
+ goto out_no_free;
+ }
+ if (!np) {
+ dev_err(&client->dev, "no device tree\n");
+ return -EINVAL;
+ }
+ pdata = devm_kzalloc(&client->dev,sizeof(*pdata), GFP_KERNEL);
+ if (!pdata) {
+ result = -ENOMEM;
+ goto out_no_free;
+ }
+ sensor = devm_kzalloc(&client->dev,sizeof(*sensor), GFP_KERNEL);
+ if (!sensor) {
+ result = -ENOMEM;
+ goto out_no_free;
+ }
+
+ of_property_read_u32(np,"type",&(pdata->type));
+
+ pdata->irq_pin = of_get_named_gpio_flags(np, "irq-gpio", 0,(enum of_gpio_flags *)&irq_flags);
+ pdata->reset_pin = of_get_named_gpio_flags(np, "reset-gpio",0,&rst_flags);
+ pdata->power_pin = of_get_named_gpio_flags(np, "power-gpio",0,&pwr_flags);
+
+ of_property_read_u32(np,"irq_enable",&(pdata->irq_enable));
+ of_property_read_u32(np,"poll_delay_ms",&(pdata->poll_delay_ms));
+
+ of_property_read_u32(np,"x_min",&(pdata->x_min));
+ of_property_read_u32(np,"y_min",&(pdata->y_min));
+ of_property_read_u32(np,"z_min",&(pdata->z_min));
+ of_property_read_u32(np,"factory",&(pdata->factory));
+ of_property_read_u32(np,"layout",&(pdata->layout));
+
+ of_property_read_u8(np,"address",&(pdata->address));
+ of_get_property(np, "project_name", pdata->project_name);
of_property_read_u32(np, "power-off-in-suspend",
&pdata->power_off_in_suspend);
-\r
- switch(pdata->layout)\r
- {\r
- case 1:\r
- pdata->orientation[0] = 1;\r
- pdata->orientation[1] = 0;\r
- pdata->orientation[2] = 0;\r
-\r
- pdata->orientation[3] = 0;\r
- pdata->orientation[4] = 1;\r
- pdata->orientation[5] = 0;\r
-\r
- pdata->orientation[6] = 0;\r
- pdata->orientation[7] = 0;\r
- pdata->orientation[8] = 1;\r
- break;\r
-\r
- case 2:\r
- pdata->orientation[0] = 0;\r
- pdata->orientation[1] = -1;\r
- pdata->orientation[2] = 0;\r
-\r
- pdata->orientation[3] = 1;\r
- pdata->orientation[4] = 0;\r
- pdata->orientation[5] = 0;\r
-\r
- pdata->orientation[6] = 0;\r
- pdata->orientation[7] = 0;\r
- pdata->orientation[8] = 1;\r
- break;\r
-\r
- case 3:\r
- pdata->orientation[0] = -1;\r
- pdata->orientation[1] = 0;\r
- pdata->orientation[2] = 0;\r
-\r
- pdata->orientation[3] = 0;\r
- pdata->orientation[4] = -1;\r
- pdata->orientation[5] = 0;\r
-\r
- pdata->orientation[6] = 0;\r
- pdata->orientation[7] = 0;\r
- pdata->orientation[8] = 1;\r
- break;\r
-\r
- case 4:\r
- pdata->orientation[0] = 0;\r
- pdata->orientation[1] = 1;\r
- pdata->orientation[2] = 0;\r
-\r
- pdata->orientation[3] = -1;\r
- pdata->orientation[4] = 0;\r
- pdata->orientation[5] = 0;\r
-\r
- pdata->orientation[6] = 0;\r
- pdata->orientation[7] = 0;\r
- pdata->orientation[8] = 1;\r
- break;\r
-\r
- case 5:\r
- pdata->orientation[0] = 1;\r
- pdata->orientation[1] = 0;\r
- pdata->orientation[2] = 0;\r
-\r
- pdata->orientation[3] = 0;\r
- pdata->orientation[4] = -1;\r
- pdata->orientation[5] = 0;\r
-\r
- pdata->orientation[6] = 0;\r
- pdata->orientation[7] = 0;\r
- pdata->orientation[8] = -1;\r
- break;\r
-\r
- case 6:\r
- pdata->orientation[0] = 0;\r
- pdata->orientation[1] = -1;\r
- pdata->orientation[2] = 0;\r
-\r
- pdata->orientation[3] = -1;\r
- pdata->orientation[4] = 0;\r
- pdata->orientation[5] = 0;\r
-\r
- pdata->orientation[6] = 0;\r
- pdata->orientation[7] = 0;\r
- pdata->orientation[8] = -1;\r
- break;\r
-\r
- case 7:\r
- pdata->orientation[0] = -1;\r
- pdata->orientation[1] = 0;\r
- pdata->orientation[2] = 0;\r
-\r
- pdata->orientation[3] = 0;\r
- pdata->orientation[4] = 1;\r
- pdata->orientation[5] = 0;\r
-\r
- pdata->orientation[6] = 0;\r
- pdata->orientation[7] = 0;\r
- pdata->orientation[8] = -1;\r
- break;\r
-\r
- case 8:\r
- pdata->orientation[0] = 0;\r
- pdata->orientation[1] = 1;\r
- pdata->orientation[2] = 0;\r
-\r
- pdata->orientation[3] = 1;\r
- pdata->orientation[4] = 0;\r
- pdata->orientation[5] = 0;\r
-\r
- pdata->orientation[6] = 0;\r
- pdata->orientation[7] = 0;\r
- pdata->orientation[8] = -1;\r
- break;\r
-\r
- default:\r
- pdata->orientation[0] = 1;\r
- pdata->orientation[1] = 0;\r
- pdata->orientation[2] = 0;\r
-\r
- pdata->orientation[3] = 0;\r
- pdata->orientation[4] = 1;\r
- pdata->orientation[5] = 0;\r
-\r
- pdata->orientation[6] = 0;\r
- pdata->orientation[7] = 0;\r
- pdata->orientation[8] = 1;\r
- break;\r
- }\r
-\r
- client->irq = pdata->irq_pin;\r
- type = pdata->type;\r
- pdata->irq_flags = irq_flags;\r
- DBG("irq_flags = %lu padta->irq_flags = %lu\n",irq_flags, pdata->irq_flags);\r
- DBG("type = %d \n",pdata->type);\r
- DBG("irq = %d \n",pdata->irq);\r
- DBG("irq_pin = %d \n",pdata->irq_pin);\r
- DBG("pwer_pin = %d \n",pdata->power_pin); \r
- DBG("reset_pin = %d \n",pdata->reset_pin);\r
- DBG("irq_enable = %d \n",pdata->irq_enable);\r
-\r
- DBG("poll_delay_ms = %d \n",pdata->poll_delay_ms);\r
- DBG("x_min = %d \n",pdata->x_min);\r
- DBG("y_min = %d \n",pdata->y_min);\r
- DBG("z_min = %d \n",pdata->z_min); \r
- DBG("factory = %d \n",pdata->factory);\r
- DBG("layout = %d \n",pdata->layout);\r
- DBG("address = 0x%x \n",pdata->address);\r
- DBG("project_name = [%s] \n",pdata->project_name);\r
- \r
- DBG(" == %d,%d ,%d \t ,%d ,%d ,%d , \t ,%d, %d, %d ,==%d\n",pdata->orientation[0],pdata->orientation[1],pdata->orientation[2]\r
- ,pdata->orientation[3],pdata->orientation[4],pdata->orientation[5]\r
- ,pdata->orientation[6],pdata->orientation[7],pdata->orientation[8],ARRAY_SIZE(pdata->orientation));\r
- \r
- \r
- if((type >= SENSOR_NUM_TYPES) || (type <= SENSOR_TYPE_NULL))\r
- { \r
- dev_err(&client->adapter->dev, "sensor type is error %d\n", type);\r
- result = -EFAULT;\r
- goto out_no_free; \r
- }\r
- if(((int)devid->driver_data >= SENSOR_NUM_ID) || ((int)devid->driver_data <= ID_INVALID))\r
- { \r
- dev_err(&client->adapter->dev, "sensor id is error %d\n", (int)devid->driver_data);\r
- result = -EFAULT;\r
- goto out_no_free; \r
- }\r
- i2c_set_clientdata(client, sensor);\r
- sensor->client = client; \r
- sensor->pdata = pdata; \r
- sensor->type = type;\r
- sensor->i2c_id = (struct i2c_device_id *)devid;\r
-\r
- \r
- memset(&(sensor->axis), 0, sizeof(struct sensor_axis) );\r
- atomic_set(&(sensor->data_ready), 0);\r
- init_waitqueue_head(&(sensor->data_ready_wq));\r
- mutex_init(&sensor->data_mutex); \r
- mutex_init(&sensor->operation_mutex); \r
- mutex_init(&sensor->sensor_mutex);\r
- mutex_init(&sensor->i2c_mutex);\r
-\r
- /* As default, report all information */\r
- atomic_set(&sensor->flags.m_flag, 1);\r
- atomic_set(&sensor->flags.a_flag, 1);\r
- atomic_set(&sensor->flags.mv_flag, 1); \r
- atomic_set(&sensor->flags.open_flag, 0);\r
- atomic_set(&sensor->flags.debug_flag, 1);\r
- init_waitqueue_head(&sensor->flags.open_wq);\r
- sensor->flags.delay = 100;\r
-\r
- sensor->status_cur = SENSOR_OFF;\r
- sensor->axis.x = 0;\r
- sensor->axis.y = 0;\r
- sensor->axis.z = 0;\r
- \r
- result = sensor_chip_init(sensor->client);\r
- if(result < 0)\r
- goto out_free_memory;\r
- \r
- sensor->input_dev = devm_input_allocate_device(&client->dev);\r
- if (!sensor->input_dev) {\r
- result = -ENOMEM;\r
- dev_err(&client->dev,\r
- "Failed to allocate input device\n");\r
- goto out_free_memory;\r
- } \r
-\r
- switch(type)\r
- {\r
- case SENSOR_TYPE_ANGLE: \r
- sensor->input_dev->name = "angle";\r
- set_bit(EV_ABS, sensor->input_dev->evbit);\r
- /* x-axis acceleration */\r
- input_set_abs_params(sensor->input_dev, ABS_X, sensor->ops->range[0], sensor->ops->range[1], 0, 0); //2g full scale range\r
- /* y-axis acceleration */\r
- input_set_abs_params(sensor->input_dev, ABS_Y, sensor->ops->range[0], sensor->ops->range[1], 0, 0); //2g full scale range\r
- /* z-axis acceleration */\r
- input_set_abs_params(sensor->input_dev, ABS_Z, sensor->ops->range[0], sensor->ops->range[1], 0, 0); //2g full scale range\r
- break; \r
-\r
- case SENSOR_TYPE_ACCEL: \r
- sensor->input_dev->name = "gsensor";\r
- set_bit(EV_ABS, sensor->input_dev->evbit);\r
- /* x-axis acceleration */\r
- input_set_abs_params(sensor->input_dev, ABS_X, sensor->ops->range[0], sensor->ops->range[1], 0, 0); //2g full scale range\r
- /* y-axis acceleration */\r
- input_set_abs_params(sensor->input_dev, ABS_Y, sensor->ops->range[0], sensor->ops->range[1], 0, 0); //2g full scale range\r
- /* z-axis acceleration */\r
- input_set_abs_params(sensor->input_dev, ABS_Z, sensor->ops->range[0], sensor->ops->range[1], 0, 0); //2g full scale range\r
- break; \r
- case SENSOR_TYPE_COMPASS: \r
- sensor->input_dev->name = "compass"; \r
- /* Setup input device */\r
- set_bit(EV_ABS, sensor->input_dev->evbit);\r
- /* yaw (0, 360) */\r
- input_set_abs_params(sensor->input_dev, ABS_RX, 0, 23040, 0, 0);\r
- /* pitch (-180, 180) */\r
- input_set_abs_params(sensor->input_dev, ABS_RY, -11520, 11520, 0, 0);\r
- /* roll (-90, 90) */\r
- input_set_abs_params(sensor->input_dev, ABS_RZ, -5760, 5760, 0, 0);\r
- /* x-axis acceleration (720 x 8G) */\r
- input_set_abs_params(sensor->input_dev, ABS_X, -5760, 5760, 0, 0);\r
- /* y-axis acceleration (720 x 8G) */\r
- input_set_abs_params(sensor->input_dev, ABS_Y, -5760, 5760, 0, 0);\r
- /* z-axis acceleration (720 x 8G) */\r
- input_set_abs_params(sensor->input_dev, ABS_Z, -5760, 5760, 0, 0);\r
- /* status of magnetic sensor */\r
- input_set_abs_params(sensor->input_dev, ABS_RUDDER, -32768, 3, 0, 0);\r
- /* status of acceleration sensor */\r
- input_set_abs_params(sensor->input_dev, ABS_WHEEL, -32768, 3, 0, 0);\r
- /* x-axis of raw magnetic vector (-4096, 4095) */\r
- input_set_abs_params(sensor->input_dev, ABS_HAT0X, -20480, 20479, 0, 0);\r
- /* y-axis of raw magnetic vector (-4096, 4095) */\r
- input_set_abs_params(sensor->input_dev, ABS_HAT0Y, -20480, 20479, 0, 0);\r
- /* z-axis of raw magnetic vector (-4096, 4095) */\r
- input_set_abs_params(sensor->input_dev, ABS_BRAKE, -20480, 20479, 0, 0);\r
- break; \r
- case SENSOR_TYPE_GYROSCOPE:\r
- sensor->input_dev->name = "gyro";\r
- /* x-axis acceleration */\r
- input_set_capability(sensor->input_dev, EV_REL, REL_RX);\r
- input_set_abs_params(sensor->input_dev, ABS_RX, sensor->ops->range[0], sensor->ops->range[1], 0, 0); \r
- /* y-axis acceleration */ \r
- input_set_capability(sensor->input_dev, EV_REL, REL_RY);\r
- input_set_abs_params(sensor->input_dev, ABS_RY, sensor->ops->range[0], sensor->ops->range[1], 0, 0); \r
- /* z-axis acceleration */\r
- input_set_capability(sensor->input_dev, EV_REL, REL_RZ);\r
- input_set_abs_params(sensor->input_dev, ABS_RZ, sensor->ops->range[0], sensor->ops->range[1], 0, 0); \r
- break;\r
- case SENSOR_TYPE_LIGHT:\r
- sensor->input_dev->name = "lightsensor-level";\r
- set_bit(EV_ABS, sensor->input_dev->evbit);\r
- input_set_abs_params(sensor->input_dev, ABS_MISC, sensor->ops->range[0], sensor->ops->range[1], 0, 0); \r
- input_set_abs_params(sensor->input_dev, ABS_TOOL_WIDTH , sensor->ops->brightness[0],sensor->ops->brightness[1], 0, 0);\r
- break;\r
- case SENSOR_TYPE_PROXIMITY:\r
- sensor->input_dev->name = "proximity"; \r
- set_bit(EV_ABS, sensor->input_dev->evbit);\r
- input_set_abs_params(sensor->input_dev, ABS_DISTANCE, sensor->ops->range[0], sensor->ops->range[1], 0, 0);\r
- break;\r
- case SENSOR_TYPE_TEMPERATURE: \r
- sensor->input_dev->name = "temperature";\r
- set_bit(EV_ABS, sensor->input_dev->evbit); \r
- input_set_abs_params(sensor->input_dev, ABS_THROTTLE, sensor->ops->range[0], sensor->ops->range[1], 0, 0);\r
- break;\r
- case SENSOR_TYPE_PRESSURE: \r
- sensor->input_dev->name = "pressure";\r
- set_bit(EV_ABS, sensor->input_dev->evbit); \r
- input_set_abs_params(sensor->input_dev, ABS_PRESSURE, sensor->ops->range[0], sensor->ops->range[1], 0, 0);\r
- break;\r
- default:\r
- printk("%s:unknow sensor type=%d\n",__func__,type);\r
- break;\r
-\r
- }\r
- sensor->input_dev->dev.parent = &client->dev;\r
-\r
- result = input_register_device(sensor->input_dev);\r
- if (result) {\r
- dev_err(&client->dev,\r
- "Unable to register input device %s\n", sensor->input_dev->name);\r
- goto out_input_register_device_failed;\r
- }\r
-\r
- result = sensor_irq_init(sensor->client);\r
- if (result) {\r
- dev_err(&client->dev,\r
- "fail to init sensor irq,ret=%d\n",result);\r
- goto out_input_register_device_failed;\r
- }\r
-\r
- \r
- sensor->miscdev.parent = &client->dev;\r
- result = sensor_misc_device_register(sensor, type);\r
- if (result) {\r
- dev_err(&client->dev,\r
- "fail to register misc device %s\n", sensor->miscdev.name);\r
- goto out_misc_device_register_device_failed;\r
- }\r
- \r
- g_sensor[type] = sensor;\r
-\r
- if((type == SENSOR_TYPE_ACCEL) && (sensor->pdata->factory)) //only support setting gsensor orientation online now \r
- {\r
- result = gsensor_class_init();\r
- if (result) {\r
- dev_err(&client->dev,\r
- "fail to register misc device %s\n", sensor->i2c_id->name);\r
- goto out_misc_device_register_device_failed;\r
- }\r
- } \r
- \r
-#ifdef CONFIG_HAS_EARLYSUSPEND\r
- if((sensor->ops->suspend) && (sensor->ops->resume))\r
- {\r
- sensor->early_suspend.suspend = sensor_suspend;\r
- sensor->early_suspend.resume = sensor_resume;\r
- sensor->early_suspend.level = 0x02;\r
- register_early_suspend(&sensor->early_suspend);\r
- }\r
-#endif\r
-\r
- 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
-\r
- return result;\r
- \r
-out_misc_device_register_device_failed:\r
-out_input_register_device_failed:\r
-out_free_memory:\r
-out_no_free:\r
- dev_err(&client->adapter->dev, "%s failed %d\n\n", __func__, result);\r
- return result;\r
-\r
-}\r
-\r
-static void sensor_shut_down(struct i2c_client *client)\r
-{\r
-#ifdef CONFIG_HAS_EARLYSUSPEND\r
- struct sensor_private_data *sensor =\r
- (struct sensor_private_data *) i2c_get_clientdata(client);\r
- if((sensor->ops->suspend) && (sensor->ops->resume)) \r
- unregister_early_suspend(&sensor->early_suspend);\r
- DBG("%s:%s\n",__func__,sensor->i2c_id->name);\r
-#endif\r
-}\r
-\r
-static int sensor_remove(struct i2c_client *client)\r
-{\r
- struct sensor_private_data *sensor =\r
- (struct sensor_private_data *) i2c_get_clientdata(client);\r
- int result = 0;\r
- \r
- cancel_delayed_work_sync(&sensor->delaywork);\r
- misc_deregister(&sensor->miscdev);\r
-#ifdef CONFIG_HAS_EARLYSUSPEND\r
- if((sensor->ops->suspend) && (sensor->ops->resume))\r
- unregister_early_suspend(&sensor->early_suspend);\r
-#endif \r
- return result;\r
-}\r
-\r
-static const struct i2c_device_id sensor_id[] = {\r
- /*angle*/ \r
- {"angle_kxtik", ANGLE_ID_KXTIK},\r
- {"angle_lis3dh", ANGLE_ID_LIS3DH}, \r
- /*gsensor*/\r
- {"gsensor", ACCEL_ID_ALL},\r
- {"gs_mma8452", ACCEL_ID_MMA845X}, \r
- {"gs_kxtik", ACCEL_ID_KXTIK}, \r
- {"gs_kxtj9", ACCEL_ID_KXTJ9},\r
- {"gs_lis3dh", ACCEL_ID_LIS3DH},\r
- {"gs_mma7660", ACCEL_ID_MMA7660},\r
- {"gs_mxc6225", ACCEL_ID_MXC6225}, \r
- {"gs_dmard10", ACCEL_ID_DMARD10},\r
- {"gs_lsm303d", ACCEL_ID_LSM303D},\r
- {"gs_mc3230",ACCEL_ID_MC3230},\r
- {"mpu6880_acc",ACCEL_ID_MPU6880},\r
- {"mpu6500_acc",ACCEL_ID_MPU6500},\r
+
+ switch(pdata->layout)
+ {
+ case 1:
+ pdata->orientation[0] = 1;
+ pdata->orientation[1] = 0;
+ pdata->orientation[2] = 0;
+
+ pdata->orientation[3] = 0;
+ pdata->orientation[4] = 1;
+ pdata->orientation[5] = 0;
+
+ pdata->orientation[6] = 0;
+ pdata->orientation[7] = 0;
+ pdata->orientation[8] = 1;
+ break;
+
+ case 2:
+ pdata->orientation[0] = 0;
+ pdata->orientation[1] = -1;
+ pdata->orientation[2] = 0;
+
+ pdata->orientation[3] = 1;
+ pdata->orientation[4] = 0;
+ pdata->orientation[5] = 0;
+
+ pdata->orientation[6] = 0;
+ pdata->orientation[7] = 0;
+ pdata->orientation[8] = 1;
+ break;
+
+ case 3:
+ pdata->orientation[0] = -1;
+ pdata->orientation[1] = 0;
+ pdata->orientation[2] = 0;
+
+ pdata->orientation[3] = 0;
+ pdata->orientation[4] = -1;
+ pdata->orientation[5] = 0;
+
+ pdata->orientation[6] = 0;
+ pdata->orientation[7] = 0;
+ pdata->orientation[8] = 1;
+ break;
+
+ case 4:
+ pdata->orientation[0] = 0;
+ pdata->orientation[1] = 1;
+ pdata->orientation[2] = 0;
+
+ pdata->orientation[3] = -1;
+ pdata->orientation[4] = 0;
+ pdata->orientation[5] = 0;
+
+ pdata->orientation[6] = 0;
+ pdata->orientation[7] = 0;
+ pdata->orientation[8] = 1;
+ break;
+
+ case 5:
+ pdata->orientation[0] = 1;
+ pdata->orientation[1] = 0;
+ pdata->orientation[2] = 0;
+
+ pdata->orientation[3] = 0;
+ pdata->orientation[4] = -1;
+ pdata->orientation[5] = 0;
+
+ pdata->orientation[6] = 0;
+ pdata->orientation[7] = 0;
+ pdata->orientation[8] = -1;
+ break;
+
+ case 6:
+ pdata->orientation[0] = 0;
+ pdata->orientation[1] = -1;
+ pdata->orientation[2] = 0;
+
+ pdata->orientation[3] = -1;
+ pdata->orientation[4] = 0;
+ pdata->orientation[5] = 0;
+
+ pdata->orientation[6] = 0;
+ pdata->orientation[7] = 0;
+ pdata->orientation[8] = -1;
+ break;
+
+ case 7:
+ pdata->orientation[0] = -1;
+ pdata->orientation[1] = 0;
+ pdata->orientation[2] = 0;
+
+ pdata->orientation[3] = 0;
+ pdata->orientation[4] = 1;
+ pdata->orientation[5] = 0;
+
+ pdata->orientation[6] = 0;
+ pdata->orientation[7] = 0;
+ pdata->orientation[8] = -1;
+ break;
+
+ case 8:
+ pdata->orientation[0] = 0;
+ pdata->orientation[1] = 1;
+ pdata->orientation[2] = 0;
+
+ pdata->orientation[3] = 1;
+ pdata->orientation[4] = 0;
+ pdata->orientation[5] = 0;
+
+ pdata->orientation[6] = 0;
+ pdata->orientation[7] = 0;
+ pdata->orientation[8] = -1;
+ break;
+
+ default:
+ pdata->orientation[0] = 1;
+ pdata->orientation[1] = 0;
+ pdata->orientation[2] = 0;
+
+ pdata->orientation[3] = 0;
+ pdata->orientation[4] = 1;
+ pdata->orientation[5] = 0;
+
+ pdata->orientation[6] = 0;
+ pdata->orientation[7] = 0;
+ pdata->orientation[8] = 1;
+ break;
+ }
+
+ client->irq = pdata->irq_pin;
+ type = pdata->type;
+ pdata->irq_flags = irq_flags;
+ DBG("irq_flags = %lu padta->irq_flags = %lu\n",irq_flags, pdata->irq_flags);
+ DBG("type = %d \n",pdata->type);
+ DBG("irq = %d \n",pdata->irq);
+ DBG("irq_pin = %d \n",pdata->irq_pin);
+ DBG("pwer_pin = %d \n",pdata->power_pin);
+ DBG("reset_pin = %d \n",pdata->reset_pin);
+ DBG("irq_enable = %d \n",pdata->irq_enable);
+
+ DBG("poll_delay_ms = %d \n",pdata->poll_delay_ms);
+ DBG("x_min = %d \n",pdata->x_min);
+ DBG("y_min = %d \n",pdata->y_min);
+ DBG("z_min = %d \n",pdata->z_min);
+ DBG("factory = %d \n",pdata->factory);
+ DBG("layout = %d \n",pdata->layout);
+ DBG("address = 0x%x \n",pdata->address);
+ DBG("project_name = [%s] \n",pdata->project_name);
+
+ DBG(" == %d,%d ,%d \t ,%d ,%d ,%d , \t ,%d, %d, %d ,==%d\n",pdata->orientation[0],pdata->orientation[1],pdata->orientation[2]
+ ,pdata->orientation[3],pdata->orientation[4],pdata->orientation[5]
+ ,pdata->orientation[6],pdata->orientation[7],pdata->orientation[8],ARRAY_SIZE(pdata->orientation));
+
+
+ if((type >= SENSOR_NUM_TYPES) || (type <= SENSOR_TYPE_NULL))
+ {
+ dev_err(&client->adapter->dev, "sensor type is error %d\n", type);
+ result = -EFAULT;
+ goto out_no_free;
+ }
+ if(((int)devid->driver_data >= SENSOR_NUM_ID) || ((int)devid->driver_data <= ID_INVALID))
+ {
+ dev_err(&client->adapter->dev, "sensor id is error %d\n", (int)devid->driver_data);
+ result = -EFAULT;
+ goto out_no_free;
+ }
+ i2c_set_clientdata(client, sensor);
+ sensor->client = client;
+ sensor->pdata = pdata;
+ sensor->type = type;
+ sensor->i2c_id = (struct i2c_device_id *)devid;
+
+
+ memset(&(sensor->axis), 0, sizeof(struct sensor_axis) );
+ atomic_set(&(sensor->data_ready), 0);
+ init_waitqueue_head(&(sensor->data_ready_wq));
+ mutex_init(&sensor->data_mutex);
+ mutex_init(&sensor->operation_mutex);
+ mutex_init(&sensor->sensor_mutex);
+ mutex_init(&sensor->i2c_mutex);
+
+ /* As default, report all information */
+ atomic_set(&sensor->flags.m_flag, 1);
+ atomic_set(&sensor->flags.a_flag, 1);
+ atomic_set(&sensor->flags.mv_flag, 1);
+ atomic_set(&sensor->flags.open_flag, 0);
+ atomic_set(&sensor->flags.debug_flag, 1);
+ init_waitqueue_head(&sensor->flags.open_wq);
+ sensor->flags.delay = 100;
+
+ sensor->status_cur = SENSOR_OFF;
+ sensor->axis.x = 0;
+ sensor->axis.y = 0;
+ sensor->axis.z = 0;
+
+ result = sensor_chip_init(sensor->client);
+ if(result < 0)
+ goto out_free_memory;
+
+ sensor->input_dev = devm_input_allocate_device(&client->dev);
+ if (!sensor->input_dev) {
+ result = -ENOMEM;
+ dev_err(&client->dev,
+ "Failed to allocate input device\n");
+ goto out_free_memory;
+ }
+
+ switch(type)
+ {
+ case SENSOR_TYPE_ANGLE:
+ sensor->input_dev->name = "angle";
+ set_bit(EV_ABS, sensor->input_dev->evbit);
+ /* x-axis acceleration */
+ input_set_abs_params(sensor->input_dev, ABS_X, sensor->ops->range[0], sensor->ops->range[1], 0, 0); //2g full scale range
+ /* y-axis acceleration */
+ input_set_abs_params(sensor->input_dev, ABS_Y, sensor->ops->range[0], sensor->ops->range[1], 0, 0); //2g full scale range
+ /* z-axis acceleration */
+ input_set_abs_params(sensor->input_dev, ABS_Z, sensor->ops->range[0], sensor->ops->range[1], 0, 0); //2g full scale range
+ break;
+
+ case SENSOR_TYPE_ACCEL:
+ sensor->input_dev->name = "gsensor";
+ set_bit(EV_ABS, sensor->input_dev->evbit);
+ /* x-axis acceleration */
+ input_set_abs_params(sensor->input_dev, ABS_X, sensor->ops->range[0], sensor->ops->range[1], 0, 0); //2g full scale range
+ /* y-axis acceleration */
+ input_set_abs_params(sensor->input_dev, ABS_Y, sensor->ops->range[0], sensor->ops->range[1], 0, 0); //2g full scale range
+ /* z-axis acceleration */
+ input_set_abs_params(sensor->input_dev, ABS_Z, sensor->ops->range[0], sensor->ops->range[1], 0, 0); //2g full scale range
+ break;
+ case SENSOR_TYPE_COMPASS:
+ sensor->input_dev->name = "compass";
+ /* Setup input device */
+ set_bit(EV_ABS, sensor->input_dev->evbit);
+ /* yaw (0, 360) */
+ input_set_abs_params(sensor->input_dev, ABS_RX, 0, 23040, 0, 0);
+ /* pitch (-180, 180) */
+ input_set_abs_params(sensor->input_dev, ABS_RY, -11520, 11520, 0, 0);
+ /* roll (-90, 90) */
+ input_set_abs_params(sensor->input_dev, ABS_RZ, -5760, 5760, 0, 0);
+ /* x-axis acceleration (720 x 8G) */
+ input_set_abs_params(sensor->input_dev, ABS_X, -5760, 5760, 0, 0);
+ /* y-axis acceleration (720 x 8G) */
+ input_set_abs_params(sensor->input_dev, ABS_Y, -5760, 5760, 0, 0);
+ /* z-axis acceleration (720 x 8G) */
+ input_set_abs_params(sensor->input_dev, ABS_Z, -5760, 5760, 0, 0);
+ /* status of magnetic sensor */
+ input_set_abs_params(sensor->input_dev, ABS_RUDDER, -32768, 3, 0, 0);
+ /* status of acceleration sensor */
+ input_set_abs_params(sensor->input_dev, ABS_WHEEL, -32768, 3, 0, 0);
+ /* x-axis of raw magnetic vector (-4096, 4095) */
+ input_set_abs_params(sensor->input_dev, ABS_HAT0X, -20480, 20479, 0, 0);
+ /* y-axis of raw magnetic vector (-4096, 4095) */
+ input_set_abs_params(sensor->input_dev, ABS_HAT0Y, -20480, 20479, 0, 0);
+ /* z-axis of raw magnetic vector (-4096, 4095) */
+ input_set_abs_params(sensor->input_dev, ABS_BRAKE, -20480, 20479, 0, 0);
+ break;
+ case SENSOR_TYPE_GYROSCOPE:
+ sensor->input_dev->name = "gyro";
+ /* x-axis acceleration */
+ input_set_capability(sensor->input_dev, EV_REL, REL_RX);
+ input_set_abs_params(sensor->input_dev, ABS_RX, sensor->ops->range[0], sensor->ops->range[1], 0, 0);
+ /* y-axis acceleration */
+ input_set_capability(sensor->input_dev, EV_REL, REL_RY);
+ input_set_abs_params(sensor->input_dev, ABS_RY, sensor->ops->range[0], sensor->ops->range[1], 0, 0);
+ /* z-axis acceleration */
+ input_set_capability(sensor->input_dev, EV_REL, REL_RZ);
+ input_set_abs_params(sensor->input_dev, ABS_RZ, sensor->ops->range[0], sensor->ops->range[1], 0, 0);
+ break;
+ case SENSOR_TYPE_LIGHT:
+ sensor->input_dev->name = "lightsensor-level";
+ set_bit(EV_ABS, sensor->input_dev->evbit);
+ input_set_abs_params(sensor->input_dev, ABS_MISC, sensor->ops->range[0], sensor->ops->range[1], 0, 0);
+ input_set_abs_params(sensor->input_dev, ABS_TOOL_WIDTH , sensor->ops->brightness[0],sensor->ops->brightness[1], 0, 0);
+ break;
+ case SENSOR_TYPE_PROXIMITY:
+ sensor->input_dev->name = "proximity";
+ set_bit(EV_ABS, sensor->input_dev->evbit);
+ input_set_abs_params(sensor->input_dev, ABS_DISTANCE, sensor->ops->range[0], sensor->ops->range[1], 0, 0);
+ break;
+ case SENSOR_TYPE_TEMPERATURE:
+ sensor->input_dev->name = "temperature";
+ set_bit(EV_ABS, sensor->input_dev->evbit);
+ input_set_abs_params(sensor->input_dev, ABS_THROTTLE, sensor->ops->range[0], sensor->ops->range[1], 0, 0);
+ break;
+ case SENSOR_TYPE_PRESSURE:
+ sensor->input_dev->name = "pressure";
+ set_bit(EV_ABS, sensor->input_dev->evbit);
+ input_set_abs_params(sensor->input_dev, ABS_PRESSURE, sensor->ops->range[0], sensor->ops->range[1], 0, 0);
+ break;
+ default:
+ printk("%s:unknow sensor type=%d\n",__func__,type);
+ break;
+
+ }
+ sensor->input_dev->dev.parent = &client->dev;
+
+ result = input_register_device(sensor->input_dev);
+ if (result) {
+ dev_err(&client->dev,
+ "Unable to register input device %s\n", sensor->input_dev->name);
+ goto out_input_register_device_failed;
+ }
+
+ result = sensor_irq_init(sensor->client);
+ if (result) {
+ dev_err(&client->dev,
+ "fail to init sensor irq,ret=%d\n",result);
+ goto out_input_register_device_failed;
+ }
+
+
+ sensor->miscdev.parent = &client->dev;
+ result = sensor_misc_device_register(sensor, type);
+ if (result) {
+ dev_err(&client->dev,
+ "fail to register misc device %s\n", sensor->miscdev.name);
+ goto out_misc_device_register_device_failed;
+ }
+
+ g_sensor[type] = sensor;
+
+ if((type == SENSOR_TYPE_ACCEL) && (sensor->pdata->factory)) //only support setting gsensor orientation online now
+ {
+ result = gsensor_class_init();
+ if (result) {
+ dev_err(&client->dev,
+ "fail to register misc device %s\n", sensor->i2c_id->name);
+ goto out_misc_device_register_device_failed;
+ }
+ }
+
+#ifdef CONFIG_HAS_EARLYSUSPEND
+ if((sensor->ops->suspend) && (sensor->ops->resume))
+ {
+ sensor->early_suspend.suspend = sensor_suspend;
+ sensor->early_suspend.resume = sensor_resume;
+ sensor->early_suspend.level = 0x02;
+ register_early_suspend(&sensor->early_suspend);
+ }
+#endif
+
+ printk("%s:initialized ok,sensor name:%s,type:%d,id=%d\n\n",__func__,sensor->ops->name,type,(int)sensor->i2c_id->driver_data);
+
+ return result;
+
+out_misc_device_register_device_failed:
+out_input_register_device_failed:
+out_free_memory:
+out_no_free:
+ dev_err(&client->adapter->dev, "%s failed %d\n\n", __func__, result);
+ return result;
+
+}
+
+static void sensor_shut_down(struct i2c_client *client)
+{
+#ifdef CONFIG_HAS_EARLYSUSPEND
+ struct sensor_private_data *sensor =
+ (struct sensor_private_data *) i2c_get_clientdata(client);
+ if((sensor->ops->suspend) && (sensor->ops->resume))
+ unregister_early_suspend(&sensor->early_suspend);
+ DBG("%s:%s\n",__func__,sensor->i2c_id->name);
+#endif
+}
+
+static int sensor_remove(struct i2c_client *client)
+{
+ struct sensor_private_data *sensor =
+ (struct sensor_private_data *) i2c_get_clientdata(client);
+ int result = 0;
+
+ cancel_delayed_work_sync(&sensor->delaywork);
+ misc_deregister(&sensor->miscdev);
+#ifdef CONFIG_HAS_EARLYSUSPEND
+ if((sensor->ops->suspend) && (sensor->ops->resume))
+ unregister_early_suspend(&sensor->early_suspend);
+#endif
+ return result;
+}
+
+static const struct i2c_device_id sensor_id[] = {
+ /*angle*/
+ {"angle_kxtik", ANGLE_ID_KXTIK},
+ {"angle_lis3dh", ANGLE_ID_LIS3DH},
+ /*gsensor*/
+ {"gsensor", ACCEL_ID_ALL},
+ {"gs_mma8452", ACCEL_ID_MMA845X},
+ {"gs_kxtik", ACCEL_ID_KXTIK},
+ {"gs_kxtj9", ACCEL_ID_KXTJ9},
+ {"gs_lis3dh", ACCEL_ID_LIS3DH},
+ {"gs_mma7660", ACCEL_ID_MMA7660},
+ {"gs_mxc6225", ACCEL_ID_MXC6225},
+ {"gs_dmard10", ACCEL_ID_DMARD10},
+ {"gs_lsm303d", ACCEL_ID_LSM303D},
+ {"gs_mc3230",ACCEL_ID_MC3230},
+ {"mpu6880_acc",ACCEL_ID_MPU6880},
+ {"mpu6500_acc",ACCEL_ID_MPU6500},
{"lsm330_acc", ACCEL_ID_LSM330},
- /*compass*/\r
- {"compass", COMPASS_ID_ALL},\r
- {"ak8975", COMPASS_ID_AK8975}, \r
- {"ak8963", COMPASS_ID_AK8963},\r
- {"ak09911", COMPASS_ID_AK09911},\r
- {"mmc314x", COMPASS_ID_MMC314X},\r
- /*gyroscope*/\r
- {"gyro", GYRO_ID_ALL}, \r
- {"l3g4200d_gyro", GYRO_ID_L3G4200D},\r
- {"l3g20d_gyro", GYRO_ID_L3G20D},\r
- {"ewtsa_gyro", GYRO_ID_EWTSA},\r
- {"k3g", GYRO_ID_K3G},\r
- {"mpu6880_gyro",GYRO_ID_MPU6880},\r
+ /*compass*/
+ {"compass", COMPASS_ID_ALL},
+ {"ak8975", COMPASS_ID_AK8975},
+ {"ak8963", COMPASS_ID_AK8963},
+ {"ak09911", COMPASS_ID_AK09911},
+ {"mmc314x", COMPASS_ID_MMC314X},
+ /*gyroscope*/
+ {"gyro", GYRO_ID_ALL},
+ {"l3g4200d_gyro", GYRO_ID_L3G4200D},
+ {"l3g20d_gyro", GYRO_ID_L3G20D},
+ {"ewtsa_gyro", GYRO_ID_EWTSA},
+ {"k3g", GYRO_ID_K3G},
+ {"mpu6880_gyro",GYRO_ID_MPU6880},
{"lsm330_gyro", GYRO_ID_LSM330},
- /*light sensor*/\r
- {"lightsensor", LIGHT_ID_ALL}, \r
- {"light_cm3217", LIGHT_ID_CM3217},\r
- {"light_cm3218", LIGHT_ID_CM3218},\r
- {"light_cm3232", LIGHT_ID_CM3232},\r
- {"light_al3006", LIGHT_ID_AL3006},\r
- {"ls_stk3171", LIGHT_ID_STK3171},\r
- {"ls_isl29023", LIGHT_ID_ISL29023},\r
- {"ls_ap321xx", LIGHT_ID_AP321XX},\r
- {"ls_photoresistor", LIGHT_ID_PHOTORESISTOR},\r
- {"ls_us5152", LIGHT_ID_US5152},\r
- /*proximity sensor*/\r
- {"psensor", PROXIMITY_ID_ALL},\r
- {"proximity_al3006", PROXIMITY_ID_AL3006}, \r
- {"ps_stk3171", PROXIMITY_ID_STK3171},\r
- {"ps_ap321xx", PROXIMITY_ID_AP321XX},\r
- \r
- /*temperature*/\r
- {"temperature", TEMPERATURE_ID_ALL}, \r
- {"tmp_ms5607", TEMPERATURE_ID_MS5607},\r
-\r
- /*pressure*/\r
- {"pressure", PRESSURE_ID_ALL},\r
- {"pr_ms5607", PRESSURE_ID_MS5607},\r
- \r
- {},\r
-};\r
-\r
-static struct of_device_id sensor_dt_ids[] = {\r
- /*gsensor*/\r
- { .compatible = "gs_mma8452" },\r
- { .compatible = "gs_lis3dh" },\r
- { .compatible = "gs_lsm303d" },\r
- { .compatible = "gs_mma7660" },\r
- { .compatible = "gs_mxc6225" },\r
- { .compatible = "gs_mc3230" },\r
+ /*light sensor*/
+ {"lightsensor", LIGHT_ID_ALL},
+ {"light_cm3217", LIGHT_ID_CM3217},
+ {"light_cm3218", LIGHT_ID_CM3218},
+ {"light_cm3232", LIGHT_ID_CM3232},
+ {"light_al3006", LIGHT_ID_AL3006},
+ {"ls_stk3171", LIGHT_ID_STK3171},
+ {"ls_isl29023", LIGHT_ID_ISL29023},
+ {"ls_ap321xx", LIGHT_ID_AP321XX},
+ {"ls_photoresistor", LIGHT_ID_PHOTORESISTOR},
+ {"ls_us5152", LIGHT_ID_US5152},
+ /*proximity sensor*/
+ {"psensor", PROXIMITY_ID_ALL},
+ {"proximity_al3006", PROXIMITY_ID_AL3006},
+ {"ps_stk3171", PROXIMITY_ID_STK3171},
+ {"ps_ap321xx", PROXIMITY_ID_AP321XX},
+
+ /*temperature*/
+ {"temperature", TEMPERATURE_ID_ALL},
+ {"tmp_ms5607", TEMPERATURE_ID_MS5607},
+
+ /*pressure*/
+ {"pressure", PRESSURE_ID_ALL},
+ {"pr_ms5607", PRESSURE_ID_MS5607},
+
+ {},
+};
+
+static struct of_device_id sensor_dt_ids[] = {
+ /*gsensor*/
+ { .compatible = "gs_mma8452" },
+ { .compatible = "gs_lis3dh" },
+ { .compatible = "gs_lsm303d" },
+ { .compatible = "gs_mma7660" },
+ { .compatible = "gs_mxc6225" },
+ { .compatible = "gs_mc3230" },
{ .compatible = "lsm330_acc" },
- /*compass*/\r
- { .compatible = "ak8975" },\r
- { .compatible = "ak8963" },\r
- { .compatible = "ak09911" },\r
- { .compatible = "mmc314x" },\r
-\r
- /* gyroscop*/\r
- { .compatible = "l3g4200d_gyro" },\r
- { .compatible = "l3g20d_gyro" },\r
- { .compatible = "ewtsa_gyro" },\r
- { .compatible = "k3g" },\r
+ /*compass*/
+ { .compatible = "ak8975" },
+ { .compatible = "ak8963" },
+ { .compatible = "ak09911" },
+ { .compatible = "mmc314x" },
+
+ /* gyroscop*/
+ { .compatible = "l3g4200d_gyro" },
+ { .compatible = "l3g20d_gyro" },
+ { .compatible = "ewtsa_gyro" },
+ { .compatible = "k3g" },
{ .compatible = "lsm330_gyro" },
- \r
- /*light sensor*/\r
- { .compatible = "light_cm3217" },\r
- { .compatible = "light_cm3232" },\r
- { .compatible = "light_al3006" },\r
- { .compatible = "ls_stk3171" },\r
- { .compatible = "ls_ap321xx" },\r
-\r
- { .compatible = "ls_photoresistor" },\r
- { .compatible = "ls_us5152" },\r
-\r
- /*temperature sensor*/\r
- { .compatible = "tmp_ms5607" },\r
- \r
- /*pressure sensor*/\r
- { .compatible = "pr_ms5607" },\r
-\r
- /*hall sensor*/\r
- { .compatible = "hall_och165t" },\r
- { }\r
-};\r
-\r
-\r
-static struct i2c_driver sensor_driver = {\r
- .probe = sensor_probe,\r
- .remove = sensor_remove,\r
- .shutdown = sensor_shut_down,\r
- .id_table = sensor_id,\r
+
+ /*light sensor*/
+ { .compatible = "light_cm3217" },
+ { .compatible = "light_cm3232" },
+ { .compatible = "light_al3006" },
+ { .compatible = "ls_stk3171" },
+ { .compatible = "ls_ap321xx" },
+
+ { .compatible = "ls_photoresistor" },
+ { .compatible = "ls_us5152" },
+
+ /*temperature sensor*/
+ { .compatible = "tmp_ms5607" },
+
+ /*pressure sensor*/
+ { .compatible = "pr_ms5607" },
+
+ /*hall sensor*/
+ { .compatible = "hall_och165t" },
+ { }
+};
+
+
+static struct i2c_driver sensor_driver = {
+ .probe = sensor_probe,
+ .remove = sensor_remove,
+ .shutdown = sensor_shut_down,
+ .id_table = sensor_id,
.driver = {
.owner = THIS_MODULE,
.name = "sensors",
.of_match_table = of_match_ptr(sensor_dt_ids),
.pm = SENSOR_PM_OPS,
- },\r
-};\r
-\r
-static int __init sensor_init(void)\r
-{\r
- int res = i2c_add_driver(&sensor_driver); \r
- struct proc_dir_entry *sensor_proc_entry; \r
- pr_info("%s: Probe name %s\n", __func__, sensor_driver.driver.name);\r
- if (res)\r
- pr_err("%s failed\n", __func__);\r
- \r
- sensor_proc_entry = proc_create("driver/sensor_dbg", 0660, NULL, &sensor_proc_fops); \r
- printk("%s\n", SENSOR_VERSION_AND_TIME);\r
- return res;\r
-}\r
-\r
-static void __exit sensor_exit(void)\r
-{\r
- pr_info("%s\n", __func__);\r
- i2c_del_driver(&sensor_driver);\r
-}\r
-\r
-late_initcall(sensor_init);\r
-module_exit(sensor_exit);\r
-\r
-MODULE_AUTHOR("ROCKCHIP Corporation:lw@rock-chips.com");\r
-MODULE_DESCRIPTION("User space character device interface for sensors");\r
-MODULE_LICENSE("GPL");\r
-\r
+ },
+};
+
+static int __init sensor_init(void)
+{
+ int res = i2c_add_driver(&sensor_driver);
+ struct proc_dir_entry *sensor_proc_entry;
+ pr_info("%s: Probe name %s\n", __func__, sensor_driver.driver.name);
+ if (res)
+ pr_err("%s failed\n", __func__);
+
+ sensor_proc_entry = proc_create("driver/sensor_dbg", 0660, NULL, &sensor_proc_fops);
+ printk("%s\n", SENSOR_VERSION_AND_TIME);
+ return res;
+}
+
+static void __exit sensor_exit(void)
+{
+ pr_info("%s\n", __func__);
+ i2c_del_driver(&sensor_driver);
+}
+
+late_initcall(sensor_init);
+module_exit(sensor_exit);
+
+MODULE_AUTHOR("ROCKCHIP Corporation:lw@rock-chips.com");
+MODULE_DESCRIPTION("User space character device interface for sensors");
+MODULE_LICENSE("GPL");
+
projects / firefly-linux-kernel-4.4.55.git / blobdiff