drivers/input/misc/ad714x.c

   1 /*
   2  * AD714X CapTouch Programmable Controller driver supporting AD7142/3/7/8/7A
   3  *
   4  * Copyright 2009 Analog Devices Inc.
   5  *
   6  * Licensed under the GPL-2 or later.
   7  */
   8
   9 #include <linux/device.h>
  10 #include <linux/init.h>
  11 #include <linux/input.h>
  12 #include <linux/interrupt.h>
  13 #include <linux/slab.h>
  14 #include <linux/input/ad714x.h>
  15 #include "ad714x.h"
  16
  17 #define AD714X_PWR_CTRL           0x0
  18 #define AD714X_STG_CAL_EN_REG     0x1
  19 #define AD714X_AMB_COMP_CTRL0_REG 0x2
  20 #define AD714X_PARTID_REG         0x17
  21 #define AD7142_PARTID             0xE620
  22 #define AD7143_PARTID             0xE630
  23 #define AD7147_PARTID             0x1470
  24 #define AD7148_PARTID             0x1480
  25 #define AD714X_STAGECFG_REG       0x80
  26 #define AD714X_SYSCFG_REG         0x0
  27
  28 #define STG_LOW_INT_EN_REG     0x5
  29 #define STG_HIGH_INT_EN_REG    0x6
  30 #define STG_COM_INT_EN_REG     0x7
  31 #define STG_LOW_INT_STA_REG    0x8
  32 #define STG_HIGH_INT_STA_REG   0x9
  33 #define STG_COM_INT_STA_REG    0xA
  34
  35 #define CDC_RESULT_S0          0xB
  36 #define CDC_RESULT_S1          0xC
  37 #define CDC_RESULT_S2          0xD
  38 #define CDC_RESULT_S3          0xE
  39 #define CDC_RESULT_S4          0xF
  40 #define CDC_RESULT_S5          0x10
  41 #define CDC_RESULT_S6          0x11
  42 #define CDC_RESULT_S7          0x12
  43 #define CDC_RESULT_S8          0x13
  44 #define CDC_RESULT_S9          0x14
  45 #define CDC_RESULT_S10         0x15
  46 #define CDC_RESULT_S11         0x16
  47
  48 #define STAGE0_AMBIENT          0xF1
  49 #define STAGE1_AMBIENT          0x115
  50 #define STAGE2_AMBIENT          0x139
  51 #define STAGE3_AMBIENT          0x15D
  52 #define STAGE4_AMBIENT          0x181
  53 #define STAGE5_AMBIENT          0x1A5
  54 #define STAGE6_AMBIENT          0x1C9
  55 #define STAGE7_AMBIENT          0x1ED
  56 #define STAGE8_AMBIENT          0x211
  57 #define STAGE9_AMBIENT          0x234
  58 #define STAGE10_AMBIENT         0x259
  59 #define STAGE11_AMBIENT         0x27D
  60
  61 #define PER_STAGE_REG_NUM      36
  62 #define STAGE_NUM              12
  63 #define STAGE_CFGREG_NUM       8
  64 #define SYS_CFGREG_NUM         8
  65
  66 /*
  67  * driver information which will be used to maintain the software flow
  68  */
  69 enum ad714x_device_state { IDLE, JITTER, ACTIVE, SPACE };
  70
  71 struct ad714x_slider_drv {
  72         int highest_stage;
  73         int abs_pos;
  74         int flt_pos;
  75         enum ad714x_device_state state;
  76         struct input_dev *input;
  77 };
  78
  79 struct ad714x_wheel_drv {
  80         int abs_pos;
  81         int flt_pos;
  82         int pre_mean_value;
  83         int pre_highest_stage;
  84         int pre_mean_value_no_offset;
  85         int mean_value;
  86         int mean_value_no_offset;
  87         int pos_offset;
  88         int pos_ratio;
  89         int highest_stage;
  90         enum ad714x_device_state state;
  91         struct input_dev *input;
  92 };
  93
  94 struct ad714x_touchpad_drv {
  95         int x_highest_stage;
  96         int x_flt_pos;
  97         int x_abs_pos;
  98         int y_highest_stage;
  99         int y_flt_pos;
 100         int y_abs_pos;
 101         int left_ep;
 102         int left_ep_val;
 103         int right_ep;
 104         int right_ep_val;
 105         int top_ep;
 106         int top_ep_val;
 107         int bottom_ep;
 108         int bottom_ep_val;
 109         enum ad714x_device_state state;
 110         struct input_dev *input;
 111 };
 112
 113 struct ad714x_button_drv {
 114         enum ad714x_device_state state;
 115         /*
 116          * Unlike slider/wheel/touchpad, all buttons point to
 117          * same input_dev instance
 118          */
 119         struct input_dev *input;
 120 };
 121
 122 struct ad714x_driver_data {
 123         struct ad714x_slider_drv *slider;
 124         struct ad714x_wheel_drv *wheel;
 125         struct ad714x_touchpad_drv *touchpad;
 126         struct ad714x_button_drv *button;
 127 };
 128
 129 /*
 130  * information to integrate all things which will be private data
 131  * of spi/i2c device
 132  */
 133 struct ad714x_chip {
 134         unsigned short h_state;
 135         unsigned short l_state;
 136         unsigned short c_state;
 137         unsigned short adc_reg[STAGE_NUM];
 138         unsigned short amb_reg[STAGE_NUM];
 139         unsigned short sensor_val[STAGE_NUM];
 140
 141         struct ad714x_platform_data *hw;
 142         struct ad714x_driver_data *sw;
 143
 144         int irq;
 145         struct device *dev;
 146         ad714x_read_t read;
 147         ad714x_write_t write;
 148
 149         struct mutex mutex;
 150
 151         unsigned product;
 152         unsigned version;
 153 };
 154
 155 static void ad714x_use_com_int(struct ad714x_chip *ad714x,
 156                                 int start_stage, int end_stage)
 157 {
 158         unsigned short data;
 159         unsigned short mask;
 160
 161         mask = ((1 << (end_stage + 1)) - 1) - (1 << start_stage);
 162
 163         ad714x->read(ad714x->dev, STG_COM_INT_EN_REG, &data);
 164         data |= 1 << start_stage;
 165         ad714x->write(ad714x->dev, STG_COM_INT_EN_REG, data);
 166
 167         ad714x->read(ad714x->dev, STG_HIGH_INT_EN_REG, &data);
 168         data &= ~mask;
 169         ad714x->write(ad714x->dev, STG_HIGH_INT_EN_REG, data);
 170 }
 171
 172 static void ad714x_use_thr_int(struct ad714x_chip *ad714x,
 173                                 int start_stage, int end_stage)
 174 {
 175         unsigned short data;
 176         unsigned short mask;
 177
 178         mask = ((1 << (end_stage + 1)) - 1) - (1 << start_stage);
 179
 180         ad714x->read(ad714x->dev, STG_COM_INT_EN_REG, &data);
 181         data &= ~(1 << start_stage);
 182         ad714x->write(ad714x->dev, STG_COM_INT_EN_REG, data);
 183
 184         ad714x->read(ad714x->dev, STG_HIGH_INT_EN_REG, &data);
 185         data |= mask;
 186         ad714x->write(ad714x->dev, STG_HIGH_INT_EN_REG, data);
 187 }
 188
 189 static int ad714x_cal_highest_stage(struct ad714x_chip *ad714x,
 190                                         int start_stage, int end_stage)
 191 {
 192         int max_res = 0;
 193         int max_idx = 0;
 194         int i;
 195
 196         for (i = start_stage; i <= end_stage; i++) {
 197                 if (ad714x->sensor_val[i] > max_res) {
 198                         max_res = ad714x->sensor_val[i];
 199                         max_idx = i;
 200                 }
 201         }
 202
 203         return max_idx;
 204 }
 205
 206 static int ad714x_cal_abs_pos(struct ad714x_chip *ad714x,
 207                                 int start_stage, int end_stage,
 208                                 int highest_stage, int max_coord)
 209 {
 210         int a_param, b_param;
 211
 212         if (highest_stage == start_stage) {
 213                 a_param = ad714x->sensor_val[start_stage + 1];
 214                 b_param = ad714x->sensor_val[start_stage] +
 215                         ad714x->sensor_val[start_stage + 1];
 216         } else if (highest_stage == end_stage) {
 217                 a_param = ad714x->sensor_val[end_stage] *
 218                         (end_stage - start_stage) +
 219                         ad714x->sensor_val[end_stage - 1] *
 220                         (end_stage - start_stage - 1);
 221                 b_param = ad714x->sensor_val[end_stage] +
 222                         ad714x->sensor_val[end_stage - 1];
 223         } else {
 224                 a_param = ad714x->sensor_val[highest_stage] *
 225                         (highest_stage - start_stage) +
 226                         ad714x->sensor_val[highest_stage - 1] *
 227                         (highest_stage - start_stage - 1) +
 228                         ad714x->sensor_val[highest_stage + 1] *
 229                         (highest_stage - start_stage + 1);
 230                 b_param = ad714x->sensor_val[highest_stage] +
 231                         ad714x->sensor_val[highest_stage - 1] +
 232                         ad714x->sensor_val[highest_stage + 1];
 233         }
 234
 235         return (max_coord / (end_stage - start_stage)) * a_param / b_param;
 236 }
 237
 238 /*
 239  * One button can connect to multi positive and negative of CDCs
 240  * Multi-buttons can connect to same positive/negative of one CDC
 241  */
 242 static void ad714x_button_state_machine(struct ad714x_chip *ad714x, int idx)
 243 {
 244         struct ad714x_button_plat *hw = &ad714x->hw->button[idx];
 245         struct ad714x_button_drv *sw = &ad714x->sw->button[idx];
 246
 247         switch (sw->state) {
 248         case IDLE:
 249                 if (((ad714x->h_state & hw->h_mask) == hw->h_mask) &&
 250                     ((ad714x->l_state & hw->l_mask) == hw->l_mask)) {
 251                         dev_dbg(ad714x->dev, "button %d touched\n", idx);
 252                         input_report_key(sw->input, hw->keycode, 1);
 253                         input_sync(sw->input);
 254                         sw->state = ACTIVE;
 255                 }
 256                 break;
 257
 258         case ACTIVE:
 259                 if (((ad714x->h_state & hw->h_mask) != hw->h_mask) ||
 260                     ((ad714x->l_state & hw->l_mask) != hw->l_mask)) {
 261                         dev_dbg(ad714x->dev, "button %d released\n", idx);
 262                         input_report_key(sw->input, hw->keycode, 0);
 263                         input_sync(sw->input);
 264                         sw->state = IDLE;
 265                 }
 266                 break;
 267
 268         default:
 269                 break;
 270         }
 271 }
 272
 273 /*
 274  * The response of a sensor is defined by the absolute number of codes
 275  * between the current CDC value and the ambient value.
 276  */
 277 static void ad714x_slider_cal_sensor_val(struct ad714x_chip *ad714x, int idx)
 278 {
 279         struct ad714x_slider_plat *hw = &ad714x->hw->slider[idx];
 280         int i;
 281
 282         for (i = hw->start_stage; i <= hw->end_stage; i++) {
 283                 ad714x->read(ad714x->dev, CDC_RESULT_S0 + i,
 284                         &ad714x->adc_reg[i]);
 285                 ad714x->read(ad714x->dev,
 286                                 STAGE0_AMBIENT + i * PER_STAGE_REG_NUM,
 287                                 &ad714x->amb_reg[i]);
 288
 289                 ad714x->sensor_val[i] = abs(ad714x->adc_reg[i] -
 290                                 ad714x->amb_reg[i]);
 291         }
 292 }
 293
 294 static void ad714x_slider_cal_highest_stage(struct ad714x_chip *ad714x, int idx)
 295 {
 296         struct ad714x_slider_plat *hw = &ad714x->hw->slider[idx];
 297         struct ad714x_slider_drv *sw = &ad714x->sw->slider[idx];
 298
 299         sw->highest_stage = ad714x_cal_highest_stage(ad714x, hw->start_stage,
 300                         hw->end_stage);
 301
 302         dev_dbg(ad714x->dev, "slider %d highest_stage:%d\n", idx,
 303                 sw->highest_stage);
 304 }
 305
 306 /*
 307  * The formulae are very straight forward. It uses the sensor with the
 308  * highest response and the 2 adjacent ones.
 309  * When Sensor 0 has the highest response, only sensor 0 and sensor 1
 310  * are used in the calculations. Similarly when the last sensor has the
 311  * highest response, only the last sensor and the second last sensors
 312  * are used in the calculations.
 313  *
 314  * For i= idx_of_peak_Sensor-1 to i= idx_of_peak_Sensor+1
 315  *         v += Sensor response(i)*i
 316  *         w += Sensor response(i)
 317  * POS=(Number_of_Positions_Wanted/(Number_of_Sensors_Used-1)) *(v/w)
 318  */
 319 static void ad714x_slider_cal_abs_pos(struct ad714x_chip *ad714x, int idx)
 320 {
 321         struct ad714x_slider_plat *hw = &ad714x->hw->slider[idx];
 322         struct ad714x_slider_drv *sw = &ad714x->sw->slider[idx];
 323
 324         sw->abs_pos = ad714x_cal_abs_pos(ad714x, hw->start_stage, hw->end_stage,
 325                 sw->highest_stage, hw->max_coord);
 326
 327         dev_dbg(ad714x->dev, "slider %d absolute position:%d\n", idx,
 328                 sw->abs_pos);
 329 }
 330
 331 /*
 332  * To minimise the Impact of the noise on the algorithm, ADI developed a
 333  * routine that filters the CDC results after they have been read by the
 334  * host processor.
 335  * The filter used is an Infinite Input Response(IIR) filter implemented
 336  * in firmware and attenuates the noise on the CDC results after they've
 337  * been read by the host processor.
 338  * Filtered_CDC_result = (Filtered_CDC_result * (10 - Coefficient) +
 339  *                              Latest_CDC_result * Coefficient)/10
 340  */
 341 static void ad714x_slider_cal_flt_pos(struct ad714x_chip *ad714x, int idx)
 342 {
 343         struct ad714x_slider_drv *sw = &ad714x->sw->slider[idx];
 344
 345         sw->flt_pos = (sw->flt_pos * (10 - 4) +
 346                         sw->abs_pos * 4)/10;
 347
 348         dev_dbg(ad714x->dev, "slider %d filter position:%d\n", idx,
 349                 sw->flt_pos);
 350 }
 351
 352 static void ad714x_slider_use_com_int(struct ad714x_chip *ad714x, int idx)
 353 {
 354         struct ad714x_slider_plat *hw = &ad714x->hw->slider[idx];
 355
 356         ad714x_use_com_int(ad714x, hw->start_stage, hw->end_stage);
 357 }
 358
 359 static void ad714x_slider_use_thr_int(struct ad714x_chip *ad714x, int idx)
 360 {
 361         struct ad714x_slider_plat *hw = &ad714x->hw->slider[idx];
 362
 363         ad714x_use_thr_int(ad714x, hw->start_stage, hw->end_stage);
 364 }
 365
 366 static void ad714x_slider_state_machine(struct ad714x_chip *ad714x, int idx)
 367 {
 368         struct ad714x_slider_plat *hw = &ad714x->hw->slider[idx];
 369         struct ad714x_slider_drv *sw = &ad714x->sw->slider[idx];
 370         unsigned short h_state, c_state;
 371         unsigned short mask;
 372
 373         mask = ((1 << (hw->end_stage + 1)) - 1) - ((1 << hw->start_stage) - 1);
 374
 375         h_state = ad714x->h_state & mask;
 376         c_state = ad714x->c_state & mask;
 377
 378         switch (sw->state) {
 379         case IDLE:
 380                 if (h_state) {
 381                         sw->state = JITTER;
 382                         /* In End of Conversion interrupt mode, the AD714X
 383                          * continuously generates hardware interrupts.
 384                          */
 385                         ad714x_slider_use_com_int(ad714x, idx);
 386                         dev_dbg(ad714x->dev, "slider %d touched\n", idx);
 387                 }
 388                 break;
 389
 390         case JITTER:
 391                 if (c_state == mask) {
 392                         ad714x_slider_cal_sensor_val(ad714x, idx);
 393                         ad714x_slider_cal_highest_stage(ad714x, idx);
 394                         ad714x_slider_cal_abs_pos(ad714x, idx);
 395                         sw->flt_pos = sw->abs_pos;
 396                         sw->state = ACTIVE;
 397                 }
 398                 break;
 399
 400         case ACTIVE:
 401                 if (c_state == mask) {
 402                         if (h_state) {
 403                                 ad714x_slider_cal_sensor_val(ad714x, idx);
 404                                 ad714x_slider_cal_highest_stage(ad714x, idx);
 405                                 ad714x_slider_cal_abs_pos(ad714x, idx);
 406                                 ad714x_slider_cal_flt_pos(ad714x, idx);
 407
 408                                 input_report_abs(sw->input, ABS_X, sw->flt_pos);
 409                                 input_report_key(sw->input, BTN_TOUCH, 1);
 410                         } else {
 411                                 /* When the user lifts off the sensor, configure
 412                                  * the AD714X back to threshold interrupt mode.
 413                                  */
 414                                 ad714x_slider_use_thr_int(ad714x, idx);
 415                                 sw->state = IDLE;
 416                                 input_report_key(sw->input, BTN_TOUCH, 0);
 417                                 dev_dbg(ad714x->dev, "slider %d released\n",
 418                                         idx);
 419                         }
 420                         input_sync(sw->input);
 421                 }
 422                 break;
 423
 424         default:
 425                 break;
 426         }
 427 }
 428
 429 /*
 430  * When the scroll wheel is activated, we compute the absolute position based
 431  * on the sensor values. To calculate the position, we first determine the
 432  * sensor that has the greatest response among the 8 sensors that constitutes
 433  * the scrollwheel. Then we determined the 2 sensors on either sides of the
 434  * sensor with the highest response and we apply weights to these sensors.
 435  */
 436 static void ad714x_wheel_cal_highest_stage(struct ad714x_chip *ad714x, int idx)
 437 {
 438         struct ad714x_wheel_plat *hw = &ad714x->hw->wheel[idx];
 439         struct ad714x_wheel_drv *sw = &ad714x->sw->wheel[idx];
 440
 441         sw->pre_highest_stage = sw->highest_stage;
 442         sw->highest_stage = ad714x_cal_highest_stage(ad714x, hw->start_stage,
 443                         hw->end_stage);
 444
 445         dev_dbg(ad714x->dev, "wheel %d highest_stage:%d\n", idx,
 446                 sw->highest_stage);
 447 }
 448
 449 static void ad714x_wheel_cal_sensor_val(struct ad714x_chip *ad714x, int idx)
 450 {
 451         struct ad714x_wheel_plat *hw = &ad714x->hw->wheel[idx];
 452         int i;
 453
 454         for (i = hw->start_stage; i <= hw->end_stage; i++) {
 455                 ad714x->read(ad714x->dev, CDC_RESULT_S0 + i,
 456                         &ad714x->adc_reg[i]);
 457                 ad714x->read(ad714x->dev,
 458                                 STAGE0_AMBIENT + i * PER_STAGE_REG_NUM,
 459                                 &ad714x->amb_reg[i]);
 460                 if (ad714x->adc_reg[i] > ad714x->amb_reg[i])
 461                         ad714x->sensor_val[i] = ad714x->adc_reg[i] -
 462                                 ad714x->amb_reg[i];
 463                 else
 464                         ad714x->sensor_val[i] = 0;
 465         }
 466 }
 467
 468 /*
 469  * When the scroll wheel is activated, we compute the absolute position based
 470  * on the sensor values. To calculate the position, we first determine the
 471  * sensor that has the greatest response among the 8 sensors that constitutes
 472  * the scrollwheel. Then we determined the 2 sensors on either sides of the
 473  * sensor with the highest response and we apply weights to these sensors. The
 474  * result of this computation gives us the mean value which defined by the
 475  * following formula:
 476  * For i= second_before_highest_stage to i= second_after_highest_stage
 477  *         v += Sensor response(i)*WEIGHT*(i+3)
 478  *         w += Sensor response(i)
 479  * Mean_Value=v/w
 480  * pos_on_scrollwheel = (Mean_Value - position_offset) / position_ratio
 481  */
 482
 483 #define WEIGHT_FACTOR 30
 484 /* This constant prevents the "PositionOffset" from reaching a big value */
 485 #define OFFSET_POSITION_CLAMP   120
 486 static void ad714x_wheel_cal_abs_pos(struct ad714x_chip *ad714x, int idx)
 487 {
 488         struct ad714x_wheel_plat *hw = &ad714x->hw->wheel[idx];
 489         struct ad714x_wheel_drv *sw = &ad714x->sw->wheel[idx];
 490         int stage_num = hw->end_stage - hw->start_stage + 1;
 491         int second_before, first_before, highest, first_after, second_after;
 492         int a_param, b_param;
 493
 494         /* Calculate Mean value */
 495
 496         second_before = (sw->highest_stage + stage_num - 2) % stage_num;
 497         first_before = (sw->highest_stage + stage_num - 1) % stage_num;
 498         highest = sw->highest_stage;
 499         first_after = (sw->highest_stage + stage_num + 1) % stage_num;
 500         second_after = (sw->highest_stage + stage_num + 2) % stage_num;
 501
 502         if (((sw->highest_stage - hw->start_stage) > 1) &&
 503             ((hw->end_stage - sw->highest_stage) > 1)) {
 504                 a_param = ad714x->sensor_val[second_before] *
 505                         (second_before - hw->start_stage + 3) +
 506                         ad714x->sensor_val[first_before] *
 507                         (second_before - hw->start_stage + 3) +
 508                         ad714x->sensor_val[highest] *
 509                         (second_before - hw->start_stage + 3) +
 510                         ad714x->sensor_val[first_after] *
 511                         (first_after - hw->start_stage + 3) +
 512                         ad714x->sensor_val[second_after] *
 513                         (second_after - hw->start_stage + 3);
 514         } else {
 515                 a_param = ad714x->sensor_val[second_before] *
 516                         (second_before - hw->start_stage + 1) +
 517                         ad714x->sensor_val[first_before] *
 518                         (second_before - hw->start_stage + 2) +
 519                         ad714x->sensor_val[highest] *
 520                         (second_before - hw->start_stage + 3) +
 521                         ad714x->sensor_val[first_after] *
 522                         (first_after - hw->start_stage + 4) +
 523                         ad714x->sensor_val[second_after] *
 524                         (second_after - hw->start_stage + 5);
 525         }
 526         a_param *= WEIGHT_FACTOR;
 527
 528         b_param = ad714x->sensor_val[second_before] +
 529                 ad714x->sensor_val[first_before] +
 530                 ad714x->sensor_val[highest] +
 531                 ad714x->sensor_val[first_after] +
 532                 ad714x->sensor_val[second_after];
 533
 534         sw->pre_mean_value = sw->mean_value;
 535         sw->mean_value = a_param / b_param;
 536
 537         /* Calculate the offset */
 538
 539         if ((sw->pre_highest_stage == hw->end_stage) &&
 540                         (sw->highest_stage == hw->start_stage))
 541                 sw->pos_offset = sw->mean_value;
 542         else if ((sw->pre_highest_stage == hw->start_stage) &&
 543                         (sw->highest_stage == hw->end_stage))
 544                 sw->pos_offset = sw->pre_mean_value;
 545
 546         if (sw->pos_offset > OFFSET_POSITION_CLAMP)
 547                 sw->pos_offset = OFFSET_POSITION_CLAMP;
 548
 549         /* Calculate the mean value without the offset */
 550
 551         sw->pre_mean_value_no_offset = sw->mean_value_no_offset;
 552         sw->mean_value_no_offset = sw->mean_value - sw->pos_offset;
 553         if (sw->mean_value_no_offset < 0)
 554                 sw->mean_value_no_offset = 0;
 555
 556         /* Calculate ratio to scale down to NUMBER_OF_WANTED_POSITIONS */
 557
 558         if ((sw->pre_highest_stage == hw->end_stage) &&
 559                         (sw->highest_stage == hw->start_stage))
 560                 sw->pos_ratio = (sw->pre_mean_value_no_offset * 100) /
 561                         hw->max_coord;
 562         else if ((sw->pre_highest_stage == hw->start_stage) &&
 563                         (sw->highest_stage == hw->end_stage))
 564                 sw->pos_ratio = (sw->mean_value_no_offset * 100) /
 565                         hw->max_coord;
 566         sw->abs_pos = (sw->mean_value_no_offset * 100) / sw->pos_ratio;
 567         if (sw->abs_pos > hw->max_coord)
 568                 sw->abs_pos = hw->max_coord;
 569 }
 570
 571 static void ad714x_wheel_cal_flt_pos(struct ad714x_chip *ad714x, int idx)
 572 {
 573         struct ad714x_wheel_plat *hw = &ad714x->hw->wheel[idx];
 574         struct ad714x_wheel_drv *sw = &ad714x->sw->wheel[idx];
 575         if (((sw->pre_highest_stage == hw->end_stage) &&
 576                         (sw->highest_stage == hw->start_stage)) ||
 577             ((sw->pre_highest_stage == hw->start_stage) &&
 578                         (sw->highest_stage == hw->end_stage)))
 579                 sw->flt_pos = sw->abs_pos;
 580         else
 581                 sw->flt_pos = ((sw->flt_pos * 30) + (sw->abs_pos * 71)) / 100;
 582
 583         if (sw->flt_pos > hw->max_coord)
 584                 sw->flt_pos = hw->max_coord;
 585 }
 586
 587 static void ad714x_wheel_use_com_int(struct ad714x_chip *ad714x, int idx)
 588 {
 589         struct ad714x_wheel_plat *hw = &ad714x->hw->wheel[idx];
 590
 591         ad714x_use_com_int(ad714x, hw->start_stage, hw->end_stage);
 592 }
 593
 594 static void ad714x_wheel_use_thr_int(struct ad714x_chip *ad714x, int idx)
 595 {
 596         struct ad714x_wheel_plat *hw = &ad714x->hw->wheel[idx];
 597
 598         ad714x_use_thr_int(ad714x, hw->start_stage, hw->end_stage);
 599 }
 600
 601 static void ad714x_wheel_state_machine(struct ad714x_chip *ad714x, int idx)
 602 {
 603         struct ad714x_wheel_plat *hw = &ad714x->hw->wheel[idx];
 604         struct ad714x_wheel_drv *sw = &ad714x->sw->wheel[idx];
 605         unsigned short h_state, c_state;
 606         unsigned short mask;
 607
 608         mask = ((1 << (hw->end_stage + 1)) - 1) - ((1 << hw->start_stage) - 1);
 609
 610         h_state = ad714x->h_state & mask;
 611         c_state = ad714x->c_state & mask;
 612
 613         switch (sw->state) {
 614         case IDLE:
 615                 if (h_state) {
 616                         sw->state = JITTER;
 617                         /* In End of Conversion interrupt mode, the AD714X
 618                          * continuously generates hardware interrupts.
 619                          */
 620                         ad714x_wheel_use_com_int(ad714x, idx);
 621                         dev_dbg(ad714x->dev, "wheel %d touched\n", idx);
 622                 }
 623                 break;
 624
 625         case JITTER:
 626                 if (c_state == mask)    {
 627                         ad714x_wheel_cal_sensor_val(ad714x, idx);
 628                         ad714x_wheel_cal_highest_stage(ad714x, idx);
 629                         ad714x_wheel_cal_abs_pos(ad714x, idx);
 630                         sw->flt_pos = sw->abs_pos;
 631                         sw->state = ACTIVE;
 632                 }
 633                 break;
 634
 635         case ACTIVE:
 636                 if (c_state == mask) {
 637                         if (h_state) {
 638                                 ad714x_wheel_cal_sensor_val(ad714x, idx);
 639                                 ad714x_wheel_cal_highest_stage(ad714x, idx);
 640                                 ad714x_wheel_cal_abs_pos(ad714x, idx);
 641                                 ad714x_wheel_cal_flt_pos(ad714x, idx);
 642
 643                                 input_report_abs(sw->input, ABS_WHEEL,
 644                                         sw->abs_pos);
 645                                 input_report_key(sw->input, BTN_TOUCH, 1);
 646                         } else {
 647                                 /* When the user lifts off the sensor, configure
 648                                  * the AD714X back to threshold interrupt mode.
 649                                  */
 650                                 ad714x_wheel_use_thr_int(ad714x, idx);
 651                                 sw->state = IDLE;
 652                                 input_report_key(sw->input, BTN_TOUCH, 0);
 653
 654                                 dev_dbg(ad714x->dev, "wheel %d released\n",
 655                                         idx);
 656                         }
 657                         input_sync(sw->input);
 658                 }
 659                 break;
 660
 661         default:
 662                 break;
 663         }
 664 }
 665
 666 static void touchpad_cal_sensor_val(struct ad714x_chip *ad714x, int idx)
 667 {
 668         struct ad714x_touchpad_plat *hw = &ad714x->hw->touchpad[idx];
 669         int i;
 670
 671         for (i = hw->x_start_stage; i <= hw->x_end_stage; i++) {
 672                 ad714x->read(ad714x->dev, CDC_RESULT_S0 + i,
 673                                 &ad714x->adc_reg[i]);
 674                 ad714x->read(ad714x->dev,
 675                                 STAGE0_AMBIENT + i * PER_STAGE_REG_NUM,
 676                                 &ad714x->amb_reg[i]);
 677                 if (ad714x->adc_reg[i] > ad714x->amb_reg[i])
 678                         ad714x->sensor_val[i] = ad714x->adc_reg[i] -
 679                                 ad714x->amb_reg[i];
 680                 else
 681                         ad714x->sensor_val[i] = 0;
 682         }
 683 }
 684
 685 static void touchpad_cal_highest_stage(struct ad714x_chip *ad714x, int idx)
 686 {
 687         struct ad714x_touchpad_plat *hw = &ad714x->hw->touchpad[idx];
 688         struct ad714x_touchpad_drv *sw = &ad714x->sw->touchpad[idx];
 689
 690         sw->x_highest_stage = ad714x_cal_highest_stage(ad714x,
 691                 hw->x_start_stage, hw->x_end_stage);
 692         sw->y_highest_stage = ad714x_cal_highest_stage(ad714x,
 693                 hw->y_start_stage, hw->y_end_stage);
 694
 695         dev_dbg(ad714x->dev,
 696                 "touchpad %d x_highest_stage:%d, y_highest_stage:%d\n",
 697                 idx, sw->x_highest_stage, sw->y_highest_stage);
 698 }
 699
 700 /*
 701  * If 2 fingers are touching the sensor then 2 peaks can be observed in the
 702  * distribution.
 703  * The arithmetic doesn't support to get absolute coordinates for multi-touch
 704  * yet.
 705  */
 706 static int touchpad_check_second_peak(struct ad714x_chip *ad714x, int idx)
 707 {
 708         struct ad714x_touchpad_plat *hw = &ad714x->hw->touchpad[idx];
 709         struct ad714x_touchpad_drv *sw = &ad714x->sw->touchpad[idx];
 710         int i;
 711
 712         for (i = hw->x_start_stage; i < sw->x_highest_stage; i++) {
 713                 if ((ad714x->sensor_val[i] - ad714x->sensor_val[i + 1])
 714                         > (ad714x->sensor_val[i + 1] / 10))
 715                         return 1;
 716         }
 717
 718         for (i = sw->x_highest_stage; i < hw->x_end_stage; i++) {
 719                 if ((ad714x->sensor_val[i + 1] - ad714x->sensor_val[i])
 720                         > (ad714x->sensor_val[i] / 10))
 721                         return 1;
 722         }
 723
 724         for (i = hw->y_start_stage; i < sw->y_highest_stage; i++) {
 725                 if ((ad714x->sensor_val[i] - ad714x->sensor_val[i + 1])
 726                         > (ad714x->sensor_val[i + 1] / 10))
 727                         return 1;
 728         }
 729
 730         for (i = sw->y_highest_stage; i < hw->y_end_stage; i++) {
 731                 if ((ad714x->sensor_val[i + 1] - ad714x->sensor_val[i])
 732                         > (ad714x->sensor_val[i] / 10))
 733                         return 1;
 734         }
 735
 736         return 0;
 737 }
 738
 739 /*
 740  * If only one finger is used to activate the touch pad then only 1 peak will be
 741  * registered in the distribution. This peak and the 2 adjacent sensors will be
 742  * used in the calculation of the absolute position. This will prevent hand
 743  * shadows to affect the absolute position calculation.
 744  */
 745 static void touchpad_cal_abs_pos(struct ad714x_chip *ad714x, int idx)
 746 {
 747         struct ad714x_touchpad_plat *hw = &ad714x->hw->touchpad[idx];
 748         struct ad714x_touchpad_drv *sw = &ad714x->sw->touchpad[idx];
 749
 750         sw->x_abs_pos = ad714x_cal_abs_pos(ad714x, hw->x_start_stage,
 751                         hw->x_end_stage, sw->x_highest_stage, hw->x_max_coord);
 752         sw->y_abs_pos = ad714x_cal_abs_pos(ad714x, hw->y_start_stage,
 753                         hw->y_end_stage, sw->y_highest_stage, hw->y_max_coord);
 754
 755         dev_dbg(ad714x->dev, "touchpad %d absolute position:(%d, %d)\n", idx,
 756                         sw->x_abs_pos, sw->y_abs_pos);
 757 }
 758
 759 static void touchpad_cal_flt_pos(struct ad714x_chip *ad714x, int idx)
 760 {
 761         struct ad714x_touchpad_drv *sw = &ad714x->sw->touchpad[idx];
 762
 763         sw->x_flt_pos = (sw->x_flt_pos * (10 - 4) +
 764                         sw->x_abs_pos * 4)/10;
 765         sw->y_flt_pos = (sw->y_flt_pos * (10 - 4) +
 766                         sw->y_abs_pos * 4)/10;
 767
 768         dev_dbg(ad714x->dev, "touchpad %d filter position:(%d, %d)\n",
 769                         idx, sw->x_flt_pos, sw->y_flt_pos);
 770 }
 771
 772 /*
 773  * To prevent distortion from showing in the absolute position, it is
 774  * necessary to detect the end points. When endpoints are detected, the
 775  * driver stops updating the status variables with absolute positions.
 776  * End points are detected on the 4 edges of the touchpad sensor. The
 777  * method to detect them is the same for all 4.
 778  * To detect the end points, the firmware computes the difference in
 779  * percent between the sensor on the edge and the adjacent one. The
 780  * difference is calculated in percent in order to make the end point
 781  * detection independent of the pressure.
 782  */
 783
 784 #define LEFT_END_POINT_DETECTION_LEVEL                  550
 785 #define RIGHT_END_POINT_DETECTION_LEVEL                 750
 786 #define LEFT_RIGHT_END_POINT_DEAVTIVALION_LEVEL         850
 787 #define TOP_END_POINT_DETECTION_LEVEL                   550
 788 #define BOTTOM_END_POINT_DETECTION_LEVEL                950
 789 #define TOP_BOTTOM_END_POINT_DEAVTIVALION_LEVEL         700
 790 static int touchpad_check_endpoint(struct ad714x_chip *ad714x, int idx)
 791 {
 792         struct ad714x_touchpad_plat *hw = &ad714x->hw->touchpad[idx];
 793         struct ad714x_touchpad_drv *sw  = &ad714x->sw->touchpad[idx];
 794         int percent_sensor_diff;
 795
 796         /* left endpoint detect */
 797         percent_sensor_diff = (ad714x->sensor_val[hw->x_start_stage] -
 798                         ad714x->sensor_val[hw->x_start_stage + 1]) * 100 /
 799                         ad714x->sensor_val[hw->x_start_stage + 1];
 800         if (!sw->left_ep) {
 801                 if (percent_sensor_diff >= LEFT_END_POINT_DETECTION_LEVEL)  {
 802                         sw->left_ep = 1;
 803                         sw->left_ep_val =
 804                                 ad714x->sensor_val[hw->x_start_stage + 1];
 805                 }
 806         } else {
 807                 if ((percent_sensor_diff < LEFT_END_POINT_DETECTION_LEVEL) &&
 808                     (ad714x->sensor_val[hw->x_start_stage + 1] >
 809                      LEFT_RIGHT_END_POINT_DEAVTIVALION_LEVEL + sw->left_ep_val))
 810                         sw->left_ep = 0;
 811         }
 812
 813         /* right endpoint detect */
 814         percent_sensor_diff = (ad714x->sensor_val[hw->x_end_stage] -
 815                         ad714x->sensor_val[hw->x_end_stage - 1]) * 100 /
 816                         ad714x->sensor_val[hw->x_end_stage - 1];
 817         if (!sw->right_ep) {
 818                 if (percent_sensor_diff >= RIGHT_END_POINT_DETECTION_LEVEL)  {
 819                         sw->right_ep = 1;
 820                         sw->right_ep_val =
 821                                 ad714x->sensor_val[hw->x_end_stage - 1];
 822                 }
 823         } else {
 824                 if ((percent_sensor_diff < RIGHT_END_POINT_DETECTION_LEVEL) &&
 825                 (ad714x->sensor_val[hw->x_end_stage - 1] >
 826                 LEFT_RIGHT_END_POINT_DEAVTIVALION_LEVEL + sw->right_ep_val))
 827                         sw->right_ep = 0;
 828         }
 829
 830         /* top endpoint detect */
 831         percent_sensor_diff = (ad714x->sensor_val[hw->y_start_stage] -
 832                         ad714x->sensor_val[hw->y_start_stage + 1]) * 100 /
 833                         ad714x->sensor_val[hw->y_start_stage + 1];
 834         if (!sw->top_ep) {
 835                 if (percent_sensor_diff >= TOP_END_POINT_DETECTION_LEVEL)  {
 836                         sw->top_ep = 1;
 837                         sw->top_ep_val =
 838                                 ad714x->sensor_val[hw->y_start_stage + 1];
 839                 }
 840         } else {
 841                 if ((percent_sensor_diff < TOP_END_POINT_DETECTION_LEVEL) &&
 842                 (ad714x->sensor_val[hw->y_start_stage + 1] >
 843                 TOP_BOTTOM_END_POINT_DEAVTIVALION_LEVEL + sw->top_ep_val))
 844                         sw->top_ep = 0;
 845         }
 846
 847         /* bottom endpoint detect */
 848         percent_sensor_diff = (ad714x->sensor_val[hw->y_end_stage] -
 849                 ad714x->sensor_val[hw->y_end_stage - 1]) * 100 /
 850                 ad714x->sensor_val[hw->y_end_stage - 1];
 851         if (!sw->bottom_ep) {
 852                 if (percent_sensor_diff >= BOTTOM_END_POINT_DETECTION_LEVEL)  {
 853                         sw->bottom_ep = 1;
 854                         sw->bottom_ep_val =
 855                                 ad714x->sensor_val[hw->y_end_stage - 1];
 856                 }
 857         } else {
 858                 if ((percent_sensor_diff < BOTTOM_END_POINT_DETECTION_LEVEL) &&
 859                 (ad714x->sensor_val[hw->y_end_stage - 1] >
 860                  TOP_BOTTOM_END_POINT_DEAVTIVALION_LEVEL + sw->bottom_ep_val))
 861                         sw->bottom_ep = 0;
 862         }
 863
 864         return sw->left_ep || sw->right_ep || sw->top_ep || sw->bottom_ep;
 865 }
 866
 867 static void touchpad_use_com_int(struct ad714x_chip *ad714x, int idx)
 868 {
 869         struct ad714x_touchpad_plat *hw = &ad714x->hw->touchpad[idx];
 870
 871         ad714x_use_com_int(ad714x, hw->x_start_stage, hw->x_end_stage);
 872 }
 873
 874 static void touchpad_use_thr_int(struct ad714x_chip *ad714x, int idx)
 875 {
 876         struct ad714x_touchpad_plat *hw = &ad714x->hw->touchpad[idx];
 877
 878         ad714x_use_thr_int(ad714x, hw->x_start_stage, hw->x_end_stage);
 879         ad714x_use_thr_int(ad714x, hw->y_start_stage, hw->y_end_stage);
 880 }
 881
 882 static void ad714x_touchpad_state_machine(struct ad714x_chip *ad714x, int idx)
 883 {
 884         struct ad714x_touchpad_plat *hw = &ad714x->hw->touchpad[idx];
 885         struct ad714x_touchpad_drv *sw = &ad714x->sw->touchpad[idx];
 886         unsigned short h_state, c_state;
 887         unsigned short mask;
 888
 889         mask = (((1 << (hw->x_end_stage + 1)) - 1) -
 890                 ((1 << hw->x_start_stage) - 1)) +
 891                 (((1 << (hw->y_end_stage + 1)) - 1) -
 892                 ((1 << hw->y_start_stage) - 1));
 893
 894         h_state = ad714x->h_state & mask;
 895         c_state = ad714x->c_state & mask;
 896
 897         switch (sw->state) {
 898         case IDLE:
 899                 if (h_state) {
 900                         sw->state = JITTER;
 901                         /* In End of Conversion interrupt mode, the AD714X
 902                          * continuously generates hardware interrupts.
 903                          */
 904                         touchpad_use_com_int(ad714x, idx);
 905                         dev_dbg(ad714x->dev, "touchpad %d touched\n", idx);
 906                 }
 907                 break;
 908
 909         case JITTER:
 910                 if (c_state == mask) {
 911                         touchpad_cal_sensor_val(ad714x, idx);
 912                         touchpad_cal_highest_stage(ad714x, idx);
 913                         if ((!touchpad_check_second_peak(ad714x, idx)) &&
 914                                 (!touchpad_check_endpoint(ad714x, idx))) {
 915                                 dev_dbg(ad714x->dev,
 916                                         "touchpad%d, 2 fingers or endpoint\n",
 917                                         idx);
 918                                 touchpad_cal_abs_pos(ad714x, idx);
 919                                 sw->x_flt_pos = sw->x_abs_pos;
 920                                 sw->y_flt_pos = sw->y_abs_pos;
 921                                 sw->state = ACTIVE;
 922                         }
 923                 }
 924                 break;
 925
 926         case ACTIVE:
 927                 if (c_state == mask) {
 928                         if (h_state) {
 929                                 touchpad_cal_sensor_val(ad714x, idx);
 930                                 touchpad_cal_highest_stage(ad714x, idx);
 931                                 if ((!touchpad_check_second_peak(ad714x, idx))
 932                                   && (!touchpad_check_endpoint(ad714x, idx))) {
 933                                         touchpad_cal_abs_pos(ad714x, idx);
 934                                         touchpad_cal_flt_pos(ad714x, idx);
 935                                         input_report_abs(sw->input, ABS_X,
 936                                                 sw->x_flt_pos);
 937                                         input_report_abs(sw->input, ABS_Y,
 938                                                 sw->y_flt_pos);
 939                                         input_report_key(sw->input, BTN_TOUCH,
 940                                                 1);
 941                                 }
 942                         } else {
 943                                 /* When the user lifts off the sensor, configure
 944                                  * the AD714X back to threshold interrupt mode.
 945                                  */
 946                                 touchpad_use_thr_int(ad714x, idx);
 947                                 sw->state = IDLE;
 948                                 input_report_key(sw->input, BTN_TOUCH, 0);
 949                                 dev_dbg(ad714x->dev, "touchpad %d released\n",
 950                                         idx);
 951                         }
 952                         input_sync(sw->input);
 953                 }
 954                 break;
 955
 956         default:
 957                 break;
 958         }
 959 }
 960
 961 static int ad714x_hw_detect(struct ad714x_chip *ad714x)
 962 {
 963         unsigned short data;
 964
 965         ad714x->read(ad714x->dev, AD714X_PARTID_REG, &data);
 966         switch (data & 0xFFF0) {
 967         case AD7142_PARTID:
 968                 ad714x->product = 0x7142;
 969                 ad714x->version = data & 0xF;
 970                 dev_info(ad714x->dev, "found AD7142 captouch, rev:%d\n",
 971                                 ad714x->version);
 972                 return 0;
 973
 974         case AD7143_PARTID:
 975                 ad714x->product = 0x7143;
 976                 ad714x->version = data & 0xF;
 977                 dev_info(ad714x->dev, "found AD7143 captouch, rev:%d\n",
 978                                 ad714x->version);
 979                 return 0;
 980
 981         case AD7147_PARTID:
 982                 ad714x->product = 0x7147;
 983                 ad714x->version = data & 0xF;
 984                 dev_info(ad714x->dev, "found AD7147(A) captouch, rev:%d\n",
 985                                 ad714x->version);
 986                 return 0;
 987
 988         case AD7148_PARTID:
 989                 ad714x->product = 0x7148;
 990                 ad714x->version = data & 0xF;
 991                 dev_info(ad714x->dev, "found AD7148 captouch, rev:%d\n",
 992                                 ad714x->version);
 993                 return 0;
 994
 995         default:
 996                 dev_err(ad714x->dev,
 997                         "fail to detect AD714X captouch, read ID is %04x\n",
 998                         data);
 999                 return -ENODEV;
1000         }
1001 }
1002
1003 static void ad714x_hw_init(struct ad714x_chip *ad714x)
1004 {
1005         int i, j;
1006         unsigned short reg_base;
1007         unsigned short data;
1008
1009         /* configuration CDC and interrupts */
1010
1011         for (i = 0; i < STAGE_NUM; i++) {
1012                 reg_base = AD714X_STAGECFG_REG + i * STAGE_CFGREG_NUM;
1013                 for (j = 0; j < STAGE_CFGREG_NUM; j++)
1014                         ad714x->write(ad714x->dev, reg_base + j,
1015                                         ad714x->hw->stage_cfg_reg[i][j]);
1016         }
1017
1018         for (i = 0; i < SYS_CFGREG_NUM; i++)
1019                 ad714x->write(ad714x->dev, AD714X_SYSCFG_REG + i,
1020                         ad714x->hw->sys_cfg_reg[i]);
1021         for (i = 0; i < SYS_CFGREG_NUM; i++)
1022                 ad714x->read(ad714x->dev, AD714X_SYSCFG_REG + i,
1023                         &data);
1024
1025         ad714x->write(ad714x->dev, AD714X_STG_CAL_EN_REG, 0xFFF);
1026
1027         /* clear all interrupts */
1028         ad714x->read(ad714x->dev, STG_LOW_INT_STA_REG, &data);
1029         ad714x->read(ad714x->dev, STG_HIGH_INT_STA_REG, &data);
1030         ad714x->read(ad714x->dev, STG_COM_INT_STA_REG, &data);
1031 }
1032
1033 static irqreturn_t ad714x_interrupt_thread(int irq, void *data)
1034 {
1035         struct ad714x_chip *ad714x = data;
1036         int i;
1037
1038         mutex_lock(&ad714x->mutex);
1039
1040         ad714x->read(ad714x->dev, STG_LOW_INT_STA_REG, &ad714x->l_state);
1041         ad714x->read(ad714x->dev, STG_HIGH_INT_STA_REG, &ad714x->h_state);
1042         ad714x->read(ad714x->dev, STG_COM_INT_STA_REG, &ad714x->c_state);
1043
1044         for (i = 0; i < ad714x->hw->button_num; i++)
1045                 ad714x_button_state_machine(ad714x, i);
1046         for (i = 0; i < ad714x->hw->slider_num; i++)
1047                 ad714x_slider_state_machine(ad714x, i);
1048         for (i = 0; i < ad714x->hw->wheel_num; i++)
1049                 ad714x_wheel_state_machine(ad714x, i);
1050         for (i = 0; i < ad714x->hw->touchpad_num; i++)
1051                 ad714x_touchpad_state_machine(ad714x, i);
1052
1053         mutex_unlock(&ad714x->mutex);
1054
1055         return IRQ_HANDLED;
1056 }
1057
1058 #define MAX_DEVICE_NUM 8
1059 struct ad714x_chip *ad714x_probe(struct device *dev, u16 bus_type, int irq,
1060                                  ad714x_read_t read, ad714x_write_t write)
1061 {
1062         int i, alloc_idx;
1063         int error;
1064         struct input_dev *input[MAX_DEVICE_NUM];
1065
1066         struct ad714x_platform_data *plat_data = dev->platform_data;
1067         struct ad714x_chip *ad714x;
1068         void *drv_mem;
1069
1070         struct ad714x_button_drv *bt_drv;
1071         struct ad714x_slider_drv *sd_drv;
1072         struct ad714x_wheel_drv *wl_drv;
1073         struct ad714x_touchpad_drv *tp_drv;
1074
1075
1076         if (irq <= 0) {
1077                 dev_err(dev, "IRQ not configured!\n");
1078                 error = -EINVAL;
1079                 goto err_out;
1080         }
1081
1082         if (dev->platform_data == NULL) {
1083                 dev_err(dev, "platform data for ad714x doesn't exist\n");
1084                 error = -EINVAL;
1085                 goto err_out;
1086         }
1087
1088         ad714x = kzalloc(sizeof(*ad714x) + sizeof(*ad714x->sw) +
1089                          sizeof(*sd_drv) * plat_data->slider_num +
1090                          sizeof(*wl_drv) * plat_data->wheel_num +
1091                          sizeof(*tp_drv) * plat_data->touchpad_num +
1092                          sizeof(*bt_drv) * plat_data->button_num, GFP_KERNEL);
1093         if (!ad714x) {
1094                 error = -ENOMEM;
1095                 goto err_out;
1096         }
1097
1098         ad714x->hw = plat_data;
1099
1100         drv_mem = ad714x + 1;
1101         ad714x->sw = drv_mem;
1102         drv_mem += sizeof(*ad714x->sw);
1103         ad714x->sw->slider = sd_drv = drv_mem;
1104         drv_mem += sizeof(*sd_drv) * ad714x->hw->slider_num;
1105         ad714x->sw->wheel = wl_drv = drv_mem;
1106         drv_mem += sizeof(*wl_drv) * ad714x->hw->wheel_num;
1107         ad714x->sw->touchpad = tp_drv = drv_mem;
1108         drv_mem += sizeof(*tp_drv) * ad714x->hw->touchpad_num;
1109         ad714x->sw->button = bt_drv = drv_mem;
1110         drv_mem += sizeof(*bt_drv) * ad714x->hw->button_num;
1111
1112         ad714x->read = read;
1113         ad714x->write = write;
1114         ad714x->irq = irq;
1115         ad714x->dev = dev;
1116
1117         error = ad714x_hw_detect(ad714x);
1118         if (error)
1119                 goto err_free_mem;
1120
1121         /* initilize and request sw/hw resources */
1122
1123         ad714x_hw_init(ad714x);
1124         mutex_init(&ad714x->mutex);
1125
1126         /*
1127          * Allocate and register AD714X input device
1128          */
1129         alloc_idx = 0;
1130
1131         /* a slider uses one input_dev instance */
1132         if (ad714x->hw->slider_num > 0) {
1133                 struct ad714x_slider_plat *sd_plat = ad714x->hw->slider;
1134
1135                 for (i = 0; i < ad714x->hw->slider_num; i++) {
1136                         sd_drv[i].input = input[alloc_idx] = input_allocate_device();
1137                         if (!input[alloc_idx]) {
1138                                 error = -ENOMEM;
1139                                 goto err_free_dev;
1140                         }
1141
1142                         __set_bit(EV_ABS, input[alloc_idx]->evbit);
1143                         __set_bit(EV_KEY, input[alloc_idx]->evbit);
1144                         __set_bit(ABS_X, input[alloc_idx]->absbit);
1145                         __set_bit(BTN_TOUCH, input[alloc_idx]->keybit);
1146                         input_set_abs_params(input[alloc_idx],
1147                                 ABS_X, 0, sd_plat->max_coord, 0, 0);
1148
1149                         input[alloc_idx]->id.bustype = bus_type;
1150                         input[alloc_idx]->id.product = ad714x->product;
1151                         input[alloc_idx]->id.version = ad714x->version;
1152
1153                         error = input_register_device(input[alloc_idx]);
1154                         if (error)
1155                                 goto err_free_dev;
1156
1157                         alloc_idx++;
1158                 }
1159         }
1160
1161         /* a wheel uses one input_dev instance */
1162         if (ad714x->hw->wheel_num > 0) {
1163                 struct ad714x_wheel_plat *wl_plat = ad714x->hw->wheel;
1164
1165                 for (i = 0; i < ad714x->hw->wheel_num; i++) {
1166                         wl_drv[i].input = input[alloc_idx] = input_allocate_device();
1167                         if (!input[alloc_idx]) {
1168                                 error = -ENOMEM;
1169                                 goto err_free_dev;
1170                         }
1171
1172                         __set_bit(EV_KEY, input[alloc_idx]->evbit);
1173                         __set_bit(EV_ABS, input[alloc_idx]->evbit);
1174                         __set_bit(ABS_WHEEL, input[alloc_idx]->absbit);
1175                         __set_bit(BTN_TOUCH, input[alloc_idx]->keybit);
1176                         input_set_abs_params(input[alloc_idx],
1177                                 ABS_WHEEL, 0, wl_plat->max_coord, 0, 0);
1178
1179                         input[alloc_idx]->id.bustype = bus_type;
1180                         input[alloc_idx]->id.product = ad714x->product;
1181                         input[alloc_idx]->id.version = ad714x->version;
1182
1183                         error = input_register_device(input[alloc_idx]);
1184                         if (error)
1185                                 goto err_free_dev;
1186
1187                         alloc_idx++;
1188                 }
1189         }
1190
1191         /* a touchpad uses one input_dev instance */
1192         if (ad714x->hw->touchpad_num > 0) {
1193                 struct ad714x_touchpad_plat *tp_plat = ad714x->hw->touchpad;
1194
1195                 for (i = 0; i < ad714x->hw->touchpad_num; i++) {
1196                         tp_drv[i].input = input[alloc_idx] = input_allocate_device();
1197                         if (!input[alloc_idx]) {
1198                                 error = -ENOMEM;
1199                                 goto err_free_dev;
1200                         }
1201
1202                         __set_bit(EV_ABS, input[alloc_idx]->evbit);
1203                         __set_bit(EV_KEY, input[alloc_idx]->evbit);
1204                         __set_bit(ABS_X, input[alloc_idx]->absbit);
1205                         __set_bit(ABS_Y, input[alloc_idx]->absbit);
1206                         __set_bit(BTN_TOUCH, input[alloc_idx]->keybit);
1207                         input_set_abs_params(input[alloc_idx],
1208                                 ABS_X, 0, tp_plat->x_max_coord, 0, 0);
1209                         input_set_abs_params(input[alloc_idx],
1210                                 ABS_Y, 0, tp_plat->y_max_coord, 0, 0);
1211
1212                         input[alloc_idx]->id.bustype = bus_type;
1213                         input[alloc_idx]->id.product = ad714x->product;
1214                         input[alloc_idx]->id.version = ad714x->version;
1215
1216                         error = input_register_device(input[alloc_idx]);
1217                         if (error)
1218                                 goto err_free_dev;
1219
1220                         alloc_idx++;
1221                 }
1222         }
1223
1224         /* all buttons use one input node */
1225         if (ad714x->hw->button_num > 0) {
1226                 struct ad714x_button_plat *bt_plat = ad714x->hw->button;
1227
1228                 input[alloc_idx] = input_allocate_device();
1229                 if (!input[alloc_idx]) {
1230                         error = -ENOMEM;
1231                         goto err_free_dev;
1232                 }
1233
1234                 __set_bit(EV_KEY, input[alloc_idx]->evbit);
1235                 for (i = 0; i < ad714x->hw->button_num; i++) {
1236                         bt_drv[i].input = input[alloc_idx];
1237                         __set_bit(bt_plat[i].keycode, input[alloc_idx]->keybit);
1238                 }
1239
1240                 input[alloc_idx]->id.bustype = bus_type;
1241                 input[alloc_idx]->id.product = ad714x->product;
1242                 input[alloc_idx]->id.version = ad714x->version;
1243
1244                 error = input_register_device(input[alloc_idx]);
1245                 if (error)
1246                         goto err_free_dev;
1247
1248                 alloc_idx++;
1249         }
1250
1251         error = request_threaded_irq(ad714x->irq, NULL, ad714x_interrupt_thread,
1252                         IRQF_TRIGGER_FALLING, "ad714x_captouch", ad714x);
1253         if (error) {
1254                 dev_err(dev, "can't allocate irq %d\n", ad714x->irq);
1255                 goto err_unreg_dev;
1256         }
1257
1258         return ad714x;
1259
1260  err_free_dev:
1261         dev_err(dev, "failed to setup AD714x input device %i\n", alloc_idx);
1262         input_free_device(input[alloc_idx]);
1263  err_unreg_dev:
1264         while (--alloc_idx >= 0)
1265                 input_unregister_device(input[alloc_idx]);
1266  err_free_mem:
1267         kfree(ad714x);
1268  err_out:
1269         return ERR_PTR(error);
1270 }
1271 EXPORT_SYMBOL(ad714x_probe);
1272
1273 void ad714x_remove(struct ad714x_chip *ad714x)
1274 {
1275         struct ad714x_platform_data *hw = ad714x->hw;
1276         struct ad714x_driver_data *sw = ad714x->sw;
1277         int i;
1278
1279         free_irq(ad714x->irq, ad714x);
1280
1281         /* unregister and free all input devices */
1282
1283         for (i = 0; i < hw->slider_num; i++)
1284                 input_unregister_device(sw->slider[i].input);
1285
1286         for (i = 0; i < hw->wheel_num; i++)
1287                 input_unregister_device(sw->wheel[i].input);
1288
1289         for (i = 0; i < hw->touchpad_num; i++)
1290                 input_unregister_device(sw->touchpad[i].input);
1291
1292         if (hw->button_num)
1293                 input_unregister_device(sw->button[0].input);
1294
1295         kfree(ad714x);
1296 }
1297 EXPORT_SYMBOL(ad714x_remove);
1298
1299 #ifdef CONFIG_PM
1300 int ad714x_disable(struct ad714x_chip *ad714x)
1301 {
1302         unsigned short data;
1303
1304         dev_dbg(ad714x->dev, "%s enter\n", __func__);
1305
1306         mutex_lock(&ad714x->mutex);
1307
1308         data = ad714x->hw->sys_cfg_reg[AD714X_PWR_CTRL] | 0x3;
1309         ad714x->write(ad714x->dev, AD714X_PWR_CTRL, data);
1310
1311         mutex_unlock(&ad714x->mutex);
1312
1313         return 0;
1314 }
1315 EXPORT_SYMBOL(ad714x_disable);
1316
1317 int ad714x_enable(struct ad714x_chip *ad714x)
1318 {
1319         unsigned short data;
1320
1321         dev_dbg(ad714x->dev, "%s enter\n", __func__);
1322
1323         mutex_lock(&ad714x->mutex);
1324
1325         /* resume to non-shutdown mode */
1326
1327         ad714x->write(ad714x->dev, AD714X_PWR_CTRL,
1328                         ad714x->hw->sys_cfg_reg[AD714X_PWR_CTRL]);
1329
1330         /* make sure the interrupt output line is not low level after resume,
1331          * otherwise we will get no chance to enter falling-edge irq again
1332          */
1333
1334         ad714x->read(ad714x->dev, STG_LOW_INT_STA_REG, &data);
1335         ad714x->read(ad714x->dev, STG_HIGH_INT_STA_REG, &data);
1336         ad714x->read(ad714x->dev, STG_COM_INT_STA_REG, &data);
1337
1338         mutex_unlock(&ad714x->mutex);
1339
1340         return 0;
1341 }
1342 EXPORT_SYMBOL(ad714x_enable);
1343 #endif
1344
1345 MODULE_DESCRIPTION("Analog Devices AD714X Capacitance Touch Sensor Driver");
1346 MODULE_AUTHOR("Barry Song <21cnbao@gmail.com>");
1347 MODULE_LICENSE("GPL");