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