Loading...
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 */
43static const unsigned short qt1070_key2code[] = {
44 KEY_0, KEY_1, KEY_2, KEY_3,
45 KEY_4, KEY_5, KEY_6,
46};
47
48struct 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
56static 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
68static 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
80static 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
103static 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
129static int qt1070_probe(struct i2c_client *client)
130{
131 struct qt1070_data *data;
132 struct input_dev *input;
133 int i;
134 int err;
135
136 err = i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE);
137 if (!err) {
138 dev_err(&client->dev, "%s adapter not supported\n",
139 dev_driver_string(&client->adapter->dev));
140 return -ENODEV;
141 }
142
143 if (!client->irq) {
144 dev_err(&client->dev, "please assign the irq to this device\n");
145 return -EINVAL;
146 }
147
148 /* Identify the qt1070 chip */
149 if (!qt1070_identify(client))
150 return -ENODEV;
151
152 data = kzalloc(sizeof(struct qt1070_data), GFP_KERNEL);
153 input = input_allocate_device();
154 if (!data || !input) {
155 dev_err(&client->dev, "insufficient memory\n");
156 err = -ENOMEM;
157 goto err_free_mem;
158 }
159
160 data->client = client;
161 data->input = input;
162 data->irq = client->irq;
163
164 input->name = "AT42QT1070 QTouch Sensor";
165 input->dev.parent = &client->dev;
166 input->id.bustype = BUS_I2C;
167
168 /* Add the keycode */
169 input->keycode = data->keycodes;
170 input->keycodesize = sizeof(data->keycodes[0]);
171 input->keycodemax = ARRAY_SIZE(qt1070_key2code);
172
173 __set_bit(EV_KEY, input->evbit);
174
175 for (i = 0; i < ARRAY_SIZE(qt1070_key2code); i++) {
176 data->keycodes[i] = qt1070_key2code[i];
177 __set_bit(qt1070_key2code[i], input->keybit);
178 }
179
180 /* Calibrate device */
181 qt1070_write(client, CALIBRATE_CMD, 1);
182 msleep(QT1070_CAL_TIME);
183
184 /* Soft reset */
185 qt1070_write(client, RESET, 1);
186 msleep(QT1070_RESET_TIME);
187
188 err = request_threaded_irq(client->irq, NULL, qt1070_interrupt,
189 IRQF_TRIGGER_NONE | IRQF_ONESHOT,
190 client->dev.driver->name, data);
191 if (err) {
192 dev_err(&client->dev, "fail to request irq\n");
193 goto err_free_mem;
194 }
195
196 /* Register the input device */
197 err = input_register_device(data->input);
198 if (err) {
199 dev_err(&client->dev, "Failed to register input device\n");
200 goto err_free_irq;
201 }
202
203 i2c_set_clientdata(client, data);
204
205 /* Read to clear the chang line */
206 qt1070_read(client, DET_STATUS);
207
208 return 0;
209
210err_free_irq:
211 free_irq(client->irq, data);
212err_free_mem:
213 input_free_device(input);
214 kfree(data);
215 return err;
216}
217
218static void qt1070_remove(struct i2c_client *client)
219{
220 struct qt1070_data *data = i2c_get_clientdata(client);
221
222 /* Release IRQ */
223 free_irq(client->irq, data);
224
225 input_unregister_device(data->input);
226 kfree(data);
227}
228
229static int qt1070_suspend(struct device *dev)
230{
231 struct i2c_client *client = to_i2c_client(dev);
232 struct qt1070_data *data = i2c_get_clientdata(client);
233
234 if (device_may_wakeup(dev))
235 enable_irq_wake(data->irq);
236
237 return 0;
238}
239
240static int qt1070_resume(struct device *dev)
241{
242 struct i2c_client *client = to_i2c_client(dev);
243 struct qt1070_data *data = i2c_get_clientdata(client);
244
245 if (device_may_wakeup(dev))
246 disable_irq_wake(data->irq);
247
248 return 0;
249}
250
251static DEFINE_SIMPLE_DEV_PM_OPS(qt1070_pm_ops, qt1070_suspend, qt1070_resume);
252
253static const struct i2c_device_id qt1070_id[] = {
254 { "qt1070", 0 },
255 { },
256};
257MODULE_DEVICE_TABLE(i2c, qt1070_id);
258
259#ifdef CONFIG_OF
260static const struct of_device_id qt1070_of_match[] = {
261 { .compatible = "qt1070", },
262 { },
263};
264MODULE_DEVICE_TABLE(of, qt1070_of_match);
265#endif
266
267static struct i2c_driver qt1070_driver = {
268 .driver = {
269 .name = "qt1070",
270 .of_match_table = of_match_ptr(qt1070_of_match),
271 .pm = pm_sleep_ptr(&qt1070_pm_ops),
272 },
273 .id_table = qt1070_id,
274 .probe_new = qt1070_probe,
275 .remove = qt1070_remove,
276};
277
278module_i2c_driver(qt1070_driver);
279
280MODULE_AUTHOR("Bo Shen <voice.shen@atmel.com>");
281MODULE_DESCRIPTION("Driver for AT42QT1070 QTouch sensor");
282MODULE_LICENSE("GPL");
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 */
43static const unsigned short qt1070_key2code[] = {
44 KEY_0, KEY_1, KEY_2, KEY_3,
45 KEY_4, KEY_5, KEY_6,
46};
47
48struct 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
56static 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
68static 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
80static 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
103static 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
129static int qt1070_probe(struct i2c_client *client)
130{
131 struct qt1070_data *data;
132 struct input_dev *input;
133 int i;
134 int err;
135
136 err = i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE);
137 if (!err) {
138 dev_err(&client->dev, "%s adapter not supported\n",
139 dev_driver_string(&client->adapter->dev));
140 return -ENODEV;
141 }
142
143 if (!client->irq) {
144 dev_err(&client->dev, "please assign the irq to this device\n");
145 return -EINVAL;
146 }
147
148 /* Identify the qt1070 chip */
149 if (!qt1070_identify(client))
150 return -ENODEV;
151
152 data = devm_kzalloc(&client->dev, sizeof(struct qt1070_data),
153 GFP_KERNEL);
154 if (!data)
155 return -ENOMEM;
156
157 input = devm_input_allocate_device(&client->dev);
158 if (!input)
159 return -ENOMEM;
160
161 data->client = client;
162 data->input = input;
163 data->irq = client->irq;
164
165 input->name = "AT42QT1070 QTouch Sensor";
166 input->id.bustype = BUS_I2C;
167
168 /* Add the keycode */
169 input->keycode = data->keycodes;
170 input->keycodesize = sizeof(data->keycodes[0]);
171 input->keycodemax = ARRAY_SIZE(qt1070_key2code);
172
173 __set_bit(EV_KEY, input->evbit);
174
175 for (i = 0; i < ARRAY_SIZE(qt1070_key2code); i++) {
176 data->keycodes[i] = qt1070_key2code[i];
177 __set_bit(qt1070_key2code[i], input->keybit);
178 }
179
180 /* Calibrate device */
181 qt1070_write(client, CALIBRATE_CMD, 1);
182 msleep(QT1070_CAL_TIME);
183
184 /* Soft reset */
185 qt1070_write(client, RESET, 1);
186 msleep(QT1070_RESET_TIME);
187
188 err = devm_request_threaded_irq(&client->dev, client->irq,
189 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 return err;
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 return err;
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
212static int qt1070_suspend(struct device *dev)
213{
214 struct i2c_client *client = to_i2c_client(dev);
215 struct qt1070_data *data = i2c_get_clientdata(client);
216
217 if (device_may_wakeup(dev))
218 enable_irq_wake(data->irq);
219
220 return 0;
221}
222
223static int qt1070_resume(struct device *dev)
224{
225 struct i2c_client *client = to_i2c_client(dev);
226 struct qt1070_data *data = i2c_get_clientdata(client);
227
228 if (device_may_wakeup(dev))
229 disable_irq_wake(data->irq);
230
231 return 0;
232}
233
234static DEFINE_SIMPLE_DEV_PM_OPS(qt1070_pm_ops, qt1070_suspend, qt1070_resume);
235
236static const struct i2c_device_id qt1070_id[] = {
237 { "qt1070", 0 },
238 { },
239};
240MODULE_DEVICE_TABLE(i2c, qt1070_id);
241
242#ifdef CONFIG_OF
243static const struct of_device_id qt1070_of_match[] = {
244 { .compatible = "qt1070", },
245 { },
246};
247MODULE_DEVICE_TABLE(of, qt1070_of_match);
248#endif
249
250static struct i2c_driver qt1070_driver = {
251 .driver = {
252 .name = "qt1070",
253 .of_match_table = of_match_ptr(qt1070_of_match),
254 .pm = pm_sleep_ptr(&qt1070_pm_ops),
255 },
256 .id_table = qt1070_id,
257 .probe = qt1070_probe,
258};
259
260module_i2c_driver(qt1070_driver);
261
262MODULE_AUTHOR("Bo Shen <voice.shen@atmel.com>");
263MODULE_DESCRIPTION("Driver for AT42QT1070 QTouch sensor");
264MODULE_LICENSE("GPL");