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