drivers/input/sensors/accel/dmard10.c

   1 /* drivers/input/sensors/access/dmard10.c
   2  *
   3  * Copyright (C) 2012-2015 ROCKCHIP.
   4  * Author: guoyi <gy@rock-chips.com>
   5  *
   6  * This software is licensed under the terms of the GNU General Public
   7  * License version 2, as published by the Free Software Foundation, and
   8  * may be copied, distributed, and modified under those terms.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  */
  16 #include <linux/interrupt.h>
  17 #include <linux/i2c.h>
  18 #include <linux/slab.h>
  19 #include <linux/irq.h>
  20 #include <linux/miscdevice.h>
  21 #include <linux/gpio.h>
  22 #include <asm/uaccess.h>
  23 #include <asm/atomic.h>
  24 #include <linux/delay.h>
  25 #include <linux/input.h>
  26 #include <linux/workqueue.h>
  27 #include <linux/freezer.h>
  28 #include <linux/of_gpio.h>
  29 #ifdef CONFIG_HAS_EARLYSUSPEND
  30 #include <linux/earlysuspend.h>
  31 #endif
  32 #include <linux/sensor-dev.h>
  33
  34 /* Default register settings */
  35 #define RBUFF_SIZE              12      /* Rx buffer size */
  36
  37 #define REG_ACTR                                0x00
  38 #define REG_WDAL                                0x01
  39 #define REG_TAPNS                               0x0f
  40 #define REG_MISC2                               0x1f
  41 #define REG_AFEM                                0x0c
  42 #define REG_CKSEL                               0x0d
  43 #define REG_INTC                                0x0e
  44 #define REG_STADR                               0x12
  45 #define REG_STAINT                              0x1C
  46 #define REG_PD                                  0x21
  47 #define REG_TCGYZ                               0x26
  48 #define REG_X_OUT                               0x41
  49
  50 #define MODE_Off                                0x00
  51 #define MODE_ResetAtOff                 0x01
  52 #define MODE_Standby                    0x02
  53 #define MODE_ResetAtStandby             0x03
  54 #define MODE_Active                             0x06
  55 #define MODE_Trigger                    0x0a
  56 #define MODE_ReadOTP                    0x12
  57 #define MODE_WriteOTP                   0x22
  58 #define MODE_WriteOTPBuf                0x42
  59 #define MODE_ResetDataPath              0x82
  60
  61 #define VALUE_STADR                                     0x55
  62 #define VALUE_STAINT                            0xAA
  63 #define VALUE_AFEM_AFEN_Normal          0x8f// AFEN set 1 , ATM[2:0]=b'000(normal),EN_Z/Y/X/T=1
  64 #define VALUE_AFEM_Normal                       0x0f// AFEN set 0 , ATM[2:0]=b'000(normal),EN_Z/Y/X/T=1
  65 #define VALUE_INTC                                      0x00// INTC[6:5]=b'00
  66 #define VALUE_INTC_Interrupt_En         0x20// INTC[6:5]=b'01 (Data ready interrupt enable, active high at INT0)
  67 #define VALUE_CKSEL_ODR_0_204           0x04// ODR[3:0]=b'0000 (0.78125Hz), CCK[3:0]=b'0100 (204.8kHZ)
  68 #define VALUE_CKSEL_ODR_1_204           0x14// ODR[3:0]=b'0001 (1.5625Hz), CCK[3:0]=b'0100 (204.8kHZ)
  69 #define VALUE_CKSEL_ODR_3_204           0x24// ODR[3:0]=b'0010 (3.125Hz), CCK[3:0]=b'0100 (204.8kHZ)
  70 #define VALUE_CKSEL_ODR_6_204           0x34// ODR[3:0]=b'0011 (6.25Hz), CCK[3:0]=b'0100 (204.8kHZ)
  71 #define VALUE_CKSEL_ODR_12_204          0x44// ODR[3:0]=b'0100 (12.5Hz), CCK[3:0]=b'0100 (204.8kHZ)
  72 #define VALUE_CKSEL_ODR_25_204          0x54// ODR[3:0]=b'0101 (25Hz), CCK[3:0]=b'0100 (204.8kHZ)
  73 #define VALUE_CKSEL_ODR_50_204          0x64// ODR[3:0]=b'0110 (50Hz), CCK[3:0]=b'0100 (204.8kHZ)
  74 #define VALUE_CKSEL_ODR_100_204         0x74// ODR[3:0]=b'0111 (100Hz), CCK[3:0]=b'0100 (204.8kHZ)
  75
  76 #define VALUE_TAPNS_NoFilter    0x00    // TAP1/TAP2    NO FILTER
  77 #define VALUE_TAPNS_Ave_2               0x11    // TAP1/TAP2    Average 2
  78 #define VALUE_TAPNS_Ave_4               0x22    // TAP1/TAP2    Average 4
  79 #define VALUE_TAPNS_Ave_8               0x33    // TAP1/TAP2    Average 8
  80 #define VALUE_TAPNS_Ave_16              0x44    // TAP1/TAP2    Average 16
  81 #define VALUE_TAPNS_Ave_32              0x55    // TAP1/TAP2    Average 32
  82 #define VALUE_MISC2_OSCA_EN             0x08
  83 #define VALUE_PD_RST                    0x52
  84
  85
  86 //#define DMARD10_REG_INTSU        0x47
  87 //#define DMARD10_REG_MODE        0x44
  88 //#define DMARD10_REG_SR               0x44
  89
  90
  91 #define DMARD10_REG_DS      0X49
  92 #define DMARD10_REG_ID       0X0F
  93 #define DMARD10_REG_IT       0X4D
  94 #define DMARD10_REG_INTSRC1_C       0X4A
  95 #define DMARD10_REG_INTSRC1_S       0X4B
  96 #define MMAIO                           0xA1
  97
  98 // IOCTLs for DMARD10 library
  99 #define ECS_IOCTL_INIT                  _IO(MMAIO, 0x01)
 100 #define ECS_IOCTL_RESET                 _IO(MMAIO, 0x04)
 101 #define ECS_IOCTL_CLOSE                 _IO(MMAIO, 0x02)
 102 #define ECS_IOCTL_START                 _IO(MMAIO, 0x03)
 103 #define ECS_IOCTL_GETDATA               _IOR(MMAIO, 0x08, char[RBUFF_SIZE+1])
 104 #define SENSOR_CALIBRATION              _IOWR(MMAIO, 0x05 , int[SENSOR_DATA_SIZE])
 105
 106 // IOCTLs for APPs
 107 #define ECS_IOCTL_APP_SET_RATE          _IOW(MMAIO, 0x10, char)
 108
 109  //rate
 110 #define DMARD10_RANGE                                           2000000
 111
 112 #define DMARD10_RATE_32         32
 113 /*
 114 #define DMARD10_RATE_64         64
 115 #define DMARD10_RATE_120        128
 116 #define DMARD10_RATE_MIN                DMARD10_RATE_1
 117 #define DMARD10_RATE_MAX                DMARD10_RATE_120
 118 */
 119 /*status*/
 120 #define DMARD10_OPEN               1
 121 #define DMARD10_CLOSE              0
 122 #define DMARD10_NORMAL             2
 123 #define DMARD10_LOWPOWER           3
 124
 125
 126
 127 #define DMARD10_IIC_ADDR            0x18
 128 #define DMARD10_REG_LEN         11
 129
 130
 131 #define DMARD10_FATOR   15
 132
 133
 134 #define DMARD10_X_OUT           0x41
 135 #define SENSOR_DATA_SIZE 3
 136 #define DMARD10_SENSOR_RATE_1   0
 137 #define DMARD10_SENSOR_RATE_2   1
 138 #define DMARD10_SENSOR_RATE_3   2
 139 #define DMARD10_SENSOR_RATE_4   3
 140
 141 #define POWER_OR_RATE 1
 142 #define SW_RESET 1
 143 #define DMARD10_INTERRUPUT 1
 144 #define DMARD10_POWERDOWN 0
 145 #define DMARD10_POWERON 1
 146
 147 //g-senor layout configuration, choose one of the following configuration
 148
 149 #define AVG_NUM                         16
 150 #define SENSOR_DATA_SIZE                3
 151 #define DEFAULT_SENSITIVITY             1024
 152
 153
 154
 155 #define DMARD10_ENABLE          1
 156
 157 #define DMARD10_REG_X_OUT       0x12
 158 #define DMARD10_REG_Y_OUT       0x1
 159 #define DMARD10_REG_Z_OUT       0x2
 160 #define DMARD10_REG_TILT        0x3
 161 #define DMARD10_REG_SRST        0x4
 162 #define DMARD10_REG_SPCNT       0x5
 163 #define DMARD10_REG_INTSU       0x6
 164 #define DMARD10_REG_MODE        0x7
 165 #define DMARD10_REG_SR          0x8
 166 #define DMARD10_REG_PDET        0x9
 167 #define DMARD10_REG_PD          0xa
 168
 169 #define DMARD10_RANGE                   4000000
 170 #define DMARD10_PRECISION       10
 171 #define DMARD10_BOUNDARY        (0x1 << (DMARD10_PRECISION  - 1))
 172 #define DMARD10_GRAVITY_STEP    (DMARD10_RANGE / DMARD10_BOUNDARY)
 173
 174
 175 struct sensor_axis_average {
 176                 int x_average;
 177                 int y_average;
 178                 int z_average;
 179                 int count;
 180 };
 181
 182 static struct sensor_axis_average axis_average;
 183 int gsensor_reset(struct i2c_client *client){
 184         struct sensor_private_data *sensor =
 185             (struct sensor_private_data *) i2c_get_clientdata(client);
 186
 187         char buffer[7], buffer2[2];
 188         /* 1. check D10 , VALUE_STADR = 0x55 , VALUE_STAINT = 0xAA */
 189         buffer[0] = REG_STADR;
 190         buffer2[0] = REG_STAINT;
 191
 192         sensor_rx_data(client, buffer, 2);
 193         sensor_rx_data(client, buffer2, 2);
 194
 195         if( buffer[0] == VALUE_STADR || buffer2[0] == VALUE_STAINT){
 196                 DBG(KERN_INFO " REG_STADR_VALUE = %d , REG_STAINT_VALUE = %d\n", buffer[0], buffer2[0]);
 197                 DBG(KERN_INFO " %s DMT_DEVICE_NAME registered I2C driver!\n",__FUNCTION__);
 198         }
 199         else{
 200                 DBG(KERN_INFO " %s gsensor I2C err @@@ REG_STADR_VALUE = %d , REG_STAINT_VALUE = %d \n", __func__, buffer[0], buffer2[0]);
 201                 return -1;
 202         }
 203         /* 2. Powerdown reset */
 204         buffer[0] = REG_PD;
 205         buffer[1] = VALUE_PD_RST;
 206         sensor_tx_data(client, buffer, 2);
 207         /* 3. ACTR => Standby mode => Download OTP to parameter reg => Standby mode => Reset data path => Standby mode */
 208         buffer[0] = REG_ACTR;
 209         buffer[1] = MODE_Standby;
 210         buffer[2] = MODE_ReadOTP;
 211         buffer[3] = MODE_Standby;
 212         buffer[4] = MODE_ResetDataPath;
 213         buffer[5] = MODE_Standby;
 214         sensor_tx_data(client, buffer, 6);
 215         /* 4. OSCA_EN = 1 ,TSTO = b'000(INT1 = normal, TEST0 = normal) */
 216         buffer[0] = REG_MISC2;
 217         buffer[1] = VALUE_MISC2_OSCA_EN;
 218         sensor_tx_data(client, buffer, 2);
 219         /* 5. AFEN = 1(AFE will powerdown after ADC) */
 220         buffer[0] = REG_AFEM;
 221         buffer[1] = VALUE_AFEM_AFEN_Normal;
 222         buffer[2] = VALUE_CKSEL_ODR_100_204;
 223         buffer[3] = VALUE_INTC;
 224         buffer[4] = VALUE_TAPNS_Ave_2;
 225         buffer[5] = 0x00;       // DLYC, no delay timing
 226         buffer[6] = 0x07;       // INTD=1 (push-pull), INTA=1 (active high), AUTOT=1 (enable T)
 227         sensor_tx_data(client, buffer, 7);
 228         /* 6. write TCGYZ & TCGX */
 229         buffer[0] = REG_WDAL;   // REG:0x01
 230         buffer[1] = 0x00;               // set TC of Y,Z gain value
 231         buffer[2] = 0x00;               // set TC of X gain value
 232         buffer[3] = 0x03;               // Temperature coefficient of X,Y,Z gain
 233         sensor_tx_data(client, buffer, 4);
 234
 235         buffer[0] = REG_ACTR;                   // REG:0x00
 236         buffer[1] = MODE_Standby;               // Standby
 237         buffer[2] = MODE_WriteOTPBuf;   // WriteOTPBuf
 238         buffer[3] = MODE_Standby;               // Standby
 239
 240         /* 7. Activation mode */
 241         buffer[0] = REG_ACTR;
 242         buffer[1] = MODE_Active;
 243         sensor_tx_data(client, buffer, 2);
 244         printk("\n dmard10 gsensor _reset SUCCESS!!\n");
 245         return 0;
 246 }
 247
 248 /****************operate according to sensor chip:start************/
 249
 250 static int sensor_active(struct i2c_client *client, int enable, int rate)
 251 {
 252         struct sensor_private_data *sensor =
 253             (struct sensor_private_data *) i2c_get_clientdata(client);
 254         int result = 0;
 255         int status = 0;
 256                 gsensor_reset(client);
 257         sensor->ops->ctrl_data = sensor_read_reg(client, sensor->ops->ctrl_reg);
 258         //register setting according to chip datasheet
 259         if(enable)
 260         {
 261                 status = DMARD10_ENABLE;        //dmard10
 262                 sensor->ops->ctrl_data |= status;
 263         }
 264         else
 265         {
 266                 status = ~DMARD10_ENABLE;       //dmard10
 267                 sensor->ops->ctrl_data &= status;
 268         }
 269
 270         DBG("%s:reg=0x%x,reg_ctrl=0x%x,enable=%d\n",__func__,sensor->ops->ctrl_reg, sensor->ops->ctrl_data, enable);
 271         result = sensor_write_reg(client, sensor->ops->ctrl_reg, sensor->ops->ctrl_data);
 272         if(result)
 273                 printk("%s:fail to active sensor\n",__func__);
 274
 275         return result;
 276
 277 }
 278
 279 static int sensor_init(struct i2c_client *client)
 280 {
 281         struct sensor_private_data *sensor =
 282             (struct sensor_private_data *) i2c_get_clientdata(client);
 283         int result = 0;
 284
 285         result = sensor->ops->active(client,0,0);
 286         if(result)
 287         {
 288                 printk("%s:line=%d,error\n",__func__,__LINE__);
 289                 return result;
 290         }
 291
 292         sensor->status_cur = SENSOR_OFF;
 293
 294         DBG("%s:DMARD10_REG_TILT=0x%x\n",__func__,sensor_read_reg(client, DMARD10_REG_TILT));
 295
 296         result = sensor_write_reg(client, DMARD10_REG_SR, (0x01<<5)| 0x02);     //32 Samples/Second Active and Auto-Sleep Mode
 297         if(result)
 298         {
 299                 printk("%s:line=%d,error\n",__func__,__LINE__);
 300                 return result;
 301         }
 302
 303         if(sensor->pdata->irq_enable)   //open interrupt
 304         {
 305                 result = sensor_write_reg(client, DMARD10_REG_INTSU, 1<<4);//enable int,GINT=1
 306                 if(result)
 307                 {
 308                         printk("%s:line=%d,error\n",__func__,__LINE__);
 309                         return result;
 310                 }
 311         }
 312
 313         sensor->ops->ctrl_data = 1<<6;  //Interrupt output INT is push-pull
 314         result = sensor_write_reg(client, sensor->ops->ctrl_reg, sensor->ops->ctrl_data);
 315         if(result)
 316         {
 317                 printk("%s:line=%d,error\n",__func__,__LINE__);
 318                 return result;
 319         }
 320
 321
 322         memset(&axis_average, 0, sizeof(struct sensor_axis_average));
 323
 324         return result;
 325 }
 326
 327
 328 static int sensor_convert_data(struct i2c_client *client, char high_byte, char low_byte)
 329 {
 330     s64 result;
 331
 332
 333                 result = ((int)high_byte << 8)|((int)low_byte);
 334
 335                 if (result < DMARD10_BOUNDARY){
 336                         result = result* DMARD10_GRAVITY_STEP;
 337                 }else{
 338                         result = ~( ((~result & (0x7fff>>(16-DMARD10_PRECISION)) ) + 1)* DMARD10_GRAVITY_STEP) + 1;
 339                 }
 340
 341                 return result;
 342
 343 }
 344
 345 static int gsensor_report_value(struct i2c_client *client, struct sensor_axis *axis)
 346 {
 347         struct sensor_private_data *sensor =
 348             (struct sensor_private_data *) i2c_get_clientdata(client);
 349
 350         /* Report acceleration sensor information */
 351         input_report_abs(sensor->input_dev, ABS_X, axis->x);
 352         input_report_abs(sensor->input_dev, ABS_Y, axis->y);
 353         input_report_abs(sensor->input_dev, ABS_Z, axis->z);
 354         input_sync(sensor->input_dev);
 355         DBG("Gsensor x==%d  y==%d z==%d\n",axis->x,axis->y,axis->z);
 356
 357         return 0;
 358 }
 359 #define DMARD10_COUNT_AVERAGE 2
 360 #define GSENSOR_MIN             2
 361 static int sensor_report_value(struct i2c_client *client)
 362 {
 363         struct sensor_private_data *sensor =
 364                 (struct sensor_private_data *) i2c_get_clientdata(client);
 365         struct sensor_platform_data *pdata = sensor->pdata;
 366         int ret = 0;
 367         int x,y,z;
 368         struct sensor_axis axis;
 369         char buffer[8] = {0};
 370         char value = 0;
 371
 372         if(sensor->ops->read_len < 3)   //sensor->ops->read_len = 3
 373         {
 374                 printk("%s:lenth is error,len=%d\n",__func__,sensor->ops->read_len);
 375                 return -1;
 376         }
 377
 378         memset(buffer, 0, 8);
 379         /* Data bytes from hardware xL, xH, yL, yH, zL, zH */
 380         do {
 381                 *buffer = sensor->ops->read_reg;
 382                 ret = sensor_rx_data(client, buffer, sensor->ops->read_len);
 383                 if (ret < 0)
 384                 return ret;
 385         } while (0);
 386
 387         //this gsensor need 6 bytes buffer
 388         x = sensor_convert_data(sensor->client, buffer[3], buffer[2]);  //buffer[1]:high bit
 389         y = sensor_convert_data(sensor->client, buffer[5], buffer[4]);
 390         z = sensor_convert_data(sensor->client, buffer[7], buffer[6]);
 391
 392         axis.x = (pdata->orientation[0])*x + (pdata->orientation[1])*y + (pdata->orientation[2])*z;
 393         axis.y = (pdata->orientation[3])*x + (pdata->orientation[4])*y + (pdata->orientation[5])*z;
 394         axis.z = (pdata->orientation[6])*x + (pdata->orientation[7])*y + (pdata->orientation[8])*z;
 395
 396
 397         axis_average.x_average += axis.x;
 398         axis_average.y_average += axis.y;
 399         axis_average.z_average += axis.z;
 400         axis_average.count++;
 401
 402         if(axis_average.count >= DMARD10_COUNT_AVERAGE)
 403         {
 404                 axis.x = axis_average.x_average / axis_average.count;
 405                 axis.y = axis_average.y_average / axis_average.count;
 406                 axis.z = axis_average.z_average / axis_average.count;
 407
 408                 DBG( "%s: axis = %d  %d  %d \n", __func__, axis.x, axis.y, axis.z);
 409
 410                 memset(&axis_average, 0, sizeof(struct sensor_axis_average));
 411
 412                 //Report event only while value is changed to save some power
 413                 if((abs(sensor->axis.x - axis.x) > GSENSOR_MIN) || (abs(sensor->axis.y - axis.y) > GSENSOR_MIN) || (abs(sensor->axis.z - axis.z) > GSENSOR_MIN))
 414                 {
 415                         gsensor_report_value(client, &axis);
 416
 417                         /* »¥³âµØ»º´æÊý¾Ý. */
 418                         mutex_lock(&(sensor->data_mutex) );
 419                         sensor->axis = axis;
 420                         mutex_unlock(&(sensor->data_mutex) );
 421                 }
 422         }
 423
 424         if((sensor->pdata->irq_enable)&& (sensor->ops->int_status_reg >= 0))    //read sensor intterupt status register
 425         {
 426
 427                 value = sensor_read_reg(client, sensor->ops->int_status_reg);
 428                 DBG("%s:sensor int status :0x%x\n",__func__,value);
 429         }
 430
 431         return ret;
 432 }
 433
 434
 435 struct sensor_operate gsensor_dmard10_ops = {
 436         .name                           = "gs_dmard10",
 437         .type                           = SENSOR_TYPE_ACCEL,                    //sensor type and it should be correct
 438         .id_i2c                         = ACCEL_ID_DMARD10,                     //i2c id number
 439         .read_reg                       = DMARD10_REG_X_OUT,                    //read data
 440         .read_len                       = 8,                                    //data length
 441         .id_reg                         = SENSOR_UNKNOW_DATA,                   //read device id from this register
 442         .id_data                        = SENSOR_UNKNOW_DATA,                   //device id
 443         .precision                      = DMARD10_PRECISION,                    //12 bit
 444         .ctrl_reg                       = DMARD10_REG_MODE,                     //enable or disable
 445         .int_status_reg         = SENSOR_UNKNOW_DATA,                   //intterupt status register
 446         .range                          = {-DMARD10_RANGE,DMARD10_RANGE},       //range
 447         .trig                           = IRQF_TRIGGER_LOW|IRQF_ONESHOT,
 448         .active                         = sensor_active,
 449         .init                           = sensor_init,
 450         .report                         = sensor_report_value,
 451 };
 452
 453 /****************operate according to sensor chip:end************/
 454
 455 //function name should not be changed
 456 static struct sensor_operate *gsensor_get_ops(void)
 457 {
 458         return &gsensor_dmard10_ops;
 459 }
 460
 461
 462 static int __init gsensor_dmard10_init(void)
 463 {
 464         struct sensor_operate *ops = gsensor_get_ops();
 465         int result = 0;
 466         int type = ops->type;
 467         result = sensor_register_slave(type, NULL, NULL, gsensor_get_ops);
 468         return result;
 469 }
 470
 471 static void __exit gsensor_dmard10_exit(void)
 472 {
 473         struct sensor_operate *ops = gsensor_get_ops();
 474         int type = ops->type;
 475         sensor_unregister_slave(type, NULL, NULL, gsensor_get_ops);
 476 }
 477
 478
 479 module_init(gsensor_dmard10_init);
 480 module_exit(gsensor_dmard10_exit);
 481
 482
 483