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