drivers/input/sensors/sensor-dev.c

   1 /* drivers/input/sensors/sensor-dev.c - handle all gsensor in this file\r
   2  *\r
   3  * Copyright (C) 2012-2015 ROCKCHIP.\r
   4  * Author: luowei <lw@rock-chips.com>\r
   5  *\r
   6  * This software is licensed under the terms of the GNU General Public\r
   7  * License version 2, as published by the Free Software Foundation, and\r
   8  * may be copied, distributed, and modified under those terms.\r
   9  *\r
  10  * This program is distributed in the hope that it will be useful,\r
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of\r
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
  13  * GNU General Public License for more details.\r
  14  *\r
  15  */\r
  16 \r
  17 #include <linux/interrupt.h>\r
  18 #include <linux/i2c.h>\r
  19 #include <linux/slab.h>\r
  20 #include <linux/irq.h>\r
  21 #include <linux/miscdevice.h>\r
  22 #include <linux/gpio.h>\r
  23 #include <asm/uaccess.h>\r
  24 #include <asm/atomic.h>\r
  25 #include <linux/delay.h>\r
  26 #include <linux/input.h>\r
  27 #include <linux/workqueue.h>\r
  28 #include <linux/freezer.h>\r
  29 #include <linux/proc_fs.h>\r
  30 #include <linux/gpio.h>\r
  31 #include <linux/of_gpio.h>\r
  32 #include <linux/of.h>\r
  33 #ifdef CONFIG_HAS_EARLYSUSPEND\r
  34 #include <linux/earlysuspend.h>\r
  35 #endif\r
  36 #include <linux/l3g4200d.h>\r
  37 #include <linux/sensor-dev.h>\r
  38 #include <linux/module.h>\r
  39 #ifdef CONFIG_COMPAT
  40 #include <linux/compat.h>
  41 #endif
  42 \r
  43 \r
  44 /*\r
  45 sensor-dev.c v1.1 add pressure and temperature support 2013-2-27\r
  46 sensor-dev.c v1.2 add akm8963 support 2013-3-10\r
  47 sensor-dev.c v1.3 add sensor debug support 2013-3-15\r
  48 sensor-dev.c v1.4 add angle calculation support between two gsensors 2013-09-01\r
  49 */\r
  50 \r
  51 #define SENSOR_VERSION_AND_TIME  "sensor-dev.c v1.4 add angle calculation support between two gsensors 2013-09-01"\r
  52 \r
  53 \r
  54 struct sensor_private_data *g_sensor[SENSOR_NUM_TYPES];\r
  55 static struct sensor_operate *sensor_ops[SENSOR_NUM_ID]; \r
  56 static struct class *g_sensor_class[SENSOR_NUM_TYPES];\r
  57 \r
  58 static ssize_t sensor_proc_write(struct file *file, const char __user *buffer,\r
  59                            size_t count, loff_t *data)\r
  60 {\r
  61         char c;\r
  62         int rc;\r
  63         int i = 0, num = 0;\r
  64         \r
  65         rc = get_user(c, buffer);\r
  66         if (rc)\r
  67         {\r
  68                 for(i=SENSOR_TYPE_NULL+1; i<SENSOR_NUM_TYPES; i++)\r
  69                 atomic_set(&g_sensor[i]->flags.debug_flag, SENSOR_TYPE_NULL);\r
  70                 return rc; \r
  71         }\r
  72 \r
  73         \r
  74         num = c - '0';\r
  75 \r
  76         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
  77                 \r
  78                 SENSOR_TYPE_NULL, SENSOR_TYPE_ANGLE, SENSOR_TYPE_ACCEL,SENSOR_TYPE_COMPASS,SENSOR_TYPE_GYROSCOPE,SENSOR_TYPE_LIGHT,SENSOR_TYPE_PROXIMITY,\r
  79 \r
  80                 SENSOR_TYPE_TEMPERATURE,SENSOR_TYPE_PRESSURE,SENSOR_NUM_TYPES,num);\r
  81 \r
  82         if((num > SENSOR_NUM_TYPES) || (num < SENSOR_TYPE_NULL))\r
  83         {\r
  84                 printk("%s:error! only support %d to %d\n",__func__, SENSOR_TYPE_NULL,SENSOR_NUM_TYPES);\r
  85                 return -1;\r
  86         }\r
  87 \r
  88         for(i=SENSOR_TYPE_NULL+1; i<SENSOR_NUM_TYPES; i++)\r
  89         {\r
  90                 if(g_sensor[i])\r
  91                 atomic_set(&g_sensor[i]->flags.debug_flag, num);\r
  92         }\r
  93         \r
  94         return count; \r
  95 }\r
  96 \r
  97 static const struct file_operations sensor_proc_fops = {\r
  98         .owner          = THIS_MODULE, \r
  99         .write          = sensor_proc_write,\r
 100 };\r
 101 \r
 102 \r
 103 \r
 104 static int sensor_get_id(struct i2c_client *client, int *value)\r
 105 {\r
 106         struct sensor_private_data *sensor =\r
 107             (struct sensor_private_data *) i2c_get_clientdata(client);  \r
 108         int result = 0;\r
 109         char temp = sensor->ops->id_reg;\r
 110         int i = 0;\r
 111 \r
 112         if(sensor->ops->id_reg >= 0)\r
 113         {\r
 114                 for(i=0; i<3; i++)\r
 115                 {\r
 116                         result = sensor_rx_data(client, &temp, 1);\r
 117                         *value = temp;\r
 118                         if(!result)\r
 119                         break;\r
 120                 }\r
 121 \r
 122                 if(result)\r
 123                         return result;\r
 124 \r
 125                 if(*value != sensor->ops->id_data)\r
 126                 {\r
 127                         printk("%s:id=0x%x is not 0x%x\n",__func__,*value, sensor->ops->id_data);\r
 128                         result = -1;\r
 129                 }\r
 130                         \r
 131                 DBG("%s:devid=0x%x\n",__func__,*value);\r
 132         }\r
 133         \r
 134         return result;\r
 135 }\r
 136 \r
 137 static int sensor_initial(struct i2c_client *client)\r
 138 {\r
 139         struct sensor_private_data *sensor =\r
 140             (struct sensor_private_data *) i2c_get_clientdata(client);  \r
 141         int result = 0;\r
 142 \r
 143         //register setting according to chip datasheet  \r
 144         result = sensor->ops->init(client);\r
 145         if(result < 0)\r
 146         {\r
 147                 printk("%s:fail to init sensor\n",__func__);\r
 148                 return result;\r
 149         }\r
 150 \r
 151 \r
 152         DBG("%s:ctrl_data=0x%x\n",__func__,sensor->ops->ctrl_data);\r
 153         \r
 154         return result;\r
 155 \r
 156 }\r
 157 \r
 158 static int sensor_chip_init(struct i2c_client *client)\r
 159 {\r
 160         struct sensor_private_data *sensor =\r
 161             (struct sensor_private_data *) i2c_get_clientdata(client);  \r
 162         struct sensor_operate *ops = sensor_ops[(int)sensor->i2c_id->driver_data];\r
 163         int result = 0;\r
 164         \r
 165         if(ops)\r
 166         {\r
 167                 sensor->ops = ops;\r
 168         }\r
 169         else\r
 170         {\r
 171                 printk("%s:ops is null,sensor name is %s\n",__func__,sensor->i2c_id->name);\r
 172                 result = -1;\r
 173                 goto error;\r
 174         }\r
 175 \r
 176         if((sensor->type != ops->type) || ((int)sensor->i2c_id->driver_data != ops->id_i2c))\r
 177         {\r
 178                 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
 179                 result = -1;\r
 180                 goto error;\r
 181         }\r
 182         \r
 183         if(!ops->init || !ops->active || !ops->report)\r
 184         {\r
 185                 printk("%s:error:some function is needed\n",__func__);          \r
 186                 result = -1;\r
 187                 goto error;\r
 188         }\r
 189 \r
 190         result = sensor_get_id(sensor->client, &sensor->devid);//get id\r
 191         if(result < 0)\r
 192         {       \r
 193                 printk("%s:fail to read %s devid:0x%x\n",__func__, sensor->i2c_id->name, sensor->devid);        \r
 194                 goto error;\r
 195         }\r
 196         \r
 197         printk("%s:%s:devid=0x%x,ops=0x%p\n",__func__, sensor->i2c_id->name, sensor->devid,sensor->ops);\r
 198 \r
 199         result = sensor_initial(sensor->client);        //init sensor\r
 200         if(result < 0)\r
 201         {       \r
 202                 printk("%s:fail to init sensor\n",__func__);            \r
 203                 goto error;\r
 204         }\r
 205 \r
 206         return 0;\r
 207 \r
 208 error:\r
 209         \r
 210         return result;\r
 211 }\r
 212 \r
 213 static int sensor_reset_rate(struct i2c_client *client, int rate)\r
 214 {\r
 215         struct sensor_private_data *sensor =\r
 216             (struct sensor_private_data *) i2c_get_clientdata(client);  \r
 217         int result = 0; \r
 218         \r
 219         result = sensor->ops->active(client,SENSOR_OFF,rate);\r
 220         sensor->ops->init(client);\r
 221         result = sensor->ops->active(client,SENSOR_ON,rate);\r
 222 \r
 223         return result;\r
 224 }\r
 225 \r
 226 static int sensor_get_data(struct i2c_client *client)\r
 227 {\r
 228         struct sensor_private_data *sensor =\r
 229             (struct sensor_private_data *) i2c_get_clientdata(client);  \r
 230         int result = 0;\r
 231         \r
 232         result = sensor->ops->report(client);\r
 233         if(result)\r
 234                 goto error;\r
 235 \r
 236         /* set data_ready */\r
 237         atomic_set(&sensor->data_ready, 1);\r
 238         /*wake up data_ready  work queue*/\r
 239         wake_up(&sensor->data_ready_wq);\r
 240         \r
 241 error:          \r
 242         return result;\r
 243 }\r
 244 \r
 245 #if 0\r
 246 int sensor_get_cached_data(struct i2c_client* client, char *buffer, int length, struct sensor_axis *axis)\r
 247 {\r
 248     struct sensor_private_data* sensor = (struct sensor_private_data *)i2c_get_clientdata(client);      \r
 249     wait_event_interruptible_timeout(sensor->data_ready_wq, \r
 250                                      atomic_read(&(sensor->data_ready) ),\r
 251                                      msecs_to_jiffies(1000) );\r
 252     if ( 0 == atomic_read(&(sensor->data_ready) ) ) {\r
 253         printk("waiting 'data_ready_wq' timed out.");\r
 254         goto error;\r
 255     }\r
 256 \r
 257         \r
 258         mutex_lock(&sensor->data_mutex);\r
 259 \r
 260         switch(sensor->type)\r
 261         {\r
 262                 case SENSOR_TYPE_ACCEL:\r
 263                 *axis = sensor->axis;\r
 264                 break;\r
 265 \r
 266                 case SENSOR_TYPE_COMPASS:\r
 267                 memcpy(buffer, sensor->sensor_data, length);\r
 268                 break;\r
 269         }\r
 270         \r
 271         mutex_unlock(&sensor->data_mutex);\r
 272         \r
 273     return 0;\r
 274         \r
 275 error:\r
 276         return -1;\r
 277 }\r
 278 #endif\r
 279 \r
 280 static void  sensor_delaywork_func(struct work_struct *work)\r
 281 {\r
 282         struct delayed_work *delaywork = container_of(work, struct delayed_work, work);\r
 283         struct sensor_private_data *sensor = container_of(delaywork, struct sensor_private_data, delaywork);\r
 284         struct i2c_client *client = sensor->client;\r
 285 \r
 286         mutex_lock(&sensor->sensor_mutex);      \r
 287         if (sensor_get_data(client) < 0) \r
 288                 DBG(KERN_ERR "%s: Get data failed\n",__func__);\r
 289         \r
 290         if(!sensor->pdata->irq_enable)//restart work while polling\r
 291         schedule_delayed_work(&sensor->delaywork, msecs_to_jiffies(sensor->pdata->poll_delay_ms));\r
 292         //else\r
 293         //{\r
 294                 //if((sensor->ops->trig == IRQF_TRIGGER_LOW) || (sensor->ops->trig == IRQF_TRIGGER_HIGH))\r
 295                 //enable_irq(sensor->client->irq);\r
 296         //}\r
 297         mutex_unlock(&sensor->sensor_mutex);\r
 298         \r
 299         DBG("%s:%s\n",__func__,sensor->i2c_id->name);\r
 300 }\r
 301 \r
 302 /*\r
 303  * This is a threaded IRQ handler so can access I2C/SPI.  Since all\r
 304  * interrupts are clear on read the IRQ line will be reasserted and\r
 305  * the physical IRQ will be handled again if another interrupt is\r
 306  * asserted while we run - in the normal course of events this is a\r
 307  * rare occurrence so we save I2C/SPI reads.  We're also assuming that\r
 308  * it's rare to get lots of interrupts firing simultaneously so try to\r
 309  * minimise I/O.\r
 310  */\r
 311 static irqreturn_t sensor_interrupt(int irq, void *dev_id)\r
 312 {\r
 313         struct sensor_private_data *sensor = (struct sensor_private_data *)dev_id;\r
 314 \r
 315         //use threaded IRQ\r
 316         if (sensor_get_data(sensor->client) < 0) \r
 317                 DBG(KERN_ERR "%s: Get data failed\n",__func__);\r
 318         msleep(sensor->pdata->poll_delay_ms);\r
 319 \r
 320         \r
 321         //if((sensor->ops->trig == IRQF_TRIGGER_LOW) || (sensor->ops->trig == IRQF_TRIGGER_HIGH))\r
 322         //disable_irq_nosync(irq);\r
 323         //schedule_delayed_work(&sensor->delaywork, msecs_to_jiffies(sensor->pdata->poll_delay_ms));\r
 324         DBG("%s:irq=%d\n",__func__,irq);\r
 325         return IRQ_HANDLED;\r
 326 }\r
 327 \r
 328 \r
 329 static int sensor_irq_init(struct i2c_client *client)\r
 330 {\r
 331         struct sensor_private_data *sensor =\r
 332             (struct sensor_private_data *) i2c_get_clientdata(client);  \r
 333         int result = 0;\r
 334         int irq;\r
 335         if((sensor->pdata->irq_enable)&&(sensor->pdata->irq_flags!= SENSOR_UNKNOW_DATA))\r
 336         {\r
 337                 //INIT_DELAYED_WORK(&sensor->delaywork, sensor_delaywork_func);\r
 338                 if(sensor->pdata->poll_delay_ms < 0)\r
 339                         sensor->pdata->poll_delay_ms = 30;\r
 340                 result = gpio_request(client->irq, sensor->i2c_id->name);\r
 341                 if (result)\r
 342                 {\r
 343                         printk("%s:fail to request gpio :%d\n",__func__,client->irq);\r
 344                 }\r
 345                 \r
 346                 //gpio_pull_updown(client->irq, PullEnable);\r
 347                 irq = gpio_to_irq(client->irq);\r
 348                 //result = request_irq(irq, sensor_interrupt, sensor->ops->trig, sensor->ops->name, sensor);\r
 349                 //result = request_threaded_irq(irq, NULL, sensor_interrupt, sensor->ops->trig, sensor->ops->name, sensor);\r
 350                 result = devm_request_threaded_irq(&client->dev, irq, NULL, sensor_interrupt, sensor->pdata->irq_flags | IRQF_ONESHOT, sensor->ops->name, sensor);\r
 351                 if (result) {\r
 352                         printk(KERN_ERR "%s:fail to request irq = %d, ret = 0x%x\n",__func__, irq, result);            \r
 353                         goto error;            \r
 354                 }\r
 355                 client->irq = irq;\r
 356                 if((sensor->pdata->type == SENSOR_TYPE_GYROSCOPE) || (sensor->pdata->type == SENSOR_TYPE_ACCEL) || (sensor->pdata->type == SENSOR_TYPE_ANGLE))\r
 357                 disable_irq_nosync(client->irq);//disable irq\r
 358                 if(((sensor->pdata->type == SENSOR_TYPE_LIGHT) || (sensor->pdata->type == SENSOR_TYPE_PROXIMITY))&& (!(sensor->ops->trig & IRQF_SHARED)))       \r
 359                 disable_irq_nosync(client->irq);//disable irq   \r
 360                 if(((sensor->pdata->type == SENSOR_TYPE_TEMPERATURE) || (sensor->pdata->type == SENSOR_TYPE_PRESSURE))&& (!(sensor->ops->trig & IRQF_SHARED)))          \r
 361                 disable_irq_nosync(client->irq);//disable irq\r
 362                 DBG("%s:use irq=%d\n",__func__,irq);\r
 363         }\r
 364         else if(!sensor->pdata->irq_enable)\r
 365         {               \r
 366                 INIT_DELAYED_WORK(&sensor->delaywork, sensor_delaywork_func);\r
 367                 if(sensor->pdata->poll_delay_ms < 0)\r
 368                         sensor->pdata->poll_delay_ms = 30;\r
 369                 \r
 370                 DBG("%s:use polling,delay=%d ms\n",__func__,sensor->pdata->poll_delay_ms);\r
 371         }\r
 372 \r
 373 error:  \r
 374         return result;\r
 375 }\r
 376 \r
 377 #ifdef CONFIG_HAS_EARLYSUSPEND\r
 378 static void sensor_suspend(struct early_suspend *h)\r
 379 {\r
 380         struct sensor_private_data *sensor = \r
 381                         container_of(h, struct sensor_private_data, early_suspend);\r
 382         \r
 383         if(sensor->ops->suspend)\r
 384                 sensor->ops->suspend(sensor->client);\r
 385 \r
 386 }\r
 387 \r
 388 static void sensor_resume(struct early_suspend *h)\r
 389 {\r
 390         struct sensor_private_data *sensor = \r
 391                         container_of(h, struct sensor_private_data, early_suspend);\r
 392 \r
 393         if(sensor->ops->resume)\r
 394                 sensor->ops->resume(sensor->client);\r
 395 }\r
 396 #endif\r
 397 \r
 398 static int angle_dev_open(struct inode *inode, struct file *file)\r
 399 {\r
 400         //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_ACCEL];     \r
 401         //struct i2c_client *client = sensor->client;\r
 402 \r
 403         int result = 0;\r
 404 \r
 405 \r
 406         return result;\r
 407 }\r
 408 \r
 409 \r
 410 static int angle_dev_release(struct inode *inode, struct file *file)\r
 411 {\r
 412         //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_ANGLE];     \r
 413         //struct i2c_client *client = sensor->client;\r
 414 \r
 415         int result = 0;\r
 416 \r
 417 \r
 418         return result;\r
 419 }\r
 420 \r
 421 /* ioctl - I/O control */\r
 422 static long angle_dev_ioctl(struct file *file,\r
 423                           unsigned int cmd, unsigned long arg)\r
 424 {\r
 425         struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_ANGLE];\r
 426         struct i2c_client *client = sensor->client;\r
 427         void __user *argp = (void __user *)arg;\r
 428         struct sensor_axis axis = {0};\r
 429         char rate;\r
 430         int result = 0;\r
 431 \r
 432         switch (cmd) {\r
 433         case GSENSOR_IOCTL_APP_SET_RATE:\r
 434                 if (copy_from_user(&rate, argp, sizeof(rate)))\r
 435                 {\r
 436                         result = -EFAULT;\r
 437                         goto error;\r
 438                 }\r
 439                 break;\r
 440         default:\r
 441                 break;\r
 442         }\r
 443 \r
 444         switch (cmd) {\r
 445         case GSENSOR_IOCTL_START:       \r
 446                 DBG("%s:GSENSOR_IOCTL_START start,status=%d\n", __func__,sensor->status_cur);\r
 447                 mutex_lock(&sensor->operation_mutex);   \r
 448                 if(++sensor->start_count == 1)\r
 449                 {\r
 450                         if(sensor->status_cur == SENSOR_OFF)\r
 451                         {\r
 452                                 atomic_set(&(sensor->data_ready), 0);\r
 453                                 if ( (result = sensor->ops->active(client, 1, 0) ) < 0 ) {\r
 454                                         mutex_unlock(&sensor->operation_mutex);\r
 455                                         printk("%s:fail to active sensor,ret=%d\n",__func__,result);         \r
 456                                         goto error;           \r
 457                                 }                       \r
 458                                 if(sensor->pdata->irq_enable)\r
 459                                 {\r
 460                                         DBG("%s:enable irq,irq=%d\n",__func__,client->irq);\r
 461                                         enable_irq(client->irq);        //enable irq\r
 462                                 }       \r
 463                                 else\r
 464                                 {\r
 465                                         schedule_delayed_work(&sensor->delaywork, msecs_to_jiffies(sensor->pdata->poll_delay_ms));\r
 466                                 }\r
 467                                 sensor->status_cur = SENSOR_ON;\r
 468                         }       \r
 469                 }\r
 470                 mutex_unlock(&sensor->operation_mutex);\r
 471                 DBG("%s:GSENSOR_IOCTL_START OK\n", __func__);\r
 472                 break;\r
 473 \r
 474         case GSENSOR_IOCTL_CLOSE:                               \r
 475                 DBG("%s:GSENSOR_IOCTL_CLOSE start,status=%d\n", __func__,sensor->status_cur);\r
 476                 mutex_lock(&sensor->operation_mutex);           \r
 477                 if(--sensor->start_count == 0)\r
 478                 {\r
 479                         if(sensor->status_cur == SENSOR_ON)\r
 480                         {\r
 481                                 atomic_set(&(sensor->data_ready), 0);\r
 482                                 if ( (result = sensor->ops->active(client, 0, 0) ) < 0 ) {\r
 483                                         mutex_unlock(&sensor->operation_mutex);              \r
 484                                         goto error;\r
 485                                 }\r
 486                                 \r
 487                                 if(sensor->pdata->irq_enable)\r
 488                                 {                               \r
 489                                         DBG("%s:disable irq,irq=%d\n",__func__,client->irq);\r
 490                                         disable_irq_nosync(client->irq);//disable irq\r
 491                                 }\r
 492                                 else\r
 493                                 cancel_delayed_work_sync(&sensor->delaywork);           \r
 494                                 sensor->status_cur = SENSOR_OFF;\r
 495                         }\r
 496                         \r
 497                         DBG("%s:GSENSOR_IOCTL_CLOSE OK\n", __func__);\r
 498                 }\r
 499                 \r
 500                 mutex_unlock(&sensor->operation_mutex); \r
 501                 break;\r
 502 \r
 503         case GSENSOR_IOCTL_APP_SET_RATE:                \r
 504                 DBG("%s:GSENSOR_IOCTL_APP_SET_RATE start\n", __func__);         \r
 505                 mutex_lock(&sensor->operation_mutex);   \r
 506                 result = sensor_reset_rate(client, rate);\r
 507                 if (result < 0){\r
 508                         mutex_unlock(&sensor->operation_mutex);\r
 509                         goto error;\r
 510                 }\r
 511 \r
 512                 sensor->status_cur = SENSOR_ON;\r
 513                 mutex_unlock(&sensor->operation_mutex); \r
 514                 DBG("%s:GSENSOR_IOCTL_APP_SET_RATE OK\n", __func__);\r
 515                 break;\r
 516                 \r
 517         case GSENSOR_IOCTL_GETDATA:\r
 518                 mutex_lock(&sensor->data_mutex);\r
 519                 memcpy(&axis, &sensor->axis, sizeof(sensor->axis));     //get data from buffer\r
 520                 mutex_unlock(&sensor->data_mutex);              \r
 521                 break;\r
 522         default:\r
 523                 result = -ENOTTY;\r
 524         goto error;\r
 525         }\r
 526 \r
 527         switch (cmd) {\r
 528         case GSENSOR_IOCTL_GETDATA:\r
 529                 if ( copy_to_user(argp, &axis, sizeof(axis) ) ) {\r
 530                     printk("failed to copy sense data to user space.");\r
 531                                 result = -EFAULT;                       \r
 532                                 goto error;\r
 533                 }               \r
 534                 DBG("%s:GSENSOR_IOCTL_GETDATA OK\n", __func__);\r
 535                 break;\r
 536         default:\r
 537                 break;\r
 538         }\r
 539         \r
 540 error:\r
 541         return result;\r
 542 }\r
 543 \r
 544 \r
 545 static int gsensor_dev_open(struct inode *inode, struct file *file)\r
 546 {\r
 547         //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_ACCEL];     \r
 548         //struct i2c_client *client = sensor->client;\r
 549 \r
 550         int result = 0;\r
 551 \r
 552 \r
 553         return result;\r
 554 }\r
 555 \r
 556 \r
 557 static int gsensor_dev_release(struct inode *inode, struct file *file)\r
 558 {\r
 559         //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_ACCEL];     \r
 560         //struct i2c_client *client = sensor->client;\r
 561 \r
 562         int result = 0;\r
 563 \r
 564 \r
 565         return result;\r
 566 }\r
 567 \r
 568 /* ioctl - I/O control */\r
 569 static long gsensor_dev_ioctl(struct file *file,\r
 570                           unsigned int cmd, unsigned long arg)\r
 571 {\r
 572         struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_ACCEL];\r
 573         struct i2c_client *client = sensor->client;\r
 574         void __user *argp = (void __user *)arg;\r
 575         struct sensor_axis axis = {0};\r
 576         char rate;\r
 577         int result = 0;\r
 578 \r
 579         switch (cmd) {\r
 580         case GSENSOR_IOCTL_APP_SET_RATE:\r
 581                 if (copy_from_user(&rate, argp, sizeof(rate)))\r
 582                 {\r
 583                         result = -EFAULT;\r
 584                         goto error;\r
 585                 }\r
 586                 break;\r
 587         default:\r
 588                 break;\r
 589         }\r
 590 \r
 591         switch (cmd) {\r
 592         case GSENSOR_IOCTL_START:       \r
 593                 DBG("%s:GSENSOR_IOCTL_START start,status=%d\n", __func__,sensor->status_cur);\r
 594                 mutex_lock(&sensor->operation_mutex);   \r
 595                 if(++sensor->start_count == 1)\r
 596                 {\r
 597                         if(sensor->status_cur == SENSOR_OFF)\r
 598                         {\r
 599                                 atomic_set(&(sensor->data_ready), 0);\r
 600                                 if ( (result = sensor->ops->active(client, 1, 0) ) < 0 ) {\r
 601                                         mutex_unlock(&sensor->operation_mutex);\r
 602                                         printk("%s:fail to active sensor,ret=%d\n",__func__,result);         \r
 603                                         goto error;           \r
 604                                 }                       \r
 605                                 if(sensor->pdata->irq_enable)\r
 606                                 {\r
 607                                         DBG("%s:enable irq,irq=%d\n",__func__,client->irq);\r
 608                                         enable_irq(client->irq);        //enable irq\r
 609                                 }       \r
 610                                 else\r
 611                                 {\r
 612                                         schedule_delayed_work(&sensor->delaywork, msecs_to_jiffies(sensor->pdata->poll_delay_ms));\r
 613                                 }\r
 614                                 sensor->status_cur = SENSOR_ON;\r
 615                         }       \r
 616                 }\r
 617                 mutex_unlock(&sensor->operation_mutex);\r
 618                 DBG("%s:GSENSOR_IOCTL_START OK\n", __func__);\r
 619                 break;\r
 620 \r
 621         case GSENSOR_IOCTL_CLOSE:                               \r
 622                 DBG("%s:GSENSOR_IOCTL_CLOSE start,status=%d\n", __func__,sensor->status_cur);\r
 623                 mutex_lock(&sensor->operation_mutex);           \r
 624                 if(--sensor->start_count == 0)\r
 625                 {\r
 626                         if(sensor->status_cur == SENSOR_ON)\r
 627                         {\r
 628                                 atomic_set(&(sensor->data_ready), 0);\r
 629                                 if ( (result = sensor->ops->active(client, 0, 0) ) < 0 ) {\r
 630                                         mutex_unlock(&sensor->operation_mutex);              \r
 631                                         goto error;\r
 632                                 }\r
 633                                 \r
 634                                 if(sensor->pdata->irq_enable)\r
 635                                 {                               \r
 636                                         DBG("%s:disable irq,irq=%d\n",__func__,client->irq);\r
 637                                         disable_irq_nosync(client->irq);//disable irq\r
 638                                 }\r
 639                                 else\r
 640                                 cancel_delayed_work_sync(&sensor->delaywork);           \r
 641                                 sensor->status_cur = SENSOR_OFF;\r
 642                         }\r
 643                         \r
 644                         DBG("%s:GSENSOR_IOCTL_CLOSE OK\n", __func__);\r
 645                 }\r
 646                 \r
 647                 mutex_unlock(&sensor->operation_mutex); \r
 648                 break;\r
 649 \r
 650         case GSENSOR_IOCTL_APP_SET_RATE:                \r
 651                 DBG("%s:GSENSOR_IOCTL_APP_SET_RATE start\n", __func__);         \r
 652                 mutex_lock(&sensor->operation_mutex);   \r
 653                 result = sensor_reset_rate(client, rate);\r
 654                 if (result < 0){\r
 655                         mutex_unlock(&sensor->operation_mutex);\r
 656                         goto error;\r
 657                 }\r
 658 \r
 659                 sensor->status_cur = SENSOR_ON;\r
 660                 mutex_unlock(&sensor->operation_mutex); \r
 661                 DBG("%s:GSENSOR_IOCTL_APP_SET_RATE OK\n", __func__);\r
 662                 break;\r
 663                 \r
 664         case GSENSOR_IOCTL_GETDATA:\r
 665                 mutex_lock(&sensor->data_mutex);\r
 666                 memcpy(&axis, &sensor->axis, sizeof(sensor->axis));     //get data from buffer\r
 667                 mutex_unlock(&sensor->data_mutex);              \r
 668                 break;\r
 669         default:\r
 670                 result = -ENOTTY;\r
 671         goto error;\r
 672         }\r
 673 \r
 674         switch (cmd) {\r
 675         case GSENSOR_IOCTL_GETDATA:\r
 676                 if ( copy_to_user(argp, &axis, sizeof(axis) ) ) {\r
 677                     printk("failed to copy sense data to user space.");\r
 678                                 result = -EFAULT;                       \r
 679                                 goto error;\r
 680                 }               \r
 681                 DBG("%s:GSENSOR_IOCTL_GETDATA OK\n", __func__);\r
 682                 break;\r
 683         default:\r
 684                 break;\r
 685         }\r
 686         \r
 687 error:\r
 688         return result;\r
 689 }\r
 690 \r
 691 static ssize_t gsensor_set_orientation_online(struct class *class,\r
 692                 struct class_attribute *attr, const char *buf, size_t count)\r
 693 {\r
 694         int i=0;\r
 695         char orientation[20];\r
 696         char *tmp;\r
 697         \r
 698         struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_ACCEL];\r
 699         struct sensor_platform_data *pdata = sensor->pdata;\r
 700 \r
 701         \r
 702         char *p = strstr(buf,"gsensor_class");\r
 703         int start = strcspn(p,"{");\r
 704         int end = strcspn(p,"}");\r
 705         \r
 706         strncpy(orientation,p+start,end-start+1);\r
 707         tmp = orientation;\r
 708         \r
 709 \r
 710         while(strncmp(tmp,"}",1)!=0)\r
 711          {\r
 712                 if((strncmp(tmp,",",1)==0)||(strncmp(tmp,"{",1)==0))\r
 713                 {\r
 714                         \r
 715                          tmp++;         \r
 716                          continue;\r
 717                 }       \r
 718                 else if(strncmp(tmp,"-",1)==0)\r
 719                 {\r
 720                         pdata->orientation[i++]=-1;\r
 721                         DBG("i=%d,data=%d\n",i,pdata->orientation[i]);\r
 722                          tmp++;\r
 723                 }               \r
 724                 else\r
 725                 {\r
 726                         pdata->orientation[i++]=tmp[0]-48;              \r
 727                         DBG("----i=%d,data=%d\n",i,pdata->orientation[i]);      \r
 728                 }       \r
 729                 tmp++;\r
 730         \r
 731                                                 \r
 732          }\r
 733 \r
 734         for(i=0;i<9;i++)\r
 735                 DBG("i=%d gsensor_info=%d\n",i,pdata->orientation[i]);\r
 736         return 0;\r
 737 \r
 738 }\r
 739 \r
 740 static CLASS_ATTR(orientation, 0660, NULL, gsensor_set_orientation_online);\r
 741 \r
 742 static int  gsensor_class_init(void)\r
 743 {\r
 744         int ret ;\r
 745         struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_ACCEL];       \r
 746         g_sensor_class[SENSOR_TYPE_ACCEL] = class_create(THIS_MODULE, "gsensor_class");\r
 747         ret =  class_create_file(g_sensor_class[SENSOR_TYPE_ACCEL], &class_attr_orientation);\r
 748         if (ret)\r
 749         {\r
 750                 printk("%s:Fail to creat class\n",__func__);\r
 751                 return ret;\r
 752         }\r
 753         printk("%s:%s\n",__func__,sensor->i2c_id->name);\r
 754         return 0;\r
 755 }\r
 756 \r
 757 \r
 758 \r
 759 static int compass_dev_open(struct inode *inode, struct file *file)\r
 760 {\r
 761         struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_COMPASS];\r
 762         //struct i2c_client *client = sensor->client;   \r
 763 \r
 764         int result = 0;\r
 765         int flag = 0;\r
 766         flag = atomic_read(&sensor->flags.open_flag);\r
 767         if(!flag)\r
 768         {       \r
 769                 atomic_set(&sensor->flags.open_flag, 1);\r
 770                 wake_up(&sensor->flags.open_wq);\r
 771         }\r
 772 \r
 773         DBG("%s\n", __func__);\r
 774         return result;\r
 775 }\r
 776 \r
 777 \r
 778 \r
 779 static int compass_dev_release(struct inode *inode, struct file *file)\r
 780 {\r
 781         struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_COMPASS];\r
 782         //struct i2c_client *client = sensor->client;\r
 783         //void __user *argp = (void __user *)arg;\r
 784         int result = 0;\r
 785         int flag = 0;\r
 786         flag = atomic_read(&sensor->flags.open_flag);\r
 787         if(flag)\r
 788         {\r
 789                 atomic_set(&sensor->flags.open_flag, 0);\r
 790                 wake_up(&sensor->flags.open_wq);        \r
 791         }\r
 792         \r
 793         DBG("%s\n", __func__);\r
 794         return result;\r
 795 }\r
 796 \r
 797 #ifdef CONFIG_COMPAT
 798 /* ioctl - I/O control */
 799 static long compass_dev_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
 800 {
 801         void __user *arg64 = compat_ptr(arg);
 802         int result = 0;
 803
 804         if (!file->f_op || !file->f_op->unlocked_ioctl) {
 805                 pr_err("file->f_op or file->f_op->unlocked_ioctl is null\n");
 806                 return -ENOTTY;
 807         }
 808
 809         switch (cmd) {
 810         case COMPAT_ECS_IOCTL_APP_SET_MFLAG:
 811                 if (file->f_op->unlocked_ioctl)
 812                         result = file->f_op->unlocked_ioctl(file, ECS_IOCTL_APP_SET_MFLAG, (unsigned long)arg64);
 813                 break;
 814         case COMPAT_ECS_IOCTL_APP_GET_MFLAG:
 815                 if (file->f_op->unlocked_ioctl)
 816                         result = file->f_op->unlocked_ioctl(file, ECS_IOCTL_APP_GET_MFLAG, (unsigned long)arg64);
 817                 break;
 818         case COMPAT_ECS_IOCTL_APP_SET_AFLAG:
 819                 if (file->f_op->unlocked_ioctl)
 820                         result = file->f_op->unlocked_ioctl(file, ECS_IOCTL_APP_SET_AFLAG, (unsigned long)arg64);
 821                 break;
 822         case COMPAT_ECS_IOCTL_APP_GET_AFLAG:
 823                 if (file->f_op->unlocked_ioctl)
 824                         result = file->f_op->unlocked_ioctl(file, ECS_IOCTL_APP_GET_AFLAG, (unsigned long)arg64);
 825                 break;
 826         case COMPAT_ECS_IOCTL_APP_SET_MVFLAG:
 827                 if (file->f_op->unlocked_ioctl)
 828                         result = file->f_op->unlocked_ioctl(file, ECS_IOCTL_APP_SET_MVFLAG, (unsigned long)arg64);
 829                 break;
 830         case COMPAT_ECS_IOCTL_APP_GET_MVFLAG:
 831                 if (file->f_op->unlocked_ioctl)
 832                         result = file->f_op->unlocked_ioctl(file, ECS_IOCTL_APP_GET_MVFLAG, (unsigned long)arg64);
 833                 break;
 834         case COMPAT_ECS_IOCTL_APP_SET_DELAY:
 835                 if (file->f_op->unlocked_ioctl)
 836                         result = file->f_op->unlocked_ioctl(file, ECS_IOCTL_APP_SET_DELAY, (unsigned long)arg64);
 837                 break;
 838         case COMPAT_ECS_IOCTL_APP_GET_DELAY:
 839                 if (file->f_op->unlocked_ioctl)
 840                         result = file->f_op->unlocked_ioctl(file, ECS_IOCTL_APP_GET_DELAY, (unsigned long)arg64);
 841                 break;
 842         default:
 843                 break;
 844         }
 845
 846         return result;
 847 }
 848 #endif
 849
 850 \r
 851 /* ioctl - I/O control */\r
 852 static long compass_dev_ioctl(struct file *file,\r
 853                           unsigned int cmd, unsigned long arg)\r
 854 {\r
 855         struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_COMPASS];\r
 856         //struct i2c_client *client = sensor->client;\r
 857         void __user *argp = (void __user *)arg;\r
 858         int result = 0;\r
 859         short flag;\r
 860         \r
 861         switch (cmd) {\r
 862                 case ECS_IOCTL_APP_SET_MFLAG:\r
 863                 case ECS_IOCTL_APP_SET_AFLAG:\r
 864                 case ECS_IOCTL_APP_SET_MVFLAG:\r
 865                         if (copy_from_user(&flag, argp, sizeof(flag))) {\r
 866                                 return -EFAULT;\r
 867                         }\r
 868                         if (flag < 0 || flag > 1) {\r
 869                                 return -EINVAL;\r
 870                         }\r
 871                         break;\r
 872                 case ECS_IOCTL_APP_SET_DELAY:\r
 873                         if (copy_from_user(&flag, argp, sizeof(flag))) {\r
 874                                 return -EFAULT;\r
 875                         }\r
 876                         break;\r
 877                 default:\r
 878                         break;\r
 879         }\r
 880         \r
 881         switch (cmd) {\r
 882                 case ECS_IOCTL_APP_SET_MFLAG:   \r
 883                         atomic_set(&sensor->flags.m_flag, flag);                        \r
 884                         DBG("%s:ECS_IOCTL_APP_SET_MFLAG,flag=%d\n", __func__,flag);\r
 885                         break;\r
 886                 case ECS_IOCTL_APP_GET_MFLAG:           \r
 887                         flag = atomic_read(&sensor->flags.m_flag);\r
 888                         DBG("%s:ECS_IOCTL_APP_GET_MFLAG,flag=%d\n", __func__,flag);\r
 889                         break;\r
 890                 case ECS_IOCTL_APP_SET_AFLAG:   \r
 891                         atomic_set(&sensor->flags.a_flag, flag);                \r
 892                         DBG("%s:ECS_IOCTL_APP_SET_AFLAG,flag=%d\n", __func__,flag);\r
 893                         break;\r
 894                 case ECS_IOCTL_APP_GET_AFLAG:\r
 895                         flag = atomic_read(&sensor->flags.a_flag);              \r
 896                         DBG("%s:ECS_IOCTL_APP_GET_AFLAG,flag=%d\n", __func__,flag);\r
 897                         break;\r
 898                 case ECS_IOCTL_APP_SET_MVFLAG:  \r
 899                         atomic_set(&sensor->flags.mv_flag, flag);               \r
 900                         DBG("%s:ECS_IOCTL_APP_SET_MVFLAG,flag=%d\n", __func__,flag);\r
 901                         break;\r
 902                 case ECS_IOCTL_APP_GET_MVFLAG:          \r
 903                         flag = atomic_read(&sensor->flags.mv_flag);             \r
 904                         DBG("%s:ECS_IOCTL_APP_GET_MVFLAG,flag=%d\n", __func__,flag);\r
 905                         break;\r
 906                 case ECS_IOCTL_APP_SET_DELAY:\r
 907                         sensor->flags.delay = flag;\r
 908                         break;\r
 909                 case ECS_IOCTL_APP_GET_DELAY:\r
 910                         flag = sensor->flags.delay;\r
 911                         break;\r
 912                 default:\r
 913                         return -ENOTTY;\r
 914         }\r
 915         \r
 916         switch (cmd) {\r
 917                 case ECS_IOCTL_APP_GET_MFLAG:\r
 918                 case ECS_IOCTL_APP_GET_AFLAG:\r
 919                 case ECS_IOCTL_APP_GET_MVFLAG:\r
 920                 case ECS_IOCTL_APP_GET_DELAY:\r
 921                         if (copy_to_user(argp, &flag, sizeof(flag))) {\r
 922                                 return -EFAULT;\r
 923                         }\r
 924                         break;\r
 925                 default:\r
 926                         break;\r
 927         }\r
 928 \r
 929         return result;\r
 930 }\r
 931 \r
 932 static int gyro_dev_open(struct inode *inode, struct file *file)\r
 933 {\r
 934         //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_GYROSCOPE];\r
 935         //struct i2c_client *client = sensor->client;\r
 936 \r
 937         int result = 0;\r
 938 \r
 939 \r
 940         return result;\r
 941 }\r
 942 \r
 943 \r
 944 static int gyro_dev_release(struct inode *inode, struct file *file)\r
 945 {\r
 946         //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_GYROSCOPE];\r
 947         //struct i2c_client *client = sensor->client;\r
 948 \r
 949         int result = 0;\r
 950 \r
 951 \r
 952         return result;\r
 953 }\r
 954 \r
 955 \r
 956 /* ioctl - I/O control */\r
 957 static long gyro_dev_ioctl(struct file *file,\r
 958                           unsigned int cmd, unsigned long arg)\r
 959 {\r
 960         struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_GYROSCOPE];   \r
 961         struct i2c_client *client = sensor->client;     \r
 962         void __user *argp = (void __user *)arg;\r
 963         int result = 0;\r
 964         char rate;\r
 965         switch (cmd) {\r
 966         case L3G4200D_IOCTL_GET_ENABLE: \r
 967                 result = !sensor->status_cur;\r
 968                 if (copy_to_user(argp, &result, sizeof(result)))\r
 969                 {\r
 970                         printk("%s:failed to copy status to user space.\n",__FUNCTION__);\r
 971                         return -EFAULT;\r
 972                 }\r
 973                 \r
 974                 DBG("%s :L3G4200D_IOCTL_GET_ENABLE,status=%d\n",__FUNCTION__,result);   \r
 975                 break;\r
 976         case L3G4200D_IOCTL_SET_ENABLE:                 \r
 977                 DBG("%s :L3G4200D_IOCTL_SET_ENABLE,flag=%d\n",__FUNCTION__,*(unsigned int *)argp);\r
 978                 mutex_lock(&sensor->operation_mutex);   \r
 979                 if(*(unsigned int *)argp)\r
 980                 {\r
 981                         if(sensor->status_cur == SENSOR_OFF)\r
 982                         {\r
 983                                 if ( (result = sensor->ops->active(client, 1, ODR100_BW12_5) ) < 0 ) {\r
 984                                 mutex_unlock(&sensor->operation_mutex);\r
 985                                 printk("%s:fail to active sensor,ret=%d\n",__func__,result);         \r
 986                                 goto error;           \r
 987                                 }                       \r
 988                                 if(sensor->pdata->irq_enable)\r
 989                                 {\r
 990                                         DBG("%s:enable irq,irq=%d\n",__func__,client->irq);\r
 991                                         enable_irq(client->irq);        //enable irq\r
 992                                 }       \r
 993                                 else\r
 994                                 {\r
 995                                         schedule_delayed_work(&sensor->delaywork, msecs_to_jiffies(sensor->pdata->poll_delay_ms));\r
 996                                 }\r
 997                                 sensor->status_cur = SENSOR_ON;\r
 998                         }       \r
 999                 }\r
1000                 else\r
1001                 {\r
1002                         if(sensor->status_cur == SENSOR_ON)\r
1003                         {\r
1004                                 if ( (result = sensor->ops->active(client, 0, 0) ) < 0 ) {\r
1005                                 mutex_unlock(&sensor->operation_mutex);              \r
1006                                 goto error;\r
1007                                 }\r
1008                                 \r
1009                                 if(sensor->pdata->irq_enable)\r
1010                                 {                               \r
1011                                         DBG("%s:disable irq,irq=%d\n",__func__,client->irq);\r
1012                                         disable_irq_nosync(client->irq);//disable irq\r
1013                                 }\r
1014                                 else\r
1015                                 cancel_delayed_work_sync(&sensor->delaywork);           \r
1016                                 sensor->status_cur = SENSOR_OFF;\r
1017                         }\r
1018                 }\r
1019         \r
1020                 result = sensor->status_cur;\r
1021                 if (copy_to_user(argp, &result, sizeof(result)))\r
1022                 {\r
1023                         printk("%s:failed to copy sense data to user space.\n",__FUNCTION__);\r
1024                         return -EFAULT;\r
1025                 }\r
1026 \r
1027                 mutex_unlock(&sensor->operation_mutex);\r
1028                 DBG("%s:L3G4200D_IOCTL_SET_ENABLE OK\n", __func__);\r
1029                 break;\r
1030         case L3G4200D_IOCTL_SET_DELAY:                                  \r
1031                 mutex_lock(&sensor->operation_mutex);\r
1032                 if (copy_from_user(&rate, argp, sizeof(rate)))\r
1033                 return -EFAULT;\r
1034                 if(sensor->status_cur == SENSOR_OFF)\r
1035                 {\r
1036                         if ( (result = sensor->ops->active(client, 1, rate) ) < 0 ) {\r
1037                         mutex_unlock(&sensor->operation_mutex);\r
1038                         printk("%s:fail to active sensor,ret=%d\n",__func__,result);         \r
1039                         goto error;           \r
1040                         }\r
1041                         \r
1042                         if(sensor->pdata->irq_enable)\r
1043                         {\r
1044                                 DBG("%s:enable irq,irq=%d\n",__func__,client->irq);\r
1045                                 enable_irq(client->irq);        //enable irq\r
1046                         }       \r
1047                         else\r
1048                         {\r
1049                                 schedule_delayed_work(&sensor->delaywork, msecs_to_jiffies(sensor->pdata->poll_delay_ms));\r
1050                         }\r
1051                         sensor->status_cur = SENSOR_ON;\r
1052                 }       \r
1053                 \r
1054                 mutex_unlock(&sensor->operation_mutex);\r
1055                 DBG("%s :L3G4200D_IOCTL_SET_DELAY,rate=%d\n",__FUNCTION__,rate);\r
1056                 break;\r
1057 \r
1058         default:\r
1059                 printk("%s:error,cmd=0x%x\n",__func__,cmd);\r
1060                 return -ENOTTY;\r
1061         }\r
1062         \r
1063         DBG("%s:line=%d,cmd=0x%x\n",__func__,__LINE__,cmd);\r
1064 \r
1065 error:\r
1066         return result;\r
1067 }\r
1068 \r
1069 static int light_dev_open(struct inode *inode, struct file *file)\r
1070 {\r
1071         //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_LIGHT];\r
1072         //struct i2c_client *client = sensor->client;   \r
1073         int result = 0; \r
1074 \r
1075 \r
1076         return result;\r
1077 }\r
1078 \r
1079 \r
1080 \r
1081 \r
1082 static int light_dev_release(struct inode *inode, struct file *file)\r
1083 {\r
1084         //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_LIGHT];\r
1085         //struct i2c_client *client = sensor->client;   \r
1086         int result = 0;\r
1087 \r
1088 \r
1089         return result;\r
1090 }\r
1091 \r
1092 #ifdef CONFIG_COMPAT
1093 static long light_dev_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
1094 {
1095         long ret = 0;
1096         void __user *arg64 = compat_ptr(arg);
1097
1098         if (!file->f_op || !file->f_op->unlocked_ioctl) {
1099                 pr_err("[DEBUG] file->f_op or file->f_op->unlocked_ioctl is null\n");
1100                 return -ENOTTY;
1101         }
1102
1103         switch (cmd) {
1104         case COMPAT_LIGHTSENSOR_IOCTL_GET_ENABLED:
1105                 if (file->f_op->unlocked_ioctl)
1106                         ret = file->f_op->unlocked_ioctl(file, LIGHTSENSOR_IOCTL_GET_ENABLED, (unsigned long)arg64);
1107                 break;
1108         case COMPAT_LIGHTSENSOR_IOCTL_ENABLE:
1109                 if (file->f_op->unlocked_ioctl)
1110                         ret = file->f_op->unlocked_ioctl(file, LIGHTSENSOR_IOCTL_ENABLE, (unsigned long)arg64);
1111                 break;
1112         default:
1113                 break;
1114         }
1115
1116         return ret;
1117 }
1118 #endif
1119 \r
1120 /* ioctl - I/O control */\r
1121 static long light_dev_ioctl(struct file *file,\r
1122                           unsigned int cmd, unsigned long arg)\r
1123 {\r
1124         struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_LIGHT];\r
1125         struct i2c_client *client = sensor->client;\r
1126         unsigned int *argp = (unsigned int *)arg;       \r
1127         int result = 0;\r
1128 \r
1129         switch(cmd)\r
1130         {\r
1131                 case LIGHTSENSOR_IOCTL_GET_ENABLED:\r
1132                         *argp = sensor->status_cur;\r
1133                         break;\r
1134                 case LIGHTSENSOR_IOCTL_ENABLE:          \r
1135                         DBG("%s:LIGHTSENSOR_IOCTL_ENABLE start\n", __func__);\r
1136                         mutex_lock(&sensor->operation_mutex);    \r
1137                         if(*(unsigned int *)argp)\r
1138                         {\r
1139                                 if(sensor->status_cur == SENSOR_OFF)\r
1140                                 {\r
1141                                         if ( (result = sensor->ops->active(client, SENSOR_ON, 0) ) < 0 ) {\r
1142                                         mutex_unlock(&sensor->operation_mutex);\r
1143                                         printk("%s:fail to active sensor,ret=%d\n",__func__,result);         \r
1144                                         goto error;           \r
1145                                         }       \r
1146                                         if(sensor->pdata->irq_enable)\r
1147                                         {\r
1148                                                 if(!(sensor->ops->trig & IRQF_SHARED))\r
1149                                                 {\r
1150                                                         DBG("%s:enable irq,irq=%d\n",__func__,client->irq);\r
1151                                                         enable_irq(client->irq);        //enable irq\r
1152                                                 }\r
1153                                         }       \r
1154                                         else\r
1155                                         {\r
1156                                                 schedule_delayed_work(&sensor->delaywork, msecs_to_jiffies(sensor->pdata->poll_delay_ms));\r
1157                                         }\r
1158                                         \r
1159                                         sensor->status_cur = SENSOR_ON;\r
1160                                 }       \r
1161                         }\r
1162                         else\r
1163                         {\r
1164                                 if(sensor->status_cur == SENSOR_ON)\r
1165                                 {\r
1166                                         if ( (result = sensor->ops->active(client, SENSOR_OFF, 0) ) < 0 ) {\r
1167                                         mutex_unlock(&sensor->operation_mutex);              \r
1168                                         goto error;\r
1169                                         }\r
1170                                         \r
1171                                         if(sensor->pdata->irq_enable)\r
1172                                         {                               \r
1173                                                 if(!(sensor->ops->trig & IRQF_SHARED))\r
1174                                                 {\r
1175                                                         DBG("%s:disable irq,irq=%d\n",__func__,client->irq);\r
1176                                                         disable_irq_nosync(client->irq);//disable irq\r
1177                                                 }\r
1178                                         }\r
1179                                         else\r
1180                                         cancel_delayed_work_sync(&sensor->delaywork);   \r
1181                                         \r
1182                                         sensor->status_cur = SENSOR_OFF;\r
1183                                 }\r
1184                         }\r
1185                         mutex_unlock(&sensor->operation_mutex);\r
1186                         DBG("%s:LIGHTSENSOR_IOCTL_ENABLE OK\n", __func__);\r
1187                         break;\r
1188                 \r
1189                 default:\r
1190                         break;\r
1191         }\r
1192         \r
1193 error:\r
1194         return result;\r
1195 }\r
1196 \r
1197 \r
1198 static int proximity_dev_open(struct inode *inode, struct file *file)\r
1199 {\r
1200         //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_PROXIMITY];\r
1201         //struct i2c_client *client = sensor->client;   \r
1202         int result = 0;\r
1203 \r
1204 \r
1205         return result;\r
1206 }\r
1207 \r
1208 \r
1209 static int proximity_dev_release(struct inode *inode, struct file *file)\r
1210 {\r
1211         //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_PROXIMITY];\r
1212         //struct i2c_client *client = sensor->client;   \r
1213         int result = 0;\r
1214 \r
1215 \r
1216         return result;\r
1217 }\r
1218 \r
1219 #ifdef CONFIG_COMPAT
1220 static long proximity_dev_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
1221 {
1222         long ret = 0;
1223         void __user *arg64 = compat_ptr(arg);
1224
1225         if (!file->f_op || !file->f_op->unlocked_ioctl) {
1226                 pr_err("file->f_op or file->f_op->unlocked_ioctl is null\n");
1227                 return -ENOTTY;
1228         }
1229
1230         switch (cmd) {
1231         case COMPAT_PSENSOR_IOCTL_GET_ENABLED:
1232                 if (file->f_op->unlocked_ioctl)
1233                         ret = file->f_op->unlocked_ioctl(file, PSENSOR_IOCTL_GET_ENABLED, (unsigned long)arg64);
1234                 break;
1235         case COMPAT_PSENSOR_IOCTL_ENABLE:
1236                 if (file->f_op->unlocked_ioctl)
1237                         ret = file->f_op->unlocked_ioctl(file, PSENSOR_IOCTL_ENABLE, (unsigned long)arg64);
1238                 break;
1239         default:
1240                 break;
1241         }
1242
1243         return ret;
1244 }
1245 #endif
1246 \r
1247 /* ioctl - I/O control */\r
1248 static long proximity_dev_ioctl(struct file *file,\r
1249                           unsigned int cmd, unsigned long arg)\r
1250 {\r
1251         struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_PROXIMITY];\r
1252         struct i2c_client *client = sensor->client;     \r
1253         unsigned int *argp = (unsigned int *)arg;       \r
1254         int result = 0;\r
1255         switch(cmd)\r
1256         {\r
1257                 case PSENSOR_IOCTL_GET_ENABLED:\r
1258                         *argp = sensor->status_cur;\r
1259                         break;\r
1260                 case PSENSOR_IOCTL_ENABLE:              \r
1261                         DBG("%s:PSENSOR_IOCTL_ENABLE start\n", __func__);\r
1262                         mutex_lock(&sensor->operation_mutex);    \r
1263                         if(*(unsigned int *)argp)\r
1264                         {\r
1265                                 if(sensor->status_cur == SENSOR_OFF)\r
1266                                 {\r
1267                                         if ( (result = sensor->ops->active(client, SENSOR_ON, 0) ) < 0 ) {\r
1268                                         mutex_unlock(&sensor->operation_mutex);\r
1269                                         printk("%s:fail to active sensor,ret=%d\n",__func__,result);         \r
1270                                         goto error;           \r
1271                                         }\r
1272                                         \r
1273                                         if(sensor->pdata->irq_enable)\r
1274                                         {\r
1275                                                 if(!(sensor->ops->trig & IRQF_SHARED))\r
1276                                                 {\r
1277                                                         DBG("%s:enable irq,irq=%d\n",__func__,client->irq);\r
1278                                                         enable_irq(client->irq);        //enable irq\r
1279                                                 }\r
1280                                         }       \r
1281                                         else\r
1282                                         {\r
1283                                                 schedule_delayed_work(&sensor->delaywork, msecs_to_jiffies(sensor->pdata->poll_delay_ms));\r
1284                                         }\r
1285                                         \r
1286                                         sensor->status_cur = SENSOR_ON;\r
1287                                 }       \r
1288                         }\r
1289                         else\r
1290                         {\r
1291                                 if(sensor->status_cur == SENSOR_ON)\r
1292                                 {\r
1293                                         if ( (result = sensor->ops->active(client, SENSOR_OFF, 0) ) < 0 ) {\r
1294                                         mutex_unlock(&sensor->operation_mutex);              \r
1295                                         goto error;\r
1296                                         }\r
1297                                         if(sensor->pdata->irq_enable)\r
1298                                         {                               \r
1299                                                 if(!(sensor->ops->trig & IRQF_SHARED))\r
1300                                                 {\r
1301                                                         DBG("%s:disable irq,irq=%d\n",__func__,client->irq);\r
1302                                                         disable_irq_nosync(client->irq);//disable irq\r
1303                                                 }\r
1304                                         }\r
1305                                         else\r
1306                                         cancel_delayed_work_sync(&sensor->delaywork);           \r
1307                                         sensor->status_cur = SENSOR_OFF;\r
1308                                 }\r
1309                         }\r
1310                         mutex_unlock(&sensor->operation_mutex);\r
1311                         DBG("%s:PSENSOR_IOCTL_ENABLE OK\n", __func__);\r
1312                         break;\r
1313                 \r
1314                 default:\r
1315                         break;\r
1316         }\r
1317         \r
1318 error:\r
1319         return result;\r
1320 }\r
1321 \r
1322 static int temperature_dev_open(struct inode *inode, struct file *file)\r
1323 {\r
1324         //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_TEMPERATURE];\r
1325         //struct i2c_client *client = sensor->client;\r
1326 \r
1327         int result = 0;\r
1328 \r
1329 \r
1330         return result;\r
1331 }\r
1332 \r
1333 \r
1334 static int temperature_dev_release(struct inode *inode, struct file *file)\r
1335 {\r
1336         //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_TEMPERATURE];\r
1337         //struct i2c_client *client = sensor->client;\r
1338 \r
1339         int result = 0;\r
1340 \r
1341 \r
1342         return result;\r
1343 }\r
1344 \r
1345 \r
1346 /* ioctl - I/O control */\r
1347 static long temperature_dev_ioctl(struct file *file,\r
1348                           unsigned int cmd, unsigned long arg)\r
1349 {\r
1350         struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_TEMPERATURE];\r
1351         struct i2c_client *client = sensor->client;\r
1352         unsigned int *argp = (unsigned int *)arg;       \r
1353         int result = 0;\r
1354 \r
1355         switch(cmd)\r
1356         {\r
1357                 case TEMPERATURE_IOCTL_GET_ENABLED:\r
1358                         *argp = sensor->status_cur;\r
1359                         break;\r
1360                 case TEMPERATURE_IOCTL_ENABLE:          \r
1361                         DBG("%s:LIGHTSENSOR_IOCTL_ENABLE start\n", __func__);\r
1362                         mutex_lock(&sensor->operation_mutex);    \r
1363                         if(*(unsigned int *)argp)\r
1364                         {\r
1365                                 if(sensor->status_cur == SENSOR_OFF)\r
1366                                 {\r
1367                                         if ( (result = sensor->ops->active(client, SENSOR_ON, 0) ) < 0 ) {\r
1368                                         mutex_unlock(&sensor->operation_mutex);\r
1369                                         printk("%s:fail to active sensor,ret=%d\n",__func__,result);         \r
1370                                         goto error;           \r
1371                                         }       \r
1372                                         if(sensor->pdata->irq_enable)\r
1373                                         {\r
1374                                                 if(!(sensor->ops->trig & IRQF_SHARED))\r
1375                                                 {\r
1376                                                         DBG("%s:enable irq,irq=%d\n",__func__,client->irq);\r
1377                                                         enable_irq(client->irq);        //enable irq\r
1378                                                 }\r
1379                                         }       \r
1380                                         else\r
1381                                         {\r
1382                                                 schedule_delayed_work(&sensor->delaywork, msecs_to_jiffies(sensor->pdata->poll_delay_ms));\r
1383                                         }\r
1384                                         \r
1385                                         sensor->status_cur = SENSOR_ON;\r
1386                                 }       \r
1387                         }\r
1388                         else\r
1389                         {\r
1390                                 if(sensor->status_cur == SENSOR_ON)\r
1391                                 {\r
1392                                         if ( (result = sensor->ops->active(client, SENSOR_OFF, 0) ) < 0 ) {\r
1393                                         mutex_unlock(&sensor->operation_mutex);              \r
1394                                         goto error;\r
1395                                         }\r
1396                                         \r
1397                                         if(sensor->pdata->irq_enable)\r
1398                                         {                               \r
1399                                                 if(!(sensor->ops->trig & IRQF_SHARED))\r
1400                                                 {\r
1401                                                         DBG("%s:disable irq,irq=%d\n",__func__,client->irq);\r
1402                                                         disable_irq_nosync(client->irq);//disable irq\r
1403                                                 }\r
1404                                         }\r
1405                                         else\r
1406                                         cancel_delayed_work_sync(&sensor->delaywork);   \r
1407                                         \r
1408                                         sensor->status_cur = SENSOR_OFF;\r
1409                                 }\r
1410                         }\r
1411                         mutex_unlock(&sensor->operation_mutex);\r
1412                         DBG("%s:LIGHTSENSOR_IOCTL_ENABLE OK\n", __func__);\r
1413                         break;\r
1414                 \r
1415                 default:\r
1416                         break;\r
1417         }\r
1418         \r
1419 error:\r
1420         return result;\r
1421 }\r
1422 \r
1423 \r
1424 static int pressure_dev_open(struct inode *inode, struct file *file)\r
1425 {\r
1426         //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_PRESSURE];\r
1427         //struct i2c_client *client = sensor->client;\r
1428 \r
1429         int result = 0;\r
1430 \r
1431 \r
1432         return result;\r
1433 }\r
1434 \r
1435 \r
1436 static int pressure_dev_release(struct inode *inode, struct file *file)\r
1437 {\r
1438         //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_PRESSURE];\r
1439         //struct i2c_client *client = sensor->client;\r
1440 \r
1441         int result = 0;\r
1442 \r
1443 \r
1444         return result;\r
1445 }\r
1446 \r
1447 \r
1448 /* ioctl - I/O control */\r
1449 static long pressure_dev_ioctl(struct file *file,\r
1450                           unsigned int cmd, unsigned long arg)\r
1451 {\r
1452         struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_PRESSURE];\r
1453         struct i2c_client *client = sensor->client;\r
1454         unsigned int *argp = (unsigned int *)arg;       \r
1455         int result = 0;\r
1456 \r
1457         switch(cmd)\r
1458         {\r
1459                 case PRESSURE_IOCTL_GET_ENABLED:\r
1460                         *argp = sensor->status_cur;\r
1461                         break;\r
1462                 case PRESSURE_IOCTL_ENABLE:             \r
1463                         DBG("%s:LIGHTSENSOR_IOCTL_ENABLE start\n", __func__);\r
1464                         mutex_lock(&sensor->operation_mutex);    \r
1465                         if(*(unsigned int *)argp)\r
1466                         {\r
1467                                 if(sensor->status_cur == SENSOR_OFF)\r
1468                                 {\r
1469                                         if ( (result = sensor->ops->active(client, SENSOR_ON, 0) ) < 0 ) {\r
1470                                         mutex_unlock(&sensor->operation_mutex);\r
1471                                         printk("%s:fail to active sensor,ret=%d\n",__func__,result);         \r
1472                                         goto error;           \r
1473                                         }       \r
1474                                         if(sensor->pdata->irq_enable)\r
1475                                         {\r
1476                                                 if(!(sensor->ops->trig & IRQF_SHARED))\r
1477                                                 {\r
1478                                                         DBG("%s:enable irq,irq=%d\n",__func__,client->irq);\r
1479                                                         enable_irq(client->irq);        //enable irq\r
1480                                                 }\r
1481                                         }       \r
1482                                         else\r
1483                                         {\r
1484                                                 schedule_delayed_work(&sensor->delaywork, msecs_to_jiffies(sensor->pdata->poll_delay_ms));\r
1485                                         }\r
1486                                         \r
1487                                         sensor->status_cur = SENSOR_ON;\r
1488                                 }       \r
1489                         }\r
1490                         else\r
1491                         {\r
1492                                 if(sensor->status_cur == SENSOR_ON)\r
1493                                 {\r
1494                                         if ( (result = sensor->ops->active(client, SENSOR_OFF, 0) ) < 0 ) {\r
1495                                         mutex_unlock(&sensor->operation_mutex);              \r
1496                                         goto error;\r
1497                                         }\r
1498                                         \r
1499                                         if(sensor->pdata->irq_enable)\r
1500                                         {                               \r
1501                                                 if(!(sensor->ops->trig & IRQF_SHARED))\r
1502                                                 {\r
1503                                                         DBG("%s:disable irq,irq=%d\n",__func__,client->irq);\r
1504                                                         disable_irq_nosync(client->irq);//disable irq\r
1505                                                 }\r
1506                                         }\r
1507                                         else\r
1508                                         cancel_delayed_work_sync(&sensor->delaywork);   \r
1509                                         \r
1510                                         sensor->status_cur = SENSOR_OFF;\r
1511                                 }\r
1512                         }\r
1513                         mutex_unlock(&sensor->operation_mutex);\r
1514                         DBG("%s:LIGHTSENSOR_IOCTL_ENABLE OK\n", __func__);\r
1515                         break;\r
1516                 \r
1517                 default:\r
1518                         break;\r
1519         }\r
1520         \r
1521 error:\r
1522         return result;\r
1523 }\r
1524 \r
1525 \r
1526 \r
1527 \r
1528 static int sensor_misc_device_register(struct sensor_private_data *sensor, int type)\r
1529 {\r
1530         int result = 0;\r
1531         \r
1532         switch(type)\r
1533         {\r
1534                 case SENSOR_TYPE_ANGLE:\r
1535                         if(!sensor->ops->misc_dev)\r
1536                         {\r
1537                                 sensor->fops.owner = THIS_MODULE;\r
1538                                 sensor->fops.unlocked_ioctl = angle_dev_ioctl;\r
1539                                 sensor->fops.open = angle_dev_open;\r
1540                                 sensor->fops.release = angle_dev_release;\r
1541 \r
1542                                 sensor->miscdev.minor = MISC_DYNAMIC_MINOR;\r
1543                                 sensor->miscdev.name = "angle";\r
1544                                 sensor->miscdev.fops = &sensor->fops;\r
1545                         }\r
1546                         else\r
1547                         {\r
1548                                 memcpy(&sensor->miscdev, sensor->ops->misc_dev, sizeof(*sensor->ops->misc_dev));\r
1549 \r
1550                         }\r
1551                                 \r
1552                         break;\r
1553                         \r
1554                 case SENSOR_TYPE_ACCEL:\r
1555                         if(!sensor->ops->misc_dev)\r
1556                         {\r
1557                                 sensor->fops.owner = THIS_MODULE;\r
1558                                 sensor->fops.unlocked_ioctl = gsensor_dev_ioctl;\r
1559                 #ifdef CONFIG_COMPAT\r
1560                                 sensor->fops.compat_ioctl = gsensor_dev_ioctl;\r
1561                                 #endif\r
1562                                 sensor->fops.open = gsensor_dev_open;\r
1563                                 sensor->fops.release = gsensor_dev_release;\r
1564 \r
1565                                 sensor->miscdev.minor = MISC_DYNAMIC_MINOR;\r
1566                                 sensor->miscdev.name = "mma8452_daemon";\r
1567                                 sensor->miscdev.fops = &sensor->fops;\r
1568                         }\r
1569                         else\r
1570                         {\r
1571                                 memcpy(&sensor->miscdev, sensor->ops->misc_dev, sizeof(*sensor->ops->misc_dev));\r
1572 \r
1573                         }\r
1574                                 \r
1575                         break;\r
1576 \r
1577                 case SENSOR_TYPE_COMPASS:                       \r
1578                         if(!sensor->ops->misc_dev)\r
1579                         {\r
1580                                 sensor->fops.owner = THIS_MODULE;\r
1581                                 sensor->fops.unlocked_ioctl = compass_dev_ioctl;\r
1582 #ifdef CONFIG_COMPAT
1583                                 sensor->fops.compat_ioctl = compass_dev_compat_ioctl;
1584 #endif
1585                                 sensor->fops.open = compass_dev_open;\r
1586                                 sensor->fops.release = compass_dev_release;\r
1587 \r
1588                                 sensor->miscdev.minor = MISC_DYNAMIC_MINOR;\r
1589                                 sensor->miscdev.name = "compass";\r
1590                                 sensor->miscdev.fops = &sensor->fops;\r
1591                         }\r
1592                         else\r
1593                         {\r
1594                                 memcpy(&sensor->miscdev, sensor->ops->misc_dev, sizeof(*sensor->ops->misc_dev));\r
1595 \r
1596                         }\r
1597 \r
1598                         break;\r
1599 \r
1600                 case SENSOR_TYPE_GYROSCOPE:                     \r
1601                         if(!sensor->ops->misc_dev)\r
1602                         {\r
1603                                 sensor->fops.owner = THIS_MODULE;\r
1604                                 sensor->fops.unlocked_ioctl = gyro_dev_ioctl;\r
1605                                 sensor->fops.open = gyro_dev_open;\r
1606                                 sensor->fops.release = gyro_dev_release;\r
1607 \r
1608                                 sensor->miscdev.minor = MISC_DYNAMIC_MINOR;\r
1609                                 sensor->miscdev.name = "gyrosensor";\r
1610                                 sensor->miscdev.fops = &sensor->fops;\r
1611                         }\r
1612                         else\r
1613                         {\r
1614                                 memcpy(&sensor->miscdev, sensor->ops->misc_dev, sizeof(*sensor->ops->misc_dev));\r
1615 \r
1616                         }\r
1617                         \r
1618                         break;\r
1619 \r
1620                 case SENSOR_TYPE_LIGHT:\r
1621                         if(!sensor->ops->misc_dev)\r
1622                         {\r
1623                                 sensor->fops.owner = THIS_MODULE;\r
1624                                 sensor->fops.unlocked_ioctl = light_dev_ioctl;\r
1625 #ifdef CONFIG_COMPAT
1626                                 sensor->fops.compat_ioctl = light_dev_compat_ioctl;
1627 #endif
1628                                 sensor->fops.open = light_dev_open;\r
1629                                 sensor->fops.release = light_dev_release;\r
1630 \r
1631                                 sensor->miscdev.minor = MISC_DYNAMIC_MINOR;\r
1632                                 sensor->miscdev.name = "lightsensor";\r
1633                                 sensor->miscdev.fops = &sensor->fops;\r
1634                         }       \r
1635                         else\r
1636                         {\r
1637                                 memcpy(&sensor->miscdev, sensor->ops->misc_dev, sizeof(*sensor->ops->misc_dev));\r
1638 \r
1639                         }\r
1640                         break;\r
1641                 \r
1642                 case SENSOR_TYPE_PROXIMITY:\r
1643                         if(!sensor->ops->misc_dev)\r
1644                         {\r
1645                                 sensor->fops.owner = THIS_MODULE;\r
1646                                 sensor->fops.unlocked_ioctl = proximity_dev_ioctl;\r
1647 #ifdef CONFIG_COMPAT
1648                                 sensor->fops.compat_ioctl = proximity_dev_compat_ioctl;
1649 #endif
1650                                 sensor->fops.open = proximity_dev_open;\r
1651                                 sensor->fops.release = proximity_dev_release;\r
1652 \r
1653                                 sensor->miscdev.minor = MISC_DYNAMIC_MINOR;\r
1654                                 sensor->miscdev.name = "psensor";\r
1655                                 sensor->miscdev.fops = &sensor->fops;\r
1656                         }       \r
1657                         else\r
1658                         {\r
1659                                 memcpy(&sensor->miscdev, sensor->ops->misc_dev, sizeof(*sensor->ops->misc_dev));\r
1660 \r
1661                         }\r
1662                         break;\r
1663 \r
1664                 case SENSOR_TYPE_TEMPERATURE:\r
1665                         if(!sensor->ops->misc_dev)\r
1666                         {\r
1667                                 sensor->fops.owner = THIS_MODULE;\r
1668                                 sensor->fops.unlocked_ioctl = temperature_dev_ioctl;\r
1669                                 sensor->fops.open = temperature_dev_open;\r
1670                                 sensor->fops.release = temperature_dev_release;\r
1671 \r
1672                                 sensor->miscdev.minor = MISC_DYNAMIC_MINOR;\r
1673                                 sensor->miscdev.name = "temperature";\r
1674                                 sensor->miscdev.fops = &sensor->fops;\r
1675                         }       \r
1676                         else\r
1677                         {\r
1678                                 memcpy(&sensor->miscdev, sensor->ops->misc_dev, sizeof(*sensor->ops->misc_dev));\r
1679 \r
1680                         }\r
1681                                 \r
1682                         break;\r
1683 \r
1684                 case SENSOR_TYPE_PRESSURE:\r
1685                         if(!sensor->ops->misc_dev)\r
1686                         {\r
1687                                 sensor->fops.owner = THIS_MODULE;\r
1688                                 sensor->fops.unlocked_ioctl = pressure_dev_ioctl;\r
1689                                 sensor->fops.open = pressure_dev_open;\r
1690                                 sensor->fops.release = pressure_dev_release;\r
1691 \r
1692                                 sensor->miscdev.minor = MISC_DYNAMIC_MINOR;\r
1693                                 sensor->miscdev.name = "pressure";\r
1694                                 sensor->miscdev.fops = &sensor->fops;\r
1695                         }       \r
1696                         else\r
1697                         {\r
1698                                 memcpy(&sensor->miscdev, sensor->ops->misc_dev, sizeof(*sensor->ops->misc_dev));\r
1699 \r
1700                         }\r
1701                                 \r
1702                         break;\r
1703 \r
1704                 default:\r
1705                         printk("%s:unknow sensor type=%d\n",__func__,type);\r
1706                         result = -1;\r
1707                         goto error;\r
1708         }\r
1709                         \r
1710         sensor->miscdev.parent = &sensor->client->dev;\r
1711         result = misc_register(&sensor->miscdev);\r
1712         if (result < 0) {\r
1713                 dev_err(&sensor->client->dev,\r
1714                         "fail to register misc device %s\n", sensor->miscdev.name);\r
1715                 goto error;\r
1716         }\r
1717         \r
1718         printk("%s:miscdevice: %s\n",__func__,sensor->miscdev.name);\r
1719 \r
1720 error:  \r
1721         \r
1722         return result;\r
1723 \r
1724 }\r
1725 \r
1726 int sensor_register_slave(int type,struct i2c_client *client,\r
1727                         struct sensor_platform_data *slave_pdata,\r
1728                         struct sensor_operate *(*get_sensor_ops)(void))\r
1729 {\r
1730         int result = 0;\r
1731         struct sensor_operate *ops = get_sensor_ops();\r
1732         if((ops->id_i2c >= SENSOR_NUM_ID) || (ops->id_i2c <= ID_INVALID))\r
1733         {       \r
1734                 printk("%s:%s id is error %d\n", __func__, ops->name, ops->id_i2c);\r
1735                 return -1;      \r
1736         }\r
1737         sensor_ops[ops->id_i2c] = ops;\r
1738         printk("%s:%s,id=%d\n",__func__,sensor_ops[ops->id_i2c]->name, ops->id_i2c);\r
1739         return result;\r
1740 }\r
1741 \r
1742 \r
1743 int sensor_unregister_slave(int type,struct i2c_client *client,\r
1744                         struct sensor_platform_data *slave_pdata,\r
1745                         struct sensor_operate *(*get_sensor_ops)(void))\r
1746 {\r
1747         int result = 0;\r
1748         struct sensor_operate *ops = get_sensor_ops();\r
1749         if((ops->id_i2c >= SENSOR_NUM_ID) || (ops->id_i2c <= ID_INVALID))\r
1750         {       \r
1751                 printk("%s:%s id is error %d\n", __func__, ops->name, ops->id_i2c);\r
1752                 return -1;      \r
1753         }\r
1754         printk("%s:%s,id=%d\n",__func__,sensor_ops[ops->id_i2c]->name, ops->id_i2c);\r
1755         sensor_ops[ops->id_i2c] = NULL; \r
1756         return result;\r
1757 }\r
1758 \r
1759 \r
1760 int sensor_probe(struct i2c_client *client, const struct i2c_device_id *devid)\r
1761 {\r
1762         struct sensor_private_data *sensor =\r
1763             (struct sensor_private_data *) i2c_get_clientdata(client);\r
1764         struct sensor_platform_data *pdata;\r
1765         struct device_node *np = client->dev.of_node;\r
1766         enum of_gpio_flags rst_flags, pwr_flags;\r
1767         unsigned long irq_flags;\r
1768         int result = 0;\r
1769         int type = 0;\r
1770         \r
1771         dev_info(&client->adapter->dev, "%s: %s,%p\n", __func__, devid->name, client);\r
1772 \r
1773         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {\r
1774                 result = -ENODEV;\r
1775                 goto out_no_free;\r
1776         }\r
1777         if (!np) {\r
1778                 dev_err(&client->dev, "no device tree\n");\r
1779                 return -EINVAL;\r
1780         }\r
1781     pdata = devm_kzalloc(&client->dev,sizeof(*pdata), GFP_KERNEL);\r
1782         if (!pdata) {\r
1783                 result = -ENOMEM;\r
1784                 goto out_no_free;\r
1785         }\r
1786         sensor = devm_kzalloc(&client->dev,sizeof(*sensor), GFP_KERNEL);\r
1787         if (!sensor) {\r
1788                 result = -ENOMEM;\r
1789                 goto out_no_free;\r
1790         }\r
1791         \r
1792         of_property_read_u32(np,"type",&(pdata->type));\r
1793 \r
1794         pdata->irq_pin = of_get_named_gpio_flags(np, "irq-gpio", 0,(enum of_gpio_flags *)&irq_flags);\r
1795         pdata->reset_pin = of_get_named_gpio_flags(np, "reset-gpio",0,&rst_flags);\r
1796         pdata->power_pin = of_get_named_gpio_flags(np, "power-gpio",0,&pwr_flags);\r
1797         \r
1798         of_property_read_u32(np,"irq_enable",&(pdata->irq_enable));\r
1799         of_property_read_u32(np,"poll_delay_ms",&(pdata->poll_delay_ms));\r
1800 \r
1801         of_property_read_u32(np,"x_min",&(pdata->x_min));\r
1802         of_property_read_u32(np,"y_min",&(pdata->y_min));\r
1803         of_property_read_u32(np,"z_min",&(pdata->z_min));\r
1804         of_property_read_u32(np,"factory",&(pdata->factory));\r
1805         of_property_read_u32(np,"layout",&(pdata->layout));\r
1806 \r
1807         of_property_read_u8(np,"address",&(pdata->address));\r
1808         of_get_property(np, "project_name", pdata->project_name);\r
1809 \r
1810 \r
1811         switch(pdata->layout)\r
1812         {\r
1813                 case 1:\r
1814                         pdata->orientation[0] = 1;\r
1815                         pdata->orientation[1] = 0;\r
1816                         pdata->orientation[2] = 0;\r
1817 \r
1818                         pdata->orientation[3] = 0;\r
1819                         pdata->orientation[4] = 1;\r
1820                         pdata->orientation[5] = 0;\r
1821 \r
1822                         pdata->orientation[6] = 0;\r
1823                         pdata->orientation[7] = 0;\r
1824                         pdata->orientation[8] = 1;\r
1825                         break;\r
1826 \r
1827                 case 2:\r
1828                         pdata->orientation[0] = 0;\r
1829                         pdata->orientation[1] = -1;\r
1830                         pdata->orientation[2] = 0;\r
1831 \r
1832                         pdata->orientation[3] = 1;\r
1833                         pdata->orientation[4] = 0;\r
1834                         pdata->orientation[5] = 0;\r
1835 \r
1836                         pdata->orientation[6] = 0;\r
1837                         pdata->orientation[7] = 0;\r
1838                         pdata->orientation[8] = 1;\r
1839                         break;\r
1840 \r
1841                 case 3:\r
1842                         pdata->orientation[0] = -1;\r
1843                         pdata->orientation[1] = 0;\r
1844                         pdata->orientation[2] = 0;\r
1845 \r
1846                         pdata->orientation[3] = 0;\r
1847                         pdata->orientation[4] = -1;\r
1848                         pdata->orientation[5] = 0;\r
1849 \r
1850                         pdata->orientation[6] = 0;\r
1851                         pdata->orientation[7] = 0;\r
1852                         pdata->orientation[8] = 1;\r
1853                         break;\r
1854 \r
1855                 case 4:\r
1856                         pdata->orientation[0] = 0;\r
1857                         pdata->orientation[1] = 1;\r
1858                         pdata->orientation[2] = 0;\r
1859 \r
1860                         pdata->orientation[3] = -1;\r
1861                         pdata->orientation[4] = 0;\r
1862                         pdata->orientation[5] = 0;\r
1863 \r
1864                         pdata->orientation[6] = 0;\r
1865                         pdata->orientation[7] = 0;\r
1866                         pdata->orientation[8] = 1;\r
1867                         break;\r
1868 \r
1869                 case 5:\r
1870                         pdata->orientation[0] = 1;\r
1871                         pdata->orientation[1] = 0;\r
1872                         pdata->orientation[2] = 0;\r
1873 \r
1874                         pdata->orientation[3] = 0;\r
1875                         pdata->orientation[4] = -1;\r
1876                         pdata->orientation[5] = 0;\r
1877 \r
1878                         pdata->orientation[6] = 0;\r
1879                         pdata->orientation[7] = 0;\r
1880                         pdata->orientation[8] = -1;\r
1881                         break;\r
1882 \r
1883                 case 6:\r
1884                         pdata->orientation[0] = 0;\r
1885                         pdata->orientation[1] = -1;\r
1886                         pdata->orientation[2] = 0;\r
1887 \r
1888                         pdata->orientation[3] = -1;\r
1889                         pdata->orientation[4] = 0;\r
1890                         pdata->orientation[5] = 0;\r
1891 \r
1892                         pdata->orientation[6] = 0;\r
1893                         pdata->orientation[7] = 0;\r
1894                         pdata->orientation[8] = -1;\r
1895                         break;\r
1896 \r
1897                 case 7:\r
1898                         pdata->orientation[0] = -1;\r
1899                         pdata->orientation[1] = 0;\r
1900                         pdata->orientation[2] = 0;\r
1901 \r
1902                         pdata->orientation[3] = 0;\r
1903                         pdata->orientation[4] = 1;\r
1904                         pdata->orientation[5] = 0;\r
1905 \r
1906                         pdata->orientation[6] = 0;\r
1907                         pdata->orientation[7] = 0;\r
1908                         pdata->orientation[8] = -1;\r
1909                         break;\r
1910 \r
1911                 case 8:\r
1912                         pdata->orientation[0] = 0;\r
1913                         pdata->orientation[1] = 1;\r
1914                         pdata->orientation[2] = 0;\r
1915 \r
1916                         pdata->orientation[3] = 1;\r
1917                         pdata->orientation[4] = 0;\r
1918                         pdata->orientation[5] = 0;\r
1919 \r
1920                         pdata->orientation[6] = 0;\r
1921                         pdata->orientation[7] = 0;\r
1922                         pdata->orientation[8] = -1;\r
1923                         break;\r
1924 \r
1925                 default:\r
1926                         pdata->orientation[0] = 1;\r
1927                         pdata->orientation[1] = 0;\r
1928                         pdata->orientation[2] = 0;\r
1929 \r
1930                         pdata->orientation[3] = 0;\r
1931                         pdata->orientation[4] = 1;\r
1932                         pdata->orientation[5] = 0;\r
1933 \r
1934                         pdata->orientation[6] = 0;\r
1935                         pdata->orientation[7] = 0;\r
1936                         pdata->orientation[8] = 1;\r
1937                         break;\r
1938         }\r
1939 \r
1940         client->irq = pdata->irq_pin;\r
1941         type = pdata->type;\r
1942         pdata->irq_flags = irq_flags;\r
1943         DBG("irq_flags = %lu  padta->irq_flags = %lu\n",irq_flags, pdata->irq_flags);\r
1944         DBG("type = %d \n",pdata->type);\r
1945         DBG("irq = %d \n",pdata->irq);\r
1946         DBG("irq_pin = %d \n",pdata->irq_pin);\r
1947         DBG("pwer_pin = %d \n",pdata->power_pin);       \r
1948         DBG("reset_pin = %d \n",pdata->reset_pin);\r
1949         DBG("irq_enable = %d \n",pdata->irq_enable);\r
1950 \r
1951         DBG("poll_delay_ms = %d \n",pdata->poll_delay_ms);\r
1952         DBG("x_min = %d \n",pdata->x_min);\r
1953         DBG("y_min = %d \n",pdata->y_min);\r
1954         DBG("z_min = %d \n",pdata->z_min);      \r
1955         DBG("factory = %d \n",pdata->factory);\r
1956         DBG("layout = %d \n",pdata->layout);\r
1957         DBG("address = 0x%x \n",pdata->address);\r
1958         DBG("project_name = [%s] \n",pdata->project_name);\r
1959         \r
1960         DBG(" == %d,%d ,%d \t ,%d ,%d ,%d , \t ,%d, %d, %d ,==%d\n",pdata->orientation[0],pdata->orientation[1],pdata->orientation[2]\r
1961                                 ,pdata->orientation[3],pdata->orientation[4],pdata->orientation[5]\r
1962                                 ,pdata->orientation[6],pdata->orientation[7],pdata->orientation[8],ARRAY_SIZE(pdata->orientation));\r
1963                 \r
1964         \r
1965         if((type >= SENSOR_NUM_TYPES) || (type <= SENSOR_TYPE_NULL))\r
1966         {       \r
1967                 dev_err(&client->adapter->dev, "sensor type is error %d\n", type);\r
1968                 result = -EFAULT;\r
1969                 goto out_no_free;       \r
1970         }\r
1971         if(((int)devid->driver_data >= SENSOR_NUM_ID) || ((int)devid->driver_data <= ID_INVALID))\r
1972         {       \r
1973                 dev_err(&client->adapter->dev, "sensor id is error %d\n", (int)devid->driver_data);\r
1974                 result = -EFAULT;\r
1975                 goto out_no_free;       \r
1976         }\r
1977         i2c_set_clientdata(client, sensor);\r
1978         sensor->client = client;        \r
1979         sensor->pdata = pdata;  \r
1980         sensor->type = type;\r
1981         sensor->i2c_id = (struct i2c_device_id *)devid;\r
1982 \r
1983                 \r
1984         memset(&(sensor->axis), 0, sizeof(struct sensor_axis) );\r
1985         atomic_set(&(sensor->data_ready), 0);\r
1986         init_waitqueue_head(&(sensor->data_ready_wq));\r
1987         mutex_init(&sensor->data_mutex);        \r
1988         mutex_init(&sensor->operation_mutex);   \r
1989         mutex_init(&sensor->sensor_mutex);\r
1990         mutex_init(&sensor->i2c_mutex);\r
1991 \r
1992         /* As default, report all information */\r
1993         atomic_set(&sensor->flags.m_flag, 1);\r
1994         atomic_set(&sensor->flags.a_flag, 1);\r
1995         atomic_set(&sensor->flags.mv_flag, 1);                  \r
1996         atomic_set(&sensor->flags.open_flag, 0);\r
1997         atomic_set(&sensor->flags.debug_flag, 1);\r
1998         init_waitqueue_head(&sensor->flags.open_wq);\r
1999         sensor->flags.delay = 100;\r
2000 \r
2001         sensor->status_cur = SENSOR_OFF;\r
2002         sensor->axis.x = 0;\r
2003         sensor->axis.y = 0;\r
2004         sensor->axis.z = 0;\r
2005         \r
2006         result = sensor_chip_init(sensor->client);\r
2007         if(result < 0)\r
2008                 goto out_free_memory;\r
2009         \r
2010         sensor->input_dev = input_allocate_device();\r
2011         if (!sensor->input_dev) {\r
2012                 result = -ENOMEM;\r
2013                 dev_err(&client->dev,\r
2014                         "Failed to allocate input device %s\n", sensor->input_dev->name);\r
2015                 goto out_free_memory;\r
2016         }       \r
2017 \r
2018         switch(type)\r
2019         {\r
2020                 case SENSOR_TYPE_ANGLE: \r
2021                         sensor->input_dev->name = "angle";\r
2022                         set_bit(EV_ABS, sensor->input_dev->evbit);\r
2023                         /* x-axis acceleration */\r
2024                         input_set_abs_params(sensor->input_dev, ABS_X, sensor->ops->range[0], sensor->ops->range[1], 0, 0); //2g full scale range\r
2025                         /* y-axis acceleration */\r
2026                         input_set_abs_params(sensor->input_dev, ABS_Y, sensor->ops->range[0], sensor->ops->range[1], 0, 0); //2g full scale range\r
2027                         /* z-axis acceleration */\r
2028                         input_set_abs_params(sensor->input_dev, ABS_Z, sensor->ops->range[0], sensor->ops->range[1], 0, 0); //2g full scale range\r
2029                         break;  \r
2030 \r
2031                 case SENSOR_TYPE_ACCEL: \r
2032                         sensor->input_dev->name = "gsensor";\r
2033                         set_bit(EV_ABS, sensor->input_dev->evbit);\r
2034                         /* x-axis acceleration */\r
2035                         input_set_abs_params(sensor->input_dev, ABS_X, sensor->ops->range[0], sensor->ops->range[1], 0, 0); //2g full scale range\r
2036                         /* y-axis acceleration */\r
2037                         input_set_abs_params(sensor->input_dev, ABS_Y, sensor->ops->range[0], sensor->ops->range[1], 0, 0); //2g full scale range\r
2038                         /* z-axis acceleration */\r
2039                         input_set_abs_params(sensor->input_dev, ABS_Z, sensor->ops->range[0], sensor->ops->range[1], 0, 0); //2g full scale range\r
2040                         break;          \r
2041                 case SENSOR_TYPE_COMPASS:       \r
2042                         sensor->input_dev->name = "compass";            \r
2043                         /* Setup input device */\r
2044                         set_bit(EV_ABS, sensor->input_dev->evbit);\r
2045                         /* yaw (0, 360) */\r
2046                         input_set_abs_params(sensor->input_dev, ABS_RX, 0, 23040, 0, 0);\r
2047                         /* pitch (-180, 180) */\r
2048                         input_set_abs_params(sensor->input_dev, ABS_RY, -11520, 11520, 0, 0);\r
2049                         /* roll (-90, 90) */\r
2050                         input_set_abs_params(sensor->input_dev, ABS_RZ, -5760, 5760, 0, 0);\r
2051                         /* x-axis acceleration (720 x 8G) */\r
2052                         input_set_abs_params(sensor->input_dev, ABS_X, -5760, 5760, 0, 0);\r
2053                         /* y-axis acceleration (720 x 8G) */\r
2054                         input_set_abs_params(sensor->input_dev, ABS_Y, -5760, 5760, 0, 0);\r
2055                         /* z-axis acceleration (720 x 8G) */\r
2056                         input_set_abs_params(sensor->input_dev, ABS_Z, -5760, 5760, 0, 0);\r
2057                         /* status of magnetic sensor */\r
2058                         input_set_abs_params(sensor->input_dev, ABS_RUDDER, -32768, 3, 0, 0);\r
2059                         /* status of acceleration sensor */\r
2060                         input_set_abs_params(sensor->input_dev, ABS_WHEEL, -32768, 3, 0, 0);\r
2061                         /* x-axis of raw magnetic vector (-4096, 4095) */\r
2062                         input_set_abs_params(sensor->input_dev, ABS_HAT0X, -20480, 20479, 0, 0);\r
2063                         /* y-axis of raw magnetic vector (-4096, 4095) */\r
2064                         input_set_abs_params(sensor->input_dev, ABS_HAT0Y, -20480, 20479, 0, 0);\r
2065                         /* z-axis of raw magnetic vector (-4096, 4095) */\r
2066                         input_set_abs_params(sensor->input_dev, ABS_BRAKE, -20480, 20479, 0, 0);\r
2067                         break;          \r
2068                 case SENSOR_TYPE_GYROSCOPE:\r
2069                         sensor->input_dev->name = "gyro";\r
2070                         /* x-axis acceleration */\r
2071                         input_set_capability(sensor->input_dev, EV_REL, REL_RX);\r
2072                         input_set_abs_params(sensor->input_dev, ABS_RX, sensor->ops->range[0], sensor->ops->range[1], 0, 0); \r
2073                         /* y-axis acceleration */       \r
2074                         input_set_capability(sensor->input_dev, EV_REL, REL_RY);\r
2075                         input_set_abs_params(sensor->input_dev, ABS_RY, sensor->ops->range[0], sensor->ops->range[1], 0, 0); \r
2076                         /* z-axis acceleration */\r
2077                         input_set_capability(sensor->input_dev, EV_REL, REL_RZ);\r
2078                         input_set_abs_params(sensor->input_dev, ABS_RZ, sensor->ops->range[0], sensor->ops->range[1], 0, 0); \r
2079                         break;\r
2080                 case SENSOR_TYPE_LIGHT:\r
2081                         sensor->input_dev->name = "lightsensor-level";\r
2082                         set_bit(EV_ABS, sensor->input_dev->evbit);\r
2083                         input_set_abs_params(sensor->input_dev, ABS_MISC, sensor->ops->range[0], sensor->ops->range[1], 0, 0);                  \r
2084                         input_set_abs_params(sensor->input_dev, ABS_TOOL_WIDTH ,  sensor->ops->brightness[0],sensor->ops->brightness[1], 0, 0);\r
2085                         break;\r
2086                 case SENSOR_TYPE_PROXIMITY:\r
2087                         sensor->input_dev->name = "proximity";  \r
2088                         set_bit(EV_ABS, sensor->input_dev->evbit);\r
2089                         input_set_abs_params(sensor->input_dev, ABS_DISTANCE, sensor->ops->range[0], sensor->ops->range[1], 0, 0);\r
2090                         break;\r
2091                 case SENSOR_TYPE_TEMPERATURE:                           \r
2092                         sensor->input_dev->name = "temperature";\r
2093                         set_bit(EV_ABS, sensor->input_dev->evbit);              \r
2094                         input_set_abs_params(sensor->input_dev, ABS_THROTTLE, sensor->ops->range[0], sensor->ops->range[1], 0, 0);\r
2095                         break;\r
2096                 case SENSOR_TYPE_PRESSURE:                              \r
2097                         sensor->input_dev->name = "pressure";\r
2098                         set_bit(EV_ABS, sensor->input_dev->evbit);              \r
2099                         input_set_abs_params(sensor->input_dev, ABS_PRESSURE, sensor->ops->range[0], sensor->ops->range[1], 0, 0);\r
2100                         break;\r
2101                 default:\r
2102                         printk("%s:unknow sensor type=%d\n",__func__,type);\r
2103                         break;\r
2104 \r
2105         }\r
2106         sensor->input_dev->dev.parent = &client->dev;\r
2107 \r
2108         result = input_register_device(sensor->input_dev);\r
2109         if (result) {\r
2110                 dev_err(&client->dev,\r
2111                         "Unable to register input device %s\n", sensor->input_dev->name);\r
2112                 goto out_input_register_device_failed;\r
2113         }\r
2114 \r
2115         result = sensor_irq_init(sensor->client);\r
2116         if (result) {\r
2117                 dev_err(&client->dev,\r
2118                         "fail to init sensor irq,ret=%d\n",result);\r
2119                 goto out_input_register_device_failed;\r
2120         }\r
2121 \r
2122         \r
2123         sensor->miscdev.parent = &client->dev;\r
2124         result = sensor_misc_device_register(sensor, type);\r
2125         if (result) {\r
2126                 dev_err(&client->dev,\r
2127                         "fail to register misc device %s\n", sensor->miscdev.name);\r
2128                 goto out_misc_device_register_device_failed;\r
2129         }\r
2130         \r
2131         g_sensor[type] = sensor;\r
2132 \r
2133         if((type == SENSOR_TYPE_ACCEL) && (sensor->pdata->factory))     //only support  setting gsensor orientation online now  \r
2134         {\r
2135                 result = gsensor_class_init();\r
2136                 if (result) {\r
2137                         dev_err(&client->dev,\r
2138                                 "fail to register misc device %s\n", sensor->i2c_id->name);\r
2139                         goto out_misc_device_register_device_failed;\r
2140                 }\r
2141         }       \r
2142         \r
2143 #ifdef CONFIG_HAS_EARLYSUSPEND\r
2144         if((sensor->ops->suspend) && (sensor->ops->resume))\r
2145         {\r
2146                 sensor->early_suspend.suspend = sensor_suspend;\r
2147                 sensor->early_suspend.resume = sensor_resume;\r
2148                 sensor->early_suspend.level = 0x02;\r
2149                 register_early_suspend(&sensor->early_suspend);\r
2150         }\r
2151 #endif\r
2152 \r
2153         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
2154 \r
2155         return result;\r
2156         \r
2157 out_misc_device_register_device_failed:\r
2158         input_unregister_device(sensor->input_dev);     \r
2159 out_input_register_device_failed:\r
2160         input_free_device(sensor->input_dev);   \r
2161 out_free_memory:\r
2162         //kfree(sensor);\r
2163 out_no_free:\r
2164         dev_err(&client->adapter->dev, "%s failed %d\n\n", __func__, result);\r
2165         return result;\r
2166 \r
2167 }\r
2168 \r
2169 static void sensor_shut_down(struct i2c_client *client)\r
2170 {\r
2171 #ifdef CONFIG_HAS_EARLYSUSPEND\r
2172         struct sensor_private_data *sensor =\r
2173             (struct sensor_private_data *) i2c_get_clientdata(client);\r
2174         if((sensor->ops->suspend) && (sensor->ops->resume))             \r
2175                 unregister_early_suspend(&sensor->early_suspend);\r
2176         DBG("%s:%s\n",__func__,sensor->i2c_id->name);\r
2177 #endif\r
2178 }\r
2179 \r
2180 static int sensor_remove(struct i2c_client *client)\r
2181 {\r
2182         struct sensor_private_data *sensor =\r
2183             (struct sensor_private_data *) i2c_get_clientdata(client);\r
2184         int result = 0;\r
2185         \r
2186         cancel_delayed_work_sync(&sensor->delaywork);\r
2187         misc_deregister(&sensor->miscdev);\r
2188         input_unregister_device(sensor->input_dev);     \r
2189         input_free_device(sensor->input_dev);   \r
2190         kfree(sensor);\r
2191 #ifdef CONFIG_HAS_EARLYSUSPEND\r
2192         if((sensor->ops->suspend) && (sensor->ops->resume))\r
2193                 unregister_early_suspend(&sensor->early_suspend);\r
2194 #endif  \r
2195         return result;\r
2196 }\r
2197 \r
2198 static const struct i2c_device_id sensor_id[] = {\r
2199         /*angle*/       \r
2200         {"angle_kxtik", ANGLE_ID_KXTIK},\r
2201         {"angle_lis3dh", ANGLE_ID_LIS3DH},      \r
2202         /*gsensor*/\r
2203         {"gsensor", ACCEL_ID_ALL},\r
2204         {"gs_mma8452", ACCEL_ID_MMA845X},       \r
2205         {"gs_kxtik", ACCEL_ID_KXTIK},   \r
2206         {"gs_kxtj9", ACCEL_ID_KXTJ9},\r
2207         {"gs_lis3dh", ACCEL_ID_LIS3DH},\r
2208         {"gs_mma7660", ACCEL_ID_MMA7660},\r
2209         {"gs_mxc6225", ACCEL_ID_MXC6225},       \r
2210         {"gs_dmard10", ACCEL_ID_DMARD10},\r
2211         {"gs_lsm303d", ACCEL_ID_LSM303D},\r
2212         {"gs_mc3230",ACCEL_ID_MC3230},\r
2213         {"mpu6880_acc",ACCEL_ID_MPU6880},\r
2214         {"mpu6500_acc",ACCEL_ID_MPU6500},\r
2215         /*compass*/\r
2216         {"compass", COMPASS_ID_ALL},\r
2217         {"ak8975", COMPASS_ID_AK8975},  \r
2218         {"ak8963", COMPASS_ID_AK8963},\r
2219         {"ak09911", COMPASS_ID_AK09911},\r
2220         {"mmc314x", COMPASS_ID_MMC314X},\r
2221         /*gyroscope*/\r
2222         {"gyro", GYRO_ID_ALL},  \r
2223         {"l3g4200d_gyro", GYRO_ID_L3G4200D},\r
2224         {"l3g20d_gyro", GYRO_ID_L3G20D},\r
2225         {"ewtsa_gyro", GYRO_ID_EWTSA},\r
2226         {"k3g", GYRO_ID_K3G},\r
2227         {"mpu6880_gyro",GYRO_ID_MPU6880},\r
2228         /*light sensor*/\r
2229         {"lightsensor", LIGHT_ID_ALL},  \r
2230         {"light_cm3217", LIGHT_ID_CM3217},\r
2231         {"light_cm3218", LIGHT_ID_CM3218},\r
2232         {"light_cm3232", LIGHT_ID_CM3232},\r
2233         {"light_al3006", LIGHT_ID_AL3006},\r
2234         {"ls_stk3171", LIGHT_ID_STK3171},\r
2235         {"ls_isl29023", LIGHT_ID_ISL29023},\r
2236         {"ls_ap321xx", LIGHT_ID_AP321XX},\r
2237         {"ls_photoresistor", LIGHT_ID_PHOTORESISTOR},\r
2238         {"ls_us5152", LIGHT_ID_US5152},\r
2239         /*proximity sensor*/\r
2240         {"psensor", PROXIMITY_ID_ALL},\r
2241         {"proximity_al3006", PROXIMITY_ID_AL3006},      \r
2242         {"ps_stk3171", PROXIMITY_ID_STK3171},\r
2243         {"ps_ap321xx", PROXIMITY_ID_AP321XX},\r
2244         \r
2245         /*temperature*/\r
2246         {"temperature", TEMPERATURE_ID_ALL},    \r
2247         {"tmp_ms5607", TEMPERATURE_ID_MS5607},\r
2248 \r
2249         /*pressure*/\r
2250         {"pressure", PRESSURE_ID_ALL},\r
2251         {"pr_ms5607", PRESSURE_ID_MS5607},\r
2252         \r
2253         {},\r
2254 };\r
2255 \r
2256 static struct of_device_id sensor_dt_ids[] = {\r
2257         /*gsensor*/\r
2258         { .compatible = "gs_mma8452" },\r
2259         { .compatible = "gs_lis3dh" },\r
2260         { .compatible = "gs_lsm303d" },\r
2261         { .compatible = "gs_mma7660" },\r
2262         { .compatible = "gs_mxc6225" },\r
2263         { .compatible = "gs_mc3230" },\r
2264         \r
2265         /*compass*/\r
2266         { .compatible = "ak8975" },\r
2267         { .compatible = "ak8963" },\r
2268         { .compatible = "ak09911" },\r
2269         { .compatible = "mmc314x" },\r
2270 \r
2271         /* gyroscop*/\r
2272         { .compatible = "l3g4200d_gyro" },\r
2273         { .compatible = "l3g20d_gyro" },\r
2274         { .compatible = "ewtsa_gyro" },\r
2275         { .compatible = "k3g" },\r
2276         \r
2277         \r
2278         /*light sensor*/\r
2279         { .compatible = "light_cm3217" },\r
2280         { .compatible = "light_cm3232" },\r
2281         { .compatible = "light_al3006" },\r
2282         { .compatible = "ls_stk3171" },\r
2283         { .compatible = "ls_ap321xx" },\r
2284 \r
2285         { .compatible = "ls_photoresistor" },\r
2286         { .compatible = "ls_us5152" },\r
2287 \r
2288         /*temperature sensor*/\r
2289         { .compatible = "tmp_ms5607" },\r
2290         \r
2291         /*pressure sensor*/\r
2292         { .compatible = "pr_ms5607" },\r
2293 \r
2294         /*hall sensor*/\r
2295         { .compatible = "hall_och165t" },\r
2296         { }\r
2297 };\r
2298 \r
2299 \r
2300 static struct i2c_driver sensor_driver = {\r
2301         .probe = sensor_probe,\r
2302         .remove = sensor_remove,\r
2303         .shutdown = sensor_shut_down,\r
2304         .id_table = sensor_id,\r
2305         .driver = {\r
2306                    .owner = THIS_MODULE,\r
2307                    .name = "sensors",\r
2308                    .of_match_table = of_match_ptr(sensor_dt_ids),\r
2309         },\r
2310 };\r
2311 \r
2312 static int __init sensor_init(void)\r
2313 {\r
2314         int res = i2c_add_driver(&sensor_driver);       \r
2315         struct proc_dir_entry *sensor_proc_entry;       \r
2316         pr_info("%s: Probe name %s\n", __func__, sensor_driver.driver.name);\r
2317         if (res)\r
2318                 pr_err("%s failed\n", __func__);\r
2319         \r
2320         sensor_proc_entry = proc_create("driver/sensor_dbg", 0660, NULL, &sensor_proc_fops); \r
2321         printk("%s\n", SENSOR_VERSION_AND_TIME);\r
2322         return res;\r
2323 }\r
2324 \r
2325 static void __exit sensor_exit(void)\r
2326 {\r
2327         pr_info("%s\n", __func__);\r
2328         i2c_del_driver(&sensor_driver);\r
2329 }\r
2330 \r
2331 late_initcall(sensor_init);\r
2332 module_exit(sensor_exit);\r
2333 \r
2334 MODULE_AUTHOR("ROCKCHIP Corporation:lw@rock-chips.com");\r
2335 MODULE_DESCRIPTION("User space character device interface for sensors");\r
2336 MODULE_LICENSE("GPL");\r
2337 \r