drivers/input/sensors/compass/ak09911.c

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