drivers/input/sensors/compass/ak8963.c

   1 /* drivers/input/sensors/access/akm8963.c\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 #include <linux/interrupt.h>\r
  17 #include <linux/i2c.h>\r
  18 #include <linux/slab.h>\r
  19 #include <linux/irq.h>\r
  20 #include <linux/miscdevice.h>\r
  21 #include <linux/gpio.h>\r
  22 #include <asm/uaccess.h>\r
  23 #include <asm/atomic.h>\r
  24 #include <linux/delay.h>\r
  25 #include <linux/input.h>\r
  26 #include <linux/workqueue.h>\r
  27 #include <linux/freezer.h>\r
  28 #include <linux/of_gpio.h>\r
  29 #ifdef CONFIG_HAS_EARLYSUSPEND\r
  30 #include <linux/earlysuspend.h>\r
  31 #endif\r
  32 #include <linux/sensor-dev.h>\r
  33 \r
  34 #define SENSOR_DATA_SIZE                8\r
  35 \r
  36 \r
  37 #define SENSOR_DATA_SIZE        8\r
  38 #define YPR_DATA_SIZE           12\r
  39 #define RWBUF_SIZE              16\r
  40 \r
  41 #define ACC_DATA_FLAG           0\r
  42 #define MAG_DATA_FLAG           1\r
  43 #define ORI_DATA_FLAG           2\r
  44 #define AKM_NUM_SENSORS         3\r
  45 \r
  46 #define ACC_DATA_READY          (1<<(ACC_DATA_FLAG))\r
  47 #define MAG_DATA_READY          (1<<(MAG_DATA_FLAG))\r
  48 #define ORI_DATA_READY          (1<<(ORI_DATA_FLAG))\r
  49 \r
  50 /*! \name AK8963 constant definition\r
  51  \anchor AK8963_Def\r
  52  Constant definitions of the AK8963.*/\r
  53 #define AK8963_MEASUREMENT_TIME_US      10000\r
  54 \r
  55 /*! \name AK8963 operation mode\r
  56  \anchor AK8963_Mode\r
  57  Defines an operation mode of the AK8963.*/\r
  58 /*! @{*/\r
  59 #define AK8963_MODE_SNG_MEASURE 0x01\r
  60 #define AK8963_MODE_SELF_TEST   0x08\r
  61 #define AK8963_MODE_FUSE_ACCESS 0x0F\r
  62 #define AK8963_MODE_POWERDOWN   0x00\r
  63 \r
  64 /*! @}*/\r
  65 \r
  66 /*! \name AK8963 register address\r
  67 \anchor AK8963_REG\r
  68 Defines a register address of the AK8963.*/\r
  69 /*! @{*/\r
  70 #define AK8963_REG_WIA          0x00\r
  71 #define AK8963_REG_INFO         0x01\r
  72 #define AK8963_REG_ST1          0x02\r
  73 #define AK8963_REG_HXL          0x03\r
  74 #define AK8963_REG_HXH          0x04\r
  75 #define AK8963_REG_HYL          0x05\r
  76 #define AK8963_REG_HYH          0x06\r
  77 #define AK8963_REG_HZL          0x07\r
  78 #define AK8963_REG_HZH          0x08\r
  79 #define AK8963_REG_ST2          0x09\r
  80 #define AK8963_REG_CNTL1        0x0A\r
  81 #define AK8963_REG_CNTL2        0x0B\r
  82 #define AK8963_REG_ASTC         0x0C\r
  83 #define AK8963_REG_TS1          0x0D\r
  84 #define AK8963_REG_TS2          0x0E\r
  85 #define AK8963_REG_I2CDIS       0x0F\r
  86 /*! @}*/\r
  87 \r
  88 /*! \name AK8963 fuse-rom address\r
  89 \anchor AK8963_FUSE\r
  90 Defines a read-only address of the fuse ROM of the AK8963.*/\r
  91 /*! @{*/\r
  92 #define AK8963_FUSE_ASAX        0x10\r
  93 #define AK8963_FUSE_ASAY        0x11\r
  94 #define AK8963_FUSE_ASAZ        0x12\r
  95 /*! @}*/\r
  96 \r
  97 #define AK8963_INFO_DATA        (0x03<<3)\r
  98 \r
  99 \r
 100 #define COMPASS_IOCTL_MAGIC                   'c'\r
 101 \r
 102 /* IOCTLs for AKM library */\r
 103 #define ECS_IOCTL_WRITE                 _IOW(COMPASS_IOCTL_MAGIC, 0x01, char*)\r
 104 #define ECS_IOCTL_READ                  _IOWR(COMPASS_IOCTL_MAGIC, 0x02, char*)\r
 105 #define ECS_IOCTL_RESET                 _IO(COMPASS_IOCTL_MAGIC, 0x03) /* NOT used in AK8975 */\r
 106 #define ECS_IOCTL_SET_MODE              _IOW(COMPASS_IOCTL_MAGIC, 0x04, short)\r
 107 #define ECS_IOCTL_GETDATA               _IOR(COMPASS_IOCTL_MAGIC, 0x05, char[SENSOR_DATA_SIZE])\r
 108 #define ECS_IOCTL_SET_YPR               _IOW(COMPASS_IOCTL_MAGIC, 0x06, short[12])\r
 109 #define ECS_IOCTL_GET_OPEN_STATUS       _IOR(COMPASS_IOCTL_MAGIC, 0x07, int)\r
 110 #define ECS_IOCTL_GET_CLOSE_STATUS      _IOR(COMPASS_IOCTL_MAGIC, 0x08, int)\r
 111 #define ECS_IOCTL_GET_LAYOUT            _IOR(COMPASS_IOCTL_MAGIC, 0x09, char)\r
 112 #define ECS_IOCTL_GET_ACCEL             _IOR(COMPASS_IOCTL_MAGIC, 0x0A, short[3])\r
 113 #define ECS_IOCTL_GET_OUTBIT            _IOR(COMPASS_IOCTL_MAGIC, 0x0B, char)\r
 114 #define ECS_IOCTL_GET_DELAY             _IOR(COMPASS_IOCTL_MAGIC, 0x30, short)\r
 115 #define ECS_IOCTL_GET_PROJECT_NAME      _IOR(COMPASS_IOCTL_MAGIC, 0x0D, char[64])\r
 116 #define ECS_IOCTL_GET_MATRIX            _IOR(COMPASS_IOCTL_MAGIC, 0x0E, short [4][3][3])\r
 117 #define ECS_IOCTL_GET_PLATFORM_DATA     _IOR(COMPASS_IOCTL_MAGIC, 0x0E, struct akm_platform_data)\r
 118 \r
 119 \r
 120 \r
 121 #define AK8963_DEVICE_ID                0x48\r
 122 static struct i2c_client *this_client;\r
 123 static struct miscdevice compass_dev_device;\r
 124 \r
 125 static short g_akm_rbuf[12];\r
 126 \r
 127 \r
 128 /****************operate according to sensor chip:start************/\r
 129 \r
 130 static int sensor_active(struct i2c_client *client, int enable, int rate)\r
 131 {\r
 132         struct sensor_private_data *sensor =\r
 133             (struct sensor_private_data *) i2c_get_clientdata(client);  \r
 134         int result = 0;\r
 135                 \r
 136         //sensor->ops->ctrl_data = sensor_read_reg(client, sensor->ops->ctrl_reg);\r
 137         \r
 138         //register setting according to chip datasheet          \r
 139         if(enable)\r
 140         {       \r
 141                 sensor->ops->ctrl_data = AK8963_MODE_SNG_MEASURE;       \r
 142         }\r
 143         else\r
 144         {\r
 145                 sensor->ops->ctrl_data = AK8963_MODE_POWERDOWN;\r
 146         }\r
 147 \r
 148         DBG("%s:reg=0x%x,reg_ctrl=0x%x,enable=%d\n",__func__,sensor->ops->ctrl_reg, sensor->ops->ctrl_data, enable);\r
 149         result = sensor_write_reg(client, sensor->ops->ctrl_reg, sensor->ops->ctrl_data);\r
 150         if(result)\r
 151                 printk("%s:fail to active sensor\n",__func__);\r
 152         \r
 153         return result;\r
 154 \r
 155 }\r
 156 \r
 157 static int sensor_init(struct i2c_client *client)\r
 158 {       \r
 159         struct sensor_private_data *sensor =\r
 160             (struct sensor_private_data *) i2c_get_clientdata(client);  \r
 161         int result = 0;\r
 162         char info = 0;\r
 163 \r
 164         this_client = client;   \r
 165 \r
 166         result = sensor->ops->active(client,0,0);\r
 167         if(result)\r
 168         {\r
 169                 printk("%s:line=%d,error\n",__func__,__LINE__);\r
 170                 return result;\r
 171         }\r
 172         \r
 173         sensor->status_cur = SENSOR_OFF;\r
 174 \r
 175         info = sensor_read_reg(client, AK8963_REG_INFO);        \r
 176         if((info & (0x0f<<3)) != AK8963_INFO_DATA)\r
 177         {\r
 178                 printk("%s:info=0x%x,it is not %s\n",__func__, info, sensor->ops->name);\r
 179                 return -1;\r
 180         }\r
 181 \r
 182         result = misc_register(&compass_dev_device);\r
 183         if (result < 0) {\r
 184                 printk("%s:fail to register misc device %s\n", __func__, compass_dev_device.name);\r
 185                 result = -1;\r
 186         }\r
 187         \r
 188         DBG("%s:status_cur=%d\n",__func__, sensor->status_cur);\r
 189         return result;\r
 190 }\r
 191 \r
 192 static int sensor_report_value(struct i2c_client *client)\r
 193 {\r
 194         struct sensor_private_data *sensor =\r
 195                 (struct sensor_private_data *) i2c_get_clientdata(client);      \r
 196         char buffer[8] = {0};   \r
 197         unsigned char *stat;\r
 198         unsigned char *stat2;   \r
 199         int ret = 0;    \r
 200         char value = 0;\r
 201         int i;\r
 202 \r
 203         if(sensor->ops->read_len < 8)   //sensor->ops->read_len = 8\r
 204         {\r
 205                 printk("%s:lenth is error,len=%d\n",__func__,sensor->ops->read_len);\r
 206                 return -1;\r
 207         }\r
 208         \r
 209         memset(buffer, 0, 8);\r
 210         \r
 211         /* Data bytes from hardware xL, xH, yL, yH, zL, zH */   \r
 212         do {\r
 213                 *buffer = sensor->ops->read_reg;\r
 214                 ret = sensor_rx_data(client, buffer, sensor->ops->read_len);\r
 215                 if (ret < 0)\r
 216                 return ret;\r
 217         } while (0);\r
 218 \r
 219         stat = &buffer[0];\r
 220         stat2 = &buffer[7];\r
 221         \r
 222         /*\r
 223          * ST : data ready -
 224          * Measurement has been completed and data is ready to be read.
 225          */\r
 226         if ((*stat & 0x01) != 0x01) {\r
 227                 DBG(KERN_ERR "%s:ST is not set\n",__func__);\r
 228                 return -1;\r
 229         }\r
 230
 231         /*
 232          * ST2 : data error -
 233          * occurs when data read is started outside of a readable period;
 234          * data read would not be correct.
 235          * Valid in continuous measurement mode only.
 236          * In single measurement mode this error should not occour but we
 237          * stil account for it and return an error, since the data would be
 238          * corrupted.
 239          * DERR bit is self-clearing when ST2 register is read.
 240          */
 241         if (*stat2 & 0x04)\r
 242         {\r
 243                 DBG(KERN_ERR "%s:compass data error\n",__func__);\r
 244                 return -2;\r
 245         }\r
 246         \r
 247         /*
 248          * ST2 : overflow -
 249          * the sum of the absolute values of all axis |X|+|Y|+|Z| < 2400uT.
 250          * This is likely to happen in presence of an external magnetic
 251          * disturbance; it indicates, the sensor data is incorrect and should
 252          * be ignored.
 253          * An error is returned.
 254          * HOFL bit clears when a new measurement starts.
 255          */
 256         if (*stat2 & 0x08)\r
 257         {       \r
 258                 DBG(KERN_ERR "%s:compass data overflow\n",__func__);\r
 259                 return -3;\r
 260         }\r
 261         \r
 262         /* »¥³âµØ»º´æÊý¾Ý. */\r
 263         mutex_lock(&sensor->data_mutex);        \r
 264         memcpy(sensor->sensor_data, buffer, sensor->ops->read_len);\r
 265         mutex_unlock(&sensor->data_mutex);\r
 266         DBG("%s:",__func__);\r
 267         for(i=0; i<sensor->ops->read_len; i++)\r
 268                 DBG("0x%x,",buffer[i]);\r
 269         DBG("\n");\r
 270 \r
 271         if((sensor->pdata->irq_enable)&& (sensor->ops->int_status_reg >= 0))    //read sensor intterupt status register\r
 272         {\r
 273                 \r
 274                 value = sensor_read_reg(client, sensor->ops->int_status_reg);\r
 275                 DBG("%s:sensor int status :0x%x\n",__func__,value);\r
 276         }\r
 277 \r
 278         \r
 279         //trigger next measurement \r
 280         ret = sensor_write_reg(client, sensor->ops->ctrl_reg, sensor->ops->ctrl_data);\r
 281         if(ret)\r
 282         {\r
 283                 printk(KERN_ERR "%s:fail to set ctrl_data:0x%x\n",__func__,sensor->ops->ctrl_data);\r
 284                 return ret;\r
 285         }\r
 286 \r
 287         return ret;\r
 288 }\r
 289 \r
 290 static void compass_set_YPR(int *rbuf)\r
 291 {\r
 292         struct sensor_private_data *sensor =\r
 293             (struct sensor_private_data *) i2c_get_clientdata(this_client);     \r
 294 \r
 295         /* No events are reported */\r
 296         if (!rbuf[0]) {\r
 297                 printk("%s:Don't waste a time.",__func__);\r
 298                 return;\r
 299         }\r
 300 \r
 301         DBG("%s:buf[0]=0x%x\n",__func__, rbuf[0]);\r
 302         \r
 303         /* Report magnetic sensor information */\r
 304         if (atomic_read(&sensor->flags.m_flag) && (rbuf[0] & ORI_DATA_READY)) {\r
 305                 input_report_abs(sensor->input_dev, ABS_RX, rbuf[9]);\r
 306                 input_report_abs(sensor->input_dev, ABS_RY, rbuf[10]);\r
 307                 input_report_abs(sensor->input_dev, ABS_RZ, rbuf[11]);\r
 308                 input_report_abs(sensor->input_dev, ABS_RUDDER, rbuf[4]);\r
 309                 DBG("%s:m_flag:x=%d,y=%d,z=%d,RUDDER=%d\n",__func__,rbuf[9], rbuf[10], rbuf[11], rbuf[4]);\r
 310         }\r
 311         \r
 312         /* Report acceleration sensor information */\r
 313         if (atomic_read(&sensor->flags.a_flag) && (rbuf[0] & ACC_DATA_READY)) {\r
 314                 input_report_abs(sensor->input_dev, ABS_X, rbuf[1]);\r
 315                 input_report_abs(sensor->input_dev, ABS_Y, rbuf[2]);\r
 316                 input_report_abs(sensor->input_dev, ABS_Z, rbuf[3]);\r
 317                 input_report_abs(sensor->input_dev, ABS_WHEEL, rbuf[4]);\r
 318                 \r
 319                 DBG("%s:a_flag:x=%d,y=%d,z=%d,WHEEL=%d\n",__func__,rbuf[1], rbuf[2], rbuf[3], rbuf[4]);\r
 320         }\r
 321         \r
 322         /* Report magnetic vector information */\r
 323         if (atomic_read(&sensor->flags.mv_flag) && (rbuf[0] & MAG_DATA_READY)) {\r
 324                 input_report_abs(sensor->input_dev, ABS_HAT0X, rbuf[5]);\r
 325                 input_report_abs(sensor->input_dev, ABS_HAT0Y, rbuf[6]);\r
 326                 input_report_abs(sensor->input_dev, ABS_BRAKE, rbuf[7]);        \r
 327                 input_report_abs(sensor->input_dev, ABS_HAT1X, rbuf[8]);\r
 328         \r
 329                 DBG("%s:mv_flag:x=%d,y=%d,z=%d,status=%d\n",__func__,rbuf[5], rbuf[6], rbuf[7], rbuf[8]);\r
 330         }\r
 331         \r
 332         input_sync(sensor->input_dev);\r
 333 \r
 334         memcpy(g_akm_rbuf, rbuf, 12);   //used for ECS_IOCTL_GET_ACCEL\r
 335 }\r
 336 \r
 337 \r
 338 \r
 339 static int compass_dev_open(struct inode *inode, struct file *file)\r
 340 {\r
 341         struct sensor_private_data* sensor = \r
 342                 (struct sensor_private_data *)i2c_get_clientdata(this_client); \r
 343         int result = 0;\r
 344         DBG("%s\n",__func__);\r
 345 \r
 346         return result;\r
 347 }\r
 348 \r
 349 \r
 350 static int compass_dev_release(struct inode *inode, struct file *file)\r
 351 {\r
 352         struct sensor_private_data* sensor = \r
 353                 (struct sensor_private_data *)i2c_get_clientdata(this_client); \r
 354         int result = 0; \r
 355         DBG("%s\n",__func__);\r
 356 \r
 357         return result;\r
 358 }\r
 359 \r
 360 static int compass_akm_set_mode(struct i2c_client *client, char mode)\r
 361 {\r
 362         struct sensor_private_data* sensor = (struct sensor_private_data *)i2c_get_clientdata(this_client); \r
 363         int result = 0; \r
 364 \r
 365         switch(mode & 0x0f)\r
 366         {\r
 367                 case AK8963_MODE_SNG_MEASURE:\r
 368                 case AK8963_MODE_SELF_TEST:     \r
 369                 case AK8963_MODE_FUSE_ACCESS:                   \r
 370                         if(sensor->status_cur == SENSOR_OFF)\r
 371                         {\r
 372                                 if(sensor->pdata->irq_enable)\r
 373                                 {\r
 374                                         //DBG("%s:enable irq=%d\n",__func__,client->irq);\r
 375                                         //enable_irq(client->irq);\r
 376                                 }       \r
 377                                 else\r
 378                                 {\r
 379                                         schedule_delayed_work(&sensor->delaywork, msecs_to_jiffies(sensor->pdata->poll_delay_ms));\r
 380                                 }\r
 381                                 \r
 382                                 sensor->status_cur = SENSOR_ON;\r
 383                         }\r
 384 \r
 385                         break;\r
 386 \r
 387                 case AK8963_MODE_POWERDOWN:     \r
 388                         if(sensor->status_cur == SENSOR_ON)\r
 389                         {\r
 390                                 if(sensor->pdata->irq_enable)\r
 391                                 {       \r
 392                                         //DBG("%s:disable irq=%d\n",__func__,client->irq);\r
 393                                         //disable_irq_nosync(client->irq);//disable irq\r
 394                                 }\r
 395                                 else\r
 396                                 cancel_delayed_work_sync(&sensor->delaywork);   \r
 397 \r
 398                                 sensor->status_cur = SENSOR_OFF;\r
 399                         }\r
 400                         break;\r
 401 \r
 402         }\r
 403         \r
 404         switch(mode & 0x0f)\r
 405         {\r
 406                 case AK8963_MODE_SNG_MEASURE:           \r
 407                         result = sensor_write_reg(client, sensor->ops->ctrl_reg, mode);\r
 408                         if(result)\r
 409                         printk("%s:i2c error,mode=%d\n",__func__,mode);                         \r
 410                         break;\r
 411                 case AK8963_MODE_SELF_TEST:                     \r
 412                         result = sensor_write_reg(client, sensor->ops->ctrl_reg, mode);\r
 413                         if(result)\r
 414                         printk("%s:i2c error,mode=%d\n",__func__,mode);\r
 415                         break;\r
 416                 case AK8963_MODE_FUSE_ACCESS:\r
 417                         result = sensor_write_reg(client, sensor->ops->ctrl_reg, mode);\r
 418                         if(result)\r
 419                         printk("%s:i2c error,mode=%d\n",__func__,mode);\r
 420                         break;\r
 421                 case AK8963_MODE_POWERDOWN:\r
 422                         /* Set powerdown mode */\r
 423                         result = sensor_write_reg(client, sensor->ops->ctrl_reg, AK8963_MODE_POWERDOWN);\r
 424                         if(result)\r
 425                         printk("%s:i2c error,mode=%d\n",__func__,mode);\r
 426                         udelay(100);\r
 427                         break;\r
 428                 default:\r
 429                         printk("%s: Unknown mode(%d)", __func__, mode);\r
 430                         result = -EINVAL;\r
 431                         break;\r
 432         }\r
 433         DBG("%s:mode=0x%x\n",__func__,mode);\r
 434         return result;\r
 435 \r
 436 }\r
 437 \r
 438 static int compass_akm_reset(struct i2c_client *client)\r
 439 {\r
 440         struct sensor_private_data* sensor = (struct sensor_private_data *)i2c_get_clientdata(this_client); \r
 441         int result = 0; \r
 442         \r
 443         if(sensor->pdata->reset_pin > 0)\r
 444         {\r
 445                 gpio_direction_output(sensor->pdata->reset_pin, GPIO_LOW);\r
 446                 udelay(10);\r
 447                 gpio_direction_output(sensor->pdata->reset_pin, GPIO_HIGH);\r
 448         }\r
 449         else    \r
 450         {\r
 451                 /* Set measure mode */\r
 452                 result = sensor_write_reg(client, AK8963_REG_CNTL2, AK8963_MODE_SNG_MEASURE);\r
 453                 if(result)\r
 454                 printk("%s:fail to Set measure mode\n",__func__);\r
 455         }\r
 456         \r
 457         udelay(100);\r
 458         \r
 459         return result;\r
 460 \r
 461 }\r
 462 \r
 463 \r
 464 \r
 465 static int compass_akm_get_openstatus(void)\r
 466 {       \r
 467         struct sensor_private_data* sensor = (struct sensor_private_data *)i2c_get_clientdata(this_client); \r
 468         wait_event_interruptible(sensor->flags.open_wq, (atomic_read(&sensor->flags.open_flag) != 0));\r
 469         return atomic_read(&sensor->flags.open_flag);\r
 470 }\r
 471 \r
 472 static int compass_akm_get_closestatus(void)\r
 473 {       \r
 474         struct sensor_private_data* sensor = (struct sensor_private_data *)i2c_get_clientdata(this_client); \r
 475         wait_event_interruptible(sensor->flags.open_wq, (atomic_read(&sensor->flags.open_flag) <= 0));\r
 476         return atomic_read(&sensor->flags.open_flag);\r
 477 }\r
 478 \r
 479 \r
 480 /* ioctl - I/O control */\r
 481 static long compass_dev_ioctl(struct file *file,\r
 482                           unsigned int cmd, unsigned long arg)\r
 483 {\r
 484     struct sensor_private_data* sensor = (struct sensor_private_data *)i2c_get_clientdata(this_client);\r
 485         struct i2c_client *client = this_client;\r
 486         void __user *argp = (void __user *)arg;\r
 487         int result = 0;\r
 488         struct akm_platform_data compass;\r
 489                 \r
 490         /* NOTE: In this function the size of "char" should be 1-byte. */\r
 491         char compass_data[SENSOR_DATA_SIZE];    /* for GETDATA */\r
 492         char rwbuf[RWBUF_SIZE];                 /* for READ/WRITE */\r
 493         char mode;                              /* for SET_MODE*/\r
 494         int value[12];                  /* for SET_YPR */\r
 495         int status;                             /* for OPEN/CLOSE_STATUS */\r
 496         int ret = -1;                           /* Return value. */\r
 497         \r
 498         //int8_t sensor_buf[SENSOR_DATA_SIZE];  /* for GETDATA */\r
 499         //int32_t ypr_buf[YPR_DATA_SIZE];       /* for SET_YPR */\r
 500         int16_t acc_buf[3];                     /* for GET_ACCEL */\r
 501         int64_t delay[AKM_NUM_SENSORS];         /* for GET_DELAY */\r
 502 \r
 503         char layout;            /* for GET_LAYOUT */\r
 504         char outbit;            /* for GET_OUTBIT */\r
 505 \r
 506         switch (cmd) {\r
 507         case ECS_IOCTL_WRITE:\r
 508         case ECS_IOCTL_READ:\r
 509                 if (argp == NULL) {\r
 510                         return -EINVAL;\r
 511                 }\r
 512                 if (copy_from_user(&rwbuf, argp, sizeof(rwbuf))) {\r
 513                         return -EFAULT;\r
 514                 }\r
 515                 break;\r
 516         case ECS_IOCTL_SET_MODE:\r
 517                 if (argp == NULL) {\r
 518                         return -EINVAL;\r
 519                 }\r
 520                 if (copy_from_user(&mode, argp, sizeof(mode))) {\r
 521                         return -EFAULT;\r
 522                 }\r
 523                 break;\r
 524         case ECS_IOCTL_SET_YPR:\r
 525                 if (argp == NULL) {\r
 526                         return -EINVAL;\r
 527                 }\r
 528                 if (copy_from_user(&value, argp, sizeof(value))) {\r
 529                         return -EFAULT;\r
 530                 }\r
 531                 break;\r
 532         case ECS_IOCTL_GETDATA:\r
 533         case ECS_IOCTL_GET_OPEN_STATUS:\r
 534         case ECS_IOCTL_GET_CLOSE_STATUS:\r
 535         case ECS_IOCTL_GET_DELAY:\r
 536         case ECS_IOCTL_GET_LAYOUT:\r
 537         case ECS_IOCTL_GET_OUTBIT:\r
 538         case ECS_IOCTL_GET_ACCEL:\r
 539                 /* Just check buffer pointer */\r
 540                 if (argp == NULL) {\r
 541                         printk("%s:invalid argument\n",__func__);\r
 542                         return -EINVAL;\r
 543                 }\r
 544                 break;\r
 545         default:\r
 546                 break;\r
 547         }\r
 548 \r
 549         switch (cmd) {\r
 550         case ECS_IOCTL_WRITE:\r
 551                 DBG("%s:ECS_IOCTL_WRITE start\n",__func__);\r
 552                 mutex_lock(&sensor->operation_mutex);\r
 553                 if ((rwbuf[0] < 2) || (rwbuf[0] > (RWBUF_SIZE-1))) {                    \r
 554                         mutex_unlock(&sensor->operation_mutex);\r
 555                         return -EINVAL;\r
 556                 }\r
 557                 ret = sensor_tx_data(client, &rwbuf[1], rwbuf[0]);\r
 558                 if (ret < 0) {  \r
 559                         mutex_unlock(&sensor->operation_mutex);         \r
 560                         printk("%s:fait to tx data\n",__func__);\r
 561                         return ret;\r
 562                 }                       \r
 563                 mutex_unlock(&sensor->operation_mutex);\r
 564                 break;\r
 565         case ECS_IOCTL_READ:                            \r
 566                 DBG("%s:ECS_IOCTL_READ start\n",__func__);\r
 567                 mutex_lock(&sensor->operation_mutex);\r
 568                 if ((rwbuf[0] < 1) || (rwbuf[0] > (RWBUF_SIZE-1))) {            \r
 569                         mutex_unlock(&sensor->operation_mutex);                 \r
 570                         printk("%s:data is error\n",__func__);\r
 571                         return -EINVAL;\r
 572                 }\r
 573                 ret = sensor_rx_data(client, &rwbuf[1], rwbuf[0]);\r
 574                 if (ret < 0) {  \r
 575                         mutex_unlock(&sensor->operation_mutex);         \r
 576                         printk("%s:fait to rx data\n",__func__);\r
 577                         return ret;\r
 578                 }               \r
 579                 mutex_unlock(&sensor->operation_mutex);\r
 580                 break;\r
 581         case ECS_IOCTL_SET_MODE:\r
 582                 DBG("%s:ECS_IOCTL_SET_MODE start\n",__func__);          \r
 583                 mutex_lock(&sensor->operation_mutex);\r
 584                 if(sensor->ops->ctrl_data != mode)\r
 585                 {\r
 586                         ret = compass_akm_set_mode(client, mode);\r
 587                         if (ret < 0) {\r
 588                                 printk("%s:fait to set mode\n",__func__);               \r
 589                                 mutex_unlock(&sensor->operation_mutex);\r
 590                                 return ret;\r
 591                         }\r
 592                         \r
 593                         sensor->ops->ctrl_data = mode;\r
 594                 }\r
 595                 mutex_unlock(&sensor->operation_mutex);\r
 596                 break;\r
 597         case ECS_IOCTL_GETDATA:\r
 598                         DBG("%s:ECS_IOCTL_GETDATA start\n",__func__);\r
 599                         mutex_lock(&sensor->data_mutex);        \r
 600                         memcpy(compass_data, sensor->sensor_data, SENSOR_DATA_SIZE);    //get data from buffer\r
 601                         mutex_unlock(&sensor->data_mutex);\r
 602                         break;\r
 603         case ECS_IOCTL_SET_YPR:                 \r
 604                         DBG("%s:ECS_IOCTL_SET_YPR start\n",__func__);\r
 605                         mutex_lock(&sensor->data_mutex);\r
 606                         compass_set_YPR(value);         \r
 607                         mutex_unlock(&sensor->data_mutex);\r
 608                 break;\r
 609         case ECS_IOCTL_GET_OPEN_STATUS:\r
 610                 status = compass_akm_get_openstatus();  \r
 611                 DBG("%s:openstatus=%d\n",__func__,status);\r
 612                 break;\r
 613         case ECS_IOCTL_GET_CLOSE_STATUS:\r
 614                 status = compass_akm_get_closestatus(); \r
 615                 DBG("%s:closestatus=%d\n",__func__,status);\r
 616                 break;\r
 617         case ECS_IOCTL_GET_DELAY:\r
 618                 DBG("%s:ECS_IOCTL_GET_DELAY start\n",__func__);\r
 619                 mutex_lock(&sensor->operation_mutex);\r
 620                 delay[0] = sensor->flags.delay;\r
 621                 delay[1] = sensor->flags.delay;\r
 622                 delay[2] = sensor->flags.delay;\r
 623                 mutex_unlock(&sensor->operation_mutex);\r
 624                 break;\r
 625         \r
 626         case ECS_IOCTL_GET_PLATFORM_DATA:                       \r
 627                 DBG("%s:ECS_IOCTL_GET_PLATFORM_DATA start\n",__func__);\r
 628                 //memcpy(compass.m_layout, sensor->pdata->m_layout, sizeof(sensor->pdata->m_layout));\r
 629                 //memcpy(compass.project_name, sensor->pdata->project_name, sizeof(sensor->pdata->project_name));\r
 630                 ret = copy_to_user(argp, &compass, sizeof(compass));\r
 631                 if(ret < 0)\r
 632                 {\r
 633                         printk("%s:error,ret=%d\n",__FUNCTION__, ret);\r
 634                         return ret;\r
 635                 }\r
 636                 break;\r
 637         case ECS_IOCTL_GET_LAYOUT:\r
 638                 DBG("%s:ECS_IOCTL_GET_LAYOUT start\n",__func__);\r
 639                 layout = sensor->pdata->layout;\r
 640                 break;\r
 641         case ECS_IOCTL_GET_OUTBIT:\r
 642                 DBG("%s:ECS_IOCTL_GET_OUTBIT start\n",__func__);\r
 643                 outbit = 1; //sensor->pdata->outbit;\r
 644                 break;\r
 645         case ECS_IOCTL_RESET:\r
 646                 DBG("%s:ECS_IOCTL_RESET start\n",__func__);\r
 647                 ret = compass_akm_reset(client);\r
 648                 if (ret < 0)\r
 649                         return ret;\r
 650                 break;\r
 651         case ECS_IOCTL_GET_ACCEL:\r
 652                 DBG("%s:ECS_IOCTL_GET_ACCEL start,no accel data\n",__func__);\r
 653                 mutex_lock(&sensor->operation_mutex);\r
 654                 acc_buf[0] = g_akm_rbuf[6];\r
 655                 acc_buf[1] = g_akm_rbuf[7];\r
 656                 acc_buf[2] = g_akm_rbuf[8];\r
 657                 mutex_unlock(&sensor->operation_mutex);\r
 658                 break;\r
 659 \r
 660         default:\r
 661                 return -ENOTTY;\r
 662         }\r
 663 \r
 664         switch (cmd) {\r
 665         case ECS_IOCTL_READ:\r
 666                 if (copy_to_user(argp, &rwbuf, rwbuf[0]+1)) {\r
 667                         return -EFAULT;\r
 668                 }\r
 669                 break;\r
 670         case ECS_IOCTL_GETDATA:\r
 671                 if (copy_to_user(argp, &compass_data, sizeof(compass_data))) {\r
 672                         return -EFAULT;\r
 673                 }\r
 674                 break;\r
 675         case ECS_IOCTL_GET_OPEN_STATUS:\r
 676         case ECS_IOCTL_GET_CLOSE_STATUS:\r
 677                 if (copy_to_user(argp, &status, sizeof(status))) {\r
 678                         return -EFAULT;\r
 679                 }\r
 680                 break;\r
 681         case ECS_IOCTL_GET_DELAY:\r
 682                 if (copy_to_user(argp, &delay, sizeof(delay))) {\r
 683                         return -EFAULT;\r
 684                 }\r
 685                 break;\r
 686         case ECS_IOCTL_GET_LAYOUT:\r
 687                 if (copy_to_user(argp, &layout, sizeof(layout))) {\r
 688                         printk("%s:error:%d\n",__FUNCTION__,__LINE__);\r
 689                         return -EFAULT;\r
 690                 }\r
 691                 break;\r
 692         case ECS_IOCTL_GET_OUTBIT:\r
 693                 if (copy_to_user(argp, &outbit, sizeof(outbit))) {\r
 694                         printk("%s:error:%d\n",__FUNCTION__,__LINE__);\r
 695                         return -EFAULT;\r
 696                 }\r
 697                 break;\r
 698         case ECS_IOCTL_GET_ACCEL:\r
 699                 if (copy_to_user(argp, &acc_buf, sizeof(acc_buf))) {\r
 700                         printk("%s:error:%d\n",__FUNCTION__,__LINE__);\r
 701                         return -EFAULT;\r
 702                 }\r
 703                 break;\r
 704         default:\r
 705                 break;\r
 706         }\r
 707 \r
 708         return result;\r
 709 }\r
 710 \r
 711 static struct file_operations compass_dev_fops =\r
 712 {\r
 713         .owner = THIS_MODULE,\r
 714         .open = compass_dev_open,\r
 715         .release = compass_dev_release, \r
 716         .unlocked_ioctl = compass_dev_ioctl,\r
 717 };\r
 718 \r
 719 \r
 720 static struct miscdevice compass_dev_device =\r
 721 {       \r
 722         .minor = MISC_DYNAMIC_MINOR,\r
 723         .name = "akm8963_dev",\r
 724         .fops = &compass_dev_fops,\r
 725 };\r
 726 \r
 727 struct sensor_operate compass_akm8963_ops = {\r
 728         .name                           = "akm8963",\r
 729         .type                           = SENSOR_TYPE_COMPASS,  //it is important\r
 730         .id_i2c                         = COMPASS_ID_AK8963,\r
 731         .read_reg                       = AK8963_REG_ST1,       //read data\r
 732         .read_len                       = SENSOR_DATA_SIZE,     //data length\r
 733         .id_reg                         = AK8963_REG_WIA,       //read id\r
 734         .id_data                        = AK8963_DEVICE_ID,\r
 735         .precision                      = 8,                    //12 bits\r
 736         .ctrl_reg                       = AK8963_REG_CNTL1,     //enable or disable \r
 737         .int_status_reg                 = SENSOR_UNKNOW_DATA,   //not exist\r
 738         .range                          = {-0xffff,0xffff},\r
 739         .trig                           = IRQF_TRIGGER_RISING,  //if LEVEL interrupt then IRQF_ONESHOT\r
 740         .active                         = sensor_active,        \r
 741         .init                           = sensor_init,\r
 742         .report                         = sensor_report_value,  \r
 743         .misc_dev                       = NULL,                 //private misc support\r
 744 };\r
 745 \r
 746 /****************operate according to sensor chip:end************/\r
 747 \r
 748 //function name should not be changed\r
 749 static struct sensor_operate *compass_get_ops(void)\r
 750 {\r
 751         return &compass_akm8963_ops; \r
 752 }\r
 753 \r
 754 \r
 755 static int __init compass_akm8963_init(void)\r
 756 {\r
 757         struct sensor_operate *ops = compass_get_ops();\r
 758         int result = 0;\r
 759         int type = ops->type;\r
 760         result = sensor_register_slave(type, NULL, NULL, compass_get_ops);\r
 761                                 \r
 762         return result;\r
 763 }\r
 764 \r
 765 static void __exit compass_akm8963_exit(void)\r
 766 {\r
 767         struct sensor_operate *ops = compass_get_ops();\r
 768         int type = ops->type;\r
 769         sensor_unregister_slave(type, NULL, NULL, compass_get_ops);\r
 770 }\r
 771 \r
 772 \r
 773 module_init(compass_akm8963_init);\r
 774 module_exit(compass_akm8963_exit);\r
 775 \r
 776 \r