Commit | Line | Data |
---|---|---|
74ba9207 | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
bd7e4e85 BS |
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 | |
bd7e4e85 BS |
12 | */ |
13 | #include <linux/kernel.h> | |
14 | #include <linux/module.h> | |
bd7e4e85 BS |
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, 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, 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 | ||
5298cc4c | 80 | static bool qt1070_identify(struct i2c_client *client) |
bd7e4e85 BS |
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(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 | ||
ee27fe8a | 129 | static int qt1070_probe(struct i2c_client *client) |
bd7e4e85 BS |
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 | ||
447c0954 YL |
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; | |
bd7e4e85 BS |
160 | |
161 | data->client = client; | |
162 | data->input = input; | |
163 | data->irq = client->irq; | |
164 | ||
165 | input->name = "AT42QT1070 QTouch Sensor"; | |
bd7e4e85 BS |
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 | ||
447c0954 YL |
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); | |
bd7e4e85 BS |
192 | if (err) { |
193 | dev_err(&client->dev, "fail to request irq\n"); | |
447c0954 | 194 | return err; |
bd7e4e85 BS |
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"); | |
447c0954 | 201 | return err; |
bd7e4e85 BS |
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; | |
bd7e4e85 BS |
210 | } |
211 | ||
3719b54b BS |
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(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(data->irq); | |
230 | ||
231 | return 0; | |
232 | } | |
3719b54b | 233 | |
9254ed3f | 234 | static DEFINE_SIMPLE_DEV_PM_OPS(qt1070_pm_ops, qt1070_suspend, qt1070_resume); |
3719b54b | 235 | |
bd7e4e85 | 236 | static const struct i2c_device_id qt1070_id[] = { |
5852f2af UKK |
237 | { "qt1070" }, |
238 | { } | |
bd7e4e85 | 239 | }; |
94bb530c | 240 | MODULE_DEVICE_TABLE(i2c, qt1070_id); |
bd7e4e85 | 241 | |
cf5cd9d4 JMC |
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 | ||
bd7e4e85 BS |
250 | static struct i2c_driver qt1070_driver = { |
251 | .driver = { | |
252 | .name = "qt1070", | |
cf5cd9d4 | 253 | .of_match_table = of_match_ptr(qt1070_of_match), |
9254ed3f | 254 | .pm = pm_sleep_ptr(&qt1070_pm_ops), |
bd7e4e85 BS |
255 | }, |
256 | .id_table = qt1070_id, | |
d8bde56d | 257 | .probe = qt1070_probe, |
bd7e4e85 BS |
258 | }; |
259 | ||
1b92c1cf | 260 | module_i2c_driver(qt1070_driver); |
bd7e4e85 BS |
261 | |
262 | MODULE_AUTHOR("Bo Shen <voice.shen@atmel.com>"); | |
263 | MODULE_DESCRIPTION("Driver for AT42QT1070 QTouch sensor"); | |
264 | MODULE_LICENSE("GPL"); |