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