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