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