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