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 <mach/gpio.h>\r
  30 #include <mach/board.h> \r
  31 #ifdef CONFIG_HAS_EARLYSUSPEND\r
  32 #include <linux/earlysuspend.h>\r
  33 #endif\r
  34 #include <linux/akm8975.h>\r
  35 #include <linux/l3g4200d.h>\r
  36 #include <linux/sensor-dev.h>\r
  37 \r
  38 #define SENSOR_ON               1\r
  39 #define SENSOR_OFF              0\r
  40 \r
  41 #if 0\r
  42 #define SENSOR_DEBUG_TYPE SENSOR_TYPE_ACCEL\r
  43 #define DBG(x...) if(sensor->pdata->type == SENSOR_DEBUG_TYPE) printk(x)\r
  44 #else\r
  45 #define DBG(x...)\r
  46 #endif\r
  47 \r
  48 struct sensor_private_data *g_sensor[SENSOR_NUM_TYPES];\r
  49 static struct sensor_operate *sensor_ops[SENSOR_NUM_TYPES]; \r
  50 \r
  51 static int sensor_get_id(struct i2c_client *client, int *value)\r
  52 {\r
  53         struct sensor_private_data *sensor =\r
  54             (struct sensor_private_data *) i2c_get_clientdata(client);  \r
  55         int result = 0;\r
  56         char temp = sensor->ops->id_reg;\r
  57         int i = 0;\r
  58 \r
  59         if(sensor->ops->id_reg >= 0)\r
  60         {\r
  61                 for(i=0; i<3; i++)\r
  62                 {\r
  63                         result = sensor_rx_data(client, &temp, 1);\r
  64                         *value = temp;\r
  65                         if(!result)\r
  66                         break;\r
  67                 }\r
  68 \r
  69                 if(result)\r
  70                         return result;\r
  71 \r
  72                 if(*value != sensor->ops->id_data)\r
  73                 {\r
  74                         printk("%s:id=0x%x is not 0x%x\n",__func__,*value, sensor->ops->id_data);\r
  75                         result = -1;\r
  76                 }\r
  77                         \r
  78                 DBG("%s:devid=0x%x\n",__func__,*value);\r
  79         }\r
  80         \r
  81         return result;\r
  82 }\r
  83 \r
  84 static int sensor_initial(struct i2c_client *client)\r
  85 {\r
  86         struct sensor_private_data *sensor =\r
  87             (struct sensor_private_data *) i2c_get_clientdata(client);  \r
  88         int result = 0;\r
  89 \r
  90         //register setting according to chip datasheet  \r
  91         result = sensor->ops->init(client);\r
  92         if(result < 0)\r
  93         {\r
  94                 printk("%s:fail to init sensor\n",__func__);\r
  95                 return result;\r
  96         }\r
  97 \r
  98 \r
  99         DBG("%s:ctrl_data=0x%x\n",__func__,sensor->ops->ctrl_data);\r
 100         \r
 101         return result;\r
 102 \r
 103 }\r
 104 \r
 105 static int sensor_chip_init(struct i2c_client *client)\r
 106 {\r
 107         struct sensor_private_data *sensor =\r
 108             (struct sensor_private_data *) i2c_get_clientdata(client);  \r
 109         struct sensor_operate *ops = sensor_ops[sensor->type];\r
 110         int result = 0;\r
 111         \r
 112         if(ops)\r
 113         {\r
 114                 sensor->ops = ops;\r
 115         }\r
 116         else\r
 117         {\r
 118                 printk("%s:ops is null,sensor name is %s\n",__func__,sensor->i2c_id->name);\r
 119                 result = -1;\r
 120                 goto error;\r
 121         }\r
 122 \r
 123         if(sensor->type != ops->type)\r
 124         {\r
 125                 printk("%s:type is different:%d,%d\n",__func__,sensor->type, sensor->type);\r
 126                 result = -1;\r
 127                 goto error;\r
 128         }\r
 129         \r
 130         if(!ops->init || !ops->active || !ops->report)\r
 131         {\r
 132                 printk("%s:error:some function is needed\n",__func__);          \r
 133                 result = -1;\r
 134                 goto error;\r
 135         }\r
 136 \r
 137         result = sensor_get_id(sensor->client, &sensor->devid);//get id\r
 138         if(result < 0)\r
 139         {       \r
 140                 printk("%s:fail to read devid:0x%x\n",__func__,sensor->devid);  \r
 141                 goto error;\r
 142         }\r
 143         \r
 144         printk("%s:sensor->devid=0x%x,ops=0x%p\n",__func__,sensor->devid,sensor->ops);\r
 145 \r
 146         result = sensor_initial(sensor->client);        //init sensor\r
 147         if(result < 0)\r
 148         {       \r
 149                 printk("%s:fail to init sensor\n",__func__);            \r
 150                 goto error;\r
 151         }\r
 152 \r
 153         return 0;\r
 154 \r
 155 error:\r
 156         \r
 157         return result;\r
 158 }\r
 159 \r
 160 static int sensor_reset_rate(struct i2c_client *client, int rate)\r
 161 {\r
 162         struct sensor_private_data *sensor =\r
 163             (struct sensor_private_data *) i2c_get_clientdata(client);  \r
 164         int result = 0; \r
 165         \r
 166         result = sensor->ops->active(client,SENSOR_OFF,rate);\r
 167         sensor->ops->init(client);\r
 168         result = sensor->ops->active(client,SENSOR_ON,rate);\r
 169 \r
 170         return result;\r
 171 }\r
 172 \r
 173 static int sensor_get_data(struct i2c_client *client)\r
 174 {\r
 175         struct sensor_private_data *sensor =\r
 176             (struct sensor_private_data *) i2c_get_clientdata(client);  \r
 177         int result = 0;\r
 178         \r
 179         result = sensor->ops->report(client);\r
 180         if(result)\r
 181                 goto error;\r
 182 \r
 183         /* set data_ready */\r
 184         atomic_set(&sensor->data_ready, 1);\r
 185         /*wake up data_ready  work queue*/\r
 186         wake_up(&sensor->data_ready_wq);\r
 187         \r
 188 error:          \r
 189         return result;\r
 190 }\r
 191 \r
 192 #if 0\r
 193 int sensor_get_cached_data(struct i2c_client* client, char *buffer, int length, struct sensor_axis *axis)\r
 194 {\r
 195     struct sensor_private_data* sensor = (struct sensor_private_data *)i2c_get_clientdata(client);      \r
 196     wait_event_interruptible_timeout(sensor->data_ready_wq, \r
 197                                      atomic_read(&(sensor->data_ready) ),\r
 198                                      msecs_to_jiffies(1000) );\r
 199     if ( 0 == atomic_read(&(sensor->data_ready) ) ) {\r
 200         printk("waiting 'data_ready_wq' timed out.");\r
 201         goto error;\r
 202     }\r
 203 \r
 204         \r
 205         mutex_lock(&sensor->data_mutex);\r
 206 \r
 207         switch(sensor->type)\r
 208         {\r
 209                 case SENSOR_TYPE_ACCEL:\r
 210                 *axis = sensor->axis;\r
 211                 break;\r
 212 \r
 213                 case SENSOR_TYPE_COMPASS:\r
 214                 memcpy(buffer, sensor->sensor_data, length);\r
 215                 break;\r
 216         }\r
 217         \r
 218         mutex_unlock(&sensor->data_mutex);\r
 219         \r
 220     return 0;\r
 221         \r
 222 error:\r
 223         return -1;\r
 224 }\r
 225 #endif\r
 226 \r
 227 static void  sensor_delaywork_func(struct work_struct *work)\r
 228 {\r
 229         struct delayed_work *delaywork = container_of(work, struct delayed_work, work);\r
 230         struct sensor_private_data *sensor = container_of(delaywork, struct sensor_private_data, delaywork);\r
 231         struct i2c_client *client = sensor->client;\r
 232 \r
 233         mutex_lock(&sensor->sensor_mutex);      \r
 234         if (sensor_get_data(client) < 0) \r
 235                 DBG(KERN_ERR "%s: Get data failed\n",__func__);\r
 236         \r
 237         if(!sensor->pdata->irq_enable)//restart work while polling\r
 238         schedule_delayed_work(&sensor->delaywork, msecs_to_jiffies(sensor->pdata->poll_delay_ms));\r
 239         //else\r
 240         //{\r
 241                 //if((sensor->ops->trig == IRQF_TRIGGER_LOW) || (sensor->ops->trig == IRQF_TRIGGER_HIGH))\r
 242                 //enable_irq(sensor->client->irq);\r
 243         //}\r
 244         mutex_unlock(&sensor->sensor_mutex);\r
 245         \r
 246         DBG("%s:%s\n",__func__,sensor->i2c_id->name);\r
 247 }\r
 248 \r
 249 /*\r
 250  * This is a threaded IRQ handler so can access I2C/SPI.  Since all\r
 251  * interrupts are clear on read the IRQ line will be reasserted and\r
 252  * the physical IRQ will be handled again if another interrupt is\r
 253  * asserted while we run - in the normal course of events this is a\r
 254  * rare occurrence so we save I2C/SPI reads.  We're also assuming that\r
 255  * it's rare to get lots of interrupts firing simultaneously so try to\r
 256  * minimise I/O.\r
 257  */\r
 258 static irqreturn_t sensor_interrupt(int irq, void *dev_id)\r
 259 {\r
 260         struct sensor_private_data *sensor = (struct sensor_private_data *)dev_id;\r
 261 \r
 262         //use threaded IRQ\r
 263         if (sensor_get_data(sensor->client) < 0) \r
 264                 DBG(KERN_ERR "%s: Get data failed\n",__func__);\r
 265         msleep(sensor->pdata->poll_delay_ms);\r
 266 \r
 267         \r
 268         //if((sensor->ops->trig == IRQF_TRIGGER_LOW) || (sensor->ops->trig == IRQF_TRIGGER_HIGH))\r
 269         //disable_irq_nosync(irq);\r
 270         //schedule_delayed_work(&sensor->delaywork, msecs_to_jiffies(sensor->pdata->poll_delay_ms));\r
 271         DBG("%s:irq=%d\n",__func__,irq);\r
 272         return IRQ_HANDLED;\r
 273 }\r
 274 \r
 275 \r
 276 static int sensor_irq_init(struct i2c_client *client)\r
 277 {\r
 278         struct sensor_private_data *sensor =\r
 279             (struct sensor_private_data *) i2c_get_clientdata(client);  \r
 280         int result = 0;\r
 281         int irq;\r
 282         if((sensor->pdata->irq_enable)&&(sensor->ops->trig != SENSOR_UNKNOW_DATA))\r
 283         {\r
 284                 //INIT_DELAYED_WORK(&sensor->delaywork, sensor_delaywork_func);\r
 285                 if(sensor->pdata->poll_delay_ms < 0)\r
 286                         sensor->pdata->poll_delay_ms = 30;\r
 287                 \r
 288                 result = gpio_request(client->irq, sensor->i2c_id->name);\r
 289                 if (result)\r
 290                 {\r
 291                         printk("%s:fail to request gpio :%d\n",__func__,client->irq);\r
 292                 }\r
 293         \r
 294                 gpio_pull_updown(client->irq, PullEnable);\r
 295                 irq = gpio_to_irq(client->irq);\r
 296                 //result = request_irq(irq, sensor_interrupt, sensor->ops->trig, sensor->ops->name, sensor);\r
 297                 result = request_threaded_irq(irq, NULL, sensor_interrupt, sensor->ops->trig, sensor->ops->name, sensor);\r
 298                 if (result) {\r
 299                         printk(KERN_ERR "%s:fail to request irq = %d, ret = 0x%x\n",__func__, irq, result);            \r
 300                         goto error;            \r
 301                 }\r
 302                 client->irq = irq;\r
 303                 if((sensor->pdata->type == SENSOR_TYPE_GYROSCOPE))\r
 304                 disable_irq_nosync(client->irq);//disable irq\r
 305                 printk("%s:use irq=%d\n",__func__,irq);\r
 306         }\r
 307         else if(!sensor->pdata->irq_enable)\r
 308         {               \r
 309                 INIT_DELAYED_WORK(&sensor->delaywork, sensor_delaywork_func);\r
 310                 if(sensor->pdata->poll_delay_ms < 0)\r
 311                         sensor->pdata->poll_delay_ms = 30;\r
 312                 \r
 313                 printk("%s:use polling,delay=%d ms\n",__func__,sensor->pdata->poll_delay_ms);\r
 314         }\r
 315 \r
 316 error:  \r
 317         return result;\r
 318 }\r
 319 \r
 320 \r
 321 static void sensor_suspend(struct early_suspend *h)\r
 322 {\r
 323         struct sensor_private_data *sensor = \r
 324                         container_of(h, struct sensor_private_data, early_suspend);\r
 325         \r
 326         if(sensor->ops->suspend)\r
 327                 sensor->ops->suspend(sensor->client);\r
 328 \r
 329 }\r
 330 \r
 331 static void sensor_resume(struct early_suspend *h)\r
 332 {\r
 333         struct sensor_private_data *sensor = \r
 334                         container_of(h, struct sensor_private_data, early_suspend);\r
 335 \r
 336         if(sensor->ops->resume)\r
 337                 sensor->ops->resume(sensor->client);\r
 338 }\r
 339 \r
 340 static int gsensor_dev_open(struct inode *inode, struct file *file)\r
 341 {\r
 342         //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_ACCEL];     \r
 343         //struct i2c_client *client = sensor->client;\r
 344 \r
 345         int result = 0;\r
 346 \r
 347 \r
 348         return result;\r
 349 }\r
 350 \r
 351 \r
 352 static int gsensor_dev_release(struct inode *inode, struct file *file)\r
 353 {\r
 354         //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_ACCEL];     \r
 355         //struct i2c_client *client = sensor->client;\r
 356 \r
 357         int result = 0;\r
 358 \r
 359 \r
 360         return result;\r
 361 }\r
 362 \r
 363 /* ioctl - I/O control */\r
 364 static long gsensor_dev_ioctl(struct file *file,\r
 365                           unsigned int cmd, unsigned long arg)\r
 366 {\r
 367         struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_ACCEL];\r
 368         struct i2c_client *client = sensor->client;\r
 369         void __user *argp = (void __user *)arg;\r
 370         struct sensor_axis axis = {0};\r
 371         char rate;\r
 372         int result = 0;\r
 373 \r
 374         switch (cmd) {\r
 375         case GSENSOR_IOCTL_APP_SET_RATE:\r
 376                 if (copy_from_user(&rate, argp, sizeof(rate)))\r
 377                 {\r
 378                         result = -EFAULT;\r
 379                         goto error;\r
 380                 }\r
 381                 break;\r
 382         default:\r
 383                 break;\r
 384         }
 385
 386         switch (cmd) {
 387         case GSENSOR_IOCTL_START:       \r
 388                 DBG("%s:GSENSOR_IOCTL_START start,status=%d\n", __func__,sensor->status_cur);\r
 389                 mutex_lock(&sensor->operation_mutex);   \r
 390                 if(++sensor->start_count == 1)\r
 391                 {\r
 392                         if(sensor->status_cur == SENSOR_OFF)\r
 393                         {\r
 394                                 atomic_set(&(sensor->data_ready), 0);\r
 395                                 if ( (result = sensor->ops->active(client, 1, 0) ) < 0 ) {\r
 396                                         mutex_unlock(&sensor->operation_mutex);\r
 397                                         printk("%s:fail to active sensor,ret=%d\n",__func__,result);         \r
 398                                         goto error;           \r
 399                                 }                       \r
 400                                 if(sensor->pdata->irq_enable)\r
 401                                 {\r
 402                                         //printk("%s:enable irq,irq=%d\n",__func__,client->irq);\r
 403                                         //enable_irq(client->irq);      //enable irq\r
 404                                 }       \r
 405                                 else\r
 406                                 {\r
 407                                         PREPARE_DELAYED_WORK(&sensor->delaywork, sensor_delaywork_func);\r
 408                                         schedule_delayed_work(&sensor->delaywork, msecs_to_jiffies(sensor->pdata->poll_delay_ms));\r
 409                                 }\r
 410                                 sensor->status_cur = SENSOR_ON;\r
 411                         }       \r
 412                 }\r
 413                 mutex_unlock(&sensor->operation_mutex);\r
 414                 DBG("%s:GSENSOR_IOCTL_START OK\n", __func__);\r
 415                 break;\r
 416
 417         case GSENSOR_IOCTL_CLOSE:                               \r
 418                 DBG("%s:GSENSOR_IOCTL_CLOSE start,status=%d\n", __func__,sensor->status_cur);\r
 419                 mutex_lock(&sensor->operation_mutex);           \r
 420                 if(--sensor->start_count == 0)\r
 421                 {\r
 422                         if(sensor->status_cur == SENSOR_ON)\r
 423                         {\r
 424                                 atomic_set(&(sensor->data_ready), 0);\r
 425                                 if ( (result = sensor->ops->active(client, 0, 0) ) < 0 ) {\r
 426                                         mutex_unlock(&sensor->operation_mutex);              \r
 427                                         goto error;\r
 428                                 }\r
 429                                 \r
 430                                 if(sensor->pdata->irq_enable)\r
 431                                 {                               \r
 432                                         //printk("%s:disable irq,irq=%d\n",__func__,client->irq);\r
 433                                         //disable_irq_nosync(client->irq);//disable irq\r
 434                                 }\r
 435                                 else\r
 436                                 cancel_delayed_work_sync(&sensor->delaywork);           \r
 437                                 sensor->status_cur = SENSOR_OFF;\r
 438                         }\r
 439                         \r
 440                         DBG("%s:GSENSOR_IOCTL_CLOSE OK\n", __func__);\r
 441                 }\r
 442                 \r
 443                 mutex_unlock(&sensor->operation_mutex); \r
 444                 break;\r
 445
 446         case GSENSOR_IOCTL_APP_SET_RATE:                \r
 447                 DBG("%s:GSENSOR_IOCTL_APP_SET_RATE start\n", __func__);         \r
 448                 mutex_lock(&sensor->operation_mutex);   \r
 449                 result = sensor_reset_rate(client, rate);\r
 450                 if (result < 0)\r
 451                 goto error;\r
 452                 if(sensor->status_cur == SENSOR_OFF)\r
 453                 {               \r
 454                         if(sensor->pdata->irq_enable)\r
 455                         {\r
 456                                 //printk("%s:enable irq,irq=%d\n",__func__,client->irq);\r
 457                                 //enable_irq(client->irq);      //enable irq\r
 458                         }       \r
 459                         else\r
 460                         {\r
 461                                 PREPARE_DELAYED_WORK(&sensor->delaywork, sensor_delaywork_func);\r
 462                                 schedule_delayed_work(&sensor->delaywork, msecs_to_jiffies(sensor->pdata->poll_delay_ms));\r
 463                         }\r
 464                         sensor->status_cur = SENSOR_ON;\r
 465                 }                       \r
 466                 mutex_unlock(&sensor->operation_mutex); \r
 467                 DBG("%s:GSENSOR_IOCTL_APP_SET_RATE OK\n", __func__);\r
 468                 break;\r
 469                 \r
 470         case GSENSOR_IOCTL_GETDATA:\r
 471                 mutex_lock(&sensor->data_mutex);\r
 472                 memcpy(&axis, &sensor->axis, sizeof(sensor->axis));     //get data from buffer\r
 473                 mutex_unlock(&sensor->data_mutex);              \r
 474                 break;\r
 475         default:\r
 476                 result = -ENOTTY;\r
 477         goto error;\r
 478         }
 479
 480         switch (cmd) {
 481         case GSENSOR_IOCTL_GETDATA:\r
 482                 if ( copy_to_user(argp, &axis, sizeof(axis) ) ) {\r
 483                     printk("failed to copy sense data to user space.");\r
 484                                 result = -EFAULT;                       \r
 485                                 goto error;\r
 486                 }               \r
 487                 DBG("%s:GSENSOR_IOCTL_GETDATA OK\n", __func__);\r
 488                 break;
 489         default:
 490                 break;
 491         }\r
 492         \r
 493 error:\r
 494         return result;\r
 495 }\r
 496 \r
 497 \r
 498 static int compass_dev_open(struct inode *inode, struct file *file)\r
 499 {\r
 500         //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_COMPASS];\r
 501         //struct i2c_client *client = sensor->client;\r
 502         int result = 0;\r
 503         \r
 504         //to do\r
 505         return result;\r
 506 }\r
 507 \r
 508 \r
 509 static int compass_dev_release(struct inode *inode, struct file *file)\r
 510 {\r
 511         //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_COMPASS];\r
 512         //struct i2c_client *client = sensor->client;   \r
 513         int result = 0;\r
 514 \r
 515         //to do\r
 516         return result;\r
 517 }\r
 518 \r
 519 \r
 520 /* ioctl - I/O control */\r
 521 static long compass_dev_ioctl(struct file *file,\r
 522                           unsigned int cmd, unsigned long arg)\r
 523 {\r
 524         //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_COMPASS];\r
 525         //struct i2c_client *client = sensor->client;\r
 526         //void __user *argp = (void __user *)arg;\r
 527         int result = 0;\r
 528         \r
 529         //to do\r
 530         return result;\r
 531 }\r
 532 \r
 533 static int gyro_dev_open(struct inode *inode, struct file *file)\r
 534 {\r
 535         //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_GYROSCOPE];\r
 536         //struct i2c_client *client = sensor->client;\r
 537 \r
 538         int result = 0;\r
 539 \r
 540 \r
 541         return result;\r
 542 }\r
 543 \r
 544 \r
 545 static int gyro_dev_release(struct inode *inode, struct file *file)\r
 546 {\r
 547         //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_GYROSCOPE];\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 /* ioctl - I/O control */\r
 558 static long gyro_dev_ioctl(struct file *file,\r
 559                           unsigned int cmd, unsigned long arg)\r
 560 {\r
 561         struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_GYROSCOPE];   \r
 562         struct i2c_client *client = sensor->client;     \r
 563         void __user *argp = (void __user *)arg;\r
 564         int result = 0;\r
 565         char rate;\r
 566         switch (cmd) {\r
 567         case L3G4200D_IOCTL_GET_ENABLE: \r
 568                 result = !sensor->status_cur;\r
 569                 if (copy_to_user(argp, &result, sizeof(result)))\r
 570                 {\r
 571                         printk("%s:failed to copy status to user space.\n",__FUNCTION__);\r
 572                         return -EFAULT;\r
 573                 }\r
 574                 \r
 575                 DBG("%s :L3G4200D_IOCTL_GET_ENABLE,status=%d\n",__FUNCTION__,result);   \r
 576                 break;\r
 577         case L3G4200D_IOCTL_SET_ENABLE:                 \r
 578                 DBG("%s :L3G4200D_IOCTL_SET_ENABLE,flag=%d\n",__FUNCTION__,*(unsigned int *)argp);\r
 579                 mutex_lock(&sensor->operation_mutex);   \r
 580                 if(*(unsigned int *)argp)\r
 581                 {\r
 582                         if(sensor->status_cur == SENSOR_OFF)\r
 583                         {\r
 584                                 if ( (result = sensor->ops->active(client, 1, ODR100_BW12_5) ) < 0 ) {\r
 585                                 mutex_unlock(&sensor->operation_mutex);\r
 586                                 printk("%s:fail to active sensor,ret=%d\n",__func__,result);         \r
 587                                 goto error;           \r
 588                                 }                       \r
 589                                 if(sensor->pdata->irq_enable)\r
 590                                 {\r
 591                                         DBG("%s:enable irq,irq=%d\n",__func__,client->irq);\r
 592                                         enable_irq(client->irq);        //enable irq\r
 593                                 }       \r
 594                                 else\r
 595                                 {\r
 596                                         PREPARE_DELAYED_WORK(&sensor->delaywork, sensor_delaywork_func);\r
 597                                         schedule_delayed_work(&sensor->delaywork, msecs_to_jiffies(sensor->pdata->poll_delay_ms));\r
 598                                 }\r
 599                                 sensor->status_cur = SENSOR_ON;\r
 600                         }       \r
 601                 }\r
 602                 else\r
 603                 {\r
 604                         if(sensor->status_cur == SENSOR_ON)\r
 605                         {\r
 606                                 if ( (result = sensor->ops->active(client, 0, 0) ) < 0 ) {\r
 607                                 mutex_unlock(&sensor->operation_mutex);              \r
 608                                 goto error;\r
 609                                 }\r
 610                                 \r
 611                                 if(sensor->pdata->irq_enable)\r
 612                                 {                               \r
 613                                         DBG("%s:disable irq,irq=%d\n",__func__,client->irq);\r
 614                                         disable_irq_nosync(client->irq);//disable irq\r
 615                                 }\r
 616                                 else\r
 617                                 cancel_delayed_work_sync(&sensor->delaywork);           \r
 618                                 sensor->status_cur = SENSOR_OFF;\r
 619                         }\r
 620                 }\r
 621         \r
 622                 result = sensor->status_cur;\r
 623                 if (copy_to_user(argp, &result, sizeof(result)))\r
 624                 {\r
 625                         printk("%s:failed to copy sense data to user space.\n",__FUNCTION__);\r
 626                         return -EFAULT;\r
 627                 }\r
 628 \r
 629                 mutex_unlock(&sensor->operation_mutex);\r
 630                 DBG("%s:L3G4200D_IOCTL_SET_ENABLE OK\n", __func__);\r
 631                 break;\r
 632         case L3G4200D_IOCTL_SET_DELAY:                                  \r
 633                 mutex_lock(&sensor->operation_mutex);\r
 634                 if (copy_from_user(&rate, argp, sizeof(rate)))\r
 635                 return -EFAULT;\r
 636                 if(sensor->status_cur == SENSOR_OFF)\r
 637                 {\r
 638                         if ( (result = sensor->ops->active(client, 1, rate) ) < 0 ) {\r
 639                         mutex_unlock(&sensor->operation_mutex);\r
 640                         printk("%s:fail to active sensor,ret=%d\n",__func__,result);         \r
 641                         goto error;           \r
 642                         }\r
 643                         \r
 644                         if(sensor->pdata->irq_enable)\r
 645                         {\r
 646                                 DBG("%s:enable irq,irq=%d\n",__func__,client->irq);\r
 647                                 enable_irq(client->irq);        //enable irq\r
 648                         }       \r
 649                         else\r
 650                         {\r
 651                                 PREPARE_DELAYED_WORK(&sensor->delaywork, sensor_delaywork_func);\r
 652                                 schedule_delayed_work(&sensor->delaywork, msecs_to_jiffies(sensor->pdata->poll_delay_ms));\r
 653                         }\r
 654                         sensor->status_cur = SENSOR_ON;\r
 655                 }       \r
 656                 \r
 657                 mutex_unlock(&sensor->operation_mutex);\r
 658                 DBG("%s :L3G4200D_IOCTL_SET_DELAY,rate=%d\n",__FUNCTION__,rate);\r
 659                 break;\r
 660 \r
 661         default:\r
 662                 printk("%s:error,cmd=0x%x\n",__func__,cmd);\r
 663                 return -ENOTTY;\r
 664         }\r
 665         \r
 666         DBG("%s:line=%d,cmd=0x%x\n",__func__,__LINE__,cmd);\r
 667 \r
 668 error:\r
 669         return result;\r
 670 }\r
 671 \r
 672 static int light_dev_open(struct inode *inode, struct file *file)\r
 673 {\r
 674         //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_LIGHT];\r
 675         //struct i2c_client *client = sensor->client;   \r
 676         int result = 0; \r
 677 \r
 678 \r
 679         return result;\r
 680 }\r
 681 \r
 682 \r
 683 \r
 684 \r
 685 static int light_dev_release(struct inode *inode, struct file *file)\r
 686 {\r
 687         //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_LIGHT];\r
 688         //struct i2c_client *client = sensor->client;   \r
 689         int result = 0;\r
 690 \r
 691 \r
 692         return result;\r
 693 }\r
 694 \r
 695 \r
 696 /* ioctl - I/O control */\r
 697 static long light_dev_ioctl(struct file *file,\r
 698                           unsigned int cmd, unsigned long arg)\r
 699 {\r
 700         struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_LIGHT];\r
 701         struct i2c_client *client = sensor->client;\r
 702         unsigned int *argp = (unsigned int *)arg;       \r
 703         int result = 0;\r
 704 \r
 705         switch(cmd)\r
 706         {\r
 707                 case LIGHTSENSOR_IOCTL_GET_ENABLED:
 708                         *argp = sensor->status_cur;\r
 709                         break;
 710                 case LIGHTSENSOR_IOCTL_ENABLE:          \r
 711                         DBG("%s:LIGHTSENSOR_IOCTL_ENABLE start\n", __func__);\r
 712                         mutex_lock(&sensor->operation_mutex);    \r
 713                         if(*(unsigned int *)argp)\r
 714                         {\r
 715                                 if(sensor->status_cur == SENSOR_OFF)\r
 716                                 {\r
 717                                         if ( (result = sensor->ops->active(client, SENSOR_ON, 0) ) < 0 ) {\r
 718                                         mutex_unlock(&sensor->operation_mutex);\r
 719                                         printk("%s:fail to active sensor,ret=%d\n",__func__,result);         \r
 720                                         goto error;           \r
 721                                         }       \r
 722                                         \r
 723                                         if(!sensor->pdata->irq_enable)\r
 724                                         {\r
 725                                                 PREPARE_DELAYED_WORK(&sensor->delaywork, sensor_delaywork_func);\r
 726                                                 schedule_delayed_work(&sensor->delaywork, msecs_to_jiffies(sensor->pdata->poll_delay_ms));\r
 727                                         }\r
 728                                         sensor->status_cur = SENSOR_ON;\r
 729                                 }       \r
 730                         }\r
 731                         else\r
 732                         {\r
 733                                 if(sensor->status_cur == SENSOR_ON)\r
 734                                 {\r
 735                                         if ( (result = sensor->ops->active(client, SENSOR_OFF, 0) ) < 0 ) {\r
 736                                         mutex_unlock(&sensor->operation_mutex);              \r
 737                                         goto error;\r
 738                                         }\r
 739                                         \r
 740                                         if(!sensor->pdata->irq_enable)\r
 741                                         cancel_delayed_work_sync(&sensor->delaywork);           \r
 742                                         sensor->status_cur = SENSOR_OFF;\r
 743                                 }\r
 744                         }\r
 745                         mutex_unlock(&sensor->operation_mutex);\r
 746                         DBG("%s:LIGHTSENSOR_IOCTL_ENABLE OK\n", __func__);\r
 747                         break;\r
 748                 \r
 749                 default:\r
 750                         break;\r
 751         }\r
 752         \r
 753 error:\r
 754         return result;\r
 755 }\r
 756 \r
 757 \r
 758 static int proximity_dev_open(struct inode *inode, struct file *file)\r
 759 {\r
 760         //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_PROXIMITY];\r
 761         //struct i2c_client *client = sensor->client;   \r
 762         int result = 0;\r
 763 \r
 764 \r
 765         return result;\r
 766 }\r
 767 \r
 768 \r
 769 static int proximity_dev_release(struct inode *inode, struct file *file)\r
 770 {\r
 771         //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_PROXIMITY];\r
 772         //struct i2c_client *client = sensor->client;   \r
 773         int result = 0;\r
 774 \r
 775 \r
 776         return result;\r
 777 }\r
 778 \r
 779 \r
 780 /* ioctl - I/O control */\r
 781 static long proximity_dev_ioctl(struct file *file,\r
 782                           unsigned int cmd, unsigned long arg)\r
 783 {\r
 784         struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_PROXIMITY];\r
 785         struct i2c_client *client = sensor->client;     \r
 786         unsigned int *argp = (unsigned int *)arg;       \r
 787         int result = 0;\r
 788         switch(cmd)\r
 789         {\r
 790                 case PSENSOR_IOCTL_GET_ENABLED:\r
 791                         *argp = sensor->status_cur;\r
 792                         break;
 793                 case PSENSOR_IOCTL_ENABLE:              \r
 794                         DBG("%s:PSENSOR_IOCTL_ENABLE start\n", __func__);\r
 795                         mutex_lock(&sensor->operation_mutex);    \r
 796                         if(*(unsigned int *)argp)\r
 797                         {\r
 798                                 if(sensor->status_cur == SENSOR_OFF)\r
 799                                 {\r
 800                                         if ( (result = sensor->ops->active(client, SENSOR_ON, 0) ) < 0 ) {\r
 801                                         mutex_unlock(&sensor->operation_mutex);\r
 802                                         printk("%s:fail to active sensor,ret=%d\n",__func__,result);         \r
 803                                         goto error;           \r
 804                                         }\r
 805                                         \r
 806                                         if(!sensor->pdata->irq_enable)\r
 807                                         {\r
 808                                                 PREPARE_DELAYED_WORK(&sensor->delaywork, sensor_delaywork_func);\r
 809                                                 schedule_delayed_work(&sensor->delaywork, msecs_to_jiffies(sensor->pdata->poll_delay_ms));\r
 810                                         }\r
 811                                         sensor->status_cur = SENSOR_ON;\r
 812                                 }       \r
 813                         }\r
 814                         else\r
 815                         {\r
 816                                 if(sensor->status_cur == SENSOR_ON)\r
 817                                 {\r
 818                                         if ( (result = sensor->ops->active(client, SENSOR_OFF, 0) ) < 0 ) {\r
 819                                         mutex_unlock(&sensor->operation_mutex);              \r
 820                                         goto error;\r
 821                                         }\r
 822                                         if(!sensor->pdata->irq_enable)\r
 823                                         cancel_delayed_work_sync(&sensor->delaywork);           \r
 824                                         sensor->status_cur = SENSOR_OFF;\r
 825                                 }\r
 826                         }\r
 827                         mutex_unlock(&sensor->operation_mutex);\r
 828                         DBG("%s:PSENSOR_IOCTL_ENABLE OK\n", __func__);\r
 829                         break;\r
 830                 \r
 831                 default:\r
 832                         break;\r
 833         }\r
 834         \r
 835 error:\r
 836         return result;\r
 837 }\r
 838 \r
 839 static int temperature_dev_open(struct inode *inode, struct file *file)\r
 840 {\r
 841         //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_TEMPERATURE];\r
 842         //struct i2c_client *client = sensor->client;\r
 843 \r
 844         int result = 0;\r
 845 \r
 846 \r
 847         return result;\r
 848 }\r
 849 \r
 850 \r
 851 static int temperature_dev_release(struct inode *inode, struct file *file)\r
 852 {\r
 853         //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_TEMPERATURE];\r
 854         //struct i2c_client *client = sensor->client;\r
 855 \r
 856         int result = 0;\r
 857 \r
 858 \r
 859         return result;\r
 860 }\r
 861 \r
 862 \r
 863 /* ioctl - I/O control */\r
 864 static long temperature_dev_ioctl(struct file *file,\r
 865                           unsigned int cmd, unsigned long arg)\r
 866 {\r
 867         //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_TEMPERATURE];\r
 868         //struct i2c_client *client = sensor->client;\r
 869         //void __user *argp = (void __user *)arg;\r
 870         int result = 0;\r
 871         \r
 872 \r
 873         return result;\r
 874 }\r
 875 \r
 876 \r
 877 static int sensor_misc_device_register(struct sensor_private_data *sensor, int type)\r
 878 {\r
 879         int result = 0;\r
 880         \r
 881         switch(type)\r
 882         {\r
 883                 case SENSOR_TYPE_ACCEL:\r
 884                         if(!sensor->ops->misc_dev)\r
 885                         {\r
 886                                 sensor->fops.owner = THIS_MODULE;\r
 887                                 sensor->fops.unlocked_ioctl = gsensor_dev_ioctl;\r
 888                                 sensor->fops.open = gsensor_dev_open;\r
 889                                 sensor->fops.release = gsensor_dev_release;\r
 890 \r
 891                                 sensor->miscdev.minor = MISC_DYNAMIC_MINOR;\r
 892                                 sensor->miscdev.name = "mma8452_daemon";\r
 893                                 sensor->miscdev.fops = &sensor->fops;\r
 894                         }\r
 895                         else\r
 896                         {\r
 897                                 memcpy(&sensor->miscdev, sensor->ops->misc_dev, sizeof(*sensor->ops->misc_dev));\r
 898 \r
 899                         }\r
 900                                 \r
 901                         break;\r
 902 \r
 903                 case SENSOR_TYPE_COMPASS:                       \r
 904                         if(!sensor->ops->misc_dev)\r
 905                         {\r
 906                                 sensor->fops.owner = THIS_MODULE;\r
 907                                 sensor->fops.unlocked_ioctl = compass_dev_ioctl;\r
 908                                 sensor->fops.open = compass_dev_open;\r
 909                                 sensor->fops.release = compass_dev_release;\r
 910 \r
 911                                 sensor->miscdev.minor = MISC_DYNAMIC_MINOR;\r
 912                                 sensor->miscdev.name = "compass";\r
 913                                 sensor->miscdev.fops = &sensor->fops;\r
 914                         }\r
 915                         else\r
 916                         {\r
 917                                 memcpy(&sensor->miscdev, sensor->ops->misc_dev, sizeof(*sensor->ops->misc_dev));\r
 918 \r
 919                         }\r
 920 \r
 921                         break;\r
 922 \r
 923                 case SENSOR_TYPE_GYROSCOPE:                     \r
 924                         if(!sensor->ops->misc_dev)\r
 925                         {\r
 926                                 sensor->fops.owner = THIS_MODULE;\r
 927                                 sensor->fops.unlocked_ioctl = gyro_dev_ioctl;\r
 928                                 sensor->fops.open = gyro_dev_open;\r
 929                                 sensor->fops.release = gyro_dev_release;\r
 930 \r
 931                                 sensor->miscdev.minor = MISC_DYNAMIC_MINOR;\r
 932                                 sensor->miscdev.name = "gyrosensor";\r
 933                                 sensor->miscdev.fops = &sensor->fops;\r
 934                         }\r
 935                         else\r
 936                         {\r
 937                                 memcpy(&sensor->miscdev, sensor->ops->misc_dev, sizeof(*sensor->ops->misc_dev));\r
 938 \r
 939                         }\r
 940                         \r
 941                         break;\r
 942 \r
 943                 case SENSOR_TYPE_LIGHT:\r
 944                         if(!sensor->ops->misc_dev)\r
 945                         {\r
 946                                 sensor->fops.owner = THIS_MODULE;\r
 947                                 sensor->fops.unlocked_ioctl = light_dev_ioctl;\r
 948                                 sensor->fops.open = light_dev_open;\r
 949                                 sensor->fops.release = light_dev_release;\r
 950 \r
 951                                 sensor->miscdev.minor = MISC_DYNAMIC_MINOR;\r
 952                                 sensor->miscdev.name = "lightsensor";\r
 953                                 sensor->miscdev.fops = &sensor->fops;\r
 954                         }       \r
 955                         else\r
 956                         {\r
 957                                 memcpy(&sensor->miscdev, sensor->ops->misc_dev, sizeof(*sensor->ops->misc_dev));\r
 958 \r
 959                         }\r
 960                         break;\r
 961                 \r
 962                 case SENSOR_TYPE_PROXIMITY:\r
 963                         if(!sensor->ops->misc_dev)\r
 964                         {\r
 965                                 sensor->fops.owner = THIS_MODULE;\r
 966                                 sensor->fops.unlocked_ioctl = proximity_dev_ioctl;\r
 967                                 sensor->fops.open = proximity_dev_open;\r
 968                                 sensor->fops.release = proximity_dev_release;\r
 969 \r
 970                                 sensor->miscdev.minor = MISC_DYNAMIC_MINOR;\r
 971                                 sensor->miscdev.name = "psensor";\r
 972                                 sensor->miscdev.fops = &sensor->fops;\r
 973                         }       \r
 974                         else\r
 975                         {\r
 976                                 memcpy(&sensor->miscdev, sensor->ops->misc_dev, sizeof(*sensor->ops->misc_dev));\r
 977 \r
 978                         }\r
 979                         break;\r
 980 \r
 981                 case SENSOR_TYPE_TEMPERATURE:\r
 982                         if(!sensor->ops->misc_dev)\r
 983                         {\r
 984                                 sensor->fops.owner = THIS_MODULE;\r
 985                                 sensor->fops.unlocked_ioctl = temperature_dev_ioctl;\r
 986                                 sensor->fops.open = temperature_dev_open;\r
 987                                 sensor->fops.release = temperature_dev_release;\r
 988 \r
 989                                 sensor->miscdev.minor = MISC_DYNAMIC_MINOR;\r
 990                                 sensor->miscdev.name = "temperature";\r
 991                                 sensor->miscdev.fops = &sensor->fops;\r
 992                         }       \r
 993                         else\r
 994                         {\r
 995                                 memcpy(&sensor->miscdev, sensor->ops->misc_dev, sizeof(*sensor->ops->misc_dev));\r
 996 \r
 997                         }\r
 998                                 \r
 999                         break;\r
1000 \r
1001                 default:\r
1002                         printk("%s:unknow sensor type=%d\n",__func__,type);\r
1003                         result = -1;\r
1004                         goto error;\r
1005         }\r
1006                         \r
1007         sensor->miscdev.parent = &sensor->client->dev;\r
1008         result = misc_register(&sensor->miscdev);\r
1009         if (result < 0) {\r
1010                 dev_err(&sensor->client->dev,\r
1011                         "fail to register misc device %s\n", sensor->miscdev.name);\r
1012                 goto error;\r
1013         }\r
1014         \r
1015         printk("%s:miscdevice: %s\n",__func__,sensor->miscdev.name);\r
1016 \r
1017 error:  \r
1018         \r
1019         return result;\r
1020 \r
1021 }\r
1022 \r
1023 int sensor_register_slave(int type,struct i2c_client *client,\r
1024                         struct sensor_platform_data *slave_pdata,\r
1025                         struct sensor_operate *(*get_sensor_ops)(void))\r
1026 {\r
1027         int result = 0;\r
1028         sensor_ops[type] = get_sensor_ops();\r
1029         printk("%s:%s\n",__func__,sensor_ops[type]->name);\r
1030         return result;\r
1031 }\r
1032 \r
1033 \r
1034 int sensor_unregister_slave(int type,struct i2c_client *client,\r
1035                         struct sensor_platform_data *slave_pdata,\r
1036                         struct sensor_operate *(*get_sensor_ops)(void))\r
1037 {\r
1038         int result = 0;\r
1039         printk("%s:%s\n",__func__,sensor_ops[type]->name);\r
1040         sensor_ops[type] = NULL;        \r
1041         return result;\r
1042 }\r
1043 \r
1044 \r
1045 int sensor_probe(struct i2c_client *client, const struct i2c_device_id *devid)\r
1046 {\r
1047         struct sensor_private_data *sensor =\r
1048             (struct sensor_private_data *) i2c_get_clientdata(client);\r
1049         struct sensor_platform_data *pdata;\r
1050         int result = 0;\r
1051         int type = 0;\r
1052         dev_info(&client->adapter->dev, "%s: %s,0x%x\n", __func__, devid->name,(unsigned int)client);\r
1053 \r
1054         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {\r
1055                 result = -ENODEV;\r
1056                 goto out_no_free;\r
1057         }\r
1058 \r
1059         pdata = client->dev.platform_data;\r
1060         if (!pdata) {\r
1061                 dev_err(&client->adapter->dev,\r
1062                         "Missing platform data for slave %s\n", devid->name);\r
1063                 result = -EFAULT;\r
1064                 goto out_no_free;\r
1065         }\r
1066 \r
1067         sensor = kzalloc(sizeof(*sensor), GFP_KERNEL);\r
1068         if (!sensor) {\r
1069                 result = -ENOMEM;\r
1070                 goto out_no_free;\r
1071         }\r
1072 \r
1073         type= pdata->type;      \r
1074         \r
1075         if((type >= SENSOR_NUM_TYPES) || (type <= SENSOR_TYPE_NULL))\r
1076         {       \r
1077                 dev_err(&client->adapter->dev, "sensor type is error %d\n", pdata->type);\r
1078                 result = -EFAULT;\r
1079                 goto out_no_free;       \r
1080         }\r
1081         \r
1082         i2c_set_clientdata(client, sensor);\r
1083         sensor->client = client;        \r
1084         sensor->pdata = pdata;  \r
1085         sensor->type = type;\r
1086         sensor->i2c_id = (struct i2c_device_id *)devid;\r
1087 \r
1088         if (pdata->init_platform_hw) {\r
1089                 result = pdata->init_platform_hw();\r
1090                 if (result < 0)\r
1091                         goto out_free_memory;\r
1092         }\r
1093 \r
1094         memset(&(sensor->axis), 0, sizeof(struct sensor_axis) );\r
1095         atomic_set(&(sensor->data_ready), 0);\r
1096         init_waitqueue_head(&(sensor->data_ready_wq));\r
1097         mutex_init(&sensor->data_mutex);        \r
1098         mutex_init(&sensor->operation_mutex);   \r
1099         mutex_init(&sensor->sensor_mutex);\r
1100         mutex_init(&sensor->i2c_mutex);\r
1101 \r
1102         sensor->status_cur = SENSOR_OFF;\r
1103         sensor->axis.x = 0;\r
1104         sensor->axis.y = 0;\r
1105         sensor->axis.z = 0;\r
1106         \r
1107         result = sensor_chip_init(sensor->client);\r
1108         if(result < 0)\r
1109                 goto out_free_memory;\r
1110         \r
1111         sensor->input_dev = input_allocate_device();\r
1112         if (!sensor->input_dev) {\r
1113                 result = -ENOMEM;\r
1114                 dev_err(&client->dev,\r
1115                         "Failed to allocate input device %s\n", sensor->input_dev->name);\r
1116                 goto out_free_memory;\r
1117         }       \r
1118 \r
1119         switch(type)\r
1120         {\r
1121                 case SENSOR_TYPE_ACCEL: \r
1122                         sensor->input_dev->name = "gsensor";\r
1123                         set_bit(EV_ABS, sensor->input_dev->evbit);\r
1124                         /* x-axis acceleration */\r
1125                         input_set_abs_params(sensor->input_dev, ABS_X, sensor->ops->range[0], sensor->ops->range[1], 0, 0); //2g full scale range\r
1126                         /* y-axis acceleration */\r
1127                         input_set_abs_params(sensor->input_dev, ABS_Y, sensor->ops->range[0], sensor->ops->range[1], 0, 0); //2g full scale range\r
1128                         /* z-axis acceleration */\r
1129                         input_set_abs_params(sensor->input_dev, ABS_Z, sensor->ops->range[0], sensor->ops->range[1], 0, 0); //2g full scale range\r
1130                         break;          \r
1131                 case SENSOR_TYPE_COMPASS:       \r
1132                         sensor->input_dev->name = "compass";            \r
1133                         /* Setup input device */\r
1134                         set_bit(EV_ABS, sensor->input_dev->evbit);\r
1135                         /* yaw (0, 360) */\r
1136                         input_set_abs_params(sensor->input_dev, ABS_RX, 0, 23040, 0, 0);\r
1137                         /* pitch (-180, 180) */\r
1138                         input_set_abs_params(sensor->input_dev, ABS_RY, -11520, 11520, 0, 0);\r
1139                         /* roll (-90, 90) */\r
1140                         input_set_abs_params(sensor->input_dev, ABS_RZ, -5760, 5760, 0, 0);\r
1141                         /* x-axis acceleration (720 x 8G) */\r
1142                         input_set_abs_params(sensor->input_dev, ABS_X, -5760, 5760, 0, 0);\r
1143                         /* y-axis acceleration (720 x 8G) */\r
1144                         input_set_abs_params(sensor->input_dev, ABS_Y, -5760, 5760, 0, 0);\r
1145                         /* z-axis acceleration (720 x 8G) */\r
1146                         input_set_abs_params(sensor->input_dev, ABS_Z, -5760, 5760, 0, 0);\r
1147                         /* status of magnetic sensor */\r
1148                         input_set_abs_params(sensor->input_dev, ABS_RUDDER, -32768, 3, 0, 0);\r
1149                         /* status of acceleration sensor */\r
1150                         input_set_abs_params(sensor->input_dev, ABS_WHEEL, -32768, 3, 0, 0);\r
1151                         /* x-axis of raw magnetic vector (-4096, 4095) */\r
1152                         input_set_abs_params(sensor->input_dev, ABS_HAT0X, -20480, 20479, 0, 0);\r
1153                         /* y-axis of raw magnetic vector (-4096, 4095) */\r
1154                         input_set_abs_params(sensor->input_dev, ABS_HAT0Y, -20480, 20479, 0, 0);\r
1155                         /* z-axis of raw magnetic vector (-4096, 4095) */\r
1156                         input_set_abs_params(sensor->input_dev, ABS_BRAKE, -20480, 20479, 0, 0);\r
1157                         break;          \r
1158                 case SENSOR_TYPE_GYROSCOPE:\r
1159                         sensor->input_dev->name = "gyro";\r
1160                         /* x-axis acceleration */\r
1161                         input_set_capability(sensor->input_dev, EV_REL, REL_RX);\r
1162                         input_set_abs_params(sensor->input_dev, ABS_RX, sensor->ops->range[0], sensor->ops->range[1], 0, 0); \r
1163                         /* y-axis acceleration */       \r
1164                         input_set_capability(sensor->input_dev, EV_REL, REL_RY);\r
1165                         input_set_abs_params(sensor->input_dev, ABS_RY, sensor->ops->range[0], sensor->ops->range[1], 0, 0); \r
1166                         /* z-axis acceleration */\r
1167                         input_set_capability(sensor->input_dev, EV_REL, REL_RZ);\r
1168                         input_set_abs_params(sensor->input_dev, ABS_RZ, sensor->ops->range[0], sensor->ops->range[1], 0, 0); \r
1169                         break;\r
1170                 case SENSOR_TYPE_LIGHT:\r
1171                         sensor->input_dev->name = "lightsensor-level";\r
1172                         set_bit(EV_ABS, sensor->input_dev->evbit);\r
1173                         input_set_abs_params(sensor->input_dev, ABS_MISC, sensor->ops->range[0], sensor->ops->range[1], 0, 0);                  \r
1174                         break;\r
1175                 case SENSOR_TYPE_PROXIMITY:\r
1176                         sensor->input_dev->name = "proximity";  \r
1177                         set_bit(EV_ABS, sensor->input_dev->evbit);\r
1178                         input_set_abs_params(sensor->input_dev, ABS_DISTANCE, sensor->ops->range[0], sensor->ops->range[1], 0, 0);\r
1179                         break;\r
1180                 case SENSOR_TYPE_TEMPERATURE:                           \r
1181                         sensor->input_dev->name = "temperature";\r
1182                         set_bit(EV_ABS, sensor->input_dev->evbit);              \r
1183                         input_set_abs_params(sensor->input_dev, ABS_THROTTLE, sensor->ops->range[0], sensor->ops->range[1], 0, 0);\r
1184                         break;\r
1185                 default:\r
1186                         printk("%s:unknow sensor type=%d\n",__func__,type);\r
1187                         break;\r
1188 \r
1189         }\r
1190         sensor->input_dev->dev.parent = &client->dev;\r
1191
1192         result = input_register_device(sensor->input_dev);\r
1193         if (result) {\r
1194                 dev_err(&client->dev,\r
1195                         "Unable to register input device %s\n", sensor->input_dev->name);\r
1196                 goto out_input_register_device_failed;\r
1197         }\r
1198 \r
1199         result = sensor_irq_init(sensor->client);\r
1200         if (result) {\r
1201                 dev_err(&client->dev,\r
1202                         "fail to init sensor irq,ret=%d\n",result);\r
1203                 goto out_input_register_device_failed;\r
1204         }\r
1205 \r
1206         \r
1207         sensor->miscdev.parent = &client->dev;\r
1208         result = sensor_misc_device_register(sensor, type);\r
1209         if (result) {\r
1210                 dev_err(&client->dev,\r
1211                         "fail to register misc device %s\n", sensor->miscdev.name);\r
1212                 goto out_misc_device_register_device_failed;\r
1213         }\r
1214         \r
1215         g_sensor[type] = sensor;\r
1216 \r
1217 #ifdef CONFIG_HAS_EARLYSUSPEND\r
1218         if((sensor->ops->suspend) && (sensor->ops->resume))\r
1219         {\r
1220                 sensor->early_suspend.suspend = sensor_suspend;\r
1221                 sensor->early_suspend.resume = sensor_resume;\r
1222                 sensor->early_suspend.level = 0x02;\r
1223                 register_early_suspend(&sensor->early_suspend);\r
1224         }\r
1225 #endif\r
1226 \r
1227         printk("%s:initialized ok,sensor name:%s,type:%d\n",__func__,sensor->ops->name,type);\r
1228 \r
1229         return result;\r
1230         \r
1231 out_misc_device_register_device_failed:\r
1232         input_unregister_device(sensor->input_dev);     \r
1233 out_input_register_device_failed:\r
1234         input_free_device(sensor->input_dev);   \r
1235 out_free_memory:\r
1236         kfree(sensor);\r
1237 out_no_free:\r
1238         dev_err(&client->adapter->dev, "%s failed %d\n", __func__, result);\r
1239         return result;\r
1240 \r
1241 }\r
1242 \r
1243 static void sensor_shut_down(struct i2c_client *client)\r
1244 {\r
1245         struct sensor_private_data *sensor =\r
1246             (struct sensor_private_data *) i2c_get_clientdata(client);\r
1247         if((sensor->ops->suspend) && (sensor->ops->resume))             \r
1248                 unregister_early_suspend(&sensor->early_suspend);\r
1249         DBG("%s:%s\n",__func__,sensor->i2c_id->name);\r
1250 }\r
1251 \r
1252 static int sensor_remove(struct i2c_client *client)\r
1253 {\r
1254         struct sensor_private_data *sensor =\r
1255             (struct sensor_private_data *) i2c_get_clientdata(client);\r
1256         int result = 0;\r
1257         \r
1258         cancel_delayed_work_sync(&sensor->delaywork);\r
1259         misc_deregister(&sensor->miscdev);\r
1260         input_unregister_device(sensor->input_dev);     \r
1261         input_free_device(sensor->input_dev);   \r
1262         kfree(sensor);\r
1263 #ifdef CONFIG_HAS_EARLYSUSPEND\r
1264         if((sensor->ops->suspend) && (sensor->ops->resume))\r
1265         unregister_early_suspend(&sensor->early_suspend);\r
1266 #endif  \r
1267         return result;\r
1268 }\r
1269 \r
1270 static const struct i2c_device_id sensor_id[] = {\r
1271         /*gsensor*/\r
1272         {"gsensor", ACCEL_ID_ALL},\r
1273         {"gs_mma8452", ACCEL_ID_MMA845X},       \r
1274         {"gs_kxtik", ACCEL_ID_KXTIK},\r
1275         {"gs_lis3dh", ACCEL_ID_LIS3DH},\r
1276         /*compass*/\r
1277         {"compass", COMPASS_ID_ALL},\r
1278         {"ak8975", COMPASS_ID_AK8975},\r
1279         {"mmc314x", COMPASS_ID_MMC314X},\r
1280         /*gyroscope*/\r
1281         {"gyro", GYRO_ID_ALL},  \r
1282         {"l3g4200d_gryo", GYRO_ID_L3G4200D},\r
1283         {"k3g", GYRO_ID_K3G},\r
1284         /*light sensor*/\r
1285         {"lightsensor", LIGHT_ID_ALL},  \r
1286         {"light_al3006", LIGHT_ID_AL3006},\r
1287         {"ls_stk3171", LIGHT_ID_STK3171},\r
1288         /*proximity sensor*/\r
1289         {"psensor", PROXIMITY_ID_ALL},\r
1290         {"proximity_al3006", PROXIMITY_ID_AL3006},      \r
1291         {"ps_stk3171", PROXIMITY_ID_STK3171},\r
1292         /*temperature*/\r
1293         {"temperature", TEMPERATURE_ID_ALL},\r
1294         {},\r
1295 };\r
1296 \r
1297 \r
1298 static struct i2c_driver sensor_driver = {\r
1299         .probe = sensor_probe,\r
1300         .remove = sensor_remove,\r
1301         .shutdown = sensor_shut_down,\r
1302         .id_table = sensor_id,\r
1303         .driver = {\r
1304                    .owner = THIS_MODULE,\r
1305                    .name = "sensors",\r
1306                    },\r
1307 };\r
1308 \r
1309 static int __init sensor_init(void)\r
1310 {\r
1311         int res = i2c_add_driver(&sensor_driver);\r
1312         pr_info("%s: Probe name %s\n", __func__, sensor_driver.driver.name);\r
1313         if (res)\r
1314                 pr_err("%s failed\n", __func__);\r
1315         return res;\r
1316 }\r
1317 \r
1318 static void __exit sensor_exit(void)\r
1319 {\r
1320         pr_info("%s\n", __func__);\r
1321         i2c_del_driver(&sensor_driver);\r
1322 }\r
1323 \r
1324 late_initcall(sensor_init);\r
1325 module_exit(sensor_exit);\r
1326 \r
1327 MODULE_AUTHOR("ROCKCHIP Corporation:lw@rock-chips.com");\r
1328 MODULE_DESCRIPTION("User space character device interface for sensors");\r
1329 MODULE_LICENSE("GPL");\r
1330 \r