]> bbs.cooldavid.org Git - net-next-2.6.git/blame - drivers/input/touchscreen/bu21013_ts.c
git://bbs.cooldavid.org / net-next-2.6.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branches 'sh/pio-death', 'sh/nommu', 'sh/clkfwk', 'sh/core' and 'sh/intc-extens...
[net-next-2.6.git] / drivers / input / touchscreen / bu21013_ts.c
CommitLineData
4780c8df
NKG		 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 */
145struct 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 */
162static 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 */
183static 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 */
248static 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 */
277static 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 */
413static 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 */
428static 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
512err_free_irq:
513 bu21013_free_irq(bu21013_data);
514err_cs_disable:
515 pdata->cs_dis(pdata->cs_pin);
516err_free_mem:
bac64d0f 517 input_free_device(in_dev);
4780c8df
NKG		 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 */
529static 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 */
553static 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 */
574static 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
596static const struct dev_pm_ops bu21013_dev_pm_ops = {
597 .suspend = bu21013_suspend,
598 .resume = bu21013_resume,
599};
600#endif
601
602static const struct i2c_device_id bu21013_id[] = {
603 { DRIVER_TP, 0 },
604 { }
605};
606MODULE_DEVICE_TABLE(i2c, bu21013_id);
607
608static 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 */
627static 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 */
638static void __exit bu21013_exit(void)
639{
640 i2c_del_driver(&bu21013_driver);
641}
642
643module_init(bu21013_init);
644module_exit(bu21013_exit);
645
646MODULE_LICENSE("GPL v2");
647MODULE_AUTHOR("Naveen Kumar G <naveen.gaddipati@stericsson.com>");
648MODULE_DESCRIPTION("bu21013 touch screen controller driver");
Clone of davem's net-next-2.6 tree