1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * Copyright (C) 2011 Kionix, Inc. |
4 | * Written by Chris Hudson <chudson@kionix.com> |
5 | */ |
6 | |
7 | #include <linux/delay.h> |
8 | #include <linux/i2c.h> |
9 | #include <linux/input.h> |
10 | #include <linux/interrupt.h> |
11 | #include <linux/module.h> |
12 | #include <linux/slab.h> |
13 | #include <linux/input/kxtj9.h> |
14 | |
15 | #define NAME "kxtj9" |
16 | #define G_MAX 8000 |
17 | /* OUTPUT REGISTERS */ |
18 | #define XOUT_L 0x06 |
19 | #define WHO_AM_I 0x0F |
20 | /* CONTROL REGISTERS */ |
21 | #define INT_REL 0x1A |
22 | #define CTRL_REG1 0x1B |
23 | #define INT_CTRL1 0x1E |
24 | #define DATA_CTRL 0x21 |
25 | /* CONTROL REGISTER 1 BITS */ |
26 | #define PC1_OFF 0x7F |
27 | #define PC1_ON (1 << 7) |
28 | /* Data ready funtion enable bit: set during probe if using irq mode */ |
29 | #define DRDYE (1 << 5) |
30 | /* DATA CONTROL REGISTER BITS */ |
31 | #define ODR12_5F 0 |
32 | #define ODR25F 1 |
33 | #define ODR50F 2 |
34 | #define ODR100F 3 |
35 | #define ODR200F 4 |
36 | #define ODR400F 5 |
37 | #define ODR800F 6 |
38 | /* INTERRUPT CONTROL REGISTER 1 BITS */ |
39 | /* Set these during probe if using irq mode */ |
40 | #define KXTJ9_IEL (1 << 3) |
41 | #define KXTJ9_IEA (1 << 4) |
42 | #define KXTJ9_IEN (1 << 5) |
43 | /* INPUT_ABS CONSTANTS */ |
44 | #define FUZZ 3 |
45 | #define FLAT 3 |
46 | /* RESUME STATE INDICES */ |
47 | #define RES_DATA_CTRL 0 |
48 | #define RES_CTRL_REG1 1 |
49 | #define RES_INT_CTRL1 2 |
50 | #define RESUME_ENTRIES 3 |
51 | |
52 | /* |
53 | * The following table lists the maximum appropriate poll interval for each |
54 | * available output data rate. |
55 | */ |
56 | static const struct { |
57 | unsigned int cutoff; |
58 | u8 mask; |
59 | } kxtj9_odr_table[] = { |
60 | { 3, ODR800F }, |
61 | { 5, ODR400F }, |
62 | { 10, ODR200F }, |
63 | { 20, ODR100F }, |
64 | { 40, ODR50F }, |
65 | { 80, ODR25F }, |
66 | { 0, ODR12_5F}, |
67 | }; |
68 | |
69 | struct kxtj9_data { |
70 | struct i2c_client *client; |
71 | struct kxtj9_platform_data pdata; |
72 | struct input_dev *input_dev; |
73 | unsigned int last_poll_interval; |
74 | u8 shift; |
75 | u8 ctrl_reg1; |
76 | u8 data_ctrl; |
77 | u8 int_ctrl; |
78 | }; |
79 | |
80 | static int kxtj9_i2c_read(struct kxtj9_data *tj9, u8 addr, u8 *data, int len) |
81 | { |
82 | struct i2c_msg msgs[] = { |
83 | { |
84 | .addr = tj9->client->addr, |
85 | .flags = tj9->client->flags, |
86 | .len = 1, |
87 | .buf = &addr, |
88 | }, |
89 | { |
90 | .addr = tj9->client->addr, |
91 | .flags = tj9->client->flags | I2C_M_RD, |
92 | .len = len, |
93 | .buf = data, |
94 | }, |
95 | }; |
96 | |
97 | return i2c_transfer(adap: tj9->client->adapter, msgs, num: 2); |
98 | } |
99 | |
100 | static void kxtj9_report_acceleration_data(struct kxtj9_data *tj9) |
101 | { |
102 | s16 acc_data[3]; /* Data bytes from hardware xL, xH, yL, yH, zL, zH */ |
103 | s16 x, y, z; |
104 | int err; |
105 | |
106 | err = kxtj9_i2c_read(tj9, XOUT_L, data: (u8 *)acc_data, len: 6); |
107 | if (err < 0) |
108 | dev_err(&tj9->client->dev, "accelerometer data read failed\n" ); |
109 | |
110 | x = le16_to_cpu(acc_data[tj9->pdata.axis_map_x]); |
111 | y = le16_to_cpu(acc_data[tj9->pdata.axis_map_y]); |
112 | z = le16_to_cpu(acc_data[tj9->pdata.axis_map_z]); |
113 | |
114 | x >>= tj9->shift; |
115 | y >>= tj9->shift; |
116 | z >>= tj9->shift; |
117 | |
118 | input_report_abs(dev: tj9->input_dev, ABS_X, value: tj9->pdata.negate_x ? -x : x); |
119 | input_report_abs(dev: tj9->input_dev, ABS_Y, value: tj9->pdata.negate_y ? -y : y); |
120 | input_report_abs(dev: tj9->input_dev, ABS_Z, value: tj9->pdata.negate_z ? -z : z); |
121 | input_sync(dev: tj9->input_dev); |
122 | } |
123 | |
124 | static irqreturn_t kxtj9_isr(int irq, void *dev) |
125 | { |
126 | struct kxtj9_data *tj9 = dev; |
127 | int err; |
128 | |
129 | /* data ready is the only possible interrupt type */ |
130 | kxtj9_report_acceleration_data(tj9); |
131 | |
132 | err = i2c_smbus_read_byte_data(client: tj9->client, INT_REL); |
133 | if (err < 0) |
134 | dev_err(&tj9->client->dev, |
135 | "error clearing interrupt status: %d\n" , err); |
136 | |
137 | return IRQ_HANDLED; |
138 | } |
139 | |
140 | static int kxtj9_update_g_range(struct kxtj9_data *tj9, u8 new_g_range) |
141 | { |
142 | switch (new_g_range) { |
143 | case KXTJ9_G_2G: |
144 | tj9->shift = 4; |
145 | break; |
146 | case KXTJ9_G_4G: |
147 | tj9->shift = 3; |
148 | break; |
149 | case KXTJ9_G_8G: |
150 | tj9->shift = 2; |
151 | break; |
152 | default: |
153 | return -EINVAL; |
154 | } |
155 | |
156 | tj9->ctrl_reg1 &= 0xe7; |
157 | tj9->ctrl_reg1 |= new_g_range; |
158 | |
159 | return 0; |
160 | } |
161 | |
162 | static int kxtj9_update_odr(struct kxtj9_data *tj9, unsigned int poll_interval) |
163 | { |
164 | int err; |
165 | int i; |
166 | |
167 | /* Use the lowest ODR that can support the requested poll interval */ |
168 | for (i = 0; i < ARRAY_SIZE(kxtj9_odr_table); i++) { |
169 | tj9->data_ctrl = kxtj9_odr_table[i].mask; |
170 | if (poll_interval < kxtj9_odr_table[i].cutoff) |
171 | break; |
172 | } |
173 | |
174 | err = i2c_smbus_write_byte_data(client: tj9->client, CTRL_REG1, value: 0); |
175 | if (err < 0) |
176 | return err; |
177 | |
178 | err = i2c_smbus_write_byte_data(client: tj9->client, DATA_CTRL, value: tj9->data_ctrl); |
179 | if (err < 0) |
180 | return err; |
181 | |
182 | err = i2c_smbus_write_byte_data(client: tj9->client, CTRL_REG1, value: tj9->ctrl_reg1); |
183 | if (err < 0) |
184 | return err; |
185 | |
186 | return 0; |
187 | } |
188 | |
189 | static int kxtj9_device_power_on(struct kxtj9_data *tj9) |
190 | { |
191 | if (tj9->pdata.power_on) |
192 | return tj9->pdata.power_on(); |
193 | |
194 | return 0; |
195 | } |
196 | |
197 | static void kxtj9_device_power_off(struct kxtj9_data *tj9) |
198 | { |
199 | int err; |
200 | |
201 | tj9->ctrl_reg1 &= PC1_OFF; |
202 | err = i2c_smbus_write_byte_data(client: tj9->client, CTRL_REG1, value: tj9->ctrl_reg1); |
203 | if (err < 0) |
204 | dev_err(&tj9->client->dev, "soft power off failed\n" ); |
205 | |
206 | if (tj9->pdata.power_off) |
207 | tj9->pdata.power_off(); |
208 | } |
209 | |
210 | static int kxtj9_enable(struct kxtj9_data *tj9) |
211 | { |
212 | int err; |
213 | |
214 | err = kxtj9_device_power_on(tj9); |
215 | if (err < 0) |
216 | return err; |
217 | |
218 | /* ensure that PC1 is cleared before updating control registers */ |
219 | err = i2c_smbus_write_byte_data(client: tj9->client, CTRL_REG1, value: 0); |
220 | if (err < 0) |
221 | return err; |
222 | |
223 | /* only write INT_CTRL_REG1 if in irq mode */ |
224 | if (tj9->client->irq) { |
225 | err = i2c_smbus_write_byte_data(client: tj9->client, |
226 | INT_CTRL1, value: tj9->int_ctrl); |
227 | if (err < 0) |
228 | return err; |
229 | } |
230 | |
231 | err = kxtj9_update_g_range(tj9, new_g_range: tj9->pdata.g_range); |
232 | if (err < 0) |
233 | return err; |
234 | |
235 | /* turn on outputs */ |
236 | tj9->ctrl_reg1 |= PC1_ON; |
237 | err = i2c_smbus_write_byte_data(client: tj9->client, CTRL_REG1, value: tj9->ctrl_reg1); |
238 | if (err < 0) |
239 | return err; |
240 | |
241 | err = kxtj9_update_odr(tj9, poll_interval: tj9->last_poll_interval); |
242 | if (err < 0) |
243 | return err; |
244 | |
245 | /* clear initial interrupt if in irq mode */ |
246 | if (tj9->client->irq) { |
247 | err = i2c_smbus_read_byte_data(client: tj9->client, INT_REL); |
248 | if (err < 0) { |
249 | dev_err(&tj9->client->dev, |
250 | "error clearing interrupt: %d\n" , err); |
251 | goto fail; |
252 | } |
253 | } |
254 | |
255 | return 0; |
256 | |
257 | fail: |
258 | kxtj9_device_power_off(tj9); |
259 | return err; |
260 | } |
261 | |
262 | static void kxtj9_disable(struct kxtj9_data *tj9) |
263 | { |
264 | kxtj9_device_power_off(tj9); |
265 | } |
266 | |
267 | static int kxtj9_input_open(struct input_dev *input) |
268 | { |
269 | struct kxtj9_data *tj9 = input_get_drvdata(dev: input); |
270 | |
271 | return kxtj9_enable(tj9); |
272 | } |
273 | |
274 | static void kxtj9_input_close(struct input_dev *dev) |
275 | { |
276 | struct kxtj9_data *tj9 = input_get_drvdata(dev); |
277 | |
278 | kxtj9_disable(tj9); |
279 | } |
280 | |
281 | /* |
282 | * When IRQ mode is selected, we need to provide an interface to allow the user |
283 | * to change the output data rate of the part. For consistency, we are using |
284 | * the set_poll method, which accepts a poll interval in milliseconds, and then |
285 | * calls update_odr() while passing this value as an argument. In IRQ mode, the |
286 | * data outputs will not be read AT the requested poll interval, rather, the |
287 | * lowest ODR that can support the requested interval. The client application |
288 | * will be responsible for retrieving data from the input node at the desired |
289 | * interval. |
290 | */ |
291 | |
292 | /* Returns currently selected poll interval (in ms) */ |
293 | static ssize_t kxtj9_get_poll(struct device *dev, |
294 | struct device_attribute *attr, char *buf) |
295 | { |
296 | struct i2c_client *client = to_i2c_client(dev); |
297 | struct kxtj9_data *tj9 = i2c_get_clientdata(client); |
298 | |
299 | return sprintf(buf, fmt: "%d\n" , tj9->last_poll_interval); |
300 | } |
301 | |
302 | /* Allow users to select a new poll interval (in ms) */ |
303 | static ssize_t kxtj9_set_poll(struct device *dev, struct device_attribute *attr, |
304 | const char *buf, size_t count) |
305 | { |
306 | struct i2c_client *client = to_i2c_client(dev); |
307 | struct kxtj9_data *tj9 = i2c_get_clientdata(client); |
308 | struct input_dev *input_dev = tj9->input_dev; |
309 | unsigned int interval; |
310 | int error; |
311 | |
312 | error = kstrtouint(s: buf, base: 10, res: &interval); |
313 | if (error < 0) |
314 | return error; |
315 | |
316 | /* Lock the device to prevent races with open/close (and itself) */ |
317 | mutex_lock(&input_dev->mutex); |
318 | |
319 | disable_irq(irq: client->irq); |
320 | |
321 | /* |
322 | * Set current interval to the greater of the minimum interval or |
323 | * the requested interval |
324 | */ |
325 | tj9->last_poll_interval = max(interval, tj9->pdata.min_interval); |
326 | |
327 | kxtj9_update_odr(tj9, poll_interval: tj9->last_poll_interval); |
328 | |
329 | enable_irq(irq: client->irq); |
330 | mutex_unlock(lock: &input_dev->mutex); |
331 | |
332 | return count; |
333 | } |
334 | |
335 | static DEVICE_ATTR(poll, S_IRUGO|S_IWUSR, kxtj9_get_poll, kxtj9_set_poll); |
336 | |
337 | static struct attribute *kxtj9_attributes[] = { |
338 | &dev_attr_poll.attr, |
339 | NULL |
340 | }; |
341 | |
342 | static struct attribute_group kxtj9_attribute_group = { |
343 | .attrs = kxtj9_attributes |
344 | }; |
345 | |
346 | static void kxtj9_poll(struct input_dev *input) |
347 | { |
348 | struct kxtj9_data *tj9 = input_get_drvdata(dev: input); |
349 | unsigned int poll_interval = input_get_poll_interval(dev: input); |
350 | |
351 | kxtj9_report_acceleration_data(tj9); |
352 | |
353 | if (poll_interval != tj9->last_poll_interval) { |
354 | kxtj9_update_odr(tj9, poll_interval); |
355 | tj9->last_poll_interval = poll_interval; |
356 | } |
357 | } |
358 | |
359 | static void kxtj9_platform_exit(void *data) |
360 | { |
361 | struct kxtj9_data *tj9 = data; |
362 | |
363 | if (tj9->pdata.exit) |
364 | tj9->pdata.exit(); |
365 | } |
366 | |
367 | static int kxtj9_verify(struct kxtj9_data *tj9) |
368 | { |
369 | int retval; |
370 | |
371 | retval = kxtj9_device_power_on(tj9); |
372 | if (retval < 0) |
373 | return retval; |
374 | |
375 | retval = i2c_smbus_read_byte_data(client: tj9->client, WHO_AM_I); |
376 | if (retval < 0) { |
377 | dev_err(&tj9->client->dev, "read err int source\n" ); |
378 | goto out; |
379 | } |
380 | |
381 | retval = (retval != 0x07 && retval != 0x08) ? -EIO : 0; |
382 | |
383 | out: |
384 | kxtj9_device_power_off(tj9); |
385 | return retval; |
386 | } |
387 | |
388 | static int kxtj9_probe(struct i2c_client *client) |
389 | { |
390 | const struct kxtj9_platform_data *pdata = |
391 | dev_get_platdata(dev: &client->dev); |
392 | struct kxtj9_data *tj9; |
393 | struct input_dev *input_dev; |
394 | int err; |
395 | |
396 | if (!i2c_check_functionality(adap: client->adapter, |
397 | I2C_FUNC_I2C | I2C_FUNC_SMBUS_BYTE_DATA)) { |
398 | dev_err(&client->dev, "client is not i2c capable\n" ); |
399 | return -ENXIO; |
400 | } |
401 | |
402 | if (!pdata) { |
403 | dev_err(&client->dev, "platform data is NULL; exiting\n" ); |
404 | return -EINVAL; |
405 | } |
406 | |
407 | tj9 = devm_kzalloc(dev: &client->dev, size: sizeof(*tj9), GFP_KERNEL); |
408 | if (!tj9) { |
409 | dev_err(&client->dev, |
410 | "failed to allocate memory for module data\n" ); |
411 | return -ENOMEM; |
412 | } |
413 | |
414 | tj9->client = client; |
415 | tj9->pdata = *pdata; |
416 | |
417 | if (pdata->init) { |
418 | err = pdata->init(); |
419 | if (err < 0) |
420 | return err; |
421 | } |
422 | |
423 | err = devm_add_action_or_reset(&client->dev, kxtj9_platform_exit, tj9); |
424 | if (err) |
425 | return err; |
426 | |
427 | err = kxtj9_verify(tj9); |
428 | if (err < 0) { |
429 | dev_err(&client->dev, "device not recognized\n" ); |
430 | return err; |
431 | } |
432 | |
433 | i2c_set_clientdata(client, data: tj9); |
434 | |
435 | tj9->ctrl_reg1 = tj9->pdata.res_12bit | tj9->pdata.g_range; |
436 | tj9->last_poll_interval = tj9->pdata.init_interval; |
437 | |
438 | input_dev = devm_input_allocate_device(&client->dev); |
439 | if (!input_dev) { |
440 | dev_err(&client->dev, "input device allocate failed\n" ); |
441 | return -ENOMEM; |
442 | } |
443 | |
444 | input_set_drvdata(dev: input_dev, data: tj9); |
445 | tj9->input_dev = input_dev; |
446 | |
447 | input_dev->name = "kxtj9_accel" ; |
448 | input_dev->id.bustype = BUS_I2C; |
449 | |
450 | input_dev->open = kxtj9_input_open; |
451 | input_dev->close = kxtj9_input_close; |
452 | |
453 | input_set_abs_params(dev: input_dev, ABS_X, min: -G_MAX, G_MAX, FUZZ, FLAT); |
454 | input_set_abs_params(dev: input_dev, ABS_Y, min: -G_MAX, G_MAX, FUZZ, FLAT); |
455 | input_set_abs_params(dev: input_dev, ABS_Z, min: -G_MAX, G_MAX, FUZZ, FLAT); |
456 | |
457 | if (client->irq <= 0) { |
458 | err = input_setup_polling(dev: input_dev, poll_fn: kxtj9_poll); |
459 | if (err) |
460 | return err; |
461 | } |
462 | |
463 | err = input_register_device(input_dev); |
464 | if (err) { |
465 | dev_err(&client->dev, |
466 | "unable to register input polled device %s: %d\n" , |
467 | input_dev->name, err); |
468 | return err; |
469 | } |
470 | |
471 | if (client->irq) { |
472 | /* If in irq mode, populate INT_CTRL_REG1 and enable DRDY. */ |
473 | tj9->int_ctrl |= KXTJ9_IEN | KXTJ9_IEA | KXTJ9_IEL; |
474 | tj9->ctrl_reg1 |= DRDYE; |
475 | |
476 | err = devm_request_threaded_irq(dev: &client->dev, irq: client->irq, |
477 | NULL, thread_fn: kxtj9_isr, |
478 | IRQF_TRIGGER_RISING | |
479 | IRQF_ONESHOT, |
480 | devname: "kxtj9-irq" , dev_id: tj9); |
481 | if (err) { |
482 | dev_err(&client->dev, "request irq failed: %d\n" , err); |
483 | return err; |
484 | } |
485 | |
486 | err = devm_device_add_group(dev: &client->dev, |
487 | grp: &kxtj9_attribute_group); |
488 | if (err) { |
489 | dev_err(&client->dev, "sysfs create failed: %d\n" , err); |
490 | return err; |
491 | } |
492 | } |
493 | |
494 | return 0; |
495 | } |
496 | |
497 | static int kxtj9_suspend(struct device *dev) |
498 | { |
499 | struct i2c_client *client = to_i2c_client(dev); |
500 | struct kxtj9_data *tj9 = i2c_get_clientdata(client); |
501 | struct input_dev *input_dev = tj9->input_dev; |
502 | |
503 | mutex_lock(&input_dev->mutex); |
504 | |
505 | if (input_device_enabled(dev: input_dev)) |
506 | kxtj9_disable(tj9); |
507 | |
508 | mutex_unlock(lock: &input_dev->mutex); |
509 | return 0; |
510 | } |
511 | |
512 | static int kxtj9_resume(struct device *dev) |
513 | { |
514 | struct i2c_client *client = to_i2c_client(dev); |
515 | struct kxtj9_data *tj9 = i2c_get_clientdata(client); |
516 | struct input_dev *input_dev = tj9->input_dev; |
517 | |
518 | mutex_lock(&input_dev->mutex); |
519 | |
520 | if (input_device_enabled(dev: input_dev)) |
521 | kxtj9_enable(tj9); |
522 | |
523 | mutex_unlock(lock: &input_dev->mutex); |
524 | return 0; |
525 | } |
526 | |
527 | static DEFINE_SIMPLE_DEV_PM_OPS(kxtj9_pm_ops, kxtj9_suspend, kxtj9_resume); |
528 | |
529 | static const struct i2c_device_id kxtj9_id[] = { |
530 | { NAME, 0 }, |
531 | { }, |
532 | }; |
533 | |
534 | MODULE_DEVICE_TABLE(i2c, kxtj9_id); |
535 | |
536 | static struct i2c_driver kxtj9_driver = { |
537 | .driver = { |
538 | .name = NAME, |
539 | .pm = pm_sleep_ptr(&kxtj9_pm_ops), |
540 | }, |
541 | .probe = kxtj9_probe, |
542 | .id_table = kxtj9_id, |
543 | }; |
544 | |
545 | module_i2c_driver(kxtj9_driver); |
546 | |
547 | MODULE_DESCRIPTION("KXTJ9 accelerometer driver" ); |
548 | MODULE_AUTHOR("Chris Hudson <chudson@kionix.com>" ); |
549 | MODULE_LICENSE("GPL" ); |
550 | |