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