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 {
409 	struct bu21013_ts *ts;
410 	struct input_dev *in_dev;
411 	struct input_absinfo *info;
412 	u32 max_x = 0, max_y = 0;
413 	int error;
414 
415 	if (!i2c_check_functionality(client->adapter,
416 				     I2C_FUNC_SMBUS_BYTE_DATA)) {
417 		dev_err(&client->dev, "i2c smbus byte data not supported\n");
418 		return -EIO;
419 	}
420 
421 	if (!client->irq) {
422 		dev_err(&client->dev, "No IRQ set up\n");
423 		return -EINVAL;
424 	}
425 
426 	ts = devm_kzalloc(&client->dev, sizeof(*ts), GFP_KERNEL);
427 	if (!ts)
428 		return -ENOMEM;
429 
430 	ts->client = client;
431 
432 	ts->x_flip = device_property_read_bool(&client->dev, "rohm,flip-x");
433 	ts->y_flip = device_property_read_bool(&client->dev, "rohm,flip-y");
434 
435 	in_dev = devm_input_allocate_device(&client->dev);
436 	if (!in_dev) {
437 		dev_err(&client->dev, "device memory alloc failed\n");
438 		return -ENOMEM;
439 	}
440 	ts->in_dev = in_dev;
441 	input_set_drvdata(in_dev, ts);
442 
443 	/* register the device to input subsystem */
444 	in_dev->name = DRIVER_TP;
445 	in_dev->id.bustype = BUS_I2C;
446 
447 	device_property_read_u32(&client->dev, "rohm,touch-max-x", &max_x);
448 	device_property_read_u32(&client->dev, "rohm,touch-max-y", &max_y);
449 
450 	input_set_abs_params(in_dev, ABS_MT_POSITION_X, 0, max_x, 0, 0);
451 	input_set_abs_params(in_dev, ABS_MT_POSITION_Y, 0, max_y, 0, 0);
452 
453 	touchscreen_parse_properties(in_dev, true, &ts->props);
454 
455 	/* Adjust for the legacy "flip" properties, if present */
456 	if (!ts->props.invert_x &&
457 	    device_property_read_bool(&client->dev, "rohm,flip-x")) {
458 		info = &in_dev->absinfo[ABS_MT_POSITION_X];
459 		info->maximum -= info->minimum;
460 		info->minimum = 0;
461 	}
462 
463 	if (!ts->props.invert_y &&
464 	    device_property_read_bool(&client->dev, "rohm,flip-y")) {
465 		info = &in_dev->absinfo[ABS_MT_POSITION_Y];
466 		info->maximum -= info->minimum;
467 		info->minimum = 0;
468 	}
469 
470 	error = input_mt_init_slots(in_dev, MAX_FINGERS,
471 				    INPUT_MT_DIRECT | INPUT_MT_TRACK |
472 					INPUT_MT_DROP_UNUSED);
473 	if (error) {
474 		dev_err(&client->dev, "failed to initialize MT slots");
475 		return error;
476 	}
477 
478 	ts->regulator = devm_regulator_get(&client->dev, "avdd");
479 	if (IS_ERR(ts->regulator)) {
480 		dev_err(&client->dev, "regulator_get failed\n");
481 		return PTR_ERR(ts->regulator);
482 	}
483 
484 	error = regulator_enable(ts->regulator);
485 	if (error) {
486 		dev_err(&client->dev, "regulator enable failed\n");
487 		return error;
488 	}
489 
490 	error = devm_add_action_or_reset(&client->dev, bu21013_power_off, ts);
491 	if (error) {
492 		dev_err(&client->dev, "failed to install power off handler\n");
493 		return error;
494 	}
495 
496 	/* Named "CS" on the chip, DT binding is "reset" */
497 	ts->cs_gpiod = devm_gpiod_get(&client->dev, "reset", GPIOD_OUT_HIGH);
498 	error = PTR_ERR_OR_ZERO(ts->cs_gpiod);
499 	if (error) {
500 		if (error != -EPROBE_DEFER)
501 			dev_err(&client->dev, "failed to get CS GPIO\n");
502 		return error;
503 	}
504 	gpiod_set_consumer_name(ts->cs_gpiod, "BU21013 CS");
505 
506 	error = devm_add_action_or_reset(&client->dev,
507 					 bu21013_disable_chip, ts);
508 	if (error) {
509 		dev_err(&client->dev,
510 			"failed to install chip disable handler\n");
511 		return error;
512 	}
513 
514 	/* Named "INT" on the chip, DT binding is "touch" */
515 	ts->int_gpiod = devm_gpiod_get_optional(&client->dev,
516 						"touch", GPIOD_IN);
517 	error = PTR_ERR_OR_ZERO(ts->int_gpiod);
518 	if (error) {
519 		if (error != -EPROBE_DEFER)
520 			dev_err(&client->dev, "failed to get INT GPIO\n");
521 		return error;
522 	}
523 
524 	if (ts->int_gpiod)
525 		gpiod_set_consumer_name(ts->int_gpiod, "BU21013 INT");
526 
527 	/* configure the touch panel controller */
528 	error = bu21013_init_chip(ts);
529 	if (error) {
530 		dev_err(&client->dev, "error in bu21013 config\n");
531 		return error;
532 	}
533 
534 	error = devm_request_threaded_irq(&client->dev, client->irq,
535 					  NULL, bu21013_gpio_irq,
536 					  IRQF_ONESHOT, DRIVER_TP, ts);
537 	if (error) {
538 		dev_err(&client->dev, "request irq %d failed\n",
539 			client->irq);
540 		return error;
541 	}
542 
543 	error = input_register_device(in_dev);
544 	if (error) {
545 		dev_err(&client->dev, "failed to register input device\n");
546 		return error;
547 	}
548 
549 	i2c_set_clientdata(client, ts);
550 
551 	return 0;
552 }
553 
554 static void bu21013_remove(struct i2c_client *client)
555 {
556 	struct bu21013_ts *ts = i2c_get_clientdata(client);
557 
558 	/* Make sure IRQ will exit quickly even if there is contact */
559 	ts->touch_stopped = true;
560 	/* The resources will be freed by devm */
561 }
562 
563 static int __maybe_unused bu21013_suspend(struct device *dev)
564 {
565 	struct i2c_client *client = to_i2c_client(dev);
566 	struct bu21013_ts *ts = i2c_get_clientdata(client);
567 
568 	ts->touch_stopped = true;
569 	mb();
570 	disable_irq(client->irq);
571 
572 	if (!device_may_wakeup(&client->dev))
573 		regulator_disable(ts->regulator);
574 
575 	return 0;
576 }
577 
578 static int __maybe_unused bu21013_resume(struct device *dev)
579 {
580 	struct i2c_client *client = to_i2c_client(dev);
581 	struct bu21013_ts *ts = i2c_get_clientdata(client);
582 	int error;
583 
584 	if (!device_may_wakeup(&client->dev)) {
585 		error = regulator_enable(ts->regulator);
586 		if (error) {
587 			dev_err(&client->dev,
588 				"failed to re-enable regulator when resuming\n");
589 			return error;
590 		}
591 
592 		error = bu21013_init_chip(ts);
593 		if (error) {
594 			dev_err(&client->dev,
595 				"failed to reinitialize chip when resuming\n");
596 			return error;
597 		}
598 	}
599 
600 	ts->touch_stopped = false;
601 	mb();
602 	enable_irq(client->irq);
603 
604 	return 0;
605 }
606 
607 static SIMPLE_DEV_PM_OPS(bu21013_dev_pm_ops, bu21013_suspend, bu21013_resume);
608 
609 static const struct i2c_device_id bu21013_id[] = {
610 	{ DRIVER_TP, 0 },
611 	{ }
612 };
613 MODULE_DEVICE_TABLE(i2c, bu21013_id);
614 
615 static struct i2c_driver bu21013_driver = {
616 	.driver	= {
617 		.name	=	DRIVER_TP,
618 		.pm	=	&bu21013_dev_pm_ops,
619 	},
620 	.probe_new	=	bu21013_probe,
621 	.remove		=	bu21013_remove,
622 	.id_table	=	bu21013_id,
623 };
624 
625 module_i2c_driver(bu21013_driver);
626 
627 MODULE_LICENSE("GPL v2");
628 MODULE_AUTHOR("Naveen Kumar G <naveen.gaddipati@stericsson.com>");
629 MODULE_DESCRIPTION("bu21013 touch screen controller driver");
630