xref: /linux/drivers/input/keyboard/qt2160.c (revision 3932b9ca55b0be314a36d3e84faff3e823c081f5)
1 /*
2  *  qt2160.c - Atmel AT42QT2160 Touch Sense Controller
3  *
4  *  Copyright (C) 2009 Raphael Derosso Pereira <raphaelpereira@gmail.com>
5  *
6  *  This program is free software; you can redistribute it and/or modify
7  *  it under the terms of the GNU General Public License as published by
8  *  the Free Software Foundation; either version 2 of the License, or
9  *  (at your option) any later version.
10  *
11  *  This program is distributed in the hope that it will be useful,
12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  *  GNU General Public License for more details.
15  *
16  *  You should have received a copy of the GNU General Public License
17  *  along with this program; if not, write to the Free Software
18  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19  */
20 
21 #include <linux/kernel.h>
22 #include <linux/leds.h>
23 #include <linux/module.h>
24 #include <linux/slab.h>
25 #include <linux/jiffies.h>
26 #include <linux/i2c.h>
27 #include <linux/irq.h>
28 #include <linux/interrupt.h>
29 #include <linux/input.h>
30 
31 #define QT2160_VALID_CHIPID  0x11
32 
33 #define QT2160_CMD_CHIPID     0
34 #define QT2160_CMD_CODEVER    1
35 #define QT2160_CMD_GSTAT      2
36 #define QT2160_CMD_KEYS3      3
37 #define QT2160_CMD_KEYS4      4
38 #define QT2160_CMD_SLIDE      5
39 #define QT2160_CMD_GPIOS      6
40 #define QT2160_CMD_SUBVER     7
41 #define QT2160_CMD_CALIBRATE  10
42 #define QT2160_CMD_DRIVE_X    70
43 #define QT2160_CMD_PWMEN_X    74
44 #define QT2160_CMD_PWM_DUTY   76
45 
46 #define QT2160_NUM_LEDS_X	8
47 
48 #define QT2160_CYCLE_INTERVAL	(2*HZ)
49 
50 static unsigned char qt2160_key2code[] = {
51 	KEY_0, KEY_1, KEY_2, KEY_3,
52 	KEY_4, KEY_5, KEY_6, KEY_7,
53 	KEY_8, KEY_9, KEY_A, KEY_B,
54 	KEY_C, KEY_D, KEY_E, KEY_F,
55 };
56 
57 #ifdef CONFIG_LEDS_CLASS
58 struct qt2160_led {
59 	struct qt2160_data *qt2160;
60 	struct led_classdev cdev;
61 	struct work_struct work;
62 	char name[32];
63 	int id;
64 	enum led_brightness new_brightness;
65 };
66 #endif
67 
68 struct qt2160_data {
69 	struct i2c_client *client;
70 	struct input_dev *input;
71 	struct delayed_work dwork;
72 	spinlock_t lock;        /* Protects canceling/rescheduling of dwork */
73 	unsigned short keycodes[ARRAY_SIZE(qt2160_key2code)];
74 	u16 key_matrix;
75 #ifdef CONFIG_LEDS_CLASS
76 	struct qt2160_led leds[QT2160_NUM_LEDS_X];
77 	struct mutex led_lock;
78 #endif
79 };
80 
81 static int qt2160_read(struct i2c_client *client, u8 reg);
82 static int qt2160_write(struct i2c_client *client, u8 reg, u8 data);
83 
84 #ifdef CONFIG_LEDS_CLASS
85 
86 static void qt2160_led_work(struct work_struct *work)
87 {
88 	struct qt2160_led *led = container_of(work, struct qt2160_led, work);
89 	struct qt2160_data *qt2160 = led->qt2160;
90 	struct i2c_client *client = qt2160->client;
91 	int value = led->new_brightness;
92 	u32 drive, pwmen;
93 
94 	mutex_lock(&qt2160->led_lock);
95 
96 	drive = qt2160_read(client, QT2160_CMD_DRIVE_X);
97 	pwmen = qt2160_read(client, QT2160_CMD_PWMEN_X);
98 	if (value != LED_OFF) {
99 		drive |= (1 << led->id);
100 		pwmen |= (1 << led->id);
101 
102 	} else {
103 		drive &= ~(1 << led->id);
104 		pwmen &= ~(1 << led->id);
105 	}
106 	qt2160_write(client, QT2160_CMD_DRIVE_X, drive);
107 	qt2160_write(client, QT2160_CMD_PWMEN_X, pwmen);
108 
109 	/*
110 	 * Changing this register will change the brightness
111 	 * of every LED in the qt2160. It's a HW limitation.
112 	 */
113 	if (value != LED_OFF)
114 		qt2160_write(client, QT2160_CMD_PWM_DUTY, value);
115 
116 	mutex_unlock(&qt2160->led_lock);
117 }
118 
119 static void qt2160_led_set(struct led_classdev *cdev,
120 			   enum led_brightness value)
121 {
122 	struct qt2160_led *led = container_of(cdev, struct qt2160_led, cdev);
123 
124 	led->new_brightness = value;
125 	schedule_work(&led->work);
126 }
127 
128 #endif /* CONFIG_LEDS_CLASS */
129 
130 static int qt2160_read_block(struct i2c_client *client,
131 			     u8 inireg, u8 *buffer, unsigned int count)
132 {
133 	int error, idx = 0;
134 
135 	/*
136 	 * Can't use SMBus block data read. Check for I2C functionality to speed
137 	 * things up whenever possible. Otherwise we will be forced to read
138 	 * sequentially.
139 	 */
140 	if (i2c_check_functionality(client->adapter, I2C_FUNC_I2C))	{
141 
142 		error = i2c_smbus_write_byte(client, inireg + idx);
143 		if (error) {
144 			dev_err(&client->dev,
145 				"couldn't send request. Returned %d\n", error);
146 			return error;
147 		}
148 
149 		error = i2c_master_recv(client, buffer, count);
150 		if (error != count) {
151 			dev_err(&client->dev,
152 				"couldn't read registers. Returned %d bytes\n", error);
153 			return error;
154 		}
155 	} else {
156 
157 		while (count--) {
158 			int data;
159 
160 			error = i2c_smbus_write_byte(client, inireg + idx);
161 			if (error) {
162 				dev_err(&client->dev,
163 					"couldn't send request. Returned %d\n", error);
164 				return error;
165 			}
166 
167 			data = i2c_smbus_read_byte(client);
168 			if (data < 0) {
169 				dev_err(&client->dev,
170 					"couldn't read register. Returned %d\n", data);
171 				return data;
172 			}
173 
174 			buffer[idx++] = data;
175 		}
176 	}
177 
178 	return 0;
179 }
180 
181 static int qt2160_get_key_matrix(struct qt2160_data *qt2160)
182 {
183 	struct i2c_client *client = qt2160->client;
184 	struct input_dev *input = qt2160->input;
185 	u8 regs[6];
186 	u16 old_matrix, new_matrix;
187 	int ret, i, mask;
188 
189 	dev_dbg(&client->dev, "requesting keys...\n");
190 
191 	/*
192 	 * Read all registers from General Status Register
193 	 * to GPIOs register
194 	 */
195 	ret = qt2160_read_block(client, QT2160_CMD_GSTAT, regs, 6);
196 	if (ret) {
197 		dev_err(&client->dev,
198 			"could not perform chip read.\n");
199 		return ret;
200 	}
201 
202 	old_matrix = qt2160->key_matrix;
203 	qt2160->key_matrix = new_matrix = (regs[2] << 8) | regs[1];
204 
205 	mask = 0x01;
206 	for (i = 0; i < 16; ++i, mask <<= 1) {
207 		int keyval = new_matrix & mask;
208 
209 		if ((old_matrix & mask) != keyval) {
210 			input_report_key(input, qt2160->keycodes[i], keyval);
211 			dev_dbg(&client->dev, "key %d %s\n",
212 				i, keyval ? "pressed" : "released");
213 		}
214 	}
215 
216 	input_sync(input);
217 
218 	return 0;
219 }
220 
221 static irqreturn_t qt2160_irq(int irq, void *_qt2160)
222 {
223 	struct qt2160_data *qt2160 = _qt2160;
224 	unsigned long flags;
225 
226 	spin_lock_irqsave(&qt2160->lock, flags);
227 
228 	mod_delayed_work(system_wq, &qt2160->dwork, 0);
229 
230 	spin_unlock_irqrestore(&qt2160->lock, flags);
231 
232 	return IRQ_HANDLED;
233 }
234 
235 static void qt2160_schedule_read(struct qt2160_data *qt2160)
236 {
237 	spin_lock_irq(&qt2160->lock);
238 	schedule_delayed_work(&qt2160->dwork, QT2160_CYCLE_INTERVAL);
239 	spin_unlock_irq(&qt2160->lock);
240 }
241 
242 static void qt2160_worker(struct work_struct *work)
243 {
244 	struct qt2160_data *qt2160 =
245 		container_of(work, struct qt2160_data, dwork.work);
246 
247 	dev_dbg(&qt2160->client->dev, "worker\n");
248 
249 	qt2160_get_key_matrix(qt2160);
250 
251 	/* Avoid device lock up by checking every so often */
252 	qt2160_schedule_read(qt2160);
253 }
254 
255 static int qt2160_read(struct i2c_client *client, u8 reg)
256 {
257 	int ret;
258 
259 	ret = i2c_smbus_write_byte(client, reg);
260 	if (ret) {
261 		dev_err(&client->dev,
262 			"couldn't send request. Returned %d\n", ret);
263 		return ret;
264 	}
265 
266 	ret = i2c_smbus_read_byte(client);
267 	if (ret < 0) {
268 		dev_err(&client->dev,
269 			"couldn't read register. Returned %d\n", ret);
270 		return ret;
271 	}
272 
273 	return ret;
274 }
275 
276 static int qt2160_write(struct i2c_client *client, u8 reg, u8 data)
277 {
278 	int ret;
279 
280 	ret = i2c_smbus_write_byte_data(client, reg, data);
281 	if (ret < 0)
282 		dev_err(&client->dev,
283 			"couldn't write data. Returned %d\n", ret);
284 
285 	return ret;
286 }
287 
288 #ifdef CONFIG_LEDS_CLASS
289 
290 static int qt2160_register_leds(struct qt2160_data *qt2160)
291 {
292 	struct i2c_client *client = qt2160->client;
293 	int ret;
294 	int i;
295 
296 	mutex_init(&qt2160->led_lock);
297 
298 	for (i = 0; i < QT2160_NUM_LEDS_X; i++) {
299 		struct qt2160_led *led = &qt2160->leds[i];
300 
301 		snprintf(led->name, sizeof(led->name), "qt2160:x%d", i);
302 		led->cdev.name = led->name;
303 		led->cdev.brightness_set = qt2160_led_set;
304 		led->cdev.brightness = LED_OFF;
305 		led->id = i;
306 		led->qt2160 = qt2160;
307 
308 		INIT_WORK(&led->work, qt2160_led_work);
309 
310 		ret = led_classdev_register(&client->dev, &led->cdev);
311 		if (ret < 0)
312 			return ret;
313 	}
314 
315 	/* Tur off LEDs */
316 	qt2160_write(client, QT2160_CMD_DRIVE_X, 0);
317 	qt2160_write(client, QT2160_CMD_PWMEN_X, 0);
318 	qt2160_write(client, QT2160_CMD_PWM_DUTY, 0);
319 
320 	return 0;
321 }
322 
323 static void qt2160_unregister_leds(struct qt2160_data *qt2160)
324 {
325 	int i;
326 
327 	for (i = 0; i < QT2160_NUM_LEDS_X; i++) {
328 		led_classdev_unregister(&qt2160->leds[i].cdev);
329 		cancel_work_sync(&qt2160->leds[i].work);
330 	}
331 }
332 
333 #else
334 
335 static inline int qt2160_register_leds(struct qt2160_data *qt2160)
336 {
337 	return 0;
338 }
339 
340 static inline void qt2160_unregister_leds(struct qt2160_data *qt2160)
341 {
342 }
343 
344 #endif
345 
346 static bool qt2160_identify(struct i2c_client *client)
347 {
348 	int id, ver, rev;
349 
350 	/* Read Chid ID to check if chip is valid */
351 	id = qt2160_read(client, QT2160_CMD_CHIPID);
352 	if (id != QT2160_VALID_CHIPID) {
353 		dev_err(&client->dev, "ID %d not supported\n", id);
354 		return false;
355 	}
356 
357 	/* Read chip firmware version */
358 	ver = qt2160_read(client, QT2160_CMD_CODEVER);
359 	if (ver < 0) {
360 		dev_err(&client->dev, "could not get firmware version\n");
361 		return false;
362 	}
363 
364 	/* Read chip firmware revision */
365 	rev = qt2160_read(client, QT2160_CMD_SUBVER);
366 	if (rev < 0) {
367 		dev_err(&client->dev, "could not get firmware revision\n");
368 		return false;
369 	}
370 
371 	dev_info(&client->dev, "AT42QT2160 firmware version %d.%d.%d\n",
372 			ver >> 4, ver & 0xf, rev);
373 
374 	return true;
375 }
376 
377 static int qt2160_probe(struct i2c_client *client,
378 			const struct i2c_device_id *id)
379 {
380 	struct qt2160_data *qt2160;
381 	struct input_dev *input;
382 	int i;
383 	int error;
384 
385 	/* Check functionality */
386 	error = i2c_check_functionality(client->adapter,
387 			I2C_FUNC_SMBUS_BYTE);
388 	if (!error) {
389 		dev_err(&client->dev, "%s adapter not supported\n",
390 				dev_driver_string(&client->adapter->dev));
391 		return -ENODEV;
392 	}
393 
394 	if (!qt2160_identify(client))
395 		return -ENODEV;
396 
397 	/* Chip is valid and active. Allocate structure */
398 	qt2160 = kzalloc(sizeof(struct qt2160_data), GFP_KERNEL);
399 	input = input_allocate_device();
400 	if (!qt2160 || !input) {
401 		dev_err(&client->dev, "insufficient memory\n");
402 		error = -ENOMEM;
403 		goto err_free_mem;
404 	}
405 
406 	qt2160->client = client;
407 	qt2160->input = input;
408 	INIT_DELAYED_WORK(&qt2160->dwork, qt2160_worker);
409 	spin_lock_init(&qt2160->lock);
410 
411 	input->name = "AT42QT2160 Touch Sense Keyboard";
412 	input->id.bustype = BUS_I2C;
413 
414 	input->keycode = qt2160->keycodes;
415 	input->keycodesize = sizeof(qt2160->keycodes[0]);
416 	input->keycodemax = ARRAY_SIZE(qt2160_key2code);
417 
418 	__set_bit(EV_KEY, input->evbit);
419 	__clear_bit(EV_REP, input->evbit);
420 	for (i = 0; i < ARRAY_SIZE(qt2160_key2code); i++) {
421 		qt2160->keycodes[i] = qt2160_key2code[i];
422 		__set_bit(qt2160_key2code[i], input->keybit);
423 	}
424 	__clear_bit(KEY_RESERVED, input->keybit);
425 
426 	/* Calibrate device */
427 	error = qt2160_write(client, QT2160_CMD_CALIBRATE, 1);
428 	if (error) {
429 		dev_err(&client->dev, "failed to calibrate device\n");
430 		goto err_free_mem;
431 	}
432 
433 	if (client->irq) {
434 		error = request_irq(client->irq, qt2160_irq,
435 				    IRQF_TRIGGER_FALLING, "qt2160", qt2160);
436 		if (error) {
437 			dev_err(&client->dev,
438 				"failed to allocate irq %d\n", client->irq);
439 			goto err_free_mem;
440 		}
441 	}
442 
443 	error = qt2160_register_leds(qt2160);
444 	if (error) {
445 		dev_err(&client->dev, "Failed to register leds\n");
446 		goto err_free_irq;
447 	}
448 
449 	error = input_register_device(qt2160->input);
450 	if (error) {
451 		dev_err(&client->dev,
452 			"Failed to register input device\n");
453 		goto err_unregister_leds;
454 	}
455 
456 	i2c_set_clientdata(client, qt2160);
457 	qt2160_schedule_read(qt2160);
458 
459 	return 0;
460 
461 err_unregister_leds:
462 	qt2160_unregister_leds(qt2160);
463 err_free_irq:
464 	if (client->irq)
465 		free_irq(client->irq, qt2160);
466 err_free_mem:
467 	input_free_device(input);
468 	kfree(qt2160);
469 	return error;
470 }
471 
472 static int qt2160_remove(struct i2c_client *client)
473 {
474 	struct qt2160_data *qt2160 = i2c_get_clientdata(client);
475 
476 	qt2160_unregister_leds(qt2160);
477 
478 	/* Release IRQ so no queue will be scheduled */
479 	if (client->irq)
480 		free_irq(client->irq, qt2160);
481 
482 	cancel_delayed_work_sync(&qt2160->dwork);
483 
484 	input_unregister_device(qt2160->input);
485 	kfree(qt2160);
486 
487 	return 0;
488 }
489 
490 static const struct i2c_device_id qt2160_idtable[] = {
491 	{ "qt2160", 0, },
492 	{ }
493 };
494 
495 MODULE_DEVICE_TABLE(i2c, qt2160_idtable);
496 
497 static struct i2c_driver qt2160_driver = {
498 	.driver = {
499 		.name	= "qt2160",
500 		.owner  = THIS_MODULE,
501 	},
502 
503 	.id_table	= qt2160_idtable,
504 	.probe		= qt2160_probe,
505 	.remove		= qt2160_remove,
506 };
507 
508 module_i2c_driver(qt2160_driver);
509 
510 MODULE_AUTHOR("Raphael Derosso Pereira <raphaelpereira@gmail.com>");
511 MODULE_DESCRIPTION("Driver for AT42QT2160 Touch Sensor");
512 MODULE_LICENSE("GPL");
513