1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) ST-Ericsson SA 2010 4 * Author: Naveen Kumar G <naveen.gaddipati@stericsson.com> for ST-Ericsson 5 */ 6 7 #include <linux/kernel.h> 8 #include <linux/delay.h> 9 #include <linux/interrupt.h> 10 #include <linux/i2c.h> 11 #include <linux/workqueue.h> 12 #include <linux/input.h> 13 #include <linux/input/bu21013.h> 14 #include <linux/slab.h> 15 #include <linux/regulator/consumer.h> 16 #include <linux/module.h> 17 #include <linux/gpio.h> 18 #include <linux/of.h> 19 #include <linux/of_gpio.h> 20 21 #define PEN_DOWN_INTR 0 22 #define MAX_FINGERS 2 23 #define RESET_DELAY 30 24 #define PENUP_TIMEOUT (10) 25 #define DELTA_MIN 16 26 #define MASK_BITS 0x03 27 #define SHIFT_8 8 28 #define SHIFT_2 2 29 #define LENGTH_OF_BUFFER 11 30 #define I2C_RETRY_COUNT 5 31 32 #define BU21013_SENSORS_BTN_0_7_REG 0x70 33 #define BU21013_SENSORS_BTN_8_15_REG 0x71 34 #define BU21013_SENSORS_BTN_16_23_REG 0x72 35 #define BU21013_X1_POS_MSB_REG 0x73 36 #define BU21013_X1_POS_LSB_REG 0x74 37 #define BU21013_Y1_POS_MSB_REG 0x75 38 #define BU21013_Y1_POS_LSB_REG 0x76 39 #define BU21013_X2_POS_MSB_REG 0x77 40 #define BU21013_X2_POS_LSB_REG 0x78 41 #define BU21013_Y2_POS_MSB_REG 0x79 42 #define BU21013_Y2_POS_LSB_REG 0x7A 43 #define BU21013_INT_CLR_REG 0xE8 44 #define BU21013_INT_MODE_REG 0xE9 45 #define BU21013_GAIN_REG 0xEA 46 #define BU21013_OFFSET_MODE_REG 0xEB 47 #define BU21013_XY_EDGE_REG 0xEC 48 #define BU21013_RESET_REG 0xED 49 #define BU21013_CALIB_REG 0xEE 50 #define BU21013_DONE_REG 0xEF 51 #define BU21013_SENSOR_0_7_REG 0xF0 52 #define BU21013_SENSOR_8_15_REG 0xF1 53 #define BU21013_SENSOR_16_23_REG 0xF2 54 #define BU21013_POS_MODE1_REG 0xF3 55 #define BU21013_POS_MODE2_REG 0xF4 56 #define BU21013_CLK_MODE_REG 0xF5 57 #define BU21013_IDLE_REG 0xFA 58 #define BU21013_FILTER_REG 0xFB 59 #define BU21013_TH_ON_REG 0xFC 60 #define BU21013_TH_OFF_REG 0xFD 61 62 63 #define BU21013_RESET_ENABLE 0x01 64 65 #define BU21013_SENSORS_EN_0_7 0x3F 66 #define BU21013_SENSORS_EN_8_15 0xFC 67 #define BU21013_SENSORS_EN_16_23 0x1F 68 69 #define BU21013_POS_MODE1_0 0x02 70 #define BU21013_POS_MODE1_1 0x04 71 #define BU21013_POS_MODE1_2 0x08 72 73 #define BU21013_POS_MODE2_ZERO 0x01 74 #define BU21013_POS_MODE2_AVG1 0x02 75 #define BU21013_POS_MODE2_AVG2 0x04 76 #define BU21013_POS_MODE2_EN_XY 0x08 77 #define BU21013_POS_MODE2_EN_RAW 0x10 78 #define BU21013_POS_MODE2_MULTI 0x80 79 80 #define BU21013_CLK_MODE_DIV 0x01 81 #define BU21013_CLK_MODE_EXT 0x02 82 #define BU21013_CLK_MODE_CALIB 0x80 83 84 #define BU21013_IDLET_0 0x01 85 #define BU21013_IDLET_1 0x02 86 #define BU21013_IDLET_2 0x04 87 #define BU21013_IDLET_3 0x08 88 #define BU21013_IDLE_INTERMIT_EN 0x10 89 90 #define BU21013_DELTA_0_6 0x7F 91 #define BU21013_FILTER_EN 0x80 92 93 #define BU21013_INT_MODE_LEVEL 0x00 94 #define BU21013_INT_MODE_EDGE 0x01 95 96 #define BU21013_GAIN_0 0x01 97 #define BU21013_GAIN_1 0x02 98 #define BU21013_GAIN_2 0x04 99 100 #define BU21013_OFFSET_MODE_DEFAULT 0x00 101 #define BU21013_OFFSET_MODE_MOVE 0x01 102 #define BU21013_OFFSET_MODE_DISABLE 0x02 103 104 #define BU21013_TH_ON_0 0x01 105 #define BU21013_TH_ON_1 0x02 106 #define BU21013_TH_ON_2 0x04 107 #define BU21013_TH_ON_3 0x08 108 #define BU21013_TH_ON_4 0x10 109 #define BU21013_TH_ON_5 0x20 110 #define BU21013_TH_ON_6 0x40 111 #define BU21013_TH_ON_7 0x80 112 #define BU21013_TH_ON_MAX 0xFF 113 114 #define BU21013_TH_OFF_0 0x01 115 #define BU21013_TH_OFF_1 0x02 116 #define BU21013_TH_OFF_2 0x04 117 #define BU21013_TH_OFF_3 0x08 118 #define BU21013_TH_OFF_4 0x10 119 #define BU21013_TH_OFF_5 0x20 120 #define BU21013_TH_OFF_6 0x40 121 #define BU21013_TH_OFF_7 0x80 122 #define BU21013_TH_OFF_MAX 0xFF 123 124 #define BU21013_X_EDGE_0 0x01 125 #define BU21013_X_EDGE_1 0x02 126 #define BU21013_X_EDGE_2 0x04 127 #define BU21013_X_EDGE_3 0x08 128 #define BU21013_Y_EDGE_0 0x10 129 #define BU21013_Y_EDGE_1 0x20 130 #define BU21013_Y_EDGE_2 0x40 131 #define BU21013_Y_EDGE_3 0x80 132 133 #define BU21013_DONE 0x01 134 #define BU21013_NUMBER_OF_X_SENSORS (6) 135 #define BU21013_NUMBER_OF_Y_SENSORS (11) 136 137 #define DRIVER_TP "bu21013_tp" 138 139 /** 140 * struct bu21013_ts_data - touch panel data structure 141 * @client: pointer to the i2c client 142 * @wait: variable to wait_queue_head_t structure 143 * @touch_stopped: touch stop flag 144 * @chip: pointer to the touch panel controller 145 * @in_dev: pointer to the input device structure 146 * @intr_pin: interrupt pin value 147 * @regulator: pointer to the Regulator used for touch screen 148 * 149 * Touch panel device data structure 150 */ 151 struct bu21013_ts_data { 152 struct i2c_client *client; 153 wait_queue_head_t wait; 154 const struct bu21013_platform_device *chip; 155 struct input_dev *in_dev; 156 struct regulator *regulator; 157 unsigned int irq; 158 unsigned int intr_pin; 159 bool touch_stopped; 160 }; 161 162 /** 163 * bu21013_read_block_data(): read the touch co-ordinates 164 * @data: bu21013_ts_data structure pointer 165 * @buf: byte pointer 166 * 167 * Read the touch co-ordinates using i2c read block into buffer 168 * and returns integer. 169 */ 170 static int bu21013_read_block_data(struct bu21013_ts_data *data, u8 *buf) 171 { 172 int ret, i; 173 174 for (i = 0; i < I2C_RETRY_COUNT; i++) { 175 ret = i2c_smbus_read_i2c_block_data 176 (data->client, BU21013_SENSORS_BTN_0_7_REG, 177 LENGTH_OF_BUFFER, buf); 178 if (ret == LENGTH_OF_BUFFER) 179 return 0; 180 } 181 return -EINVAL; 182 } 183 184 /** 185 * bu21013_do_touch_report(): Get the touch co-ordinates 186 * @data: bu21013_ts_data structure pointer 187 * 188 * Get the touch co-ordinates from touch sensor registers and writes 189 * into device structure and returns integer. 190 */ 191 static int bu21013_do_touch_report(struct bu21013_ts_data *data) 192 { 193 u8 buf[LENGTH_OF_BUFFER]; 194 unsigned int pos_x[2], pos_y[2]; 195 bool has_x_sensors, has_y_sensors; 196 int finger_down_count = 0; 197 int i; 198 199 if (data == NULL) 200 return -EINVAL; 201 202 if (bu21013_read_block_data(data, buf) < 0) 203 return -EINVAL; 204 205 has_x_sensors = hweight32(buf[0] & BU21013_SENSORS_EN_0_7); 206 has_y_sensors = hweight32(((buf[1] & BU21013_SENSORS_EN_8_15) | 207 ((buf[2] & BU21013_SENSORS_EN_16_23) << SHIFT_8)) >> SHIFT_2); 208 if (!has_x_sensors || !has_y_sensors) 209 return 0; 210 211 for (i = 0; i < MAX_FINGERS; i++) { 212 const u8 *p = &buf[4 * i + 3]; 213 unsigned int x = p[0] << SHIFT_2 | (p[1] & MASK_BITS); 214 unsigned int y = p[2] << SHIFT_2 | (p[3] & MASK_BITS); 215 if (x == 0 || y == 0) 216 continue; 217 pos_x[finger_down_count] = x; 218 pos_y[finger_down_count] = y; 219 finger_down_count++; 220 } 221 222 if (finger_down_count) { 223 if (finger_down_count == 2 && 224 (abs(pos_x[0] - pos_x[1]) < DELTA_MIN || 225 abs(pos_y[0] - pos_y[1]) < DELTA_MIN)) { 226 return 0; 227 } 228 229 for (i = 0; i < finger_down_count; i++) { 230 if (data->chip->x_flip) 231 pos_x[i] = data->chip->touch_x_max - pos_x[i]; 232 if (data->chip->y_flip) 233 pos_y[i] = data->chip->touch_y_max - pos_y[i]; 234 235 input_report_abs(data->in_dev, 236 ABS_MT_POSITION_X, pos_x[i]); 237 input_report_abs(data->in_dev, 238 ABS_MT_POSITION_Y, pos_y[i]); 239 input_mt_sync(data->in_dev); 240 } 241 } else 242 input_mt_sync(data->in_dev); 243 244 input_sync(data->in_dev); 245 246 return 0; 247 } 248 /** 249 * bu21013_gpio_irq() - gpio thread function for touch interrupt 250 * @irq: irq value 251 * @device_data: void pointer 252 * 253 * This gpio thread function for touch interrupt 254 * and returns irqreturn_t. 255 */ 256 static irqreturn_t bu21013_gpio_irq(int irq, void *device_data) 257 { 258 struct bu21013_ts_data *data = device_data; 259 struct i2c_client *i2c = data->client; 260 int retval; 261 262 do { 263 retval = bu21013_do_touch_report(data); 264 if (retval < 0) { 265 dev_err(&i2c->dev, "bu21013_do_touch_report failed\n"); 266 return IRQ_NONE; 267 } 268 269 data->intr_pin = gpio_get_value(data->chip->touch_pin); 270 if (data->intr_pin == PEN_DOWN_INTR) 271 wait_event_timeout(data->wait, data->touch_stopped, 272 msecs_to_jiffies(2)); 273 } while (!data->intr_pin && !data->touch_stopped); 274 275 return IRQ_HANDLED; 276 } 277 278 /** 279 * bu21013_init_chip() - power on sequence for the bu21013 controller 280 * @data: device structure pointer 281 * 282 * This function is used to power on 283 * the bu21013 controller and returns integer. 284 */ 285 static int bu21013_init_chip(struct bu21013_ts_data *data) 286 { 287 int retval; 288 struct i2c_client *i2c = data->client; 289 290 retval = i2c_smbus_write_byte_data(i2c, BU21013_RESET_REG, 291 BU21013_RESET_ENABLE); 292 if (retval < 0) { 293 dev_err(&i2c->dev, "BU21013_RESET reg write failed\n"); 294 return retval; 295 } 296 msleep(RESET_DELAY); 297 298 retval = i2c_smbus_write_byte_data(i2c, BU21013_SENSOR_0_7_REG, 299 BU21013_SENSORS_EN_0_7); 300 if (retval < 0) { 301 dev_err(&i2c->dev, "BU21013_SENSOR_0_7 reg write failed\n"); 302 return retval; 303 } 304 305 retval = i2c_smbus_write_byte_data(i2c, BU21013_SENSOR_8_15_REG, 306 BU21013_SENSORS_EN_8_15); 307 if (retval < 0) { 308 dev_err(&i2c->dev, "BU21013_SENSOR_8_15 reg write failed\n"); 309 return retval; 310 } 311 312 retval = i2c_smbus_write_byte_data(i2c, BU21013_SENSOR_16_23_REG, 313 BU21013_SENSORS_EN_16_23); 314 if (retval < 0) { 315 dev_err(&i2c->dev, "BU21013_SENSOR_16_23 reg write failed\n"); 316 return retval; 317 } 318 319 retval = i2c_smbus_write_byte_data(i2c, BU21013_POS_MODE1_REG, 320 (BU21013_POS_MODE1_0 | BU21013_POS_MODE1_1)); 321 if (retval < 0) { 322 dev_err(&i2c->dev, "BU21013_POS_MODE1 reg write failed\n"); 323 return retval; 324 } 325 326 retval = i2c_smbus_write_byte_data(i2c, BU21013_POS_MODE2_REG, 327 (BU21013_POS_MODE2_ZERO | BU21013_POS_MODE2_AVG1 | 328 BU21013_POS_MODE2_AVG2 | BU21013_POS_MODE2_EN_RAW | 329 BU21013_POS_MODE2_MULTI)); 330 if (retval < 0) { 331 dev_err(&i2c->dev, "BU21013_POS_MODE2 reg write failed\n"); 332 return retval; 333 } 334 335 if (data->chip->ext_clk) 336 retval = i2c_smbus_write_byte_data(i2c, BU21013_CLK_MODE_REG, 337 (BU21013_CLK_MODE_EXT | BU21013_CLK_MODE_CALIB)); 338 else 339 retval = i2c_smbus_write_byte_data(i2c, BU21013_CLK_MODE_REG, 340 (BU21013_CLK_MODE_DIV | BU21013_CLK_MODE_CALIB)); 341 if (retval < 0) { 342 dev_err(&i2c->dev, "BU21013_CLK_MODE reg write failed\n"); 343 return retval; 344 } 345 346 retval = i2c_smbus_write_byte_data(i2c, BU21013_IDLE_REG, 347 (BU21013_IDLET_0 | BU21013_IDLE_INTERMIT_EN)); 348 if (retval < 0) { 349 dev_err(&i2c->dev, "BU21013_IDLE reg write failed\n"); 350 return retval; 351 } 352 353 retval = i2c_smbus_write_byte_data(i2c, BU21013_INT_MODE_REG, 354 BU21013_INT_MODE_LEVEL); 355 if (retval < 0) { 356 dev_err(&i2c->dev, "BU21013_INT_MODE reg write failed\n"); 357 return retval; 358 } 359 360 retval = i2c_smbus_write_byte_data(i2c, BU21013_FILTER_REG, 361 (BU21013_DELTA_0_6 | 362 BU21013_FILTER_EN)); 363 if (retval < 0) { 364 dev_err(&i2c->dev, "BU21013_FILTER reg write failed\n"); 365 return retval; 366 } 367 368 retval = i2c_smbus_write_byte_data(i2c, BU21013_TH_ON_REG, 369 BU21013_TH_ON_5); 370 if (retval < 0) { 371 dev_err(&i2c->dev, "BU21013_TH_ON reg write failed\n"); 372 return retval; 373 } 374 375 retval = i2c_smbus_write_byte_data(i2c, BU21013_TH_OFF_REG, 376 BU21013_TH_OFF_4 | BU21013_TH_OFF_3); 377 if (retval < 0) { 378 dev_err(&i2c->dev, "BU21013_TH_OFF reg write failed\n"); 379 return retval; 380 } 381 382 retval = i2c_smbus_write_byte_data(i2c, BU21013_GAIN_REG, 383 (BU21013_GAIN_0 | BU21013_GAIN_1)); 384 if (retval < 0) { 385 dev_err(&i2c->dev, "BU21013_GAIN reg write failed\n"); 386 return retval; 387 } 388 389 retval = i2c_smbus_write_byte_data(i2c, BU21013_OFFSET_MODE_REG, 390 BU21013_OFFSET_MODE_DEFAULT); 391 if (retval < 0) { 392 dev_err(&i2c->dev, "BU21013_OFFSET_MODE reg write failed\n"); 393 return retval; 394 } 395 396 retval = i2c_smbus_write_byte_data(i2c, BU21013_XY_EDGE_REG, 397 (BU21013_X_EDGE_0 | BU21013_X_EDGE_2 | 398 BU21013_Y_EDGE_1 | BU21013_Y_EDGE_3)); 399 if (retval < 0) { 400 dev_err(&i2c->dev, "BU21013_XY_EDGE reg write failed\n"); 401 return retval; 402 } 403 404 retval = i2c_smbus_write_byte_data(i2c, BU21013_DONE_REG, 405 BU21013_DONE); 406 if (retval < 0) { 407 dev_err(&i2c->dev, "BU21013_REG_DONE reg write failed\n"); 408 return retval; 409 } 410 411 return 0; 412 } 413 414 /** 415 * bu21013_free_irq() - frees IRQ registered for touchscreen 416 * @bu21013_data: device structure pointer 417 * 418 * This function signals interrupt thread to stop processing and 419 * frees interrupt. 420 */ 421 static void bu21013_free_irq(struct bu21013_ts_data *bu21013_data) 422 { 423 bu21013_data->touch_stopped = true; 424 wake_up(&bu21013_data->wait); 425 free_irq(bu21013_data->irq, bu21013_data); 426 } 427 428 /** 429 * bu21013_cs_disable() - deconfigures the touch panel controller 430 * @bu21013_data: device structure pointer 431 * 432 * This function is used to deconfigure the chip selection 433 * for touch panel controller. 434 */ 435 static void bu21013_cs_disable(struct bu21013_ts_data *bu21013_data) 436 { 437 int error; 438 439 error = gpio_direction_output(bu21013_data->chip->cs_pin, 0); 440 if (error < 0) 441 dev_warn(&bu21013_data->client->dev, 442 "%s: gpio direction failed, error: %d\n", 443 __func__, error); 444 else 445 gpio_set_value(bu21013_data->chip->cs_pin, 0); 446 447 gpio_free(bu21013_data->chip->cs_pin); 448 } 449 450 #ifdef CONFIG_OF 451 static const struct bu21013_platform_device * 452 bu21013_parse_dt(struct device *dev) 453 { 454 struct device_node *np = dev->of_node; 455 struct bu21013_platform_device *pdata; 456 457 if (!np) { 458 dev_err(dev, "no device tree or platform data\n"); 459 return ERR_PTR(-EINVAL); 460 } 461 462 pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL); 463 if (!pdata) 464 return ERR_PTR(-ENOMEM); 465 466 pdata->y_flip = pdata->x_flip = false; 467 468 pdata->x_flip = of_property_read_bool(np, "rohm,flip-x"); 469 pdata->y_flip = of_property_read_bool(np, "rohm,flip-y"); 470 471 of_property_read_u32(np, "rohm,touch-max-x", &pdata->touch_x_max); 472 of_property_read_u32(np, "rohm,touch-max-y", &pdata->touch_y_max); 473 474 pdata->touch_pin = of_get_named_gpio(np, "touch-gpio", 0); 475 pdata->cs_pin = of_get_named_gpio(np, "reset-gpio", 0); 476 477 pdata->ext_clk = false; 478 479 return pdata; 480 } 481 #else 482 static inline const struct bu21013_platform_device * 483 bu21013_parse_dt(struct device *dev) 484 { 485 dev_err(dev, "no platform data available\n"); 486 return ERR_PTR(-EINVAL); 487 } 488 #endif 489 490 /** 491 * bu21013_probe() - initializes the i2c-client touchscreen driver 492 * @client: i2c client structure pointer 493 * @id: i2c device id pointer 494 * 495 * This function used to initializes the i2c-client touchscreen 496 * driver and returns integer. 497 */ 498 static int bu21013_probe(struct i2c_client *client, 499 const struct i2c_device_id *id) 500 { 501 const struct bu21013_platform_device *pdata = 502 dev_get_platdata(&client->dev); 503 struct bu21013_ts_data *bu21013_data; 504 struct input_dev *in_dev; 505 int error; 506 507 if (!i2c_check_functionality(client->adapter, 508 I2C_FUNC_SMBUS_BYTE_DATA)) { 509 dev_err(&client->dev, "i2c smbus byte data not supported\n"); 510 return -EIO; 511 } 512 513 if (!pdata) { 514 pdata = bu21013_parse_dt(&client->dev); 515 if (IS_ERR(pdata)) 516 return PTR_ERR(pdata); 517 } 518 519 if (!gpio_is_valid(pdata->touch_pin)) { 520 dev_err(&client->dev, "invalid touch_pin supplied\n"); 521 return -EINVAL; 522 } 523 524 bu21013_data = kzalloc(sizeof(struct bu21013_ts_data), GFP_KERNEL); 525 in_dev = input_allocate_device(); 526 if (!bu21013_data || !in_dev) { 527 dev_err(&client->dev, "device memory alloc failed\n"); 528 error = -ENOMEM; 529 goto err_free_mem; 530 } 531 532 bu21013_data->in_dev = in_dev; 533 bu21013_data->chip = pdata; 534 bu21013_data->client = client; 535 bu21013_data->irq = gpio_to_irq(pdata->touch_pin); 536 537 bu21013_data->regulator = regulator_get(&client->dev, "avdd"); 538 if (IS_ERR(bu21013_data->regulator)) { 539 dev_err(&client->dev, "regulator_get failed\n"); 540 error = PTR_ERR(bu21013_data->regulator); 541 goto err_free_mem; 542 } 543 544 error = regulator_enable(bu21013_data->regulator); 545 if (error < 0) { 546 dev_err(&client->dev, "regulator enable failed\n"); 547 goto err_put_regulator; 548 } 549 550 bu21013_data->touch_stopped = false; 551 init_waitqueue_head(&bu21013_data->wait); 552 553 /* configure the gpio pins */ 554 error = gpio_request_one(pdata->cs_pin, GPIOF_OUT_INIT_HIGH, 555 "touchp_reset"); 556 if (error < 0) { 557 dev_err(&client->dev, "Unable to request gpio reset_pin\n"); 558 goto err_disable_regulator; 559 } 560 561 /* configure the touch panel controller */ 562 error = bu21013_init_chip(bu21013_data); 563 if (error) { 564 dev_err(&client->dev, "error in bu21013 config\n"); 565 goto err_cs_disable; 566 } 567 568 /* register the device to input subsystem */ 569 in_dev->name = DRIVER_TP; 570 in_dev->id.bustype = BUS_I2C; 571 in_dev->dev.parent = &client->dev; 572 573 __set_bit(EV_SYN, in_dev->evbit); 574 __set_bit(EV_KEY, in_dev->evbit); 575 __set_bit(EV_ABS, in_dev->evbit); 576 577 input_set_abs_params(in_dev, ABS_MT_POSITION_X, 0, 578 pdata->touch_x_max, 0, 0); 579 input_set_abs_params(in_dev, ABS_MT_POSITION_Y, 0, 580 pdata->touch_y_max, 0, 0); 581 input_set_drvdata(in_dev, bu21013_data); 582 583 error = request_threaded_irq(bu21013_data->irq, NULL, bu21013_gpio_irq, 584 IRQF_TRIGGER_FALLING | IRQF_SHARED | 585 IRQF_ONESHOT, 586 DRIVER_TP, bu21013_data); 587 if (error) { 588 dev_err(&client->dev, "request irq %d failed\n", 589 bu21013_data->irq); 590 goto err_cs_disable; 591 } 592 593 error = input_register_device(in_dev); 594 if (error) { 595 dev_err(&client->dev, "failed to register input device\n"); 596 goto err_free_irq; 597 } 598 599 device_init_wakeup(&client->dev, pdata->wakeup); 600 i2c_set_clientdata(client, bu21013_data); 601 602 return 0; 603 604 err_free_irq: 605 bu21013_free_irq(bu21013_data); 606 err_cs_disable: 607 bu21013_cs_disable(bu21013_data); 608 err_disable_regulator: 609 regulator_disable(bu21013_data->regulator); 610 err_put_regulator: 611 regulator_put(bu21013_data->regulator); 612 err_free_mem: 613 input_free_device(in_dev); 614 kfree(bu21013_data); 615 616 return error; 617 } 618 /** 619 * bu21013_remove() - removes the i2c-client touchscreen driver 620 * @client: i2c client structure pointer 621 * 622 * This function uses to remove the i2c-client 623 * touchscreen driver and returns integer. 624 */ 625 static int bu21013_remove(struct i2c_client *client) 626 { 627 struct bu21013_ts_data *bu21013_data = i2c_get_clientdata(client); 628 629 bu21013_free_irq(bu21013_data); 630 631 bu21013_cs_disable(bu21013_data); 632 633 input_unregister_device(bu21013_data->in_dev); 634 635 regulator_disable(bu21013_data->regulator); 636 regulator_put(bu21013_data->regulator); 637 638 kfree(bu21013_data); 639 640 return 0; 641 } 642 643 #ifdef CONFIG_PM 644 /** 645 * bu21013_suspend() - suspend the touch screen controller 646 * @dev: pointer to device structure 647 * 648 * This function is used to suspend the 649 * touch panel controller and returns integer 650 */ 651 static int bu21013_suspend(struct device *dev) 652 { 653 struct bu21013_ts_data *bu21013_data = dev_get_drvdata(dev); 654 struct i2c_client *client = bu21013_data->client; 655 656 bu21013_data->touch_stopped = true; 657 if (device_may_wakeup(&client->dev)) 658 enable_irq_wake(bu21013_data->irq); 659 else 660 disable_irq(bu21013_data->irq); 661 662 regulator_disable(bu21013_data->regulator); 663 664 return 0; 665 } 666 667 /** 668 * bu21013_resume() - resume the touch screen controller 669 * @dev: pointer to device structure 670 * 671 * This function is used to resume the touch panel 672 * controller and returns integer. 673 */ 674 static int bu21013_resume(struct device *dev) 675 { 676 struct bu21013_ts_data *bu21013_data = dev_get_drvdata(dev); 677 struct i2c_client *client = bu21013_data->client; 678 int retval; 679 680 retval = regulator_enable(bu21013_data->regulator); 681 if (retval < 0) { 682 dev_err(&client->dev, "bu21013 regulator enable failed\n"); 683 return retval; 684 } 685 686 retval = bu21013_init_chip(bu21013_data); 687 if (retval < 0) { 688 dev_err(&client->dev, "bu21013 controller config failed\n"); 689 return retval; 690 } 691 692 bu21013_data->touch_stopped = false; 693 694 if (device_may_wakeup(&client->dev)) 695 disable_irq_wake(bu21013_data->irq); 696 else 697 enable_irq(bu21013_data->irq); 698 699 return 0; 700 } 701 702 static const struct dev_pm_ops bu21013_dev_pm_ops = { 703 .suspend = bu21013_suspend, 704 .resume = bu21013_resume, 705 }; 706 #endif 707 708 static const struct i2c_device_id bu21013_id[] = { 709 { DRIVER_TP, 0 }, 710 { } 711 }; 712 MODULE_DEVICE_TABLE(i2c, bu21013_id); 713 714 static struct i2c_driver bu21013_driver = { 715 .driver = { 716 .name = DRIVER_TP, 717 #ifdef CONFIG_PM 718 .pm = &bu21013_dev_pm_ops, 719 #endif 720 }, 721 .probe = bu21013_probe, 722 .remove = bu21013_remove, 723 .id_table = bu21013_id, 724 }; 725 726 module_i2c_driver(bu21013_driver); 727 728 MODULE_LICENSE("GPL v2"); 729 MODULE_AUTHOR("Naveen Kumar G <naveen.gaddipati@stericsson.com>"); 730 MODULE_DESCRIPTION("bu21013 touch screen controller driver"); 731