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/bitops.h>
8 #include <linux/delay.h>
9 #include <linux/gpio/consumer.h>
10 #include <linux/i2c.h>
11 #include <linux/input.h>
12 #include <linux/input/mt.h>
13 #include <linux/input/touchscreen.h>
14 #include <linux/interrupt.h>
15 #include <linux/kernel.h>
16 #include <linux/module.h>
17 #include <linux/property.h>
18 #include <linux/regulator/consumer.h>
19 #include <linux/slab.h>
20 #include <linux/types.h>
21 
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 - touch panel data structure
141  * @client: pointer to the i2c client
142  * @in_dev: pointer to the input device structure
143  * @props: the device coordinate transformation properties
144  * @regulator: pointer to the Regulator used for touch screen
145  * @cs_gpiod: chip select GPIO line
146  * @int_gpiod: touch interrupt GPIO line
147  * @touch_x_max: maximum X coordinate reported by the device
148  * @touch_y_max: maximum Y coordinate reported by the device
149  * @x_flip: indicates that the driver should invert X coordinate before
150  *	reporting
151  * @y_flip: indicates that the driver should invert Y coordinate before
152  *	reporting
153  * @touch_stopped: touch stop flag
154  *
155  * Touch panel device data structure
156  */
157 struct bu21013_ts {
158 	struct i2c_client *client;
159 	struct input_dev *in_dev;
160 	struct touchscreen_properties props;
161 	struct regulator *regulator;
162 	struct gpio_desc *cs_gpiod;
163 	struct gpio_desc *int_gpiod;
164 	u32 touch_x_max;
165 	u32 touch_y_max;
166 	bool x_flip;
167 	bool y_flip;
168 	bool touch_stopped;
169 };
170 
171 static int bu21013_read_block_data(struct bu21013_ts *ts, u8 *buf)
172 {
173 	int ret, i;
174 
175 	for (i = 0; i < I2C_RETRY_COUNT; i++) {
176 		ret = i2c_smbus_read_i2c_block_data(ts->client,
177 						    BU21013_SENSORS_BTN_0_7_REG,
178 						    LENGTH_OF_BUFFER, buf);
179 		if (ret == LENGTH_OF_BUFFER)
180 			return 0;
181 	}
182 
183 	return -EINVAL;
184 }
185 
186 static int bu21013_do_touch_report(struct bu21013_ts *ts)
187 {
188 	struct input_dev *input = ts->in_dev;
189 	struct input_mt_pos pos[MAX_FINGERS];
190 	int slots[MAX_FINGERS];
191 	u8 buf[LENGTH_OF_BUFFER];
192 	bool has_x_sensors, has_y_sensors;
193 	int finger_down_count = 0;
194 	int i;
195 
196 	if (bu21013_read_block_data(ts, buf) < 0)
197 		return -EINVAL;
198 
199 	has_x_sensors = hweight32(buf[0] & BU21013_SENSORS_EN_0_7);
200 	has_y_sensors = hweight32(((buf[1] & BU21013_SENSORS_EN_8_15) |
201 		((buf[2] & BU21013_SENSORS_EN_16_23) << SHIFT_8)) >> SHIFT_2);
202 	if (!has_x_sensors || !has_y_sensors)
203 		return 0;
204 
205 	for (i = 0; i < MAX_FINGERS; i++) {
206 		const u8 *data = &buf[4 * i + 3];
207 		unsigned int x, y;
208 
209 		x = data[0] << SHIFT_2 | (data[1] & MASK_BITS);
210 		y = data[2] << SHIFT_2 | (data[3] & MASK_BITS);
211 		if (x != 0 && y != 0)
212 			touchscreen_set_mt_pos(&pos[finger_down_count++],
213 					       &ts->props, x, y);
214 	}
215 
216 	if (finger_down_count == 2 &&
217 	    (abs(pos[0].x - pos[1].x) < DELTA_MIN ||
218 	     abs(pos[0].y - pos[1].y) < DELTA_MIN)) {
219 		return 0;
220 	}
221 
222 	input_mt_assign_slots(input, slots, pos, finger_down_count, DELTA_MIN);
223 	for (i = 0; i < finger_down_count; i++) {
224 		input_mt_slot(input, slots[i]);
225 		input_mt_report_slot_state(input, MT_TOOL_FINGER, true);
226 		input_report_abs(input, ABS_MT_POSITION_X, pos[i].x);
227 		input_report_abs(input, ABS_MT_POSITION_Y, pos[i].y);
228 	}
229 
230 	input_mt_sync_frame(input);
231 	input_sync(input);
232 
233 	return 0;
234 }
235 
236 static irqreturn_t bu21013_gpio_irq(int irq, void *device_data)
237 {
238 	struct bu21013_ts *ts = device_data;
239 	int keep_polling;
240 	int error;
241 
242 	do {
243 		error = bu21013_do_touch_report(ts);
244 		if (error) {
245 			dev_err(&ts->client->dev, "%s failed\n", __func__);
246 			break;
247 		}
248 
249 		if (unlikely(ts->touch_stopped))
250 			break;
251 
252 		keep_polling = ts->int_gpiod ?
253 			gpiod_get_value(ts->int_gpiod) : false;
254 		if (keep_polling)
255 			usleep_range(2000, 2500);
256 	} while (keep_polling);
257 
258 	return IRQ_HANDLED;
259 }
260 
261 static int bu21013_init_chip(struct bu21013_ts *ts)
262 {
263 	struct i2c_client *client = ts->client;
264 	int error;
265 
266 	error = i2c_smbus_write_byte_data(client, BU21013_RESET_REG,
267 					  BU21013_RESET_ENABLE);
268 	if (error) {
269 		dev_err(&client->dev, "BU21013_RESET reg write failed\n");
270 		return error;
271 	}
272 	msleep(RESET_DELAY);
273 
274 	error = i2c_smbus_write_byte_data(client, BU21013_SENSOR_0_7_REG,
275 					  BU21013_SENSORS_EN_0_7);
276 	if (error) {
277 		dev_err(&client->dev, "BU21013_SENSOR_0_7 reg write failed\n");
278 		return error;
279 	}
280 
281 	error = i2c_smbus_write_byte_data(client, BU21013_SENSOR_8_15_REG,
282 					  BU21013_SENSORS_EN_8_15);
283 	if (error) {
284 		dev_err(&client->dev, "BU21013_SENSOR_8_15 reg write failed\n");
285 		return error;
286 	}
287 
288 	error = i2c_smbus_write_byte_data(client, BU21013_SENSOR_16_23_REG,
289 					  BU21013_SENSORS_EN_16_23);
290 	if (error) {
291 		dev_err(&client->dev, "BU21013_SENSOR_16_23 reg write failed\n");
292 		return error;
293 	}
294 
295 	error = i2c_smbus_write_byte_data(client, BU21013_POS_MODE1_REG,
296 					  BU21013_POS_MODE1_0 |
297 						BU21013_POS_MODE1_1);
298 	if (error) {
299 		dev_err(&client->dev, "BU21013_POS_MODE1 reg write failed\n");
300 		return error;
301 	}
302 
303 	error = i2c_smbus_write_byte_data(client, BU21013_POS_MODE2_REG,
304 					  BU21013_POS_MODE2_ZERO |
305 						BU21013_POS_MODE2_AVG1 |
306 						BU21013_POS_MODE2_AVG2 |
307 						BU21013_POS_MODE2_EN_RAW |
308 						BU21013_POS_MODE2_MULTI);
309 	if (error) {
310 		dev_err(&client->dev, "BU21013_POS_MODE2 reg write failed\n");
311 		return error;
312 	}
313 
314 	error = i2c_smbus_write_byte_data(client, BU21013_CLK_MODE_REG,
315 					  BU21013_CLK_MODE_DIV |
316 						BU21013_CLK_MODE_CALIB);
317 	if (error) {
318 		dev_err(&client->dev, "BU21013_CLK_MODE reg write failed\n");
319 		return error;
320 	}
321 
322 	error = i2c_smbus_write_byte_data(client, BU21013_IDLE_REG,
323 					  BU21013_IDLET_0 |
324 						BU21013_IDLE_INTERMIT_EN);
325 	if (error) {
326 		dev_err(&client->dev, "BU21013_IDLE reg write failed\n");
327 		return error;
328 	}
329 
330 	error = i2c_smbus_write_byte_data(client, BU21013_INT_MODE_REG,
331 					  BU21013_INT_MODE_LEVEL);
332 	if (error) {
333 		dev_err(&client->dev, "BU21013_INT_MODE reg write failed\n");
334 		return error;
335 	}
336 
337 	error = i2c_smbus_write_byte_data(client, BU21013_FILTER_REG,
338 					  BU21013_DELTA_0_6 |
339 						BU21013_FILTER_EN);
340 	if (error) {
341 		dev_err(&client->dev, "BU21013_FILTER reg write failed\n");
342 		return error;
343 	}
344 
345 	error = i2c_smbus_write_byte_data(client, BU21013_TH_ON_REG,
346 					  BU21013_TH_ON_5);
347 	if (error) {
348 		dev_err(&client->dev, "BU21013_TH_ON reg write failed\n");
349 		return error;
350 	}
351 
352 	error = i2c_smbus_write_byte_data(client, BU21013_TH_OFF_REG,
353 					  BU21013_TH_OFF_4 | BU21013_TH_OFF_3);
354 	if (error) {
355 		dev_err(&client->dev, "BU21013_TH_OFF reg write failed\n");
356 		return error;
357 	}
358 
359 	error = i2c_smbus_write_byte_data(client, BU21013_GAIN_REG,
360 					  BU21013_GAIN_0 | BU21013_GAIN_1);
361 	if (error) {
362 		dev_err(&client->dev, "BU21013_GAIN reg write failed\n");
363 		return error;
364 	}
365 
366 	error = i2c_smbus_write_byte_data(client, BU21013_OFFSET_MODE_REG,
367 					  BU21013_OFFSET_MODE_DEFAULT);
368 	if (error) {
369 		dev_err(&client->dev, "BU21013_OFFSET_MODE reg write failed\n");
370 		return error;
371 	}
372 
373 	error = i2c_smbus_write_byte_data(client, BU21013_XY_EDGE_REG,
374 					  BU21013_X_EDGE_0 |
375 						BU21013_X_EDGE_2 |
376 						BU21013_Y_EDGE_1 |
377 						BU21013_Y_EDGE_3);
378 	if (error) {
379 		dev_err(&client->dev, "BU21013_XY_EDGE reg write failed\n");
380 		return error;
381 	}
382 
383 	error = i2c_smbus_write_byte_data(client, BU21013_DONE_REG,
384 					  BU21013_DONE);
385 	if (error) {
386 		dev_err(&client->dev, "BU21013_REG_DONE reg write failed\n");
387 		return error;
388 	}
389 
390 	return 0;
391 }
392 
393 static void bu21013_power_off(void *_ts)
394 {
395 	struct bu21013_ts *ts = _ts;
396 
397 	regulator_disable(ts->regulator);
398 }
399 
400 static void bu21013_disable_chip(void *_ts)
401 {
402 	struct bu21013_ts *ts = _ts;
403 
404 	gpiod_set_value(ts->cs_gpiod, 0);
405 }
406 
407 static int bu21013_probe(struct i2c_client *client,
408 			 const struct i2c_device_id *id)
409 {
410 	struct bu21013_ts *ts;
411 	struct input_dev *in_dev;
412 	struct input_absinfo *info;
413 	u32 max_x = 0, max_y = 0;
414 	int error;
415 
416 	if (!i2c_check_functionality(client->adapter,
417 				     I2C_FUNC_SMBUS_BYTE_DATA)) {
418 		dev_err(&client->dev, "i2c smbus byte data not supported\n");
419 		return -EIO;
420 	}
421 
422 	if (!client->irq) {
423 		dev_err(&client->dev, "No IRQ set up\n");
424 		return -EINVAL;
425 	}
426 
427 	ts = devm_kzalloc(&client->dev, sizeof(*ts), GFP_KERNEL);
428 	if (!ts)
429 		return -ENOMEM;
430 
431 	ts->client = client;
432 
433 	ts->x_flip = device_property_read_bool(&client->dev, "rohm,flip-x");
434 	ts->y_flip = device_property_read_bool(&client->dev, "rohm,flip-y");
435 
436 	in_dev = devm_input_allocate_device(&client->dev);
437 	if (!in_dev) {
438 		dev_err(&client->dev, "device memory alloc failed\n");
439 		return -ENOMEM;
440 	}
441 	ts->in_dev = in_dev;
442 	input_set_drvdata(in_dev, ts);
443 
444 	/* register the device to input subsystem */
445 	in_dev->name = DRIVER_TP;
446 	in_dev->id.bustype = BUS_I2C;
447 
448 	device_property_read_u32(&client->dev, "rohm,touch-max-x", &max_x);
449 	device_property_read_u32(&client->dev, "rohm,touch-max-y", &max_y);
450 
451 	input_set_abs_params(in_dev, ABS_MT_POSITION_X, 0, max_x, 0, 0);
452 	input_set_abs_params(in_dev, ABS_MT_POSITION_Y, 0, max_y, 0, 0);
453 
454 	touchscreen_parse_properties(in_dev, true, &ts->props);
455 
456 	/* Adjust for the legacy "flip" properties, if present */
457 	if (!ts->props.invert_x &&
458 	    device_property_read_bool(&client->dev, "rohm,flip-x")) {
459 		info = &in_dev->absinfo[ABS_MT_POSITION_X];
460 		info->maximum -= info->minimum;
461 		info->minimum = 0;
462 	}
463 
464 	if (!ts->props.invert_y &&
465 	    device_property_read_bool(&client->dev, "rohm,flip-y")) {
466 		info = &in_dev->absinfo[ABS_MT_POSITION_Y];
467 		info->maximum -= info->minimum;
468 		info->minimum = 0;
469 	}
470 
471 	error = input_mt_init_slots(in_dev, MAX_FINGERS,
472 				    INPUT_MT_DIRECT | INPUT_MT_TRACK |
473 					INPUT_MT_DROP_UNUSED);
474 	if (error) {
475 		dev_err(&client->dev, "failed to initialize MT slots");
476 		return error;
477 	}
478 
479 	ts->regulator = devm_regulator_get(&client->dev, "avdd");
480 	if (IS_ERR(ts->regulator)) {
481 		dev_err(&client->dev, "regulator_get failed\n");
482 		return PTR_ERR(ts->regulator);
483 	}
484 
485 	error = regulator_enable(ts->regulator);
486 	if (error) {
487 		dev_err(&client->dev, "regulator enable failed\n");
488 		return error;
489 	}
490 
491 	error = devm_add_action_or_reset(&client->dev, bu21013_power_off, ts);
492 	if (error) {
493 		dev_err(&client->dev, "failed to install power off handler\n");
494 		return error;
495 	}
496 
497 	/* Named "CS" on the chip, DT binding is "reset" */
498 	ts->cs_gpiod = devm_gpiod_get(&client->dev, "reset", GPIOD_OUT_HIGH);
499 	error = PTR_ERR_OR_ZERO(ts->cs_gpiod);
500 	if (error) {
501 		if (error != -EPROBE_DEFER)
502 			dev_err(&client->dev, "failed to get CS GPIO\n");
503 		return error;
504 	}
505 	gpiod_set_consumer_name(ts->cs_gpiod, "BU21013 CS");
506 
507 	error = devm_add_action_or_reset(&client->dev,
508 					 bu21013_disable_chip, ts);
509 	if (error) {
510 		dev_err(&client->dev,
511 			"failed to install chip disable handler\n");
512 		return error;
513 	}
514 
515 	/* Named "INT" on the chip, DT binding is "touch" */
516 	ts->int_gpiod = devm_gpiod_get_optional(&client->dev,
517 						"touch", GPIOD_IN);
518 	error = PTR_ERR_OR_ZERO(ts->int_gpiod);
519 	if (error) {
520 		if (error != -EPROBE_DEFER)
521 			dev_err(&client->dev, "failed to get INT GPIO\n");
522 		return error;
523 	}
524 
525 	if (ts->int_gpiod)
526 		gpiod_set_consumer_name(ts->int_gpiod, "BU21013 INT");
527 
528 	/* configure the touch panel controller */
529 	error = bu21013_init_chip(ts);
530 	if (error) {
531 		dev_err(&client->dev, "error in bu21013 config\n");
532 		return error;
533 	}
534 
535 	error = devm_request_threaded_irq(&client->dev, client->irq,
536 					  NULL, bu21013_gpio_irq,
537 					  IRQF_ONESHOT, DRIVER_TP, ts);
538 	if (error) {
539 		dev_err(&client->dev, "request irq %d failed\n",
540 			client->irq);
541 		return error;
542 	}
543 
544 	error = input_register_device(in_dev);
545 	if (error) {
546 		dev_err(&client->dev, "failed to register input device\n");
547 		return error;
548 	}
549 
550 	i2c_set_clientdata(client, ts);
551 
552 	return 0;
553 }
554 
555 static int bu21013_remove(struct i2c_client *client)
556 {
557 	struct bu21013_ts *ts = i2c_get_clientdata(client);
558 
559 	/* Make sure IRQ will exit quickly even if there is contact */
560 	ts->touch_stopped = true;
561 	/* The resources will be freed by devm */
562 
563 	return 0;
564 }
565 
566 static int __maybe_unused bu21013_suspend(struct device *dev)
567 {
568 	struct i2c_client *client = to_i2c_client(dev);
569 	struct bu21013_ts *ts = i2c_get_clientdata(client);
570 
571 	ts->touch_stopped = true;
572 	mb();
573 	disable_irq(client->irq);
574 
575 	if (!device_may_wakeup(&client->dev))
576 		regulator_disable(ts->regulator);
577 
578 	return 0;
579 }
580 
581 static int __maybe_unused bu21013_resume(struct device *dev)
582 {
583 	struct i2c_client *client = to_i2c_client(dev);
584 	struct bu21013_ts *ts = i2c_get_clientdata(client);
585 	int error;
586 
587 	if (!device_may_wakeup(&client->dev)) {
588 		error = regulator_enable(ts->regulator);
589 		if (error) {
590 			dev_err(&client->dev,
591 				"failed to re-enable regulator when resuming\n");
592 			return error;
593 		}
594 
595 		error = bu21013_init_chip(ts);
596 		if (error) {
597 			dev_err(&client->dev,
598 				"failed to reinitialize chip when resuming\n");
599 			return error;
600 		}
601 	}
602 
603 	ts->touch_stopped = false;
604 	mb();
605 	enable_irq(client->irq);
606 
607 	return 0;
608 }
609 
610 static SIMPLE_DEV_PM_OPS(bu21013_dev_pm_ops, bu21013_suspend, bu21013_resume);
611 
612 static const struct i2c_device_id bu21013_id[] = {
613 	{ DRIVER_TP, 0 },
614 	{ }
615 };
616 MODULE_DEVICE_TABLE(i2c, bu21013_id);
617 
618 static struct i2c_driver bu21013_driver = {
619 	.driver	= {
620 		.name	=	DRIVER_TP,
621 		.pm	=	&bu21013_dev_pm_ops,
622 	},
623 	.probe		=	bu21013_probe,
624 	.remove		=	bu21013_remove,
625 	.id_table	=	bu21013_id,
626 };
627 
628 module_i2c_driver(bu21013_driver);
629 
630 MODULE_LICENSE("GPL v2");
631 MODULE_AUTHOR("Naveen Kumar G <naveen.gaddipati@stericsson.com>");
632 MODULE_DESCRIPTION("bu21013 touch screen controller driver");
633