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