- 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
projects / firefly-linux-kernel-4.4.55.git / commitdiff