drivers/input/sensors/gyro/ewtsa.c

   1 /* drivers/input/sensors/gyro/Ewtsa.c\r
   2  *\r
   3  * Copyright (C) 2012-2015 ROCKCHIP.\r
   4  * Author: zhangaihui <zah@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 <mach/gpio.h>\r
  29 #include <mach/board.h> \r
  30 #ifdef CONFIG_HAS_EARLYSUSPEND\r
  31 #include <linux/earlysuspend.h>\r
  32 #endif\r
  33 #include <linux/sensor-dev.h>\r
  34 \r
  35 /** This define controls compilation of the master device interface */\r
  36 /*#define EWTSA_MASTER_DEVICE*/\r
  37 /* configurable */\r
  38 #define GYRO_MOUNT_SWAP_XY      0   /* swap X, Y */\r
  39 #define GYRO_MOUNT_REVERSE_X    0   /* reverse X */\r
  40 #define GYRO_MOUNT_REVERSE_Y    0   /* reverse Y */\r
  41 #define GYRO_MOUNT_REVERSE_Z    0   /* reverse Z */\r
  42 \r
  43 /* macro defines */\r
  44 /*#define CHIP_ID                 0x68*/\r
  45 #define DEVICE_NAME             "ewtsa"\r
  46 #define EWTSA_ON                1\r
  47 #define EWTSA_OFF               0\r
  48 #define SLEEP_PIN               14\r
  49 #define DRDY_PIN                12\r
  50 #define DIAG_PIN                11\r
  51 #define MAX_VALUE               32768\r
  52 \r
  53 /* ewtsa_delay parameter */\r
  54 #define DELAY_THRES_MIN         1\r
  55 #define DELAY_THRES_1           4\r
  56 #define DELAY_THRES_2           9   /* msec x 90% */\r
  57 #define DELAY_THRES_3           18\r
  58 #define DELAY_THRES_4           45\r
  59 #define DELAY_THRES_5           90\r
  60 #define DELAY_THRES_6           128\r
  61 #define DELAY_THRES_MAX         255\r
  62 #define DELAY_DLPF_2            2\r
  63 #define DELAY_DLPF_3            3\r
  64 #define DELAY_DLPF_4            4\r
  65 #define DELAY_DLPF_5            5\r
  66 #define DELAY_DLPF_6            6\r
  67 #define DELAY_INTMIN_THRES      9\r
  68 \r
  69 #define DATA_RATE_1             0x01\r
  70 \r
  71 /* ewtsa_sleep parameter */\r
  72 #define SLEEP_OFF               0\r
  73 #define SLEEP_ON                1\r
  74 \r
  75 /* event mode */\r
  76 #define EWTSA_POLLING_MODE    0\r
  77 #define EWTSA_INTERUPT_MODE   1\r
  78 \r
  79 /* ewtsa register address */\r
  80 #define REG_SMPL                0x15\r
  81 #define REG_FS_DLPF             0x16\r
  82 #define REG_INT_CFG             0x17\r
  83 #define REG_INT_STATUS          0x1A\r
  84 #define REG_SELF_O_C            0x29\r
  85 #define REG_PWR_MGM             0x3E\r
  86 #define REG_MBURST_ALL          0xFF\r
  87 #define GYRO_DATA_REG            0x1D\r
  88 \r
  89 /* ewtsa register param */\r
  90 #define SELF_O_C_ENABLE         0x00\r
  91 #define SELF_O_C_DISABLE        0x01\r
  92 #define SLEEP_CTRL_ACTIVATE     0x40\r
  93 #define SLEEP_CTRL_SLEEP        0x00\r
  94 #define INT_CFG_INT_ENABLE      0x01\r
  95 #define INT_CFG_INT_DISABLE     0x00\r
  96 \r
  97 /* ewtsa interrupt control */\r
  98 #define EWSTA_INT_CLEAR         0x00\r
  99 #define EWSTA_INT_SKIP          0x01\r
 100 \r
 101 /* wait time(ms)*/\r
 102 #define EWTSA_BOOST_TIME_0      500\r
 103 \r
 104 /* sleep setting range */\r
 105 #define EWTSA_SLP_MIN 0\r
 106 #define EWTSA_SLP_MAX 1\r
 107 \r
 108 /* delay setting range */\r
 109 #define EWTSA_DLY_MIN 1\r
 110 #define EWTSA_DLY_MAX 255\r
 111 \r
 112 /* range setting range */\r
 113 #define EWTSA_RNG_MIN 0\r
 114 #define EWTSA_RNG_MAX 3\r
 115 \r
 116 /* soc setting range */\r
 117 #define EWTSA_SOC_MIN 0\r
 118 #define EWTSA_SOC_MAX 1\r
 119 \r
 120 /* event setting range */\r
 121 #define EWTSA_EVE_MIN 0\r
 122 #define EWTSA_EVE_MAX 1\r
 123 \r
 124 /* init param */\r
 125 #define SLEEP_INIT_VAL       (SLEEP_ON)\r
 126 #define DELAY_INIT_VAL       10\r
 127 #define RANGE_INIT_VAL       2 /*range 1000*/\r
 128 #define DLPF_INIT_VAL        (DELAY_DLPF_2)\r
 129 #define CALIB_FUNC_INIT_VAL  (EWTSA_ON)\r
 130 \r
 131 /*config store counter num*/\r
 132 #define CONFIG_COUNTER_MIN (6+9)\r
 133 #define CONFIG_COUNTER_MAX (32+9)\r
 134 \r
 135 /*command name */\r
 136 #define COMMAND_NAME_SOC 0\r
 137 #define COMMAND_NAME_DLY 1\r
 138 #define COMMAND_NAME_RNG 2\r
 139 #define COMMAND_NAME_EVE 3\r
 140 #define COMMAND_NAME_SLP 4\r
 141 #define COMMAND_NAME_NUM 5\r
 142 \r
 143 #define EWTSA_delay  DELAY_INIT_VAL\r
 144 #define EWTSA_range    RANGE_INIT_VAL\r
 145 #define EWTSA_calib    EWTSA_ON\r
 146 \r
 147 /****************operate according to sensor chip:start************/\r
 148 static int i2c_read_byte(struct i2c_client *thisClient, unsigned char regAddr, char *pReadData)\r
 149 {
 150     int    ret = 0;
 151
 152     ret = i2c_master_send( thisClient, (char*)&regAddr, 1);
 153     if(ret < 0)
 154     {
 155         printk("EWTSA send cAddress=0x%x error!\n", regAddr);\r
 156         return ret;
 157     }
 158     ret = i2c_master_recv( thisClient, (char*)pReadData, 1);
 159     if(ret < 0)
 160     {
 161         printk("EWTSAread *pReadData=0x%x error!\n", *pReadData);\r
 162         return ret;
 163     }
 164
 165     return 1;
 166 }\r
 167 static int i2c_write_byte(struct i2c_client *thisClient, unsigned char regAddr, unsigned char writeData)\r
 168 {
 169     char    write_data[2] = {0};
 170     int    ret=0;
 171
 172     write_data[0] = regAddr;
 173     write_data[1] = writeData;
 174
 175     ret = i2c_master_send(thisClient, write_data, 2);
 176     if (ret < 0)
 177     {
 178         ret = i2c_master_send(thisClient, write_data, 2);
 179         if (ret < 0)
 180          {
 181              printk("EWTSA send regAddr=0x%x error!\n", regAddr);\r
 182              return ret;
 183         }
 184         return 1;
 185     }
 186
 187     return 1;
 188 }\r
 189 \r
 190 static int ewtsa_system_restart(struct i2c_client *client)\r
 191 {
 192     int             err;
 193      char   reg;\r
 194      char   smpl , dlpf;\r
 195 \r
 196     err = i2c_write_byte(client, ( unsigned char)REG_SELF_O_C, ( unsigned char)SELF_O_C_DISABLE);\r
 197     if (err < 0) {
 198         return err;
 199     }
 200
 201     ///Set SMPL register
 202         if (EWTSA_delay <= ( unsigned char)DELAY_THRES_2) {\r
 203             smpl = ( unsigned char)DELAY_INTMIN_THRES;\r
 204         }else{
 205             smpl = ( unsigned char)(EWTSA_delay - ( unsigned char)1);\r
 206         }\r
 207     err = i2c_write_byte(client, ( unsigned char)REG_SMPL, ( unsigned char)smpl);\r
 208     if (err < 0) {
 209         return err;
 210     }
 211
 212     ///Set DLPF register
 213     if (EWTSA_delay >= ( unsigned char)DELAY_THRES_6){\r
 214         dlpf = ( unsigned char)DELAY_DLPF_6;\r
 215     }else if (EWTSA_delay >= ( unsigned char)DELAY_THRES_5) {\r
 216         dlpf = ( unsigned char)DELAY_DLPF_5;\r
 217     }else if (EWTSA_delay >= ( unsigned char)DELAY_THRES_4){\r
 218         dlpf = ( unsigned char)DELAY_DLPF_4;\r
 219     }else if (EWTSA_delay >= ( unsigned char)DELAY_THRES_3) {\r
 220         dlpf = ( unsigned char)DELAY_DLPF_3;\r
 221     }else{
 222         dlpf = ( unsigned char)DELAY_DLPF_2;\r
 223     }
 224
 225     reg = ( unsigned char)(( unsigned char)(EWTSA_range << 3) | dlpf | ( unsigned char)0x80 ) ;\r
 226 \r
 227     err = i2c_write_byte(client, REG_FS_DLPF, reg);\r
 228     if (err < 0) {
 229         return err;
 230     }
 231
 232     if (EWTSA_calib==  EWTSA_ON) {              \r
 233         printk("EWTSA_set_calibration() start \n");\r
 234         err =  i2c_write_byte(client,( unsigned char)REG_SELF_O_C, ( unsigned char)SELF_O_C_ENABLE);\r
 235         if (err < 0) {\r
 236                 return err;\r
 237         }\r
 238         mdelay(500); \r
 239         printk("EWTSA_set_calibration() end \n");\r
 240      \r
 241     }
 242
 243     return 0;\r
 244 }
 245 \r
 246 static int ewtsa_disable(struct i2c_client *client)\r
 247 {
 248         struct sensor_private_data *sensor =\r
 249             (struct sensor_private_data *) i2c_get_clientdata(client);  \r
 250         \r
 251         gpio_direction_output(sensor->pdata->standby_pin, GPIO_HIGH);\r
 252 \r
 253         DBG("%s: end \n",__func__);     \r
 254 \r
 255         return 0;          \r
 256 }
 257 \r
 258 static int ewtsa_enable(struct i2c_client *client)\r
 259 {
 260         int err;\r
 261         struct sensor_private_data *sensor =\r
 262             (struct sensor_private_data *) i2c_get_clientdata(client);  \r
 263         \r
 264         gpio_direction_output(sensor->pdata->standby_pin, GPIO_LOW);\r
 265         err = i2c_write_byte(client, ( unsigned char)REG_PWR_MGM, ( unsigned char)SLEEP_CTRL_ACTIVATE);////0x44\r
 266         if (err < 0){\r
 267                 //return err;\r
 268                 err = ewtsa_system_restart(client);///restart; only when i2c error\r
 269                 if (err < 0){\r
 270                         return err;\r
 271                 }\r
 272         }\r
 273 \r
 274         err = i2c_write_byte(client,  ( unsigned char) REG_INT_CFG, ( unsigned char)INT_CFG_INT_ENABLE);\r
 275         if (err < 0) {\r
 276                 return err;\r
 277         }\r
 278         DBG("%s: end \n",__func__);     \r
 279         return 0;\r
 280 }
 281 \r
 282 void gyro_dev_reset(struct i2c_client *client)\r
 283 {
 284         struct sensor_private_data *sensor =\r
 285             (struct sensor_private_data *) i2c_get_clientdata(client);  \r
 286 \r
 287         \r
 288     DBG("%s\n",__func__);\r
 289         gpio_direction_output(sensor->pdata->standby_pin, GPIO_HIGH);\r
 290         msleep(100); \r
 291         gpio_direction_output(sensor->pdata->standby_pin, GPIO_LOW);\r
 292         msleep(100); \r
 293 }\r
 294 \r
 295 static int sensor_active(struct i2c_client *client, int enable, int rate)\r
 296 {\r
 297         struct sensor_private_data *sensor =\r
 298             (struct sensor_private_data *) i2c_get_clientdata(client);  \r
 299         int result = 0;\r
 300         int status = 0;\r
 301         //register setting according to chip datasheet          \r
 302         if(enable)\r
 303         {       \r
 304                 result=ewtsa_enable(client);\r
 305         }\r
 306         else\r
 307         {\r
 308                 result=ewtsa_disable(client);\r
 309         }\r
 310 \r
 311         if(result)\r
 312                 printk("%s:fail to active sensor\n",__func__);\r
 313 \r
 314         return result;\r
 315 \r
 316 }\r
 317 \r
 318 static int sensor_init(struct i2c_client *client)\r
 319 {       \r
 320         struct sensor_private_data *sensor =\r
 321             (struct sensor_private_data *) i2c_get_clientdata(client);  \r
 322         int result = 0; \r
 323         unsigned char buf[5];           \r
 324         unsigned char data = 0;\r
 325         int i = 0;\r
 326         char pReadData=0;\r
 327         \r
 328         sensor->status_cur = SENSOR_OFF;\r
 329         gyro_dev_reset(client);\r
 330         ewtsa_system_restart(client);\r
 331         return result;\r
 332 }\r
 333 \r
 334 \r
 335 static int gyro_report_value(struct i2c_client *client, struct sensor_axis *axis)\r
 336 {\r
 337         struct sensor_private_data *sensor =\r
 338                 (struct sensor_private_data *) i2c_get_clientdata(client);      \r
 339 \r
 340         /* Report GYRO  information */\r
 341         input_report_rel(sensor->input_dev, ABS_RX, axis->x);\r
 342         input_report_rel(sensor->input_dev, ABS_RY, axis->y);\r
 343         input_report_rel(sensor->input_dev, ABS_RZ, axis->z);\r
 344         input_sync(sensor->input_dev);\r
 345         DBG("gyro x==%d  y==%d z==%d\n",axis->x,axis->y,axis->z);\r
 346 \r
 347         return 0;\r
 348 }\r
 349 \r
 350 static int sensor_report_value(struct i2c_client *client)\r
 351 {\r
 352         struct sensor_private_data *sensor =\r
 353                 (struct sensor_private_data *) i2c_get_clientdata(client);      \r
 354         struct sensor_platform_data *pdata = sensor->pdata;\r
 355         int ret = 0;\r
 356         int x = 0, y = 0, z = 0;\r
 357         struct sensor_axis axis;\r
 358         char buffer[6] = {0};   \r
 359         int i = 0;\r
 360         int value = 0;\r
 361 \r
 362         memset(buffer, 0, 6);\r
 363 #if 0   \r
 364         /* Data bytes from hardware xL, xH, yL, yH, zL, zH */   \r
 365         do {\r
 366                 buffer[0] = sensor->ops->read_reg;\r
 367                 ret = sensor_rx_data(client, buffer, sensor->ops->read_len);\r
 368                 if (ret < 0)\r
 369                 return ret;\r
 370         } while (0);\r
 371 #else\r
 372 \r
 373         for(i=0; i<6; i++)\r
 374         {
 375                 i2c_read_byte(client, sensor->ops->read_reg + i,&buffer[i]);\r
 376         }\r
 377 #endif\r
 378                 \r
 379         x = (short) (((buffer[0]) << 8) | buffer[1]);\r
 380         y = (short) (((buffer[2]) << 8) | buffer[3]);\r
 381         z = (short) (((buffer[4]) << 8) | buffer[5]);\r
 382
 383         //printk("%s: x=%d  y=%d z=%d \n",__func__, x,y,z);\r
 384         if(pdata && pdata->orientation)
 385         {
 386                 axis.x = (pdata->orientation[0])*x + (pdata->orientation[1])*y + (pdata->orientation[2])*z;
 387                 axis.y = (pdata->orientation[3])*x + (pdata->orientation[4])*y + (pdata->orientation[5])*z;
 388                 axis.z = (pdata->orientation[6])*x + (pdata->orientation[7])*y + (pdata->orientation[8])*z;
 389         }
 390         else
 391         {
 392                 axis.x = x;
 393                 axis.y = y;
 394                 axis.z = z;
 395         }
 396
 397         //filter gyro data
 398         if((abs(axis.x) > pdata->x_min)||(abs(axis.y) > pdata->y_min)||(abs(axis.z) > pdata->z_min))\r
 399         {       \r
 400                 gyro_report_value(client, &axis);       \r
 401 \r
 402                  /* »¥³âµØ»º´æÊý¾Ý. */\r
 403                 mutex_lock(&(sensor->data_mutex) );\r
 404                 sensor->axis = axis;\r
 405                 mutex_unlock(&(sensor->data_mutex) );\r
 406         }       \r
 407         \r
 408         return ret;\r
 409 }\r
 410 \r
 411 \r
 412 struct sensor_operate gyro_ewtsa_ops = {\r
 413         .name                           = "ewtsa",\r
 414         .type                           = SENSOR_TYPE_GYROSCOPE,//sensor type and it should be correct\r
 415         .id_i2c                         = GYRO_ID_EWTSA,                //i2c id number\r
 416         .read_reg                       = GYRO_DATA_REG,                //read data\r
 417         .read_len                       = 6,                            //data length\r
 418         .id_reg                         = -1,           //read device id from this register\r
 419         .id_data                        = -1,           //device id\r
 420         .precision                      = 8,                            //8 bits\r
 421         .ctrl_reg                       = REG_PWR_MGM,          //enable or disable \r
 422         .int_status_reg                 = REG_INT_STATUS,                       //intterupt status register,if no exist then -1\r
 423         .range                          = {-32768,32768},               //range\r
 424         .trig                           = IRQF_TRIGGER_HIGH|IRQF_ONESHOT,               \r
 425         .active                         = sensor_active,        \r
 426         .init                           = sensor_init,\r
 427         .report                         = sensor_report_value,\r
 428 };\r
 429 \r
 430 /****************operate according to sensor chip:end************/\r
 431 \r
 432 //function name should not be changed\r
 433 static struct sensor_operate *gyro_get_ops(void)\r
 434 {\r
 435         return &gyro_ewtsa_ops;\r
 436 }\r
 437 \r
 438 \r
 439 static int __init gyro_ewtsa_init(void)\r
 440 {\r
 441         struct sensor_operate *ops = gyro_get_ops();\r
 442         int result = 0;\r
 443         int type = ops->type;\r
 444         result = sensor_register_slave(type, NULL, NULL, gyro_get_ops);\r
 445         return result;\r
 446 }\r
 447 \r
 448 static void __exit gyro_ewtsa_exit(void)\r
 449 {\r
 450         struct sensor_operate *ops = gyro_get_ops();\r
 451         int type = ops->type;\r
 452         sensor_unregister_slave(type, NULL, NULL, gyro_get_ops);\r
 453 }\r
 454 \r
 455 \r
 456 module_init(gyro_ewtsa_init);\r
 457 module_exit(gyro_ewtsa_exit);\r
 458 \r
 459 \r