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                 #ifdef CONFIG_COMPAT\r
1460                                 sensor->fops.compat_ioctl = gsensor_dev_ioctl;\r
1461                                 #endif\r
1462                                 sensor->fops.open = gsensor_dev_open;\r
1463                                 sensor->fops.release = gsensor_dev_release;\r
1464 \r
1465                                 sensor->miscdev.minor = MISC_DYNAMIC_MINOR;\r
1466                                 sensor->miscdev.name = "mma8452_daemon";\r
1467                                 sensor->miscdev.fops = &sensor->fops;\r
1468                         }\r
1469                         else\r
1470                         {\r
1471                                 memcpy(&sensor->miscdev, sensor->ops->misc_dev, sizeof(*sensor->ops->misc_dev));\r
1472 \r
1473                         }\r
1474                                 \r
1475                         break;\r
1476 \r
1477                 case SENSOR_TYPE_COMPASS:                       \r
1478                         if(!sensor->ops->misc_dev)\r
1479                         {\r
1480                                 sensor->fops.owner = THIS_MODULE;\r
1481                                 sensor->fops.unlocked_ioctl = compass_dev_ioctl;\r
1482                                 sensor->fops.open = compass_dev_open;\r
1483                                 sensor->fops.release = compass_dev_release;\r
1484 \r
1485                                 sensor->miscdev.minor = MISC_DYNAMIC_MINOR;\r
1486                                 sensor->miscdev.name = "compass";\r
1487                                 sensor->miscdev.fops = &sensor->fops;\r
1488                         }\r
1489                         else\r
1490                         {\r
1491                                 memcpy(&sensor->miscdev, sensor->ops->misc_dev, sizeof(*sensor->ops->misc_dev));\r
1492 \r
1493                         }\r
1494 \r
1495                         break;\r
1496 \r
1497                 case SENSOR_TYPE_GYROSCOPE:                     \r
1498                         if(!sensor->ops->misc_dev)\r
1499                         {\r
1500                                 sensor->fops.owner = THIS_MODULE;\r
1501                                 sensor->fops.unlocked_ioctl = gyro_dev_ioctl;\r
1502                                 sensor->fops.open = gyro_dev_open;\r
1503                                 sensor->fops.release = gyro_dev_release;\r
1504 \r
1505                                 sensor->miscdev.minor = MISC_DYNAMIC_MINOR;\r
1506                                 sensor->miscdev.name = "gyrosensor";\r
1507                                 sensor->miscdev.fops = &sensor->fops;\r
1508                         }\r
1509                         else\r
1510                         {\r
1511                                 memcpy(&sensor->miscdev, sensor->ops->misc_dev, sizeof(*sensor->ops->misc_dev));\r
1512 \r
1513                         }\r
1514                         \r
1515                         break;\r
1516 \r
1517                 case SENSOR_TYPE_LIGHT:\r
1518                         if(!sensor->ops->misc_dev)\r
1519                         {\r
1520                                 sensor->fops.owner = THIS_MODULE;\r
1521                                 sensor->fops.unlocked_ioctl = light_dev_ioctl;\r
1522                                 sensor->fops.open = light_dev_open;\r
1523                                 sensor->fops.release = light_dev_release;\r
1524 \r
1525                                 sensor->miscdev.minor = MISC_DYNAMIC_MINOR;\r
1526                                 sensor->miscdev.name = "lightsensor";\r
1527                                 sensor->miscdev.fops = &sensor->fops;\r
1528                         }       \r
1529                         else\r
1530                         {\r
1531                                 memcpy(&sensor->miscdev, sensor->ops->misc_dev, sizeof(*sensor->ops->misc_dev));\r
1532 \r
1533                         }\r
1534                         break;\r
1535                 \r
1536                 case SENSOR_TYPE_PROXIMITY:\r
1537                         if(!sensor->ops->misc_dev)\r
1538                         {\r
1539                                 sensor->fops.owner = THIS_MODULE;\r
1540                                 sensor->fops.unlocked_ioctl = proximity_dev_ioctl;\r
1541                                 sensor->fops.open = proximity_dev_open;\r
1542                                 sensor->fops.release = proximity_dev_release;\r
1543 \r
1544                                 sensor->miscdev.minor = MISC_DYNAMIC_MINOR;\r
1545                                 sensor->miscdev.name = "psensor";\r
1546                                 sensor->miscdev.fops = &sensor->fops;\r
1547                         }       \r
1548                         else\r
1549                         {\r
1550                                 memcpy(&sensor->miscdev, sensor->ops->misc_dev, sizeof(*sensor->ops->misc_dev));\r
1551 \r
1552                         }\r
1553                         break;\r
1554 \r
1555                 case SENSOR_TYPE_TEMPERATURE:\r
1556                         if(!sensor->ops->misc_dev)\r
1557                         {\r
1558                                 sensor->fops.owner = THIS_MODULE;\r
1559                                 sensor->fops.unlocked_ioctl = temperature_dev_ioctl;\r
1560                                 sensor->fops.open = temperature_dev_open;\r
1561                                 sensor->fops.release = temperature_dev_release;\r
1562 \r
1563                                 sensor->miscdev.minor = MISC_DYNAMIC_MINOR;\r
1564                                 sensor->miscdev.name = "temperature";\r
1565                                 sensor->miscdev.fops = &sensor->fops;\r
1566                         }       \r
1567                         else\r
1568                         {\r
1569                                 memcpy(&sensor->miscdev, sensor->ops->misc_dev, sizeof(*sensor->ops->misc_dev));\r
1570 \r
1571                         }\r
1572                                 \r
1573                         break;\r
1574 \r
1575                 case SENSOR_TYPE_PRESSURE:\r
1576                         if(!sensor->ops->misc_dev)\r
1577                         {\r
1578                                 sensor->fops.owner = THIS_MODULE;\r
1579                                 sensor->fops.unlocked_ioctl = pressure_dev_ioctl;\r
1580                                 sensor->fops.open = pressure_dev_open;\r
1581                                 sensor->fops.release = pressure_dev_release;\r
1582 \r
1583                                 sensor->miscdev.minor = MISC_DYNAMIC_MINOR;\r
1584                                 sensor->miscdev.name = "pressure";\r
1585                                 sensor->miscdev.fops = &sensor->fops;\r
1586                         }       \r
1587                         else\r
1588                         {\r
1589                                 memcpy(&sensor->miscdev, sensor->ops->misc_dev, sizeof(*sensor->ops->misc_dev));\r
1590 \r
1591                         }\r
1592                                 \r
1593                         break;\r
1594 \r
1595                 default:\r
1596                         printk("%s:unknow sensor type=%d\n",__func__,type);\r
1597                         result = -1;\r
1598                         goto error;\r
1599         }\r
1600                         \r
1601         sensor->miscdev.parent = &sensor->client->dev;\r
1602         result = misc_register(&sensor->miscdev);\r
1603         if (result < 0) {\r
1604                 dev_err(&sensor->client->dev,\r
1605                         "fail to register misc device %s\n", sensor->miscdev.name);\r
1606                 goto error;\r
1607         }\r
1608         \r
1609         printk("%s:miscdevice: %s\n",__func__,sensor->miscdev.name);\r
1610 \r
1611 error:  \r
1612         \r
1613         return result;\r
1614 \r
1615 }\r
1616 \r
1617 int sensor_register_slave(int type,struct i2c_client *client,\r
1618                         struct sensor_platform_data *slave_pdata,\r
1619                         struct sensor_operate *(*get_sensor_ops)(void))\r
1620 {\r
1621         int result = 0;\r
1622         struct sensor_operate *ops = get_sensor_ops();\r
1623         if((ops->id_i2c >= SENSOR_NUM_ID) || (ops->id_i2c <= ID_INVALID))\r
1624         {       \r
1625                 printk("%s:%s id is error %d\n", __func__, ops->name, ops->id_i2c);\r
1626                 return -1;      \r
1627         }\r
1628         sensor_ops[ops->id_i2c] = ops;\r
1629         printk("%s:%s,id=%d\n",__func__,sensor_ops[ops->id_i2c]->name, ops->id_i2c);\r
1630         return result;\r
1631 }\r
1632 \r
1633 \r
1634 int sensor_unregister_slave(int type,struct i2c_client *client,\r
1635                         struct sensor_platform_data *slave_pdata,\r
1636                         struct sensor_operate *(*get_sensor_ops)(void))\r
1637 {\r
1638         int result = 0;\r
1639         struct sensor_operate *ops = get_sensor_ops();\r
1640         if((ops->id_i2c >= SENSOR_NUM_ID) || (ops->id_i2c <= ID_INVALID))\r
1641         {       \r
1642                 printk("%s:%s id is error %d\n", __func__, ops->name, ops->id_i2c);\r
1643                 return -1;      \r
1644         }\r
1645         printk("%s:%s,id=%d\n",__func__,sensor_ops[ops->id_i2c]->name, ops->id_i2c);\r
1646         sensor_ops[ops->id_i2c] = NULL; \r
1647         return result;\r
1648 }\r
1649 \r
1650 \r
1651 int sensor_probe(struct i2c_client *client, const struct i2c_device_id *devid)\r
1652 {\r
1653         struct sensor_private_data *sensor =\r
1654             (struct sensor_private_data *) i2c_get_clientdata(client);\r
1655         struct sensor_platform_data *pdata;\r
1656         struct device_node *np = client->dev.of_node;\r
1657         enum of_gpio_flags rst_flags, pwr_flags;\r
1658         unsigned long irq_flags;\r
1659         int result = 0;\r
1660         int type = 0;\r
1661         \r
1662         dev_info(&client->adapter->dev, "%s: %s,%p\n", __func__, devid->name, client);\r
1663 \r
1664         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {\r
1665                 result = -ENODEV;\r
1666                 goto out_no_free;\r
1667         }\r
1668         if (!np) {\r
1669                 dev_err(&client->dev, "no device tree\n");\r
1670                 return -EINVAL;\r
1671         }\r
1672     pdata = devm_kzalloc(&client->dev,sizeof(*pdata), GFP_KERNEL);\r
1673         if (!pdata) {\r
1674                 result = -ENOMEM;\r
1675                 goto out_no_free;\r
1676         }\r
1677         sensor = devm_kzalloc(&client->dev,sizeof(*sensor), GFP_KERNEL);\r
1678         if (!sensor) {\r
1679                 result = -ENOMEM;\r
1680                 goto out_no_free;\r
1681         }\r
1682         \r
1683         of_property_read_u32(np,"type",&(pdata->type));\r
1684 \r
1685         pdata->irq_pin = of_get_named_gpio_flags(np, "irq-gpio", 0,(enum of_gpio_flags *)&irq_flags);\r
1686         pdata->reset_pin = of_get_named_gpio_flags(np, "reset-gpio",0,&rst_flags);\r
1687         pdata->power_pin = of_get_named_gpio_flags(np, "power-gpio",0,&pwr_flags);\r
1688         \r
1689         of_property_read_u32(np,"irq_enable",&(pdata->irq_enable));\r
1690         of_property_read_u32(np,"poll_delay_ms",&(pdata->poll_delay_ms));\r
1691 \r
1692         of_property_read_u32(np,"x_min",&(pdata->x_min));\r
1693         of_property_read_u32(np,"y_min",&(pdata->y_min));\r
1694         of_property_read_u32(np,"z_min",&(pdata->z_min));\r
1695         of_property_read_u32(np,"factory",&(pdata->factory));\r
1696         of_property_read_u32(np,"layout",&(pdata->layout));\r
1697 \r
1698         of_property_read_u8(np,"address",&(pdata->address));\r
1699         of_get_property(np, "project_name", pdata->project_name);\r
1700 \r
1701 \r
1702         switch(pdata->layout)\r
1703         {\r
1704                 case 1:\r
1705                         pdata->orientation[0] = 1;\r
1706                         pdata->orientation[1] = 0;\r
1707                         pdata->orientation[2] = 0;\r
1708 \r
1709                         pdata->orientation[3] = 0;\r
1710                         pdata->orientation[4] = 1;\r
1711                         pdata->orientation[5] = 0;\r
1712 \r
1713                         pdata->orientation[6] = 0;\r
1714                         pdata->orientation[7] = 0;\r
1715                         pdata->orientation[8] = 1;\r
1716                         break;\r
1717 \r
1718                 case 2:\r
1719                         pdata->orientation[0] = 0;\r
1720                         pdata->orientation[1] = -1;\r
1721                         pdata->orientation[2] = 0;\r
1722 \r
1723                         pdata->orientation[3] = 1;\r
1724                         pdata->orientation[4] = 0;\r
1725                         pdata->orientation[5] = 0;\r
1726 \r
1727                         pdata->orientation[6] = 0;\r
1728                         pdata->orientation[7] = 0;\r
1729                         pdata->orientation[8] = 1;\r
1730                         break;\r
1731 \r
1732                 case 3:\r
1733                         pdata->orientation[0] = -1;\r
1734                         pdata->orientation[1] = 0;\r
1735                         pdata->orientation[2] = 0;\r
1736 \r
1737                         pdata->orientation[3] = 0;\r
1738                         pdata->orientation[4] = -1;\r
1739                         pdata->orientation[5] = 0;\r
1740 \r
1741                         pdata->orientation[6] = 0;\r
1742                         pdata->orientation[7] = 0;\r
1743                         pdata->orientation[8] = 1;\r
1744                         break;\r
1745 \r
1746                 case 4:\r
1747                         pdata->orientation[0] = 0;\r
1748                         pdata->orientation[1] = 1;\r
1749                         pdata->orientation[2] = 0;\r
1750 \r
1751                         pdata->orientation[3] = -1;\r
1752                         pdata->orientation[4] = 0;\r
1753                         pdata->orientation[5] = 0;\r
1754 \r
1755                         pdata->orientation[6] = 0;\r
1756                         pdata->orientation[7] = 0;\r
1757                         pdata->orientation[8] = 1;\r
1758                         break;\r
1759 \r
1760                 case 5:\r
1761                         pdata->orientation[0] = 1;\r
1762                         pdata->orientation[1] = 0;\r
1763                         pdata->orientation[2] = 0;\r
1764 \r
1765                         pdata->orientation[3] = 0;\r
1766                         pdata->orientation[4] = -1;\r
1767                         pdata->orientation[5] = 0;\r
1768 \r
1769                         pdata->orientation[6] = 0;\r
1770                         pdata->orientation[7] = 0;\r
1771                         pdata->orientation[8] = -1;\r
1772                         break;\r
1773 \r
1774                 case 6:\r
1775                         pdata->orientation[0] = 0;\r
1776                         pdata->orientation[1] = -1;\r
1777                         pdata->orientation[2] = 0;\r
1778 \r
1779                         pdata->orientation[3] = -1;\r
1780                         pdata->orientation[4] = 0;\r
1781                         pdata->orientation[5] = 0;\r
1782 \r
1783                         pdata->orientation[6] = 0;\r
1784                         pdata->orientation[7] = 0;\r
1785                         pdata->orientation[8] = -1;\r
1786                         break;\r
1787 \r
1788                 case 7:\r
1789                         pdata->orientation[0] = -1;\r
1790                         pdata->orientation[1] = 0;\r
1791                         pdata->orientation[2] = 0;\r
1792 \r
1793                         pdata->orientation[3] = 0;\r
1794                         pdata->orientation[4] = 1;\r
1795                         pdata->orientation[5] = 0;\r
1796 \r
1797                         pdata->orientation[6] = 0;\r
1798                         pdata->orientation[7] = 0;\r
1799                         pdata->orientation[8] = -1;\r
1800                         break;\r
1801 \r
1802                 case 8:\r
1803                         pdata->orientation[0] = 0;\r
1804                         pdata->orientation[1] = 1;\r
1805                         pdata->orientation[2] = 0;\r
1806 \r
1807                         pdata->orientation[3] = 1;\r
1808                         pdata->orientation[4] = 0;\r
1809                         pdata->orientation[5] = 0;\r
1810 \r
1811                         pdata->orientation[6] = 0;\r
1812                         pdata->orientation[7] = 0;\r
1813                         pdata->orientation[8] = -1;\r
1814                         break;\r
1815 \r
1816                 default:\r
1817                         pdata->orientation[0] = 1;\r
1818                         pdata->orientation[1] = 0;\r
1819                         pdata->orientation[2] = 0;\r
1820 \r
1821                         pdata->orientation[3] = 0;\r
1822                         pdata->orientation[4] = 1;\r
1823                         pdata->orientation[5] = 0;\r
1824 \r
1825                         pdata->orientation[6] = 0;\r
1826                         pdata->orientation[7] = 0;\r
1827                         pdata->orientation[8] = 1;\r
1828                         break;\r
1829         }\r
1830 \r
1831         client->irq = pdata->irq_pin;\r
1832         type = pdata->type;\r
1833         pdata->irq_flags = irq_flags;\r
1834         DBG("irq_flags = %lu  padta->irq_flags = %lu\n",irq_flags, pdata->irq_flags);\r
1835         DBG("type = %d \n",pdata->type);\r
1836         DBG("irq = %d \n",pdata->irq);\r
1837         DBG("irq_pin = %d \n",pdata->irq_pin);\r
1838         DBG("pwer_pin = %d \n",pdata->power_pin);       \r
1839         DBG("reset_pin = %d \n",pdata->reset_pin);\r
1840         DBG("irq_enable = %d \n",pdata->irq_enable);\r
1841 \r
1842         DBG("poll_delay_ms = %d \n",pdata->poll_delay_ms);\r
1843         DBG("x_min = %d \n",pdata->x_min);\r
1844         DBG("y_min = %d \n",pdata->y_min);\r
1845         DBG("z_min = %d \n",pdata->z_min);      \r
1846         DBG("factory = %d \n",pdata->factory);\r
1847         DBG("layout = %d \n",pdata->layout);\r
1848         DBG("address = 0x%x \n",pdata->address);\r
1849         DBG("project_name = [%s] \n",pdata->project_name);\r
1850         \r
1851         DBG(" == %d,%d ,%d \t ,%d ,%d ,%d , \t ,%d, %d, %d ,==%d\n",pdata->orientation[0],pdata->orientation[1],pdata->orientation[2]\r
1852                                 ,pdata->orientation[3],pdata->orientation[4],pdata->orientation[5]\r
1853                                 ,pdata->orientation[6],pdata->orientation[7],pdata->orientation[8],ARRAY_SIZE(pdata->orientation));\r
1854                 \r
1855         \r
1856         if((type >= SENSOR_NUM_TYPES) || (type <= SENSOR_TYPE_NULL))\r
1857         {       \r
1858                 dev_err(&client->adapter->dev, "sensor type is error %d\n", type);\r
1859                 result = -EFAULT;\r
1860                 goto out_no_free;       \r
1861         }\r
1862         if(((int)devid->driver_data >= SENSOR_NUM_ID) || ((int)devid->driver_data <= ID_INVALID))\r
1863         {       \r
1864                 dev_err(&client->adapter->dev, "sensor id is error %d\n", (int)devid->driver_data);\r
1865                 result = -EFAULT;\r
1866                 goto out_no_free;       \r
1867         }\r
1868         i2c_set_clientdata(client, sensor);\r
1869         sensor->client = client;        \r
1870         sensor->pdata = pdata;  \r
1871         sensor->type = type;\r
1872         sensor->i2c_id = (struct i2c_device_id *)devid;\r
1873 \r
1874                 \r
1875         memset(&(sensor->axis), 0, sizeof(struct sensor_axis) );\r
1876         atomic_set(&(sensor->data_ready), 0);\r
1877         init_waitqueue_head(&(sensor->data_ready_wq));\r
1878         mutex_init(&sensor->data_mutex);        \r
1879         mutex_init(&sensor->operation_mutex);   \r
1880         mutex_init(&sensor->sensor_mutex);\r
1881         mutex_init(&sensor->i2c_mutex);\r
1882 \r
1883         /* As default, report all information */\r
1884         atomic_set(&sensor->flags.m_flag, 1);\r
1885         atomic_set(&sensor->flags.a_flag, 1);\r
1886         atomic_set(&sensor->flags.mv_flag, 1);                  \r
1887         atomic_set(&sensor->flags.open_flag, 0);\r
1888         atomic_set(&sensor->flags.debug_flag, 1);\r
1889         init_waitqueue_head(&sensor->flags.open_wq);\r
1890         sensor->flags.delay = 100;\r
1891 \r
1892         sensor->status_cur = SENSOR_OFF;\r
1893         sensor->axis.x = 0;\r
1894         sensor->axis.y = 0;\r
1895         sensor->axis.z = 0;\r
1896         \r
1897         result = sensor_chip_init(sensor->client);\r
1898         if(result < 0)\r
1899                 goto out_free_memory;\r
1900         \r
1901         sensor->input_dev = input_allocate_device();\r
1902         if (!sensor->input_dev) {\r
1903                 result = -ENOMEM;\r
1904                 dev_err(&client->dev,\r
1905                         "Failed to allocate input device %s\n", sensor->input_dev->name);\r
1906                 goto out_free_memory;\r
1907         }       \r
1908 \r
1909         switch(type)\r
1910         {\r
1911                 case SENSOR_TYPE_ANGLE: \r
1912                         sensor->input_dev->name = "angle";\r
1913                         set_bit(EV_ABS, sensor->input_dev->evbit);\r
1914                         /* x-axis acceleration */\r
1915                         input_set_abs_params(sensor->input_dev, ABS_X, sensor->ops->range[0], sensor->ops->range[1], 0, 0); //2g full scale range\r
1916                         /* y-axis acceleration */\r
1917                         input_set_abs_params(sensor->input_dev, ABS_Y, sensor->ops->range[0], sensor->ops->range[1], 0, 0); //2g full scale range\r
1918                         /* z-axis acceleration */\r
1919                         input_set_abs_params(sensor->input_dev, ABS_Z, sensor->ops->range[0], sensor->ops->range[1], 0, 0); //2g full scale range\r
1920                         break;  \r
1921 \r
1922                 case SENSOR_TYPE_ACCEL: \r
1923                         sensor->input_dev->name = "gsensor";\r
1924                         set_bit(EV_ABS, sensor->input_dev->evbit);\r
1925                         /* x-axis acceleration */\r
1926                         input_set_abs_params(sensor->input_dev, ABS_X, sensor->ops->range[0], sensor->ops->range[1], 0, 0); //2g full scale range\r
1927                         /* y-axis acceleration */\r
1928                         input_set_abs_params(sensor->input_dev, ABS_Y, sensor->ops->range[0], sensor->ops->range[1], 0, 0); //2g full scale range\r
1929                         /* z-axis acceleration */\r
1930                         input_set_abs_params(sensor->input_dev, ABS_Z, sensor->ops->range[0], sensor->ops->range[1], 0, 0); //2g full scale range\r
1931                         break;          \r
1932                 case SENSOR_TYPE_COMPASS:       \r
1933                         sensor->input_dev->name = "compass";            \r
1934                         /* Setup input device */\r
1935                         set_bit(EV_ABS, sensor->input_dev->evbit);\r
1936                         /* yaw (0, 360) */\r
1937                         input_set_abs_params(sensor->input_dev, ABS_RX, 0, 23040, 0, 0);\r
1938                         /* pitch (-180, 180) */\r
1939                         input_set_abs_params(sensor->input_dev, ABS_RY, -11520, 11520, 0, 0);\r
1940                         /* roll (-90, 90) */\r
1941                         input_set_abs_params(sensor->input_dev, ABS_RZ, -5760, 5760, 0, 0);\r
1942                         /* x-axis acceleration (720 x 8G) */\r
1943                         input_set_abs_params(sensor->input_dev, ABS_X, -5760, 5760, 0, 0);\r
1944                         /* y-axis acceleration (720 x 8G) */\r
1945                         input_set_abs_params(sensor->input_dev, ABS_Y, -5760, 5760, 0, 0);\r
1946                         /* z-axis acceleration (720 x 8G) */\r
1947                         input_set_abs_params(sensor->input_dev, ABS_Z, -5760, 5760, 0, 0);\r
1948                         /* status of magnetic sensor */\r
1949                         input_set_abs_params(sensor->input_dev, ABS_RUDDER, -32768, 3, 0, 0);\r
1950                         /* status of acceleration sensor */\r
1951                         input_set_abs_params(sensor->input_dev, ABS_WHEEL, -32768, 3, 0, 0);\r
1952                         /* x-axis of raw magnetic vector (-4096, 4095) */\r
1953                         input_set_abs_params(sensor->input_dev, ABS_HAT0X, -20480, 20479, 0, 0);\r
1954                         /* y-axis of raw magnetic vector (-4096, 4095) */\r
1955                         input_set_abs_params(sensor->input_dev, ABS_HAT0Y, -20480, 20479, 0, 0);\r
1956                         /* z-axis of raw magnetic vector (-4096, 4095) */\r
1957                         input_set_abs_params(sensor->input_dev, ABS_BRAKE, -20480, 20479, 0, 0);\r
1958                         break;          \r
1959                 case SENSOR_TYPE_GYROSCOPE:\r
1960                         sensor->input_dev->name = "gyro";\r
1961                         /* x-axis acceleration */\r
1962                         input_set_capability(sensor->input_dev, EV_REL, REL_RX);\r
1963                         input_set_abs_params(sensor->input_dev, ABS_RX, sensor->ops->range[0], sensor->ops->range[1], 0, 0); \r
1964                         /* y-axis acceleration */       \r
1965                         input_set_capability(sensor->input_dev, EV_REL, REL_RY);\r
1966                         input_set_abs_params(sensor->input_dev, ABS_RY, sensor->ops->range[0], sensor->ops->range[1], 0, 0); \r
1967                         /* z-axis acceleration */\r
1968                         input_set_capability(sensor->input_dev, EV_REL, REL_RZ);\r
1969                         input_set_abs_params(sensor->input_dev, ABS_RZ, sensor->ops->range[0], sensor->ops->range[1], 0, 0); \r
1970                         break;\r
1971                 case SENSOR_TYPE_LIGHT:\r
1972                         sensor->input_dev->name = "lightsensor-level";\r
1973                         set_bit(EV_ABS, sensor->input_dev->evbit);\r
1974                         input_set_abs_params(sensor->input_dev, ABS_MISC, sensor->ops->range[0], sensor->ops->range[1], 0, 0);                  \r
1975                         input_set_abs_params(sensor->input_dev, ABS_TOOL_WIDTH ,  sensor->ops->brightness[0],sensor->ops->brightness[1], 0, 0);\r
1976                         break;\r
1977                 case SENSOR_TYPE_PROXIMITY:\r
1978                         sensor->input_dev->name = "proximity";  \r
1979                         set_bit(EV_ABS, sensor->input_dev->evbit);\r
1980                         input_set_abs_params(sensor->input_dev, ABS_DISTANCE, sensor->ops->range[0], sensor->ops->range[1], 0, 0);\r
1981                         break;\r
1982                 case SENSOR_TYPE_TEMPERATURE:                           \r
1983                         sensor->input_dev->name = "temperature";\r
1984                         set_bit(EV_ABS, sensor->input_dev->evbit);              \r
1985                         input_set_abs_params(sensor->input_dev, ABS_THROTTLE, sensor->ops->range[0], sensor->ops->range[1], 0, 0);\r
1986                         break;\r
1987                 case SENSOR_TYPE_PRESSURE:                              \r
1988                         sensor->input_dev->name = "pressure";\r
1989                         set_bit(EV_ABS, sensor->input_dev->evbit);              \r
1990                         input_set_abs_params(sensor->input_dev, ABS_PRESSURE, sensor->ops->range[0], sensor->ops->range[1], 0, 0);\r
1991                         break;\r
1992                 default:\r
1993                         printk("%s:unknow sensor type=%d\n",__func__,type);\r
1994                         break;\r
1995 \r
1996         }\r
1997         sensor->input_dev->dev.parent = &client->dev;\r
1998 \r
1999         result = input_register_device(sensor->input_dev);\r
2000         if (result) {\r
2001                 dev_err(&client->dev,\r
2002                         "Unable to register input device %s\n", sensor->input_dev->name);\r
2003                 goto out_input_register_device_failed;\r
2004         }\r
2005 \r
2006         result = sensor_irq_init(sensor->client);\r
2007         if (result) {\r
2008                 dev_err(&client->dev,\r
2009                         "fail to init sensor irq,ret=%d\n",result);\r
2010                 goto out_input_register_device_failed;\r
2011         }\r
2012 \r
2013         \r
2014         sensor->miscdev.parent = &client->dev;\r
2015         result = sensor_misc_device_register(sensor, type);\r
2016         if (result) {\r
2017                 dev_err(&client->dev,\r
2018                         "fail to register misc device %s\n", sensor->miscdev.name);\r
2019                 goto out_misc_device_register_device_failed;\r
2020         }\r
2021         \r
2022         g_sensor[type] = sensor;\r
2023 \r
2024         if((type == SENSOR_TYPE_ACCEL) && (sensor->pdata->factory))     //only support  setting gsensor orientation online now  \r
2025         {\r
2026                 result = gsensor_class_init();\r
2027                 if (result) {\r
2028                         dev_err(&client->dev,\r
2029                                 "fail to register misc device %s\n", sensor->i2c_id->name);\r
2030                         goto out_misc_device_register_device_failed;\r
2031                 }\r
2032         }       \r
2033         \r
2034 #ifdef CONFIG_HAS_EARLYSUSPEND\r
2035         if((sensor->ops->suspend) && (sensor->ops->resume))\r
2036         {\r
2037                 sensor->early_suspend.suspend = sensor_suspend;\r
2038                 sensor->early_suspend.resume = sensor_resume;\r
2039                 sensor->early_suspend.level = 0x02;\r
2040                 register_early_suspend(&sensor->early_suspend);\r
2041         }\r
2042 #endif\r
2043 \r
2044         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
2045 \r
2046         return result;\r
2047         \r
2048 out_misc_device_register_device_failed:\r
2049         input_unregister_device(sensor->input_dev);     \r
2050 out_input_register_device_failed:\r
2051         input_free_device(sensor->input_dev);   \r
2052 out_free_memory:\r
2053         //kfree(sensor);\r
2054 out_no_free:\r
2055         dev_err(&client->adapter->dev, "%s failed %d\n\n", __func__, result);\r
2056         return result;\r
2057 \r
2058 }\r
2059 \r
2060 static void sensor_shut_down(struct i2c_client *client)\r
2061 {\r
2062 #ifdef CONFIG_HAS_EARLYSUSPEND\r
2063         struct sensor_private_data *sensor =\r
2064             (struct sensor_private_data *) i2c_get_clientdata(client);\r
2065         if((sensor->ops->suspend) && (sensor->ops->resume))             \r
2066                 unregister_early_suspend(&sensor->early_suspend);\r
2067         DBG("%s:%s\n",__func__,sensor->i2c_id->name);\r
2068 #endif\r
2069 }\r
2070 \r
2071 static int sensor_remove(struct i2c_client *client)\r
2072 {\r
2073         struct sensor_private_data *sensor =\r
2074             (struct sensor_private_data *) i2c_get_clientdata(client);\r
2075         int result = 0;\r
2076         \r
2077         cancel_delayed_work_sync(&sensor->delaywork);\r
2078         misc_deregister(&sensor->miscdev);\r
2079         input_unregister_device(sensor->input_dev);     \r
2080         input_free_device(sensor->input_dev);   \r
2081         kfree(sensor);\r
2082 #ifdef CONFIG_HAS_EARLYSUSPEND\r
2083         if((sensor->ops->suspend) && (sensor->ops->resume))\r
2084                 unregister_early_suspend(&sensor->early_suspend);\r
2085 #endif  \r
2086         return result;\r
2087 }\r
2088 \r
2089 static const struct i2c_device_id sensor_id[] = {\r
2090         /*angle*/       \r
2091         {"angle_kxtik", ANGLE_ID_KXTIK},\r
2092         {"angle_lis3dh", ANGLE_ID_LIS3DH},      \r
2093         /*gsensor*/\r
2094         {"gsensor", ACCEL_ID_ALL},\r
2095         {"gs_mma8452", ACCEL_ID_MMA845X},       \r
2096         {"gs_kxtik", ACCEL_ID_KXTIK},   \r
2097         {"gs_kxtj9", ACCEL_ID_KXTJ9},\r
2098         {"gs_lis3dh", ACCEL_ID_LIS3DH},\r
2099         {"gs_mma7660", ACCEL_ID_MMA7660},\r
2100         {"gs_mxc6225", ACCEL_ID_MXC6225},       \r
2101         {"gs_dmard10", ACCEL_ID_DMARD10},\r
2102         {"gs_lsm303d", ACCEL_ID_LSM303D},\r
2103         {"gs_mc3230",ACCEL_ID_MC3230},\r
2104         {"mpu6880_acc",ACCEL_ID_MPU6880},\r
2105         {"mpu6500_acc",ACCEL_ID_MPU6500},\r
2106         /*compass*/\r
2107         {"compass", COMPASS_ID_ALL},\r
2108         {"ak8975", COMPASS_ID_AK8975},  \r
2109         {"ak8963", COMPASS_ID_AK8963},\r
2110         {"ak09911", COMPASS_ID_AK09911},\r
2111         {"mmc314x", COMPASS_ID_MMC314X},\r
2112         /*gyroscope*/\r
2113         {"gyro", GYRO_ID_ALL},  \r
2114         {"l3g4200d_gyro", GYRO_ID_L3G4200D},\r
2115         {"l3g20d_gyro", GYRO_ID_L3G20D},\r
2116         {"ewtsa_gyro", GYRO_ID_EWTSA},\r
2117         {"k3g", GYRO_ID_K3G},\r
2118         {"mpu6880_gyro",GYRO_ID_MPU6880},\r
2119         /*light sensor*/\r
2120         {"lightsensor", LIGHT_ID_ALL},  \r
2121         {"light_cm3217", LIGHT_ID_CM3217},\r
2122         {"light_cm3218", LIGHT_ID_CM3218},\r
2123         {"light_cm3232", LIGHT_ID_CM3232},\r
2124         {"light_al3006", LIGHT_ID_AL3006},\r
2125         {"ls_stk3171", LIGHT_ID_STK3171},\r
2126         {"ls_isl29023", LIGHT_ID_ISL29023},\r
2127         {"ls_ap321xx", LIGHT_ID_AP321XX},\r
2128         {"ls_photoresistor", LIGHT_ID_PHOTORESISTOR},\r
2129         {"ls_us5152", LIGHT_ID_US5152},\r
2130         /*proximity sensor*/\r
2131         {"psensor", PROXIMITY_ID_ALL},\r
2132         {"proximity_al3006", PROXIMITY_ID_AL3006},      \r
2133         {"ps_stk3171", PROXIMITY_ID_STK3171},\r
2134         {"ps_ap321xx", PROXIMITY_ID_AP321XX},\r
2135         \r
2136         /*temperature*/\r
2137         {"temperature", TEMPERATURE_ID_ALL},    \r
2138         {"tmp_ms5607", TEMPERATURE_ID_MS5607},\r
2139 \r
2140         /*pressure*/\r
2141         {"pressure", PRESSURE_ID_ALL},\r
2142         {"pr_ms5607", PRESSURE_ID_MS5607},\r
2143         \r
2144         {},\r
2145 };\r
2146 \r
2147 static struct of_device_id sensor_dt_ids[] = {\r
2148         /*gsensor*/\r
2149         { .compatible = "gs_mma8452" },\r
2150         { .compatible = "gs_lis3dh" },\r
2151         { .compatible = "gs_lsm303d" },\r
2152         { .compatible = "gs_mma7660" },\r
2153         { .compatible = "gs_mxc6225" },\r
2154         { .compatible = "gs_mc3230" },\r
2155         \r
2156         /*compass*/\r
2157         { .compatible = "ak8975" },\r
2158         { .compatible = "ak8963" },\r
2159         { .compatible = "ak09911" },\r
2160         { .compatible = "mmc314x" },\r
2161 \r
2162         /* gyroscop*/\r
2163         { .compatible = "l3g4200d_gyro" },\r
2164         { .compatible = "l3g20d_gyro" },\r
2165         { .compatible = "ewtsa_gyro" },\r
2166         { .compatible = "k3g" },\r
2167         \r
2168         \r
2169         /*light sensor*/\r
2170         { .compatible = "light_cm3217" },\r
2171         { .compatible = "light_cm3232" },\r
2172         { .compatible = "light_al3006" },\r
2173         { .compatible = "ls_stk3171" },\r
2174         { .compatible = "ls_ap321xx" },\r
2175 \r
2176         { .compatible = "ls_photoresistor" },\r
2177         { .compatible = "ls_us5152" },\r
2178 \r
2179         /*temperature sensor*/\r
2180         { .compatible = "tmp_ms5607" },\r
2181         \r
2182         /*pressure sensor*/\r
2183         { .compatible = "pr_ms5607" },\r
2184 \r
2185         /*hall sensor*/\r
2186         { .compatible = "hall_och165t" },\r
2187         { }\r
2188 };\r
2189 \r
2190 \r
2191 static struct i2c_driver sensor_driver = {\r
2192         .probe = sensor_probe,\r
2193         .remove = sensor_remove,\r
2194         .shutdown = sensor_shut_down,\r
2195         .id_table = sensor_id,\r
2196         .driver = {\r
2197                    .owner = THIS_MODULE,\r
2198                    .name = "sensors",\r
2199                    .of_match_table = of_match_ptr(sensor_dt_ids),\r
2200         },\r
2201 };\r
2202 \r
2203 static int __init sensor_init(void)\r
2204 {\r
2205         int res = i2c_add_driver(&sensor_driver);       \r
2206         struct proc_dir_entry *sensor_proc_entry;       \r
2207         pr_info("%s: Probe name %s\n", __func__, sensor_driver.driver.name);\r
2208         if (res)\r
2209                 pr_err("%s failed\n", __func__);\r
2210         \r
2211         sensor_proc_entry = proc_create("driver/sensor_dbg", 0660, NULL, &sensor_proc_fops); \r
2212         printk("%s\n", SENSOR_VERSION_AND_TIME);\r
2213         return res;\r
2214 }\r
2215 \r
2216 static void __exit sensor_exit(void)\r
2217 {\r
2218         pr_info("%s\n", __func__);\r
2219         i2c_del_driver(&sensor_driver);\r
2220 }\r
2221 \r
2222 late_initcall(sensor_init);\r
2223 module_exit(sensor_exit);\r
2224 \r
2225 MODULE_AUTHOR("ROCKCHIP Corporation:lw@rock-chips.com");\r
2226 MODULE_DESCRIPTION("User space character device interface for sensors");\r
2227 MODULE_LICENSE("GPL");\r
2228 \r