1/*
2 *  Atmel AT42QT1070 QTouch Sensor Controller
3 *
4 *  Copyright (C) 2011 Atmel
5 *
6 *  Authors: Bo Shen <voice.shen@atmel.com>
7 *
8 *  Base on AT42QT2160 driver by:
9 *  Raphael Derosso Pereira <raphaelpereira@gmail.com>
10 *  Copyright (C) 2009
11 *
12 *  This program is free software; you can redistribute it and/or modify
13 *  it under the terms of the GNU General Public License as published by
14 *  the Free Software Foundation; either version 2 of the License, or
15 *  (at your option) any later version.
16 *
17 *  This program is distributed in the hope that it will be useful,
18 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
19 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
20 *  GNU General Public License for more details.
21 *
22 *  You should have received a copy of the GNU General Public License
23 *  along with this program; if not, write to the Free Software
24 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 */
26#include <linux/kernel.h>
27#include <linux/module.h>
28#include <linux/i2c.h>
29#include <linux/input.h>
30#include <linux/slab.h>
31#include <linux/irq.h>
32#include <linux/interrupt.h>
33#include <linux/jiffies.h>
34#include <linux/delay.h>
35
36/* Address for each register */
37#define CHIP_ID            0x00
38#define QT1070_CHIP_ID     0x2E
39
40#define FW_VERSION         0x01
41#define QT1070_FW_VERSION  0x15
42
43#define DET_STATUS         0x02
44
45#define KEY_STATUS         0x03
46
47/* Calibrate */
48#define CALIBRATE_CMD      0x38
49#define QT1070_CAL_TIME    200
50
51/* Reset */
52#define RESET              0x39
53#define QT1070_RESET_TIME  255
54
55/* AT42QT1070 support up to 7 keys */
56static const unsigned short qt1070_key2code[] = {
57	KEY_0, KEY_1, KEY_2, KEY_3,
58	KEY_4, KEY_5, KEY_6,
59};
60
61struct qt1070_data {
62	struct i2c_client *client;
63	struct input_dev *input;
64	unsigned int irq;
65	unsigned short keycodes[ARRAY_SIZE(qt1070_key2code)];
66	u8 last_keys;
67};
68
69static int qt1070_read(struct i2c_client *client, u8 reg)
70{
71	int ret;
72
73	ret = i2c_smbus_read_byte_data(client, reg);
74	if (ret < 0)
75		dev_err(&client->dev,
76			"can not read register, returned %d\n", ret);
77
78	return ret;
79}
80
81static int qt1070_write(struct i2c_client *client, u8 reg, u8 data)
82{
83	int ret;
84
85	ret = i2c_smbus_write_byte_data(client, reg, data);
86	if (ret < 0)
87		dev_err(&client->dev,
88			"can not write register, returned %d\n", ret);
89
90	return ret;
91}
92
93static bool qt1070_identify(struct i2c_client *client)
94{
95	int id, ver;
96
97	/* Read Chip ID */
98	id = qt1070_read(client, CHIP_ID);
99	if (id != QT1070_CHIP_ID) {
100		dev_err(&client->dev, "ID %d not supported\n", id);
101		return false;
102	}
103
104	/* Read firmware version */
105	ver = qt1070_read(client, FW_VERSION);
106	if (ver < 0) {
107		dev_err(&client->dev, "could not read the firmware version\n");
108		return false;
109	}
110
111	dev_info(&client->dev, "AT42QT1070 firmware version %x\n", ver);
112
113	return true;
114}
115
116static irqreturn_t qt1070_interrupt(int irq, void *dev_id)
117{
118	struct qt1070_data *data = dev_id;
119	struct i2c_client *client = data->client;
120	struct input_dev *input = data->input;
121	int i;
122	u8 new_keys, keyval, mask = 0x01;
123
124	/* Read the detected status register, thus clearing interrupt */
125	qt1070_read(client, DET_STATUS);
126
127	/* Read which key changed */
128	new_keys = qt1070_read(client, KEY_STATUS);
129
130	for (i = 0; i < ARRAY_SIZE(qt1070_key2code); i++) {
131		keyval = new_keys & mask;
132		if ((data->last_keys & mask) != keyval)
133			input_report_key(input, data->keycodes[i], keyval);
134		mask <<= 1;
135	}
136	input_sync(input);
137
138	data->last_keys = new_keys;
139	return IRQ_HANDLED;
140}
141
142static int qt1070_probe(struct i2c_client *client,
143				const struct i2c_device_id *id)
144{
145	struct qt1070_data *data;
146	struct input_dev *input;
147	int i;
148	int err;
149
150	err = i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE);
151	if (!err) {
152		dev_err(&client->dev, "%s adapter not supported\n",
153			dev_driver_string(&client->adapter->dev));
154		return -ENODEV;
155	}
156
157	if (!client->irq) {
158		dev_err(&client->dev, "please assign the irq to this device\n");
159		return -EINVAL;
160	}
161
162	/* Identify the qt1070 chip */
163	if (!qt1070_identify(client))
164		return -ENODEV;
165
166	data = kzalloc(sizeof(struct qt1070_data), GFP_KERNEL);
167	input = input_allocate_device();
168	if (!data || !input) {
169		dev_err(&client->dev, "insufficient memory\n");
170		err = -ENOMEM;
171		goto err_free_mem;
172	}
173
174	data->client = client;
175	data->input = input;
176	data->irq = client->irq;
177
178	input->name = "AT42QT1070 QTouch Sensor";
179	input->dev.parent = &client->dev;
180	input->id.bustype = BUS_I2C;
181
182	/* Add the keycode */
183	input->keycode = data->keycodes;
184	input->keycodesize = sizeof(data->keycodes[0]);
185	input->keycodemax = ARRAY_SIZE(qt1070_key2code);
186
187	__set_bit(EV_KEY, input->evbit);
188
189	for (i = 0; i < ARRAY_SIZE(qt1070_key2code); i++) {
190		data->keycodes[i] = qt1070_key2code[i];
191		__set_bit(qt1070_key2code[i], input->keybit);
192	}
193
194	/* Calibrate device */
195	qt1070_write(client, CALIBRATE_CMD, 1);
196	msleep(QT1070_CAL_TIME);
197
198	/* Soft reset */
199	qt1070_write(client, RESET, 1);
200	msleep(QT1070_RESET_TIME);
201
202	err = request_threaded_irq(client->irq, NULL, qt1070_interrupt,
203				   IRQF_TRIGGER_NONE | IRQF_ONESHOT,
204				   client->dev.driver->name, data);
205	if (err) {
206		dev_err(&client->dev, "fail to request irq\n");
207		goto err_free_mem;
208	}
209
210	/* Register the input device */
211	err = input_register_device(data->input);
212	if (err) {
213		dev_err(&client->dev, "Failed to register input device\n");
214		goto err_free_irq;
215	}
216
217	i2c_set_clientdata(client, data);
218
219	/* Read to clear the chang line */
220	qt1070_read(client, DET_STATUS);
221
222	return 0;
223
224err_free_irq:
225	free_irq(client->irq, data);
226err_free_mem:
227	input_free_device(input);
228	kfree(data);
229	return err;
230}
231
232static int qt1070_remove(struct i2c_client *client)
233{
234	struct qt1070_data *data = i2c_get_clientdata(client);
235
236	/* Release IRQ */
237	free_irq(client->irq, data);
238
239	input_unregister_device(data->input);
240	kfree(data);
241
242	return 0;
243}
244
245#ifdef CONFIG_PM_SLEEP
246static int qt1070_suspend(struct device *dev)
247{
248	struct i2c_client *client = to_i2c_client(dev);
249	struct qt1070_data *data = i2c_get_clientdata(client);
250
251	if (device_may_wakeup(dev))
252		enable_irq_wake(data->irq);
253
254	return 0;
255}
256
257static int qt1070_resume(struct device *dev)
258{
259	struct i2c_client *client = to_i2c_client(dev);
260	struct qt1070_data *data = i2c_get_clientdata(client);
261
262	if (device_may_wakeup(dev))
263		disable_irq_wake(data->irq);
264
265	return 0;
266}
267#endif
268
269static SIMPLE_DEV_PM_OPS(qt1070_pm_ops, qt1070_suspend, qt1070_resume);
270
271static const struct i2c_device_id qt1070_id[] = {
272	{ "qt1070", 0 },
273	{ },
274};
275MODULE_DEVICE_TABLE(i2c, qt1070_id);
276
277static struct i2c_driver qt1070_driver = {
278	.driver	= {
279		.name	= "qt1070",
280		.owner	= THIS_MODULE,
281		.pm	= &qt1070_pm_ops,
282	},
283	.id_table	= qt1070_id,
284	.probe		= qt1070_probe,
285	.remove		= qt1070_remove,
286};
287
288module_i2c_driver(qt1070_driver);
289
290MODULE_AUTHOR("Bo Shen <voice.shen@atmel.com>");
291MODULE_DESCRIPTION("Driver for AT42QT1070 QTouch sensor");
292MODULE_LICENSE("GPL");
293