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 | |
56 | static int qt1070_read(struct i2c_client *client, u8 reg) |
57 | { |
58 | int ret; |
59 | |
60 | ret = i2c_smbus_read_byte_data(client, command: 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 | |
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, command: reg, value: 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 | |
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 | |
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(dev: input, code: data->keycodes[i], value: keyval); |
121 | mask <<= 1; |
122 | } |
123 | input_sync(dev: input); |
124 | |
125 | data->last_keys = new_keys; |
126 | return IRQ_HANDLED; |
127 | } |
128 | |
129 | static 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(adap: 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(dev: &client->dev, size: 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, data: 1); |
182 | msleep(QT1070_CAL_TIME); |
183 | |
184 | /* Soft reset */ |
185 | qt1070_write(client, RESET, data: 1); |
186 | msleep(QT1070_RESET_TIME); |
187 | |
188 | err = devm_request_threaded_irq(dev: &client->dev, irq: client->irq, |
189 | NULL, thread_fn: qt1070_interrupt, |
190 | IRQF_TRIGGER_NONE | IRQF_ONESHOT, |
191 | devname: client->dev.driver->name, dev_id: 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 | |
212 | static 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(irq: data->irq); |
219 | |
220 | return 0; |
221 | } |
222 | |
223 | static 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(irq: data->irq); |
230 | |
231 | return 0; |
232 | } |
233 | |
234 | static DEFINE_SIMPLE_DEV_PM_OPS(qt1070_pm_ops, qt1070_suspend, qt1070_resume); |
235 | |
236 | static const struct i2c_device_id qt1070_id[] = { |
237 | { "qt1070" , 0 }, |
238 | { }, |
239 | }; |
240 | MODULE_DEVICE_TABLE(i2c, qt1070_id); |
241 | |
242 | #ifdef CONFIG_OF |
243 | static const struct of_device_id qt1070_of_match[] = { |
244 | { .compatible = "qt1070" , }, |
245 | { }, |
246 | }; |
247 | MODULE_DEVICE_TABLE(of, qt1070_of_match); |
248 | #endif |
249 | |
250 | static 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 | |
260 | module_i2c_driver(qt1070_driver); |
261 | |
262 | MODULE_AUTHOR("Bo Shen <voice.shen@atmel.com>" ); |
263 | MODULE_DESCRIPTION("Driver for AT42QT1070 QTouch sensor" ); |
264 | MODULE_LICENSE("GPL" ); |
265 | |