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                         printk("%s:failed to copy sense data to user space.\n",__FUNCTION__);\r
1056                         return -EFAULT;\r
1057                 }\r
1058 \r
1059                 mutex_unlock(&sensor->operation_mutex);\r
1060                 DBG("%s:L3G4200D_IOCTL_SET_ENABLE OK\n", __func__);\r
1061                 break;\r
1062         case L3G4200D_IOCTL_SET_DELAY:                                  \r
1063                 mutex_lock(&sensor->operation_mutex);\r
1064                 if (copy_from_user(&rate, argp, sizeof(rate)))\r
1065                 return -EFAULT;\r
1066                 if(sensor->status_cur == SENSOR_OFF)\r
1067                 {\r
1068                         if ( (result = sensor->ops->active(client, 1, rate) ) < 0 ) {\r
1069                         mutex_unlock(&sensor->operation_mutex);\r
1070                         printk("%s:fail to active sensor,ret=%d\n",__func__,result);         \r
1071                         goto error;           \r
1072                         }\r
1073                         \r
1074                         if(sensor->pdata->irq_enable)\r
1075                         {\r
1076                                 DBG("%s:enable irq,irq=%d\n",__func__,client->irq);\r
1077                                 enable_irq(client->irq);        //enable irq\r
1078                         }       \r
1079                         else\r
1080                         {\r
1081                                 schedule_delayed_work(&sensor->delaywork, msecs_to_jiffies(sensor->pdata->poll_delay_ms));\r
1082                         }\r
1083                         sensor->status_cur = SENSOR_ON;\r
1084                 }       \r
1085                 \r
1086                 mutex_unlock(&sensor->operation_mutex);\r
1087                 DBG("%s :L3G4200D_IOCTL_SET_DELAY,rate=%d\n",__FUNCTION__,rate);\r
1088                 break;\r
1089 \r
1090         default:\r
1091                 printk("%s:error,cmd=0x%x\n",__func__,cmd);\r
1092                 return -ENOTTY;\r
1093         }\r
1094         \r
1095         DBG("%s:line=%d,cmd=0x%x\n",__func__,__LINE__,cmd);\r
1096 \r
1097 error:\r
1098         return result;\r
1099 }\r
1100 \r
1101 static int light_dev_open(struct inode *inode, struct file *file)\r
1102 {\r
1103         //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_LIGHT];\r
1104         //struct i2c_client *client = sensor->client;   \r
1105         int result = 0; \r
1106 \r
1107 \r
1108         return result;\r
1109 }\r
1110 \r
1111 \r
1112 \r
1113 \r
1114 static int light_dev_release(struct inode *inode, struct file *file)\r
1115 {\r
1116         //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_LIGHT];\r
1117         //struct i2c_client *client = sensor->client;   \r
1118         int result = 0;\r
1119 \r
1120 \r
1121         return result;\r
1122 }\r
1123 \r
1124 #ifdef CONFIG_COMPAT
1125 static long light_dev_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
1126 {
1127         long ret = 0;
1128         void __user *arg64 = compat_ptr(arg);
1129
1130         if (!file->f_op || !file->f_op->unlocked_ioctl) {
1131                 pr_err("[DEBUG] file->f_op or file->f_op->unlocked_ioctl is null\n");
1132                 return -ENOTTY;
1133         }
1134
1135         switch (cmd) {
1136         case COMPAT_LIGHTSENSOR_IOCTL_GET_ENABLED:
1137                 if (file->f_op->unlocked_ioctl)
1138                         ret = file->f_op->unlocked_ioctl(file, LIGHTSENSOR_IOCTL_GET_ENABLED, (unsigned long)arg64);
1139                 break;
1140         case COMPAT_LIGHTSENSOR_IOCTL_ENABLE:
1141                 if (file->f_op->unlocked_ioctl)
1142                         ret = file->f_op->unlocked_ioctl(file, LIGHTSENSOR_IOCTL_ENABLE, (unsigned long)arg64);
1143                 break;
1144         default:
1145                 break;
1146         }
1147
1148         return ret;
1149 }
1150 #endif
1151 \r
1152 /* ioctl - I/O control */\r
1153 static long light_dev_ioctl(struct file *file,\r
1154                           unsigned int cmd, unsigned long arg)\r
1155 {\r
1156         struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_LIGHT];\r
1157         struct i2c_client *client = sensor->client;\r
1158         unsigned int *argp = (unsigned int *)arg;       \r
1159         int result = 0;\r
1160 \r
1161         switch(cmd)\r
1162         {\r
1163                 case LIGHTSENSOR_IOCTL_GET_ENABLED:\r
1164                         *argp = sensor->status_cur;\r
1165                         break;\r
1166                 case LIGHTSENSOR_IOCTL_ENABLE:          \r
1167                         DBG("%s:LIGHTSENSOR_IOCTL_ENABLE start\n", __func__);\r
1168                         mutex_lock(&sensor->operation_mutex);    \r
1169                         if(*(unsigned int *)argp)\r
1170                         {\r
1171                                 if(sensor->status_cur == SENSOR_OFF)\r
1172                                 {\r
1173                                         if ( (result = sensor->ops->active(client, SENSOR_ON, 0) ) < 0 ) {\r
1174                                         mutex_unlock(&sensor->operation_mutex);\r
1175                                         printk("%s:fail to active sensor,ret=%d\n",__func__,result);         \r
1176                                         goto error;           \r
1177                                         }       \r
1178                                         if(sensor->pdata->irq_enable)\r
1179                                         {\r
1180                                                 if(!(sensor->ops->trig & IRQF_SHARED))\r
1181                                                 {\r
1182                                                         DBG("%s:enable irq,irq=%d\n",__func__,client->irq);\r
1183                                                         enable_irq(client->irq);        //enable irq\r
1184                                                 }\r
1185                                         }       \r
1186                                         else\r
1187                                         {\r
1188                                                 schedule_delayed_work(&sensor->delaywork, msecs_to_jiffies(sensor->pdata->poll_delay_ms));\r
1189                                         }\r
1190                                         \r
1191                                         sensor->status_cur = SENSOR_ON;\r
1192                                 }       \r
1193                         }\r
1194                         else\r
1195                         {\r
1196                                 if(sensor->status_cur == SENSOR_ON)\r
1197                                 {\r
1198                                         if ( (result = sensor->ops->active(client, SENSOR_OFF, 0) ) < 0 ) {\r
1199                                         mutex_unlock(&sensor->operation_mutex);              \r
1200                                         goto error;\r
1201                                         }\r
1202                                         \r
1203                                         if(sensor->pdata->irq_enable)\r
1204                                         {                               \r
1205                                                 if(!(sensor->ops->trig & IRQF_SHARED))\r
1206                                                 {\r
1207                                                         DBG("%s:disable irq,irq=%d\n",__func__,client->irq);\r
1208                                                         disable_irq_nosync(client->irq);//disable irq\r
1209                                                 }\r
1210                                         }\r
1211                                         else\r
1212                                         cancel_delayed_work_sync(&sensor->delaywork);   \r
1213                                         \r
1214                                         sensor->status_cur = SENSOR_OFF;\r
1215                                 }\r
1216                         }\r
1217                         mutex_unlock(&sensor->operation_mutex);\r
1218                         DBG("%s:LIGHTSENSOR_IOCTL_ENABLE OK\n", __func__);\r
1219                         break;\r
1220                 \r
1221                 default:\r
1222                         break;\r
1223         }\r
1224         \r
1225 error:\r
1226         return result;\r
1227 }\r
1228 \r
1229 \r
1230 static int proximity_dev_open(struct inode *inode, struct file *file)\r
1231 {\r
1232         //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_PROXIMITY];\r
1233         //struct i2c_client *client = sensor->client;   \r
1234         int result = 0;\r
1235 \r
1236 \r
1237         return result;\r
1238 }\r
1239 \r
1240 \r
1241 static int proximity_dev_release(struct inode *inode, struct file *file)\r
1242 {\r
1243         //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_PROXIMITY];\r
1244         //struct i2c_client *client = sensor->client;   \r
1245         int result = 0;\r
1246 \r
1247 \r
1248         return result;\r
1249 }\r
1250 \r
1251 #ifdef CONFIG_COMPAT
1252 static long proximity_dev_compat_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
1253 {
1254         long ret = 0;
1255         void __user *arg64 = compat_ptr(arg);
1256
1257         if (!file->f_op || !file->f_op->unlocked_ioctl) {
1258                 pr_err("file->f_op or file->f_op->unlocked_ioctl is null\n");
1259                 return -ENOTTY;
1260         }
1261
1262         switch (cmd) {
1263         case COMPAT_PSENSOR_IOCTL_GET_ENABLED:
1264                 if (file->f_op->unlocked_ioctl)
1265                         ret = file->f_op->unlocked_ioctl(file, PSENSOR_IOCTL_GET_ENABLED, (unsigned long)arg64);
1266                 break;
1267         case COMPAT_PSENSOR_IOCTL_ENABLE:
1268                 if (file->f_op->unlocked_ioctl)
1269                         ret = file->f_op->unlocked_ioctl(file, PSENSOR_IOCTL_ENABLE, (unsigned long)arg64);
1270                 break;
1271         default:
1272                 break;
1273         }
1274
1275         return ret;
1276 }
1277 #endif
1278 \r
1279 /* ioctl - I/O control */\r
1280 static long proximity_dev_ioctl(struct file *file,\r
1281                           unsigned int cmd, unsigned long arg)\r
1282 {\r
1283         struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_PROXIMITY];\r
1284         struct i2c_client *client = sensor->client;     \r
1285         unsigned int *argp = (unsigned int *)arg;       \r
1286         int result = 0;\r
1287         switch(cmd)\r
1288         {\r
1289                 case PSENSOR_IOCTL_GET_ENABLED:\r
1290                         *argp = sensor->status_cur;\r
1291                         break;\r
1292                 case PSENSOR_IOCTL_ENABLE:              \r
1293                         DBG("%s:PSENSOR_IOCTL_ENABLE start\n", __func__);\r
1294                         mutex_lock(&sensor->operation_mutex);    \r
1295                         if(*(unsigned int *)argp)\r
1296                         {\r
1297                                 if(sensor->status_cur == SENSOR_OFF)\r
1298                                 {\r
1299                                         if ( (result = sensor->ops->active(client, SENSOR_ON, 0) ) < 0 ) {\r
1300                                         mutex_unlock(&sensor->operation_mutex);\r
1301                                         printk("%s:fail to active sensor,ret=%d\n",__func__,result);         \r
1302                                         goto error;           \r
1303                                         }\r
1304                                         \r
1305                                         if(sensor->pdata->irq_enable)\r
1306                                         {\r
1307                                                 if(!(sensor->ops->trig & IRQF_SHARED))\r
1308                                                 {\r
1309                                                         DBG("%s:enable irq,irq=%d\n",__func__,client->irq);\r
1310                                                         enable_irq(client->irq);        //enable irq\r
1311                                                 }\r
1312                                         }       \r
1313                                         else\r
1314                                         {\r
1315                                                 schedule_delayed_work(&sensor->delaywork, msecs_to_jiffies(sensor->pdata->poll_delay_ms));\r
1316                                         }\r
1317                                         \r
1318                                         sensor->status_cur = SENSOR_ON;\r
1319                                 }       \r
1320                         }\r
1321                         else\r
1322                         {\r
1323                                 if(sensor->status_cur == SENSOR_ON)\r
1324                                 {\r
1325                                         if ( (result = sensor->ops->active(client, SENSOR_OFF, 0) ) < 0 ) {\r
1326                                         mutex_unlock(&sensor->operation_mutex);              \r
1327                                         goto error;\r
1328                                         }\r
1329                                         if(sensor->pdata->irq_enable)\r
1330                                         {                               \r
1331                                                 if(!(sensor->ops->trig & IRQF_SHARED))\r
1332                                                 {\r
1333                                                         DBG("%s:disable irq,irq=%d\n",__func__,client->irq);\r
1334                                                         disable_irq_nosync(client->irq);//disable irq\r
1335                                                 }\r
1336                                         }\r
1337                                         else\r
1338                                         cancel_delayed_work_sync(&sensor->delaywork);           \r
1339                                         sensor->status_cur = SENSOR_OFF;\r
1340                                 }\r
1341                         }\r
1342                         mutex_unlock(&sensor->operation_mutex);\r
1343                         DBG("%s:PSENSOR_IOCTL_ENABLE OK\n", __func__);\r
1344                         break;\r
1345                 \r
1346                 default:\r
1347                         break;\r
1348         }\r
1349         \r
1350 error:\r
1351         return result;\r
1352 }\r
1353 \r
1354 static int temperature_dev_open(struct inode *inode, struct file *file)\r
1355 {\r
1356         //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_TEMPERATURE];\r
1357         //struct i2c_client *client = sensor->client;\r
1358 \r
1359         int result = 0;\r
1360 \r
1361 \r
1362         return result;\r
1363 }\r
1364 \r
1365 \r
1366 static int temperature_dev_release(struct inode *inode, struct file *file)\r
1367 {\r
1368         //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_TEMPERATURE];\r
1369         //struct i2c_client *client = sensor->client;\r
1370 \r
1371         int result = 0;\r
1372 \r
1373 \r
1374         return result;\r
1375 }\r
1376 \r
1377 \r
1378 /* ioctl - I/O control */\r
1379 static long temperature_dev_ioctl(struct file *file,\r
1380                           unsigned int cmd, unsigned long arg)\r
1381 {\r
1382         struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_TEMPERATURE];\r
1383         struct i2c_client *client = sensor->client;\r
1384         unsigned int *argp = (unsigned int *)arg;       \r
1385         int result = 0;\r
1386 \r
1387         switch(cmd)\r
1388         {\r
1389                 case TEMPERATURE_IOCTL_GET_ENABLED:\r
1390                         *argp = sensor->status_cur;\r
1391                         break;\r
1392                 case TEMPERATURE_IOCTL_ENABLE:          \r
1393                         DBG("%s:LIGHTSENSOR_IOCTL_ENABLE start\n", __func__);\r
1394                         mutex_lock(&sensor->operation_mutex);    \r
1395                         if(*(unsigned int *)argp)\r
1396                         {\r
1397                                 if(sensor->status_cur == SENSOR_OFF)\r
1398                                 {\r
1399                                         if ( (result = sensor->ops->active(client, SENSOR_ON, 0) ) < 0 ) {\r
1400                                         mutex_unlock(&sensor->operation_mutex);\r
1401                                         printk("%s:fail to active sensor,ret=%d\n",__func__,result);         \r
1402                                         goto error;           \r
1403                                         }       \r
1404                                         if(sensor->pdata->irq_enable)\r
1405                                         {\r
1406                                                 if(!(sensor->ops->trig & IRQF_SHARED))\r
1407                                                 {\r
1408                                                         DBG("%s:enable irq,irq=%d\n",__func__,client->irq);\r
1409                                                         enable_irq(client->irq);        //enable irq\r
1410                                                 }\r
1411                                         }       \r
1412                                         else\r
1413                                         {\r
1414                                                 schedule_delayed_work(&sensor->delaywork, msecs_to_jiffies(sensor->pdata->poll_delay_ms));\r
1415                                         }\r
1416                                         \r
1417                                         sensor->status_cur = SENSOR_ON;\r
1418                                 }       \r
1419                         }\r
1420                         else\r
1421                         {\r
1422                                 if(sensor->status_cur == SENSOR_ON)\r
1423                                 {\r
1424                                         if ( (result = sensor->ops->active(client, SENSOR_OFF, 0) ) < 0 ) {\r
1425                                         mutex_unlock(&sensor->operation_mutex);              \r
1426                                         goto error;\r
1427                                         }\r
1428                                         \r
1429                                         if(sensor->pdata->irq_enable)\r
1430                                         {                               \r
1431                                                 if(!(sensor->ops->trig & IRQF_SHARED))\r
1432                                                 {\r
1433                                                         DBG("%s:disable irq,irq=%d\n",__func__,client->irq);\r
1434                                                         disable_irq_nosync(client->irq);//disable irq\r
1435                                                 }\r
1436                                         }\r
1437                                         else\r
1438                                         cancel_delayed_work_sync(&sensor->delaywork);   \r
1439                                         \r
1440                                         sensor->status_cur = SENSOR_OFF;\r
1441                                 }\r
1442                         }\r
1443                         mutex_unlock(&sensor->operation_mutex);\r
1444                         DBG("%s:LIGHTSENSOR_IOCTL_ENABLE OK\n", __func__);\r
1445                         break;\r
1446                 \r
1447                 default:\r
1448                         break;\r
1449         }\r
1450         \r
1451 error:\r
1452         return result;\r
1453 }\r
1454 \r
1455 \r
1456 static int pressure_dev_open(struct inode *inode, struct file *file)\r
1457 {\r
1458         //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_PRESSURE];\r
1459         //struct i2c_client *client = sensor->client;\r
1460 \r
1461         int result = 0;\r
1462 \r
1463 \r
1464         return result;\r
1465 }\r
1466 \r
1467 \r
1468 static int pressure_dev_release(struct inode *inode, struct file *file)\r
1469 {\r
1470         //struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_PRESSURE];\r
1471         //struct i2c_client *client = sensor->client;\r
1472 \r
1473         int result = 0;\r
1474 \r
1475 \r
1476         return result;\r
1477 }\r
1478 \r
1479 \r
1480 /* ioctl - I/O control */\r
1481 static long pressure_dev_ioctl(struct file *file,\r
1482                           unsigned int cmd, unsigned long arg)\r
1483 {\r
1484         struct sensor_private_data *sensor = g_sensor[SENSOR_TYPE_PRESSURE];\r
1485         struct i2c_client *client = sensor->client;\r
1486         unsigned int *argp = (unsigned int *)arg;       \r
1487         int result = 0;\r
1488 \r
1489         switch(cmd)\r
1490         {\r
1491                 case PRESSURE_IOCTL_GET_ENABLED:\r
1492                         *argp = sensor->status_cur;\r
1493                         break;\r
1494                 case PRESSURE_IOCTL_ENABLE:             \r
1495                         DBG("%s:LIGHTSENSOR_IOCTL_ENABLE start\n", __func__);\r
1496                         mutex_lock(&sensor->operation_mutex);    \r
1497                         if(*(unsigned int *)argp)\r
1498                         {\r
1499                                 if(sensor->status_cur == SENSOR_OFF)\r
1500                                 {\r
1501                                         if ( (result = sensor->ops->active(client, SENSOR_ON, 0) ) < 0 ) {\r
1502                                         mutex_unlock(&sensor->operation_mutex);\r
1503                                         printk("%s:fail to active sensor,ret=%d\n",__func__,result);         \r
1504                                         goto error;           \r
1505                                         }       \r
1506                                         if(sensor->pdata->irq_enable)\r
1507                                         {\r
1508                                                 if(!(sensor->ops->trig & IRQF_SHARED))\r
1509                                                 {\r
1510                                                         DBG("%s:enable irq,irq=%d\n",__func__,client->irq);\r
1511                                                         enable_irq(client->irq);        //enable irq\r
1512                                                 }\r
1513                                         }       \r
1514                                         else\r
1515                                         {\r
1516                                                 schedule_delayed_work(&sensor->delaywork, msecs_to_jiffies(sensor->pdata->poll_delay_ms));\r
1517                                         }\r
1518                                         \r
1519                                         sensor->status_cur = SENSOR_ON;\r
1520                                 }       \r
1521                         }\r
1522                         else\r
1523                         {\r
1524                                 if(sensor->status_cur == SENSOR_ON)\r
1525                                 {\r
1526                                         if ( (result = sensor->ops->active(client, SENSOR_OFF, 0) ) < 0 ) {\r
1527                                         mutex_unlock(&sensor->operation_mutex);              \r
1528                                         goto error;\r
1529                                         }\r
1530                                         \r
1531                                         if(sensor->pdata->irq_enable)\r
1532                                         {                               \r
1533                                                 if(!(sensor->ops->trig & IRQF_SHARED))\r
1534                                                 {\r
1535                                                         DBG("%s:disable irq,irq=%d\n",__func__,client->irq);\r
1536                                                         disable_irq_nosync(client->irq);//disable irq\r
1537                                                 }\r
1538                                         }\r
1539                                         else\r
1540                                         cancel_delayed_work_sync(&sensor->delaywork);   \r
1541                                         \r
1542                                         sensor->status_cur = SENSOR_OFF;\r
1543                                 }\r
1544                         }\r
1545                         mutex_unlock(&sensor->operation_mutex);\r
1546                         DBG("%s:LIGHTSENSOR_IOCTL_ENABLE OK\n", __func__);\r
1547                         break;\r
1548                 \r
1549                 default:\r
1550                         break;\r
1551         }\r
1552         \r
1553 error:\r
1554         return result;\r
1555 }\r
1556 \r
1557 \r
1558 \r
1559 \r
1560 static int sensor_misc_device_register(struct sensor_private_data *sensor, int type)\r
1561 {\r
1562         int result = 0;\r
1563         \r
1564         switch(type)\r
1565         {\r
1566                 case SENSOR_TYPE_ANGLE:\r
1567                         if(!sensor->ops->misc_dev)\r
1568                         {\r
1569                                 sensor->fops.owner = THIS_MODULE;\r
1570                                 sensor->fops.unlocked_ioctl = angle_dev_ioctl;\r
1571                                 sensor->fops.open = angle_dev_open;\r
1572                                 sensor->fops.release = angle_dev_release;\r
1573 \r
1574                                 sensor->miscdev.minor = MISC_DYNAMIC_MINOR;\r
1575                                 sensor->miscdev.name = "angle";\r
1576                                 sensor->miscdev.fops = &sensor->fops;\r
1577                         }\r
1578                         else\r
1579                         {\r
1580                                 memcpy(&sensor->miscdev, sensor->ops->misc_dev, sizeof(*sensor->ops->misc_dev));\r
1581 \r
1582                         }\r
1583                                 \r
1584                         break;\r
1585                         \r
1586                 case SENSOR_TYPE_ACCEL:\r
1587                         if(!sensor->ops->misc_dev)\r
1588                         {\r
1589                                 sensor->fops.owner = THIS_MODULE;\r
1590                                 sensor->fops.unlocked_ioctl = gsensor_dev_ioctl;\r
1591                 #ifdef CONFIG_COMPAT\r
1592                                 sensor->fops.compat_ioctl = gsensor_dev_ioctl;\r
1593                                 #endif\r
1594                                 sensor->fops.open = gsensor_dev_open;\r
1595                                 sensor->fops.release = gsensor_dev_release;\r
1596 \r
1597                                 sensor->miscdev.minor = MISC_DYNAMIC_MINOR;\r
1598                                 sensor->miscdev.name = "mma8452_daemon";\r
1599                                 sensor->miscdev.fops = &sensor->fops;\r
1600                         }\r
1601                         else\r
1602                         {\r
1603                                 memcpy(&sensor->miscdev, sensor->ops->misc_dev, sizeof(*sensor->ops->misc_dev));\r
1604 \r
1605                         }\r
1606                                 \r
1607                         break;\r
1608 \r
1609                 case SENSOR_TYPE_COMPASS:                       \r
1610                         if(!sensor->ops->misc_dev)\r
1611                         {\r
1612                                 sensor->fops.owner = THIS_MODULE;\r
1613                                 sensor->fops.unlocked_ioctl = compass_dev_ioctl;\r
1614 #ifdef CONFIG_COMPAT
1615                                 sensor->fops.compat_ioctl = compass_dev_compat_ioctl;
1616 #endif
1617                                 sensor->fops.open = compass_dev_open;\r
1618                                 sensor->fops.release = compass_dev_release;\r
1619 \r
1620                                 sensor->miscdev.minor = MISC_DYNAMIC_MINOR;\r
1621                                 sensor->miscdev.name = "compass";\r
1622                                 sensor->miscdev.fops = &sensor->fops;\r
1623                         }\r
1624                         else\r
1625                         {\r
1626                                 memcpy(&sensor->miscdev, sensor->ops->misc_dev, sizeof(*sensor->ops->misc_dev));\r
1627 \r
1628                         }\r
1629 \r
1630                         break;\r
1631 \r
1632                 case SENSOR_TYPE_GYROSCOPE:                     \r
1633                         if(!sensor->ops->misc_dev)\r
1634                         {\r
1635                                 sensor->fops.owner = THIS_MODULE;\r
1636                                 sensor->fops.unlocked_ioctl = gyro_dev_ioctl;\r
1637                                 sensor->fops.open = gyro_dev_open;\r
1638                                 sensor->fops.release = gyro_dev_release;\r
1639 \r
1640                                 sensor->miscdev.minor = MISC_DYNAMIC_MINOR;\r
1641                                 sensor->miscdev.name = "gyrosensor";\r
1642                                 sensor->miscdev.fops = &sensor->fops;\r
1643                         }\r
1644                         else\r
1645                         {\r
1646                                 memcpy(&sensor->miscdev, sensor->ops->misc_dev, sizeof(*sensor->ops->misc_dev));\r
1647 \r
1648                         }\r
1649                         \r
1650                         break;\r
1651 \r
1652                 case SENSOR_TYPE_LIGHT:\r
1653                         if(!sensor->ops->misc_dev)\r
1654                         {\r
1655                                 sensor->fops.owner = THIS_MODULE;\r
1656                                 sensor->fops.unlocked_ioctl = light_dev_ioctl;\r
1657 #ifdef CONFIG_COMPAT
1658                                 sensor->fops.compat_ioctl = light_dev_compat_ioctl;
1659 #endif
1660                                 sensor->fops.open = light_dev_open;\r
1661                                 sensor->fops.release = light_dev_release;\r
1662 \r
1663                                 sensor->miscdev.minor = MISC_DYNAMIC_MINOR;\r
1664                                 sensor->miscdev.name = "lightsensor";\r
1665                                 sensor->miscdev.fops = &sensor->fops;\r
1666                         }       \r
1667                         else\r
1668                         {\r
1669                                 memcpy(&sensor->miscdev, sensor->ops->misc_dev, sizeof(*sensor->ops->misc_dev));\r
1670 \r
1671                         }\r
1672                         break;\r
1673                 \r
1674                 case SENSOR_TYPE_PROXIMITY:\r
1675                         if(!sensor->ops->misc_dev)\r
1676                         {\r
1677                                 sensor->fops.owner = THIS_MODULE;\r
1678                                 sensor->fops.unlocked_ioctl = proximity_dev_ioctl;\r
1679 #ifdef CONFIG_COMPAT
1680                                 sensor->fops.compat_ioctl = proximity_dev_compat_ioctl;
1681 #endif
1682                                 sensor->fops.open = proximity_dev_open;\r
1683                                 sensor->fops.release = proximity_dev_release;\r
1684 \r
1685                                 sensor->miscdev.minor = MISC_DYNAMIC_MINOR;\r
1686                                 sensor->miscdev.name = "psensor";\r
1687                                 sensor->miscdev.fops = &sensor->fops;\r
1688                         }       \r
1689                         else\r
1690                         {\r
1691                                 memcpy(&sensor->miscdev, sensor->ops->misc_dev, sizeof(*sensor->ops->misc_dev));\r
1692 \r
1693                         }\r
1694                         break;\r
1695 \r
1696                 case SENSOR_TYPE_TEMPERATURE:\r
1697                         if(!sensor->ops->misc_dev)\r
1698                         {\r
1699                                 sensor->fops.owner = THIS_MODULE;\r
1700                                 sensor->fops.unlocked_ioctl = temperature_dev_ioctl;\r
1701                                 sensor->fops.open = temperature_dev_open;\r
1702                                 sensor->fops.release = temperature_dev_release;\r
1703 \r
1704                                 sensor->miscdev.minor = MISC_DYNAMIC_MINOR;\r
1705                                 sensor->miscdev.name = "temperature";\r
1706                                 sensor->miscdev.fops = &sensor->fops;\r
1707                         }       \r
1708                         else\r
1709                         {\r
1710                                 memcpy(&sensor->miscdev, sensor->ops->misc_dev, sizeof(*sensor->ops->misc_dev));\r
1711 \r
1712                         }\r
1713                                 \r
1714                         break;\r
1715 \r
1716                 case SENSOR_TYPE_PRESSURE:\r
1717                         if(!sensor->ops->misc_dev)\r
1718                         {\r
1719                                 sensor->fops.owner = THIS_MODULE;\r
1720                                 sensor->fops.unlocked_ioctl = pressure_dev_ioctl;\r
1721                                 sensor->fops.open = pressure_dev_open;\r
1722                                 sensor->fops.release = pressure_dev_release;\r
1723 \r
1724                                 sensor->miscdev.minor = MISC_DYNAMIC_MINOR;\r
1725                                 sensor->miscdev.name = "pressure";\r
1726                                 sensor->miscdev.fops = &sensor->fops;\r
1727                         }       \r
1728                         else\r
1729                         {\r
1730                                 memcpy(&sensor->miscdev, sensor->ops->misc_dev, sizeof(*sensor->ops->misc_dev));\r
1731 \r
1732                         }\r
1733                                 \r
1734                         break;\r
1735 \r
1736                 default:\r
1737                         printk("%s:unknow sensor type=%d\n",__func__,type);\r
1738                         result = -1;\r
1739                         goto error;\r
1740         }\r
1741                         \r
1742         sensor->miscdev.parent = &sensor->client->dev;\r
1743         result = misc_register(&sensor->miscdev);\r
1744         if (result < 0) {\r
1745                 dev_err(&sensor->client->dev,\r
1746                         "fail to register misc device %s\n", sensor->miscdev.name);\r
1747                 goto error;\r
1748         }\r
1749         \r
1750         printk("%s:miscdevice: %s\n",__func__,sensor->miscdev.name);\r
1751 \r
1752 error:  \r
1753         \r
1754         return result;\r
1755 \r
1756 }\r
1757 \r
1758 int sensor_register_slave(int type,struct i2c_client *client,\r
1759                         struct sensor_platform_data *slave_pdata,\r
1760                         struct sensor_operate *(*get_sensor_ops)(void))\r
1761 {\r
1762         int result = 0;\r
1763         struct sensor_operate *ops = get_sensor_ops();\r
1764         if((ops->id_i2c >= SENSOR_NUM_ID) || (ops->id_i2c <= ID_INVALID))\r
1765         {       \r
1766                 printk("%s:%s id is error %d\n", __func__, ops->name, ops->id_i2c);\r
1767                 return -1;      \r
1768         }\r
1769         sensor_ops[ops->id_i2c] = ops;\r
1770         printk("%s:%s,id=%d\n",__func__,sensor_ops[ops->id_i2c]->name, ops->id_i2c);\r
1771         return result;\r
1772 }\r
1773 \r
1774 \r
1775 int sensor_unregister_slave(int type,struct i2c_client *client,\r
1776                         struct sensor_platform_data *slave_pdata,\r
1777                         struct sensor_operate *(*get_sensor_ops)(void))\r
1778 {\r
1779         int result = 0;\r
1780         struct sensor_operate *ops = get_sensor_ops();\r
1781         if((ops->id_i2c >= SENSOR_NUM_ID) || (ops->id_i2c <= ID_INVALID))\r
1782         {       \r
1783                 printk("%s:%s id is error %d\n", __func__, ops->name, ops->id_i2c);\r
1784                 return -1;      \r
1785         }\r
1786         printk("%s:%s,id=%d\n",__func__,sensor_ops[ops->id_i2c]->name, ops->id_i2c);\r
1787         sensor_ops[ops->id_i2c] = NULL; \r
1788         return result;\r
1789 }\r
1790 \r
1791 \r
1792 int sensor_probe(struct i2c_client *client, const struct i2c_device_id *devid)\r
1793 {\r
1794         struct sensor_private_data *sensor =\r
1795             (struct sensor_private_data *) i2c_get_clientdata(client);\r
1796         struct sensor_platform_data *pdata;\r
1797         struct device_node *np = client->dev.of_node;\r
1798         enum of_gpio_flags rst_flags, pwr_flags;\r
1799         unsigned long irq_flags;\r
1800         int result = 0;\r
1801         int type = 0;\r
1802         \r
1803         dev_info(&client->adapter->dev, "%s: %s,%p\n", __func__, devid->name, client);\r
1804 \r
1805         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {\r
1806                 result = -ENODEV;\r
1807                 goto out_no_free;\r
1808         }\r
1809         if (!np) {\r
1810                 dev_err(&client->dev, "no device tree\n");\r
1811                 return -EINVAL;\r
1812         }\r
1813     pdata = devm_kzalloc(&client->dev,sizeof(*pdata), GFP_KERNEL);\r
1814         if (!pdata) {\r
1815                 result = -ENOMEM;\r
1816                 goto out_no_free;\r
1817         }\r
1818         sensor = devm_kzalloc(&client->dev,sizeof(*sensor), GFP_KERNEL);\r
1819         if (!sensor) {\r
1820                 result = -ENOMEM;\r
1821                 goto out_no_free;\r
1822         }\r
1823         \r
1824         of_property_read_u32(np,"type",&(pdata->type));\r
1825 \r
1826         pdata->irq_pin = of_get_named_gpio_flags(np, "irq-gpio", 0,(enum of_gpio_flags *)&irq_flags);\r
1827         pdata->reset_pin = of_get_named_gpio_flags(np, "reset-gpio",0,&rst_flags);\r
1828         pdata->power_pin = of_get_named_gpio_flags(np, "power-gpio",0,&pwr_flags);\r
1829         \r
1830         of_property_read_u32(np,"irq_enable",&(pdata->irq_enable));\r
1831         of_property_read_u32(np,"poll_delay_ms",&(pdata->poll_delay_ms));\r
1832 \r
1833         of_property_read_u32(np,"x_min",&(pdata->x_min));\r
1834         of_property_read_u32(np,"y_min",&(pdata->y_min));\r
1835         of_property_read_u32(np,"z_min",&(pdata->z_min));\r
1836         of_property_read_u32(np,"factory",&(pdata->factory));\r
1837         of_property_read_u32(np,"layout",&(pdata->layout));\r
1838 \r
1839         of_property_read_u8(np,"address",&(pdata->address));\r
1840         of_get_property(np, "project_name", pdata->project_name);\r
1841
1842         of_property_read_u32(np, "power-off-in-suspend",
1843                              &pdata->power_off_in_suspend);
1844 \r
1845         switch(pdata->layout)\r
1846         {\r
1847                 case 1:\r
1848                         pdata->orientation[0] = 1;\r
1849                         pdata->orientation[1] = 0;\r
1850                         pdata->orientation[2] = 0;\r
1851 \r
1852                         pdata->orientation[3] = 0;\r
1853                         pdata->orientation[4] = 1;\r
1854                         pdata->orientation[5] = 0;\r
1855 \r
1856                         pdata->orientation[6] = 0;\r
1857                         pdata->orientation[7] = 0;\r
1858                         pdata->orientation[8] = 1;\r
1859                         break;\r
1860 \r
1861                 case 2:\r
1862                         pdata->orientation[0] = 0;\r
1863                         pdata->orientation[1] = -1;\r
1864                         pdata->orientation[2] = 0;\r
1865 \r
1866                         pdata->orientation[3] = 1;\r
1867                         pdata->orientation[4] = 0;\r
1868                         pdata->orientation[5] = 0;\r
1869 \r
1870                         pdata->orientation[6] = 0;\r
1871                         pdata->orientation[7] = 0;\r
1872                         pdata->orientation[8] = 1;\r
1873                         break;\r
1874 \r
1875                 case 3:\r
1876                         pdata->orientation[0] = -1;\r
1877                         pdata->orientation[1] = 0;\r
1878                         pdata->orientation[2] = 0;\r
1879 \r
1880                         pdata->orientation[3] = 0;\r
1881                         pdata->orientation[4] = -1;\r
1882                         pdata->orientation[5] = 0;\r
1883 \r
1884                         pdata->orientation[6] = 0;\r
1885                         pdata->orientation[7] = 0;\r
1886                         pdata->orientation[8] = 1;\r
1887                         break;\r
1888 \r
1889                 case 4:\r
1890                         pdata->orientation[0] = 0;\r
1891                         pdata->orientation[1] = 1;\r
1892                         pdata->orientation[2] = 0;\r
1893 \r
1894                         pdata->orientation[3] = -1;\r
1895                         pdata->orientation[4] = 0;\r
1896                         pdata->orientation[5] = 0;\r
1897 \r
1898                         pdata->orientation[6] = 0;\r
1899                         pdata->orientation[7] = 0;\r
1900                         pdata->orientation[8] = 1;\r
1901                         break;\r
1902 \r
1903                 case 5:\r
1904                         pdata->orientation[0] = 1;\r
1905                         pdata->orientation[1] = 0;\r
1906                         pdata->orientation[2] = 0;\r
1907 \r
1908                         pdata->orientation[3] = 0;\r
1909                         pdata->orientation[4] = -1;\r
1910                         pdata->orientation[5] = 0;\r
1911 \r
1912                         pdata->orientation[6] = 0;\r
1913                         pdata->orientation[7] = 0;\r
1914                         pdata->orientation[8] = -1;\r
1915                         break;\r
1916 \r
1917                 case 6:\r
1918                         pdata->orientation[0] = 0;\r
1919                         pdata->orientation[1] = -1;\r
1920                         pdata->orientation[2] = 0;\r
1921 \r
1922                         pdata->orientation[3] = -1;\r
1923                         pdata->orientation[4] = 0;\r
1924                         pdata->orientation[5] = 0;\r
1925 \r
1926                         pdata->orientation[6] = 0;\r
1927                         pdata->orientation[7] = 0;\r
1928                         pdata->orientation[8] = -1;\r
1929                         break;\r
1930 \r
1931                 case 7:\r
1932                         pdata->orientation[0] = -1;\r
1933                         pdata->orientation[1] = 0;\r
1934                         pdata->orientation[2] = 0;\r
1935 \r
1936                         pdata->orientation[3] = 0;\r
1937                         pdata->orientation[4] = 1;\r
1938                         pdata->orientation[5] = 0;\r
1939 \r
1940                         pdata->orientation[6] = 0;\r
1941                         pdata->orientation[7] = 0;\r
1942                         pdata->orientation[8] = -1;\r
1943                         break;\r
1944 \r
1945                 case 8:\r
1946                         pdata->orientation[0] = 0;\r
1947                         pdata->orientation[1] = 1;\r
1948                         pdata->orientation[2] = 0;\r
1949 \r
1950                         pdata->orientation[3] = 1;\r
1951                         pdata->orientation[4] = 0;\r
1952                         pdata->orientation[5] = 0;\r
1953 \r
1954                         pdata->orientation[6] = 0;\r
1955                         pdata->orientation[7] = 0;\r
1956                         pdata->orientation[8] = -1;\r
1957                         break;\r
1958 \r
1959                 default:\r
1960                         pdata->orientation[0] = 1;\r
1961                         pdata->orientation[1] = 0;\r
1962                         pdata->orientation[2] = 0;\r
1963 \r
1964                         pdata->orientation[3] = 0;\r
1965                         pdata->orientation[4] = 1;\r
1966                         pdata->orientation[5] = 0;\r
1967 \r
1968                         pdata->orientation[6] = 0;\r
1969                         pdata->orientation[7] = 0;\r
1970                         pdata->orientation[8] = 1;\r
1971                         break;\r
1972         }\r
1973 \r
1974         client->irq = pdata->irq_pin;\r
1975         type = pdata->type;\r
1976         pdata->irq_flags = irq_flags;\r
1977         DBG("irq_flags = %lu  padta->irq_flags = %lu\n",irq_flags, pdata->irq_flags);\r
1978         DBG("type = %d \n",pdata->type);\r
1979         DBG("irq = %d \n",pdata->irq);\r
1980         DBG("irq_pin = %d \n",pdata->irq_pin);\r
1981         DBG("pwer_pin = %d \n",pdata->power_pin);       \r
1982         DBG("reset_pin = %d \n",pdata->reset_pin);\r
1983         DBG("irq_enable = %d \n",pdata->irq_enable);\r
1984 \r
1985         DBG("poll_delay_ms = %d \n",pdata->poll_delay_ms);\r
1986         DBG("x_min = %d \n",pdata->x_min);\r
1987         DBG("y_min = %d \n",pdata->y_min);\r
1988         DBG("z_min = %d \n",pdata->z_min);      \r
1989         DBG("factory = %d \n",pdata->factory);\r
1990         DBG("layout = %d \n",pdata->layout);\r
1991         DBG("address = 0x%x \n",pdata->address);\r
1992         DBG("project_name = [%s] \n",pdata->project_name);\r
1993         \r
1994         DBG(" == %d,%d ,%d \t ,%d ,%d ,%d , \t ,%d, %d, %d ,==%d\n",pdata->orientation[0],pdata->orientation[1],pdata->orientation[2]\r
1995                                 ,pdata->orientation[3],pdata->orientation[4],pdata->orientation[5]\r
1996                                 ,pdata->orientation[6],pdata->orientation[7],pdata->orientation[8],ARRAY_SIZE(pdata->orientation));\r
1997                 \r
1998         \r
1999         if((type >= SENSOR_NUM_TYPES) || (type <= SENSOR_TYPE_NULL))\r
2000         {       \r
2001                 dev_err(&client->adapter->dev, "sensor type is error %d\n", type);\r
2002                 result = -EFAULT;\r
2003                 goto out_no_free;       \r
2004         }\r
2005         if(((int)devid->driver_data >= SENSOR_NUM_ID) || ((int)devid->driver_data <= ID_INVALID))\r
2006         {       \r
2007                 dev_err(&client->adapter->dev, "sensor id is error %d\n", (int)devid->driver_data);\r
2008                 result = -EFAULT;\r
2009                 goto out_no_free;       \r
2010         }\r
2011         i2c_set_clientdata(client, sensor);\r
2012         sensor->client = client;        \r
2013         sensor->pdata = pdata;  \r
2014         sensor->type = type;\r
2015         sensor->i2c_id = (struct i2c_device_id *)devid;\r
2016 \r
2017                 \r
2018         memset(&(sensor->axis), 0, sizeof(struct sensor_axis) );\r
2019         atomic_set(&(sensor->data_ready), 0);\r
2020         init_waitqueue_head(&(sensor->data_ready_wq));\r
2021         mutex_init(&sensor->data_mutex);        \r
2022         mutex_init(&sensor->operation_mutex);   \r
2023         mutex_init(&sensor->sensor_mutex);\r
2024         mutex_init(&sensor->i2c_mutex);\r
2025 \r
2026         /* As default, report all information */\r
2027         atomic_set(&sensor->flags.m_flag, 1);\r
2028         atomic_set(&sensor->flags.a_flag, 1);\r
2029         atomic_set(&sensor->flags.mv_flag, 1);                  \r
2030         atomic_set(&sensor->flags.open_flag, 0);\r
2031         atomic_set(&sensor->flags.debug_flag, 1);\r
2032         init_waitqueue_head(&sensor->flags.open_wq);\r
2033         sensor->flags.delay = 100;\r
2034 \r
2035         sensor->status_cur = SENSOR_OFF;\r
2036         sensor->axis.x = 0;\r
2037         sensor->axis.y = 0;\r
2038         sensor->axis.z = 0;\r
2039         \r
2040         result = sensor_chip_init(sensor->client);\r
2041         if(result < 0)\r
2042                 goto out_free_memory;\r
2043         \r
2044         sensor->input_dev = input_allocate_device();\r
2045         if (!sensor->input_dev) {\r
2046                 result = -ENOMEM;\r
2047                 dev_err(&client->dev,\r
2048                         "Failed to allocate input device %s\n", sensor->input_dev->name);\r
2049                 goto out_free_memory;\r
2050         }       \r
2051 \r
2052         switch(type)\r
2053         {\r
2054                 case SENSOR_TYPE_ANGLE: \r
2055                         sensor->input_dev->name = "angle";\r
2056                         set_bit(EV_ABS, sensor->input_dev->evbit);\r
2057                         /* x-axis acceleration */\r
2058                         input_set_abs_params(sensor->input_dev, ABS_X, sensor->ops->range[0], sensor->ops->range[1], 0, 0); //2g full scale range\r
2059                         /* y-axis acceleration */\r
2060                         input_set_abs_params(sensor->input_dev, ABS_Y, sensor->ops->range[0], sensor->ops->range[1], 0, 0); //2g full scale range\r
2061                         /* z-axis acceleration */\r
2062                         input_set_abs_params(sensor->input_dev, ABS_Z, sensor->ops->range[0], sensor->ops->range[1], 0, 0); //2g full scale range\r
2063                         break;  \r
2064 \r
2065                 case SENSOR_TYPE_ACCEL: \r
2066                         sensor->input_dev->name = "gsensor";\r
2067                         set_bit(EV_ABS, sensor->input_dev->evbit);\r
2068                         /* x-axis acceleration */\r
2069                         input_set_abs_params(sensor->input_dev, ABS_X, sensor->ops->range[0], sensor->ops->range[1], 0, 0); //2g full scale range\r
2070                         /* y-axis acceleration */\r
2071                         input_set_abs_params(sensor->input_dev, ABS_Y, sensor->ops->range[0], sensor->ops->range[1], 0, 0); //2g full scale range\r
2072                         /* z-axis acceleration */\r
2073                         input_set_abs_params(sensor->input_dev, ABS_Z, sensor->ops->range[0], sensor->ops->range[1], 0, 0); //2g full scale range\r
2074                         break;          \r
2075                 case SENSOR_TYPE_COMPASS:       \r
2076                         sensor->input_dev->name = "compass";            \r
2077                         /* Setup input device */\r
2078                         set_bit(EV_ABS, sensor->input_dev->evbit);\r
2079                         /* yaw (0, 360) */\r
2080                         input_set_abs_params(sensor->input_dev, ABS_RX, 0, 23040, 0, 0);\r
2081                         /* pitch (-180, 180) */\r
2082                         input_set_abs_params(sensor->input_dev, ABS_RY, -11520, 11520, 0, 0);\r
2083                         /* roll (-90, 90) */\r
2084                         input_set_abs_params(sensor->input_dev, ABS_RZ, -5760, 5760, 0, 0);\r
2085                         /* x-axis acceleration (720 x 8G) */\r
2086                         input_set_abs_params(sensor->input_dev, ABS_X, -5760, 5760, 0, 0);\r
2087                         /* y-axis acceleration (720 x 8G) */\r
2088                         input_set_abs_params(sensor->input_dev, ABS_Y, -5760, 5760, 0, 0);\r
2089                         /* z-axis acceleration (720 x 8G) */\r
2090                         input_set_abs_params(sensor->input_dev, ABS_Z, -5760, 5760, 0, 0);\r
2091                         /* status of magnetic sensor */\r
2092                         input_set_abs_params(sensor->input_dev, ABS_RUDDER, -32768, 3, 0, 0);\r
2093                         /* status of acceleration sensor */\r
2094                         input_set_abs_params(sensor->input_dev, ABS_WHEEL, -32768, 3, 0, 0);\r
2095                         /* x-axis of raw magnetic vector (-4096, 4095) */\r
2096                         input_set_abs_params(sensor->input_dev, ABS_HAT0X, -20480, 20479, 0, 0);\r
2097                         /* y-axis of raw magnetic vector (-4096, 4095) */\r
2098                         input_set_abs_params(sensor->input_dev, ABS_HAT0Y, -20480, 20479, 0, 0);\r
2099                         /* z-axis of raw magnetic vector (-4096, 4095) */\r
2100                         input_set_abs_params(sensor->input_dev, ABS_BRAKE, -20480, 20479, 0, 0);\r
2101                         break;          \r
2102                 case SENSOR_TYPE_GYROSCOPE:\r
2103                         sensor->input_dev->name = "gyro";\r
2104                         /* x-axis acceleration */\r
2105                         input_set_capability(sensor->input_dev, EV_REL, REL_RX);\r
2106                         input_set_abs_params(sensor->input_dev, ABS_RX, sensor->ops->range[0], sensor->ops->range[1], 0, 0); \r
2107                         /* y-axis acceleration */       \r
2108                         input_set_capability(sensor->input_dev, EV_REL, REL_RY);\r
2109                         input_set_abs_params(sensor->input_dev, ABS_RY, sensor->ops->range[0], sensor->ops->range[1], 0, 0); \r
2110                         /* z-axis acceleration */\r
2111                         input_set_capability(sensor->input_dev, EV_REL, REL_RZ);\r
2112                         input_set_abs_params(sensor->input_dev, ABS_RZ, sensor->ops->range[0], sensor->ops->range[1], 0, 0); \r
2113                         break;\r
2114                 case SENSOR_TYPE_LIGHT:\r
2115                         sensor->input_dev->name = "lightsensor-level";\r
2116                         set_bit(EV_ABS, sensor->input_dev->evbit);\r
2117                         input_set_abs_params(sensor->input_dev, ABS_MISC, sensor->ops->range[0], sensor->ops->range[1], 0, 0);                  \r
2118                         input_set_abs_params(sensor->input_dev, ABS_TOOL_WIDTH ,  sensor->ops->brightness[0],sensor->ops->brightness[1], 0, 0);\r
2119                         break;\r
2120                 case SENSOR_TYPE_PROXIMITY:\r
2121                         sensor->input_dev->name = "proximity";  \r
2122                         set_bit(EV_ABS, sensor->input_dev->evbit);\r
2123                         input_set_abs_params(sensor->input_dev, ABS_DISTANCE, sensor->ops->range[0], sensor->ops->range[1], 0, 0);\r
2124                         break;\r
2125                 case SENSOR_TYPE_TEMPERATURE:                           \r
2126                         sensor->input_dev->name = "temperature";\r
2127                         set_bit(EV_ABS, sensor->input_dev->evbit);              \r
2128                         input_set_abs_params(sensor->input_dev, ABS_THROTTLE, sensor->ops->range[0], sensor->ops->range[1], 0, 0);\r
2129                         break;\r
2130                 case SENSOR_TYPE_PRESSURE:                              \r
2131                         sensor->input_dev->name = "pressure";\r
2132                         set_bit(EV_ABS, sensor->input_dev->evbit);              \r
2133                         input_set_abs_params(sensor->input_dev, ABS_PRESSURE, sensor->ops->range[0], sensor->ops->range[1], 0, 0);\r
2134                         break;\r
2135                 default:\r
2136                         printk("%s:unknow sensor type=%d\n",__func__,type);\r
2137                         break;\r
2138 \r
2139         }\r
2140         sensor->input_dev->dev.parent = &client->dev;\r
2141 \r
2142         result = input_register_device(sensor->input_dev);\r
2143         if (result) {\r
2144                 dev_err(&client->dev,\r
2145                         "Unable to register input device %s\n", sensor->input_dev->name);\r
2146                 goto out_input_register_device_failed;\r
2147         }\r
2148 \r
2149         result = sensor_irq_init(sensor->client);\r
2150         if (result) {\r
2151                 dev_err(&client->dev,\r
2152                         "fail to init sensor irq,ret=%d\n",result);\r
2153                 goto out_input_register_device_failed;\r
2154         }\r
2155 \r
2156         \r
2157         sensor->miscdev.parent = &client->dev;\r
2158         result = sensor_misc_device_register(sensor, type);\r
2159         if (result) {\r
2160                 dev_err(&client->dev,\r
2161                         "fail to register misc device %s\n", sensor->miscdev.name);\r
2162                 goto out_misc_device_register_device_failed;\r
2163         }\r
2164         \r
2165         g_sensor[type] = sensor;\r
2166 \r
2167         if((type == SENSOR_TYPE_ACCEL) && (sensor->pdata->factory))     //only support  setting gsensor orientation online now  \r
2168         {\r
2169                 result = gsensor_class_init();\r
2170                 if (result) {\r
2171                         dev_err(&client->dev,\r
2172                                 "fail to register misc device %s\n", sensor->i2c_id->name);\r
2173                         goto out_misc_device_register_device_failed;\r
2174                 }\r
2175         }       \r
2176         \r
2177 #ifdef CONFIG_HAS_EARLYSUSPEND\r
2178         if((sensor->ops->suspend) && (sensor->ops->resume))\r
2179         {\r
2180                 sensor->early_suspend.suspend = sensor_suspend;\r
2181                 sensor->early_suspend.resume = sensor_resume;\r
2182                 sensor->early_suspend.level = 0x02;\r
2183                 register_early_suspend(&sensor->early_suspend);\r
2184         }\r
2185 #endif\r
2186 \r
2187         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
2188 \r
2189         return result;\r
2190         \r
2191 out_misc_device_register_device_failed:\r
2192         input_unregister_device(sensor->input_dev);     \r
2193 out_input_register_device_failed:\r
2194         input_free_device(sensor->input_dev);   \r
2195 out_free_memory:\r
2196         //kfree(sensor);\r
2197 out_no_free:\r
2198         dev_err(&client->adapter->dev, "%s failed %d\n\n", __func__, result);\r
2199         return result;\r
2200 \r
2201 }\r
2202 \r
2203 static void sensor_shut_down(struct i2c_client *client)\r
2204 {\r
2205 #ifdef CONFIG_HAS_EARLYSUSPEND\r
2206         struct sensor_private_data *sensor =\r
2207             (struct sensor_private_data *) i2c_get_clientdata(client);\r
2208         if((sensor->ops->suspend) && (sensor->ops->resume))             \r
2209                 unregister_early_suspend(&sensor->early_suspend);\r
2210         DBG("%s:%s\n",__func__,sensor->i2c_id->name);\r
2211 #endif\r
2212 }\r
2213 \r
2214 static int sensor_remove(struct i2c_client *client)\r
2215 {\r
2216         struct sensor_private_data *sensor =\r
2217             (struct sensor_private_data *) i2c_get_clientdata(client);\r
2218         int result = 0;\r
2219         \r
2220         cancel_delayed_work_sync(&sensor->delaywork);\r
2221         misc_deregister(&sensor->miscdev);\r
2222         input_unregister_device(sensor->input_dev);     \r
2223         input_free_device(sensor->input_dev);   \r
2224         kfree(sensor);\r
2225 #ifdef CONFIG_HAS_EARLYSUSPEND\r
2226         if((sensor->ops->suspend) && (sensor->ops->resume))\r
2227                 unregister_early_suspend(&sensor->early_suspend);\r
2228 #endif  \r
2229         return result;\r
2230 }\r
2231 \r
2232 static const struct i2c_device_id sensor_id[] = {\r
2233         /*angle*/       \r
2234         {"angle_kxtik", ANGLE_ID_KXTIK},\r
2235         {"angle_lis3dh", ANGLE_ID_LIS3DH},      \r
2236         /*gsensor*/\r
2237         {"gsensor", ACCEL_ID_ALL},\r
2238         {"gs_mma8452", ACCEL_ID_MMA845X},       \r
2239         {"gs_kxtik", ACCEL_ID_KXTIK},   \r
2240         {"gs_kxtj9", ACCEL_ID_KXTJ9},\r
2241         {"gs_lis3dh", ACCEL_ID_LIS3DH},\r
2242         {"gs_mma7660", ACCEL_ID_MMA7660},\r
2243         {"gs_mxc6225", ACCEL_ID_MXC6225},       \r
2244         {"gs_dmard10", ACCEL_ID_DMARD10},\r
2245         {"gs_lsm303d", ACCEL_ID_LSM303D},\r
2246         {"gs_mc3230",ACCEL_ID_MC3230},\r
2247         {"mpu6880_acc",ACCEL_ID_MPU6880},\r
2248         {"mpu6500_acc",ACCEL_ID_MPU6500},\r
2249         {"lsm330_acc", ACCEL_ID_LSM330},
2250         /*compass*/\r
2251         {"compass", COMPASS_ID_ALL},\r
2252         {"ak8975", COMPASS_ID_AK8975},  \r
2253         {"ak8963", COMPASS_ID_AK8963},\r
2254         {"ak09911", COMPASS_ID_AK09911},\r
2255         {"mmc314x", COMPASS_ID_MMC314X},\r
2256         /*gyroscope*/\r
2257         {"gyro", GYRO_ID_ALL},  \r
2258         {"l3g4200d_gyro", GYRO_ID_L3G4200D},\r
2259         {"l3g20d_gyro", GYRO_ID_L3G20D},\r
2260         {"ewtsa_gyro", GYRO_ID_EWTSA},\r
2261         {"k3g", GYRO_ID_K3G},\r
2262         {"mpu6880_gyro",GYRO_ID_MPU6880},\r
2263         {"lsm330_gyro", GYRO_ID_LSM330},
2264         /*light sensor*/\r
2265         {"lightsensor", LIGHT_ID_ALL},  \r
2266         {"light_cm3217", LIGHT_ID_CM3217},\r
2267         {"light_cm3218", LIGHT_ID_CM3218},\r
2268         {"light_cm3232", LIGHT_ID_CM3232},\r
2269         {"light_al3006", LIGHT_ID_AL3006},\r
2270         {"ls_stk3171", LIGHT_ID_STK3171},\r
2271         {"ls_isl29023", LIGHT_ID_ISL29023},\r
2272         {"ls_ap321xx", LIGHT_ID_AP321XX},\r
2273         {"ls_photoresistor", LIGHT_ID_PHOTORESISTOR},\r
2274         {"ls_us5152", LIGHT_ID_US5152},\r
2275         /*proximity sensor*/\r
2276         {"psensor", PROXIMITY_ID_ALL},\r
2277         {"proximity_al3006", PROXIMITY_ID_AL3006},      \r
2278         {"ps_stk3171", PROXIMITY_ID_STK3171},\r
2279         {"ps_ap321xx", PROXIMITY_ID_AP321XX},\r
2280         \r
2281         /*temperature*/\r
2282         {"temperature", TEMPERATURE_ID_ALL},    \r
2283         {"tmp_ms5607", TEMPERATURE_ID_MS5607},\r
2284 \r
2285         /*pressure*/\r
2286         {"pressure", PRESSURE_ID_ALL},\r
2287         {"pr_ms5607", PRESSURE_ID_MS5607},\r
2288         \r
2289         {},\r
2290 };\r
2291 \r
2292 static struct of_device_id sensor_dt_ids[] = {\r
2293         /*gsensor*/\r
2294         { .compatible = "gs_mma8452" },\r
2295         { .compatible = "gs_lis3dh" },\r
2296         { .compatible = "gs_lsm303d" },\r
2297         { .compatible = "gs_mma7660" },\r
2298         { .compatible = "gs_mxc6225" },\r
2299         { .compatible = "gs_mc3230" },\r
2300         { .compatible = "lsm330_acc" },
2301         /*compass*/\r
2302         { .compatible = "ak8975" },\r
2303         { .compatible = "ak8963" },\r
2304         { .compatible = "ak09911" },\r
2305         { .compatible = "mmc314x" },\r
2306 \r
2307         /* gyroscop*/\r
2308         { .compatible = "l3g4200d_gyro" },\r
2309         { .compatible = "l3g20d_gyro" },\r
2310         { .compatible = "ewtsa_gyro" },\r
2311         { .compatible = "k3g" },\r
2312         { .compatible = "lsm330_gyro" },
2313         \r
2314         /*light sensor*/\r
2315         { .compatible = "light_cm3217" },\r
2316         { .compatible = "light_cm3232" },\r
2317         { .compatible = "light_al3006" },\r
2318         { .compatible = "ls_stk3171" },\r
2319         { .compatible = "ls_ap321xx" },\r
2320 \r
2321         { .compatible = "ls_photoresistor" },\r
2322         { .compatible = "ls_us5152" },\r
2323 \r
2324         /*temperature sensor*/\r
2325         { .compatible = "tmp_ms5607" },\r
2326         \r
2327         /*pressure sensor*/\r
2328         { .compatible = "pr_ms5607" },\r
2329 \r
2330         /*hall sensor*/\r
2331         { .compatible = "hall_och165t" },\r
2332         { }\r
2333 };\r
2334 \r
2335 \r
2336 static struct i2c_driver sensor_driver = {\r
2337         .probe = sensor_probe,\r
2338         .remove = sensor_remove,\r
2339         .shutdown = sensor_shut_down,\r
2340         .id_table = sensor_id,\r
2341         .driver = {
2342                 .owner = THIS_MODULE,
2343                 .name = "sensors",
2344                 .of_match_table = of_match_ptr(sensor_dt_ids),
2345                 .pm = SENSOR_PM_OPS,
2346         },\r
2347 };\r
2348 \r
2349 static int __init sensor_init(void)\r
2350 {\r
2351         int res = i2c_add_driver(&sensor_driver);       \r
2352         struct proc_dir_entry *sensor_proc_entry;       \r
2353         pr_info("%s: Probe name %s\n", __func__, sensor_driver.driver.name);\r
2354         if (res)\r
2355                 pr_err("%s failed\n", __func__);\r
2356         \r
2357         sensor_proc_entry = proc_create("driver/sensor_dbg", 0660, NULL, &sensor_proc_fops); \r
2358         printk("%s\n", SENSOR_VERSION_AND_TIME);\r
2359         return res;\r
2360 }\r
2361 \r
2362 static void __exit sensor_exit(void)\r
2363 {\r
2364         pr_info("%s\n", __func__);\r
2365         i2c_del_driver(&sensor_driver);\r
2366 }\r
2367 \r
2368 late_initcall(sensor_init);\r
2369 module_exit(sensor_exit);\r
2370 \r
2371 MODULE_AUTHOR("ROCKCHIP Corporation:lw@rock-chips.com");\r
2372 MODULE_DESCRIPTION("User space character device interface for sensors");\r
2373 MODULE_LICENSE("GPL");\r
2374 \r