1
2
3
4
5
6
7#include <linux/module.h>
8#include <linux/i2c.h>
9#include <linux/interrupt.h>
10#include <linux/delay.h>
11#include <linux/bitops.h>
12#include <linux/slab.h>
13#include <linux/string.h>
14#include <linux/acpi.h>
15#include <linux/pm.h>
16#include <linux/pm_runtime.h>
17#include <linux/iio/iio.h>
18#include <linux/iio/sysfs.h>
19#include <linux/iio/buffer.h>
20#include <linux/iio/trigger.h>
21#include <linux/iio/events.h>
22#include <linux/iio/trigger_consumer.h>
23#include <linux/iio/triggered_buffer.h>
24#include <linux/iio/accel/kxcjk_1013.h>
25
26#define KXCJK1013_DRV_NAME "kxcjk1013"
27#define KXCJK1013_IRQ_NAME "kxcjk1013_event"
28
29#define KXTF9_REG_HP_XOUT_L 0x00
30#define KXTF9_REG_HP_XOUT_H 0x01
31#define KXTF9_REG_HP_YOUT_L 0x02
32#define KXTF9_REG_HP_YOUT_H 0x03
33#define KXTF9_REG_HP_ZOUT_L 0x04
34#define KXTF9_REG_HP_ZOUT_H 0x05
35
36#define KXCJK1013_REG_XOUT_L 0x06
37
38
39
40
41
42#define KXCJK1013_REG_XOUT_H 0x07
43#define KXCJK1013_REG_YOUT_L 0x08
44#define KXCJK1013_REG_YOUT_H 0x09
45#define KXCJK1013_REG_ZOUT_L 0x0A
46#define KXCJK1013_REG_ZOUT_H 0x0B
47
48#define KXCJK1013_REG_DCST_RESP 0x0C
49#define KXCJK1013_REG_WHO_AM_I 0x0F
50#define KXTF9_REG_TILT_POS_CUR 0x10
51#define KXTF9_REG_TILT_POS_PREV 0x11
52#define KXTF9_REG_INT_SRC1 0x15
53#define KXCJK1013_REG_INT_SRC1 0x16
54#define KXCJK1013_REG_INT_SRC2 0x17
55#define KXCJK1013_REG_STATUS_REG 0x18
56#define KXCJK1013_REG_INT_REL 0x1A
57#define KXCJK1013_REG_CTRL1 0x1B
58#define KXTF9_REG_CTRL2 0x1C
59#define KXCJK1013_REG_CTRL2 0x1D
60#define KXCJK1013_REG_INT_CTRL1 0x1E
61#define KXCJK1013_REG_INT_CTRL2 0x1F
62#define KXTF9_REG_INT_CTRL3 0x20
63#define KXCJK1013_REG_DATA_CTRL 0x21
64#define KXTF9_REG_TILT_TIMER 0x28
65#define KXCJK1013_REG_WAKE_TIMER 0x29
66#define KXTF9_REG_TDT_TIMER 0x2B
67#define KXTF9_REG_TDT_THRESH_H 0x2C
68#define KXTF9_REG_TDT_THRESH_L 0x2D
69#define KXTF9_REG_TDT_TAP_TIMER 0x2E
70#define KXTF9_REG_TDT_TOTAL_TIMER 0x2F
71#define KXTF9_REG_TDT_LATENCY_TIMER 0x30
72#define KXTF9_REG_TDT_WINDOW_TIMER 0x31
73#define KXCJK1013_REG_SELF_TEST 0x3A
74#define KXTF9_REG_WAKE_THRESH 0x5A
75#define KXTF9_REG_TILT_ANGLE 0x5C
76#define KXTF9_REG_HYST_SET 0x5F
77#define KXCJK1013_REG_WAKE_THRES 0x6A
78
79#define KXCJK1013_REG_CTRL1_BIT_PC1 BIT(7)
80#define KXCJK1013_REG_CTRL1_BIT_RES BIT(6)
81#define KXCJK1013_REG_CTRL1_BIT_DRDY BIT(5)
82#define KXCJK1013_REG_CTRL1_BIT_GSEL1 BIT(4)
83#define KXCJK1013_REG_CTRL1_BIT_GSEL0 BIT(3)
84#define KXCJK1013_REG_CTRL1_BIT_WUFE BIT(1)
85
86#define KXCJK1013_REG_INT_CTRL1_BIT_IEU BIT(2)
87#define KXCJK1013_REG_INT_CTRL1_BIT_IEL BIT(3)
88#define KXCJK1013_REG_INT_CTRL1_BIT_IEA BIT(4)
89#define KXCJK1013_REG_INT_CTRL1_BIT_IEN BIT(5)
90
91#define KXTF9_REG_TILT_BIT_LEFT_EDGE BIT(5)
92#define KXTF9_REG_TILT_BIT_RIGHT_EDGE BIT(4)
93#define KXTF9_REG_TILT_BIT_LOWER_EDGE BIT(3)
94#define KXTF9_REG_TILT_BIT_UPPER_EDGE BIT(2)
95#define KXTF9_REG_TILT_BIT_FACE_DOWN BIT(1)
96#define KXTF9_REG_TILT_BIT_FACE_UP BIT(0)
97
98#define KXCJK1013_DATA_MASK_12_BIT 0x0FFF
99#define KXCJK1013_MAX_STARTUP_TIME_US 100000
100
101#define KXCJK1013_SLEEP_DELAY_MS 2000
102
103#define KXCJK1013_REG_INT_SRC1_BIT_TPS BIT(0)
104#define KXCJK1013_REG_INT_SRC1_BIT_WUFS BIT(1)
105#define KXCJK1013_REG_INT_SRC1_MASK_TDTS (BIT(2) | BIT(3))
106#define KXCJK1013_REG_INT_SRC1_TAP_NONE 0
107#define KXCJK1013_REG_INT_SRC1_TAP_SINGLE BIT(2)
108#define KXCJK1013_REG_INT_SRC1_TAP_DOUBLE BIT(3)
109#define KXCJK1013_REG_INT_SRC1_BIT_DRDY BIT(4)
110
111
112#define KXCJK1013_REG_INT_SRC2_BIT_ZP BIT(0)
113#define KXCJK1013_REG_INT_SRC2_BIT_ZN BIT(1)
114#define KXCJK1013_REG_INT_SRC2_BIT_YP BIT(2)
115#define KXCJK1013_REG_INT_SRC2_BIT_YN BIT(3)
116#define KXCJK1013_REG_INT_SRC2_BIT_XP BIT(4)
117#define KXCJK1013_REG_INT_SRC2_BIT_XN BIT(5)
118
119#define KXCJK1013_DEFAULT_WAKE_THRES 1
120
121enum kx_chipset {
122 KXCJK1013,
123 KXCJ91008,
124 KXTJ21009,
125 KXTF9,
126 KX_MAX_CHIPS
127};
128
129enum kx_acpi_type {
130 ACPI_GENERIC,
131 ACPI_SMO8500,
132 ACPI_KIOX010A,
133};
134
135struct kxcjk1013_data {
136 struct i2c_client *client;
137 struct iio_trigger *dready_trig;
138 struct iio_trigger *motion_trig;
139 struct iio_mount_matrix orientation;
140 struct mutex mutex;
141 s16 buffer[8];
142 u8 odr_bits;
143 u8 range;
144 int wake_thres;
145 int wake_dur;
146 bool active_high_intr;
147 bool dready_trigger_on;
148 int ev_enable_state;
149 bool motion_trigger_on;
150 int64_t timestamp;
151 enum kx_chipset chipset;
152 enum kx_acpi_type acpi_type;
153};
154
155enum kxcjk1013_axis {
156 AXIS_X,
157 AXIS_Y,
158 AXIS_Z,
159 AXIS_MAX,
160};
161
162enum kxcjk1013_mode {
163 STANDBY,
164 OPERATION,
165};
166
167enum kxcjk1013_range {
168 KXCJK1013_RANGE_2G,
169 KXCJK1013_RANGE_4G,
170 KXCJK1013_RANGE_8G,
171};
172
173struct kx_odr_map {
174 int val;
175 int val2;
176 int odr_bits;
177 int wuf_bits;
178};
179
180static const struct kx_odr_map samp_freq_table[] = {
181 { 0, 781000, 0x08, 0x00 },
182 { 1, 563000, 0x09, 0x01 },
183 { 3, 125000, 0x0A, 0x02 },
184 { 6, 250000, 0x0B, 0x03 },
185 { 12, 500000, 0x00, 0x04 },
186 { 25, 0, 0x01, 0x05 },
187 { 50, 0, 0x02, 0x06 },
188 { 100, 0, 0x03, 0x06 },
189 { 200, 0, 0x04, 0x06 },
190 { 400, 0, 0x05, 0x06 },
191 { 800, 0, 0x06, 0x06 },
192 { 1600, 0, 0x07, 0x06 },
193};
194
195static const char *const kxcjk1013_samp_freq_avail =
196 "0.781000 1.563000 3.125000 6.250000 12.500000 25 50 100 200 400 800 1600";
197
198static const struct kx_odr_map kxtf9_samp_freq_table[] = {
199 { 25, 0, 0x01, 0x00 },
200 { 50, 0, 0x02, 0x01 },
201 { 100, 0, 0x03, 0x01 },
202 { 200, 0, 0x04, 0x01 },
203 { 400, 0, 0x05, 0x01 },
204 { 800, 0, 0x06, 0x01 },
205};
206
207static const char *const kxtf9_samp_freq_avail =
208 "25 50 100 200 400 800";
209
210
211static const struct {
212 int odr_bits;
213 int usec;
214} odr_start_up_times[KX_MAX_CHIPS][12] = {
215
216 {
217 {0x08, 100000},
218 {0x09, 100000},
219 {0x0A, 100000},
220 {0x0B, 100000},
221 {0, 80000},
222 {0x01, 41000},
223 {0x02, 21000},
224 {0x03, 11000},
225 {0x04, 6400},
226 {0x05, 3900},
227 {0x06, 2700},
228 {0x07, 2100},
229 },
230
231 {
232 {0x08, 100000},
233 {0x09, 100000},
234 {0x0A, 100000},
235 {0x0B, 100000},
236 {0, 80000},
237 {0x01, 41000},
238 {0x02, 21000},
239 {0x03, 11000},
240 {0x04, 6400},
241 {0x05, 3900},
242 {0x06, 2700},
243 {0x07, 2100},
244 },
245
246 {
247 {0x08, 1240000},
248 {0x09, 621000},
249 {0x0A, 309000},
250 {0x0B, 151000},
251 {0, 80000},
252 {0x01, 41000},
253 {0x02, 21000},
254 {0x03, 11000},
255 {0x04, 6000},
256 {0x05, 4000},
257 {0x06, 3000},
258 {0x07, 2000},
259 },
260
261 {
262 {0x01, 81000},
263 {0x02, 41000},
264 {0x03, 21000},
265 {0x04, 11000},
266 {0x05, 5100},
267 {0x06, 2700},
268 },
269};
270
271static const struct {
272 u16 scale;
273 u8 gsel_0;
274 u8 gsel_1;
275} KXCJK1013_scale_table[] = { {9582, 0, 0},
276 {19163, 1, 0},
277 {38326, 0, 1} };
278
279#ifdef CONFIG_ACPI
280enum kiox010a_fn_index {
281 KIOX010A_SET_LAPTOP_MODE = 1,
282 KIOX010A_SET_TABLET_MODE = 2,
283};
284
285static int kiox010a_dsm(struct device *dev, int fn_index)
286{
287 acpi_handle handle = ACPI_HANDLE(dev);
288 guid_t kiox010a_dsm_guid;
289 union acpi_object *obj;
290
291 if (!handle)
292 return -ENODEV;
293
294 guid_parse("1f339696-d475-4e26-8cad-2e9f8e6d7a91", &kiox010a_dsm_guid);
295
296 obj = acpi_evaluate_dsm(handle, &kiox010a_dsm_guid, 1, fn_index, NULL);
297 if (!obj)
298 return -EIO;
299
300 ACPI_FREE(obj);
301 return 0;
302}
303#endif
304
305static int kxcjk1013_set_mode(struct kxcjk1013_data *data,
306 enum kxcjk1013_mode mode)
307{
308 int ret;
309
310 ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_CTRL1);
311 if (ret < 0) {
312 dev_err(&data->client->dev, "Error reading reg_ctrl1\n");
313 return ret;
314 }
315
316 if (mode == STANDBY)
317 ret &= ~KXCJK1013_REG_CTRL1_BIT_PC1;
318 else
319 ret |= KXCJK1013_REG_CTRL1_BIT_PC1;
320
321 ret = i2c_smbus_write_byte_data(data->client,
322 KXCJK1013_REG_CTRL1, ret);
323 if (ret < 0) {
324 dev_err(&data->client->dev, "Error writing reg_ctrl1\n");
325 return ret;
326 }
327
328 return 0;
329}
330
331static int kxcjk1013_get_mode(struct kxcjk1013_data *data,
332 enum kxcjk1013_mode *mode)
333{
334 int ret;
335
336 ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_CTRL1);
337 if (ret < 0) {
338 dev_err(&data->client->dev, "Error reading reg_ctrl1\n");
339 return ret;
340 }
341
342 if (ret & KXCJK1013_REG_CTRL1_BIT_PC1)
343 *mode = OPERATION;
344 else
345 *mode = STANDBY;
346
347 return 0;
348}
349
350static int kxcjk1013_set_range(struct kxcjk1013_data *data, int range_index)
351{
352 int ret;
353
354 ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_CTRL1);
355 if (ret < 0) {
356 dev_err(&data->client->dev, "Error reading reg_ctrl1\n");
357 return ret;
358 }
359
360 ret &= ~(KXCJK1013_REG_CTRL1_BIT_GSEL0 |
361 KXCJK1013_REG_CTRL1_BIT_GSEL1);
362 ret |= (KXCJK1013_scale_table[range_index].gsel_0 << 3);
363 ret |= (KXCJK1013_scale_table[range_index].gsel_1 << 4);
364
365 ret = i2c_smbus_write_byte_data(data->client,
366 KXCJK1013_REG_CTRL1,
367 ret);
368 if (ret < 0) {
369 dev_err(&data->client->dev, "Error writing reg_ctrl1\n");
370 return ret;
371 }
372
373 data->range = range_index;
374
375 return 0;
376}
377
378static int kxcjk1013_chip_init(struct kxcjk1013_data *data)
379{
380 int ret;
381
382#ifdef CONFIG_ACPI
383 if (data->acpi_type == ACPI_KIOX010A) {
384
385 kiox010a_dsm(&data->client->dev, KIOX010A_SET_LAPTOP_MODE);
386 }
387#endif
388
389 ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_WHO_AM_I);
390 if (ret < 0) {
391 dev_err(&data->client->dev, "Error reading who_am_i\n");
392 return ret;
393 }
394
395 dev_dbg(&data->client->dev, "KXCJK1013 Chip Id %x\n", ret);
396
397 ret = kxcjk1013_set_mode(data, STANDBY);
398 if (ret < 0)
399 return ret;
400
401 ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_CTRL1);
402 if (ret < 0) {
403 dev_err(&data->client->dev, "Error reading reg_ctrl1\n");
404 return ret;
405 }
406
407
408 ret |= KXCJK1013_REG_CTRL1_BIT_RES;
409
410 ret = i2c_smbus_write_byte_data(data->client, KXCJK1013_REG_CTRL1,
411 ret);
412 if (ret < 0) {
413 dev_err(&data->client->dev, "Error reading reg_ctrl\n");
414 return ret;
415 }
416
417
418 ret = kxcjk1013_set_range(data, KXCJK1013_RANGE_4G);
419 if (ret < 0)
420 return ret;
421
422 ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_DATA_CTRL);
423 if (ret < 0) {
424 dev_err(&data->client->dev, "Error reading reg_data_ctrl\n");
425 return ret;
426 }
427
428 data->odr_bits = ret;
429
430
431 ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_INT_CTRL1);
432 if (ret < 0) {
433 dev_err(&data->client->dev, "Error reading reg_int_ctrl1\n");
434 return ret;
435 }
436
437 if (data->active_high_intr)
438 ret |= KXCJK1013_REG_INT_CTRL1_BIT_IEA;
439 else
440 ret &= ~KXCJK1013_REG_INT_CTRL1_BIT_IEA;
441
442 ret = i2c_smbus_write_byte_data(data->client, KXCJK1013_REG_INT_CTRL1,
443 ret);
444 if (ret < 0) {
445 dev_err(&data->client->dev, "Error writing reg_int_ctrl1\n");
446 return ret;
447 }
448
449 ret = kxcjk1013_set_mode(data, OPERATION);
450 if (ret < 0)
451 return ret;
452
453 data->wake_thres = KXCJK1013_DEFAULT_WAKE_THRES;
454
455 return 0;
456}
457
458#ifdef CONFIG_PM
459static int kxcjk1013_get_startup_times(struct kxcjk1013_data *data)
460{
461 int i;
462 int idx = data->chipset;
463
464 for (i = 0; i < ARRAY_SIZE(odr_start_up_times[idx]); ++i) {
465 if (odr_start_up_times[idx][i].odr_bits == data->odr_bits)
466 return odr_start_up_times[idx][i].usec;
467 }
468
469 return KXCJK1013_MAX_STARTUP_TIME_US;
470}
471#endif
472
473static int kxcjk1013_set_power_state(struct kxcjk1013_data *data, bool on)
474{
475#ifdef CONFIG_PM
476 int ret;
477
478 if (on)
479 ret = pm_runtime_get_sync(&data->client->dev);
480 else {
481 pm_runtime_mark_last_busy(&data->client->dev);
482 ret = pm_runtime_put_autosuspend(&data->client->dev);
483 }
484 if (ret < 0) {
485 dev_err(&data->client->dev,
486 "Failed: %s for %d\n", __func__, on);
487 if (on)
488 pm_runtime_put_noidle(&data->client->dev);
489 return ret;
490 }
491#endif
492
493 return 0;
494}
495
496static int kxcjk1013_chip_update_thresholds(struct kxcjk1013_data *data)
497{
498 int waketh_reg, ret;
499
500 ret = i2c_smbus_write_byte_data(data->client,
501 KXCJK1013_REG_WAKE_TIMER,
502 data->wake_dur);
503 if (ret < 0) {
504 dev_err(&data->client->dev,
505 "Error writing reg_wake_timer\n");
506 return ret;
507 }
508
509 waketh_reg = data->chipset == KXTF9 ?
510 KXTF9_REG_WAKE_THRESH : KXCJK1013_REG_WAKE_THRES;
511 ret = i2c_smbus_write_byte_data(data->client, waketh_reg,
512 data->wake_thres);
513 if (ret < 0) {
514 dev_err(&data->client->dev, "Error writing reg_wake_thres\n");
515 return ret;
516 }
517
518 return 0;
519}
520
521static int kxcjk1013_setup_any_motion_interrupt(struct kxcjk1013_data *data,
522 bool status)
523{
524 int ret;
525 enum kxcjk1013_mode store_mode;
526
527 ret = kxcjk1013_get_mode(data, &store_mode);
528 if (ret < 0)
529 return ret;
530
531
532 ret = kxcjk1013_set_mode(data, STANDBY);
533 if (ret < 0)
534 return ret;
535
536 ret = kxcjk1013_chip_update_thresholds(data);
537 if (ret < 0)
538 return ret;
539
540 ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_INT_CTRL1);
541 if (ret < 0) {
542 dev_err(&data->client->dev, "Error reading reg_int_ctrl1\n");
543 return ret;
544 }
545
546 if (status)
547 ret |= KXCJK1013_REG_INT_CTRL1_BIT_IEN;
548 else
549 ret &= ~KXCJK1013_REG_INT_CTRL1_BIT_IEN;
550
551 ret = i2c_smbus_write_byte_data(data->client, KXCJK1013_REG_INT_CTRL1,
552 ret);
553 if (ret < 0) {
554 dev_err(&data->client->dev, "Error writing reg_int_ctrl1\n");
555 return ret;
556 }
557
558 ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_CTRL1);
559 if (ret < 0) {
560 dev_err(&data->client->dev, "Error reading reg_ctrl1\n");
561 return ret;
562 }
563
564 if (status)
565 ret |= KXCJK1013_REG_CTRL1_BIT_WUFE;
566 else
567 ret &= ~KXCJK1013_REG_CTRL1_BIT_WUFE;
568
569 ret = i2c_smbus_write_byte_data(data->client,
570 KXCJK1013_REG_CTRL1, ret);
571 if (ret < 0) {
572 dev_err(&data->client->dev, "Error writing reg_ctrl1\n");
573 return ret;
574 }
575
576 if (store_mode == OPERATION) {
577 ret = kxcjk1013_set_mode(data, OPERATION);
578 if (ret < 0)
579 return ret;
580 }
581
582 return 0;
583}
584
585static int kxcjk1013_setup_new_data_interrupt(struct kxcjk1013_data *data,
586 bool status)
587{
588 int ret;
589 enum kxcjk1013_mode store_mode;
590
591 ret = kxcjk1013_get_mode(data, &store_mode);
592 if (ret < 0)
593 return ret;
594
595
596 ret = kxcjk1013_set_mode(data, STANDBY);
597 if (ret < 0)
598 return ret;
599
600 ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_INT_CTRL1);
601 if (ret < 0) {
602 dev_err(&data->client->dev, "Error reading reg_int_ctrl1\n");
603 return ret;
604 }
605
606 if (status)
607 ret |= KXCJK1013_REG_INT_CTRL1_BIT_IEN;
608 else
609 ret &= ~KXCJK1013_REG_INT_CTRL1_BIT_IEN;
610
611 ret = i2c_smbus_write_byte_data(data->client, KXCJK1013_REG_INT_CTRL1,
612 ret);
613 if (ret < 0) {
614 dev_err(&data->client->dev, "Error writing reg_int_ctrl1\n");
615 return ret;
616 }
617
618 ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_CTRL1);
619 if (ret < 0) {
620 dev_err(&data->client->dev, "Error reading reg_ctrl1\n");
621 return ret;
622 }
623
624 if (status)
625 ret |= KXCJK1013_REG_CTRL1_BIT_DRDY;
626 else
627 ret &= ~KXCJK1013_REG_CTRL1_BIT_DRDY;
628
629 ret = i2c_smbus_write_byte_data(data->client,
630 KXCJK1013_REG_CTRL1, ret);
631 if (ret < 0) {
632 dev_err(&data->client->dev, "Error writing reg_ctrl1\n");
633 return ret;
634 }
635
636 if (store_mode == OPERATION) {
637 ret = kxcjk1013_set_mode(data, OPERATION);
638 if (ret < 0)
639 return ret;
640 }
641
642 return 0;
643}
644
645static const struct kx_odr_map *kxcjk1013_find_odr_value(
646 const struct kx_odr_map *map, size_t map_size, int val, int val2)
647{
648 int i;
649
650 for (i = 0; i < map_size; ++i) {
651 if (map[i].val == val && map[i].val2 == val2)
652 return &map[i];
653 }
654
655 return ERR_PTR(-EINVAL);
656}
657
658static int kxcjk1013_convert_odr_value(const struct kx_odr_map *map,
659 size_t map_size, int odr_bits,
660 int *val, int *val2)
661{
662 int i;
663
664 for (i = 0; i < map_size; ++i) {
665 if (map[i].odr_bits == odr_bits) {
666 *val = map[i].val;
667 *val2 = map[i].val2;
668 return IIO_VAL_INT_PLUS_MICRO;
669 }
670 }
671
672 return -EINVAL;
673}
674
675static int kxcjk1013_set_odr(struct kxcjk1013_data *data, int val, int val2)
676{
677 int ret;
678 enum kxcjk1013_mode store_mode;
679 const struct kx_odr_map *odr_setting;
680
681 ret = kxcjk1013_get_mode(data, &store_mode);
682 if (ret < 0)
683 return ret;
684
685 if (data->chipset == KXTF9)
686 odr_setting = kxcjk1013_find_odr_value(kxtf9_samp_freq_table,
687 ARRAY_SIZE(kxtf9_samp_freq_table),
688 val, val2);
689 else
690 odr_setting = kxcjk1013_find_odr_value(samp_freq_table,
691 ARRAY_SIZE(samp_freq_table),
692 val, val2);
693
694 if (IS_ERR(odr_setting))
695 return PTR_ERR(odr_setting);
696
697
698 ret = kxcjk1013_set_mode(data, STANDBY);
699 if (ret < 0)
700 return ret;
701
702 ret = i2c_smbus_write_byte_data(data->client, KXCJK1013_REG_DATA_CTRL,
703 odr_setting->odr_bits);
704 if (ret < 0) {
705 dev_err(&data->client->dev, "Error writing data_ctrl\n");
706 return ret;
707 }
708
709 data->odr_bits = odr_setting->odr_bits;
710
711 ret = i2c_smbus_write_byte_data(data->client, KXCJK1013_REG_CTRL2,
712 odr_setting->wuf_bits);
713 if (ret < 0) {
714 dev_err(&data->client->dev, "Error writing reg_ctrl2\n");
715 return ret;
716 }
717
718 if (store_mode == OPERATION) {
719 ret = kxcjk1013_set_mode(data, OPERATION);
720 if (ret < 0)
721 return ret;
722 }
723
724 return 0;
725}
726
727static int kxcjk1013_get_odr(struct kxcjk1013_data *data, int *val, int *val2)
728{
729 if (data->chipset == KXTF9)
730 return kxcjk1013_convert_odr_value(kxtf9_samp_freq_table,
731 ARRAY_SIZE(kxtf9_samp_freq_table),
732 data->odr_bits, val, val2);
733 else
734 return kxcjk1013_convert_odr_value(samp_freq_table,
735 ARRAY_SIZE(samp_freq_table),
736 data->odr_bits, val, val2);
737}
738
739static int kxcjk1013_get_acc_reg(struct kxcjk1013_data *data, int axis)
740{
741 u8 reg = KXCJK1013_REG_XOUT_L + axis * 2;
742 int ret;
743
744 ret = i2c_smbus_read_word_data(data->client, reg);
745 if (ret < 0) {
746 dev_err(&data->client->dev,
747 "failed to read accel_%c registers\n", 'x' + axis);
748 return ret;
749 }
750
751 return ret;
752}
753
754static int kxcjk1013_set_scale(struct kxcjk1013_data *data, int val)
755{
756 int ret, i;
757 enum kxcjk1013_mode store_mode;
758
759 for (i = 0; i < ARRAY_SIZE(KXCJK1013_scale_table); ++i) {
760 if (KXCJK1013_scale_table[i].scale == val) {
761 ret = kxcjk1013_get_mode(data, &store_mode);
762 if (ret < 0)
763 return ret;
764
765 ret = kxcjk1013_set_mode(data, STANDBY);
766 if (ret < 0)
767 return ret;
768
769 ret = kxcjk1013_set_range(data, i);
770 if (ret < 0)
771 return ret;
772
773 if (store_mode == OPERATION) {
774 ret = kxcjk1013_set_mode(data, OPERATION);
775 if (ret)
776 return ret;
777 }
778
779 return 0;
780 }
781 }
782
783 return -EINVAL;
784}
785
786static int kxcjk1013_read_raw(struct iio_dev *indio_dev,
787 struct iio_chan_spec const *chan, int *val,
788 int *val2, long mask)
789{
790 struct kxcjk1013_data *data = iio_priv(indio_dev);
791 int ret;
792
793 switch (mask) {
794 case IIO_CHAN_INFO_RAW:
795 mutex_lock(&data->mutex);
796 if (iio_buffer_enabled(indio_dev))
797 ret = -EBUSY;
798 else {
799 ret = kxcjk1013_set_power_state(data, true);
800 if (ret < 0) {
801 mutex_unlock(&data->mutex);
802 return ret;
803 }
804 ret = kxcjk1013_get_acc_reg(data, chan->scan_index);
805 if (ret < 0) {
806 kxcjk1013_set_power_state(data, false);
807 mutex_unlock(&data->mutex);
808 return ret;
809 }
810 *val = sign_extend32(ret >> 4, 11);
811 ret = kxcjk1013_set_power_state(data, false);
812 }
813 mutex_unlock(&data->mutex);
814
815 if (ret < 0)
816 return ret;
817
818 return IIO_VAL_INT;
819
820 case IIO_CHAN_INFO_SCALE:
821 *val = 0;
822 *val2 = KXCJK1013_scale_table[data->range].scale;
823 return IIO_VAL_INT_PLUS_MICRO;
824
825 case IIO_CHAN_INFO_SAMP_FREQ:
826 mutex_lock(&data->mutex);
827 ret = kxcjk1013_get_odr(data, val, val2);
828 mutex_unlock(&data->mutex);
829 return ret;
830
831 default:
832 return -EINVAL;
833 }
834}
835
836static int kxcjk1013_write_raw(struct iio_dev *indio_dev,
837 struct iio_chan_spec const *chan, int val,
838 int val2, long mask)
839{
840 struct kxcjk1013_data *data = iio_priv(indio_dev);
841 int ret;
842
843 switch (mask) {
844 case IIO_CHAN_INFO_SAMP_FREQ:
845 mutex_lock(&data->mutex);
846 ret = kxcjk1013_set_odr(data, val, val2);
847 mutex_unlock(&data->mutex);
848 break;
849 case IIO_CHAN_INFO_SCALE:
850 if (val)
851 return -EINVAL;
852
853 mutex_lock(&data->mutex);
854 ret = kxcjk1013_set_scale(data, val2);
855 mutex_unlock(&data->mutex);
856 break;
857 default:
858 ret = -EINVAL;
859 }
860
861 return ret;
862}
863
864static int kxcjk1013_read_event(struct iio_dev *indio_dev,
865 const struct iio_chan_spec *chan,
866 enum iio_event_type type,
867 enum iio_event_direction dir,
868 enum iio_event_info info,
869 int *val, int *val2)
870{
871 struct kxcjk1013_data *data = iio_priv(indio_dev);
872
873 *val2 = 0;
874 switch (info) {
875 case IIO_EV_INFO_VALUE:
876 *val = data->wake_thres;
877 break;
878 case IIO_EV_INFO_PERIOD:
879 *val = data->wake_dur;
880 break;
881 default:
882 return -EINVAL;
883 }
884
885 return IIO_VAL_INT;
886}
887
888static int kxcjk1013_write_event(struct iio_dev *indio_dev,
889 const struct iio_chan_spec *chan,
890 enum iio_event_type type,
891 enum iio_event_direction dir,
892 enum iio_event_info info,
893 int val, int val2)
894{
895 struct kxcjk1013_data *data = iio_priv(indio_dev);
896
897 if (data->ev_enable_state)
898 return -EBUSY;
899
900 switch (info) {
901 case IIO_EV_INFO_VALUE:
902 data->wake_thres = val;
903 break;
904 case IIO_EV_INFO_PERIOD:
905 data->wake_dur = val;
906 break;
907 default:
908 return -EINVAL;
909 }
910
911 return 0;
912}
913
914static int kxcjk1013_read_event_config(struct iio_dev *indio_dev,
915 const struct iio_chan_spec *chan,
916 enum iio_event_type type,
917 enum iio_event_direction dir)
918{
919 struct kxcjk1013_data *data = iio_priv(indio_dev);
920
921 return data->ev_enable_state;
922}
923
924static int kxcjk1013_write_event_config(struct iio_dev *indio_dev,
925 const struct iio_chan_spec *chan,
926 enum iio_event_type type,
927 enum iio_event_direction dir,
928 int state)
929{
930 struct kxcjk1013_data *data = iio_priv(indio_dev);
931 int ret;
932
933 if (state && data->ev_enable_state)
934 return 0;
935
936 mutex_lock(&data->mutex);
937
938 if (!state && data->motion_trigger_on) {
939 data->ev_enable_state = 0;
940 mutex_unlock(&data->mutex);
941 return 0;
942 }
943
944
945
946
947
948
949
950
951
952
953 ret = kxcjk1013_set_power_state(data, state);
954 if (ret < 0) {
955 mutex_unlock(&data->mutex);
956 return ret;
957 }
958
959 ret = kxcjk1013_setup_any_motion_interrupt(data, state);
960 if (ret < 0) {
961 kxcjk1013_set_power_state(data, false);
962 data->ev_enable_state = 0;
963 mutex_unlock(&data->mutex);
964 return ret;
965 }
966
967 data->ev_enable_state = state;
968 mutex_unlock(&data->mutex);
969
970 return 0;
971}
972
973static int kxcjk1013_buffer_preenable(struct iio_dev *indio_dev)
974{
975 struct kxcjk1013_data *data = iio_priv(indio_dev);
976
977 return kxcjk1013_set_power_state(data, true);
978}
979
980static int kxcjk1013_buffer_postdisable(struct iio_dev *indio_dev)
981{
982 struct kxcjk1013_data *data = iio_priv(indio_dev);
983
984 return kxcjk1013_set_power_state(data, false);
985}
986
987static ssize_t kxcjk1013_get_samp_freq_avail(struct device *dev,
988 struct device_attribute *attr,
989 char *buf)
990{
991 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
992 struct kxcjk1013_data *data = iio_priv(indio_dev);
993 const char *str;
994
995 if (data->chipset == KXTF9)
996 str = kxtf9_samp_freq_avail;
997 else
998 str = kxcjk1013_samp_freq_avail;
999
1000 return sprintf(buf, "%s\n", str);
1001}
1002
1003static IIO_DEVICE_ATTR(in_accel_sampling_frequency_available, S_IRUGO,
1004 kxcjk1013_get_samp_freq_avail, NULL, 0);
1005
1006static IIO_CONST_ATTR(in_accel_scale_available, "0.009582 0.019163 0.038326");
1007
1008static struct attribute *kxcjk1013_attributes[] = {
1009 &iio_dev_attr_in_accel_sampling_frequency_available.dev_attr.attr,
1010 &iio_const_attr_in_accel_scale_available.dev_attr.attr,
1011 NULL,
1012};
1013
1014static const struct attribute_group kxcjk1013_attrs_group = {
1015 .attrs = kxcjk1013_attributes,
1016};
1017
1018static const struct iio_event_spec kxcjk1013_event = {
1019 .type = IIO_EV_TYPE_THRESH,
1020 .dir = IIO_EV_DIR_EITHER,
1021 .mask_separate = BIT(IIO_EV_INFO_VALUE) |
1022 BIT(IIO_EV_INFO_ENABLE) |
1023 BIT(IIO_EV_INFO_PERIOD)
1024};
1025
1026static const struct iio_mount_matrix *
1027kxcjk1013_get_mount_matrix(const struct iio_dev *indio_dev,
1028 const struct iio_chan_spec *chan)
1029{
1030 struct kxcjk1013_data *data = iio_priv(indio_dev);
1031
1032 return &data->orientation;
1033}
1034
1035static const struct iio_chan_spec_ext_info kxcjk1013_ext_info[] = {
1036 IIO_MOUNT_MATRIX(IIO_SHARED_BY_TYPE, kxcjk1013_get_mount_matrix),
1037 { }
1038};
1039
1040#define KXCJK1013_CHANNEL(_axis) { \
1041 .type = IIO_ACCEL, \
1042 .modified = 1, \
1043 .channel2 = IIO_MOD_##_axis, \
1044 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
1045 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
1046 BIT(IIO_CHAN_INFO_SAMP_FREQ), \
1047 .scan_index = AXIS_##_axis, \
1048 .scan_type = { \
1049 .sign = 's', \
1050 .realbits = 12, \
1051 .storagebits = 16, \
1052 .shift = 4, \
1053 .endianness = IIO_LE, \
1054 }, \
1055 .event_spec = &kxcjk1013_event, \
1056 .ext_info = kxcjk1013_ext_info, \
1057 .num_event_specs = 1 \
1058}
1059
1060static const struct iio_chan_spec kxcjk1013_channels[] = {
1061 KXCJK1013_CHANNEL(X),
1062 KXCJK1013_CHANNEL(Y),
1063 KXCJK1013_CHANNEL(Z),
1064 IIO_CHAN_SOFT_TIMESTAMP(3),
1065};
1066
1067static const struct iio_buffer_setup_ops kxcjk1013_buffer_setup_ops = {
1068 .preenable = kxcjk1013_buffer_preenable,
1069 .postdisable = kxcjk1013_buffer_postdisable,
1070};
1071
1072static const struct iio_info kxcjk1013_info = {
1073 .attrs = &kxcjk1013_attrs_group,
1074 .read_raw = kxcjk1013_read_raw,
1075 .write_raw = kxcjk1013_write_raw,
1076 .read_event_value = kxcjk1013_read_event,
1077 .write_event_value = kxcjk1013_write_event,
1078 .write_event_config = kxcjk1013_write_event_config,
1079 .read_event_config = kxcjk1013_read_event_config,
1080};
1081
1082static const unsigned long kxcjk1013_scan_masks[] = {0x7, 0};
1083
1084static irqreturn_t kxcjk1013_trigger_handler(int irq, void *p)
1085{
1086 struct iio_poll_func *pf = p;
1087 struct iio_dev *indio_dev = pf->indio_dev;
1088 struct kxcjk1013_data *data = iio_priv(indio_dev);
1089 int ret;
1090
1091 mutex_lock(&data->mutex);
1092 ret = i2c_smbus_read_i2c_block_data_or_emulated(data->client,
1093 KXCJK1013_REG_XOUT_L,
1094 AXIS_MAX * 2,
1095 (u8 *)data->buffer);
1096 mutex_unlock(&data->mutex);
1097 if (ret < 0)
1098 goto err;
1099
1100 iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,
1101 data->timestamp);
1102err:
1103 iio_trigger_notify_done(indio_dev->trig);
1104
1105 return IRQ_HANDLED;
1106}
1107
1108static int kxcjk1013_trig_try_reen(struct iio_trigger *trig)
1109{
1110 struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
1111 struct kxcjk1013_data *data = iio_priv(indio_dev);
1112 int ret;
1113
1114 ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_INT_REL);
1115 if (ret < 0) {
1116 dev_err(&data->client->dev, "Error reading reg_int_rel\n");
1117 return ret;
1118 }
1119
1120 return 0;
1121}
1122
1123static int kxcjk1013_data_rdy_trigger_set_state(struct iio_trigger *trig,
1124 bool state)
1125{
1126 struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
1127 struct kxcjk1013_data *data = iio_priv(indio_dev);
1128 int ret;
1129
1130 mutex_lock(&data->mutex);
1131
1132 if (!state && data->ev_enable_state && data->motion_trigger_on) {
1133 data->motion_trigger_on = false;
1134 mutex_unlock(&data->mutex);
1135 return 0;
1136 }
1137
1138 ret = kxcjk1013_set_power_state(data, state);
1139 if (ret < 0) {
1140 mutex_unlock(&data->mutex);
1141 return ret;
1142 }
1143 if (data->motion_trig == trig)
1144 ret = kxcjk1013_setup_any_motion_interrupt(data, state);
1145 else
1146 ret = kxcjk1013_setup_new_data_interrupt(data, state);
1147 if (ret < 0) {
1148 kxcjk1013_set_power_state(data, false);
1149 mutex_unlock(&data->mutex);
1150 return ret;
1151 }
1152 if (data->motion_trig == trig)
1153 data->motion_trigger_on = state;
1154 else
1155 data->dready_trigger_on = state;
1156
1157 mutex_unlock(&data->mutex);
1158
1159 return 0;
1160}
1161
1162static const struct iio_trigger_ops kxcjk1013_trigger_ops = {
1163 .set_trigger_state = kxcjk1013_data_rdy_trigger_set_state,
1164 .try_reenable = kxcjk1013_trig_try_reen,
1165};
1166
1167static void kxcjk1013_report_motion_event(struct iio_dev *indio_dev)
1168{
1169 struct kxcjk1013_data *data = iio_priv(indio_dev);
1170
1171 int ret = i2c_smbus_read_byte_data(data->client,
1172 KXCJK1013_REG_INT_SRC2);
1173 if (ret < 0) {
1174 dev_err(&data->client->dev, "Error reading reg_int_src2\n");
1175 return;
1176 }
1177
1178 if (ret & KXCJK1013_REG_INT_SRC2_BIT_XN)
1179 iio_push_event(indio_dev,
1180 IIO_MOD_EVENT_CODE(IIO_ACCEL,
1181 0,
1182 IIO_MOD_X,
1183 IIO_EV_TYPE_THRESH,
1184 IIO_EV_DIR_FALLING),
1185 data->timestamp);
1186
1187 if (ret & KXCJK1013_REG_INT_SRC2_BIT_XP)
1188 iio_push_event(indio_dev,
1189 IIO_MOD_EVENT_CODE(IIO_ACCEL,
1190 0,
1191 IIO_MOD_X,
1192 IIO_EV_TYPE_THRESH,
1193 IIO_EV_DIR_RISING),
1194 data->timestamp);
1195
1196 if (ret & KXCJK1013_REG_INT_SRC2_BIT_YN)
1197 iio_push_event(indio_dev,
1198 IIO_MOD_EVENT_CODE(IIO_ACCEL,
1199 0,
1200 IIO_MOD_Y,
1201 IIO_EV_TYPE_THRESH,
1202 IIO_EV_DIR_FALLING),
1203 data->timestamp);
1204
1205 if (ret & KXCJK1013_REG_INT_SRC2_BIT_YP)
1206 iio_push_event(indio_dev,
1207 IIO_MOD_EVENT_CODE(IIO_ACCEL,
1208 0,
1209 IIO_MOD_Y,
1210 IIO_EV_TYPE_THRESH,
1211 IIO_EV_DIR_RISING),
1212 data->timestamp);
1213
1214 if (ret & KXCJK1013_REG_INT_SRC2_BIT_ZN)
1215 iio_push_event(indio_dev,
1216 IIO_MOD_EVENT_CODE(IIO_ACCEL,
1217 0,
1218 IIO_MOD_Z,
1219 IIO_EV_TYPE_THRESH,
1220 IIO_EV_DIR_FALLING),
1221 data->timestamp);
1222
1223 if (ret & KXCJK1013_REG_INT_SRC2_BIT_ZP)
1224 iio_push_event(indio_dev,
1225 IIO_MOD_EVENT_CODE(IIO_ACCEL,
1226 0,
1227 IIO_MOD_Z,
1228 IIO_EV_TYPE_THRESH,
1229 IIO_EV_DIR_RISING),
1230 data->timestamp);
1231}
1232
1233static irqreturn_t kxcjk1013_event_handler(int irq, void *private)
1234{
1235 struct iio_dev *indio_dev = private;
1236 struct kxcjk1013_data *data = iio_priv(indio_dev);
1237 int ret;
1238
1239 ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_INT_SRC1);
1240 if (ret < 0) {
1241 dev_err(&data->client->dev, "Error reading reg_int_src1\n");
1242 goto ack_intr;
1243 }
1244
1245 if (ret & KXCJK1013_REG_INT_SRC1_BIT_WUFS) {
1246 if (data->chipset == KXTF9)
1247 iio_push_event(indio_dev,
1248 IIO_MOD_EVENT_CODE(IIO_ACCEL,
1249 0,
1250 IIO_MOD_X_AND_Y_AND_Z,
1251 IIO_EV_TYPE_THRESH,
1252 IIO_EV_DIR_RISING),
1253 data->timestamp);
1254 else
1255 kxcjk1013_report_motion_event(indio_dev);
1256 }
1257
1258ack_intr:
1259 if (data->dready_trigger_on)
1260 return IRQ_HANDLED;
1261
1262 ret = i2c_smbus_read_byte_data(data->client, KXCJK1013_REG_INT_REL);
1263 if (ret < 0)
1264 dev_err(&data->client->dev, "Error reading reg_int_rel\n");
1265
1266 return IRQ_HANDLED;
1267}
1268
1269static irqreturn_t kxcjk1013_data_rdy_trig_poll(int irq, void *private)
1270{
1271 struct iio_dev *indio_dev = private;
1272 struct kxcjk1013_data *data = iio_priv(indio_dev);
1273
1274 data->timestamp = iio_get_time_ns(indio_dev);
1275
1276 if (data->dready_trigger_on)
1277 iio_trigger_poll(data->dready_trig);
1278 else if (data->motion_trigger_on)
1279 iio_trigger_poll(data->motion_trig);
1280
1281 if (data->ev_enable_state)
1282 return IRQ_WAKE_THREAD;
1283 else
1284 return IRQ_HANDLED;
1285}
1286
1287static const char *kxcjk1013_match_acpi_device(struct device *dev,
1288 enum kx_chipset *chipset,
1289 enum kx_acpi_type *acpi_type)
1290{
1291 const struct acpi_device_id *id;
1292
1293 id = acpi_match_device(dev->driver->acpi_match_table, dev);
1294 if (!id)
1295 return NULL;
1296
1297 if (strcmp(id->id, "SMO8500") == 0)
1298 *acpi_type = ACPI_SMO8500;
1299 else if (strcmp(id->id, "KIOX010A") == 0)
1300 *acpi_type = ACPI_KIOX010A;
1301
1302 *chipset = (enum kx_chipset)id->driver_data;
1303
1304 return dev_name(dev);
1305}
1306
1307static int kxcjk1013_probe(struct i2c_client *client,
1308 const struct i2c_device_id *id)
1309{
1310 struct kxcjk1013_data *data;
1311 struct iio_dev *indio_dev;
1312 struct kxcjk_1013_platform_data *pdata;
1313 const char *name;
1314 int ret;
1315
1316 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
1317 if (!indio_dev)
1318 return -ENOMEM;
1319
1320 data = iio_priv(indio_dev);
1321 i2c_set_clientdata(client, indio_dev);
1322 data->client = client;
1323
1324 pdata = dev_get_platdata(&client->dev);
1325 if (pdata) {
1326 data->active_high_intr = pdata->active_high_intr;
1327 data->orientation = pdata->orientation;
1328 } else {
1329 data->active_high_intr = true;
1330
1331 ret = iio_read_mount_matrix(&client->dev, "mount-matrix",
1332 &data->orientation);
1333 if (ret)
1334 return ret;
1335 }
1336
1337 if (id) {
1338 data->chipset = (enum kx_chipset)(id->driver_data);
1339 name = id->name;
1340 } else if (ACPI_HANDLE(&client->dev)) {
1341 name = kxcjk1013_match_acpi_device(&client->dev,
1342 &data->chipset,
1343 &data->acpi_type);
1344 } else
1345 return -ENODEV;
1346
1347 ret = kxcjk1013_chip_init(data);
1348 if (ret < 0)
1349 return ret;
1350
1351 mutex_init(&data->mutex);
1352
1353 indio_dev->channels = kxcjk1013_channels;
1354 indio_dev->num_channels = ARRAY_SIZE(kxcjk1013_channels);
1355 indio_dev->available_scan_masks = kxcjk1013_scan_masks;
1356 indio_dev->name = name;
1357 indio_dev->modes = INDIO_DIRECT_MODE;
1358 indio_dev->info = &kxcjk1013_info;
1359
1360 if (client->irq > 0 && data->acpi_type != ACPI_SMO8500) {
1361 ret = devm_request_threaded_irq(&client->dev, client->irq,
1362 kxcjk1013_data_rdy_trig_poll,
1363 kxcjk1013_event_handler,
1364 IRQF_TRIGGER_RISING,
1365 KXCJK1013_IRQ_NAME,
1366 indio_dev);
1367 if (ret)
1368 goto err_poweroff;
1369
1370 data->dready_trig = devm_iio_trigger_alloc(&client->dev,
1371 "%s-dev%d",
1372 indio_dev->name,
1373 indio_dev->id);
1374 if (!data->dready_trig) {
1375 ret = -ENOMEM;
1376 goto err_poweroff;
1377 }
1378
1379 data->motion_trig = devm_iio_trigger_alloc(&client->dev,
1380 "%s-any-motion-dev%d",
1381 indio_dev->name,
1382 indio_dev->id);
1383 if (!data->motion_trig) {
1384 ret = -ENOMEM;
1385 goto err_poweroff;
1386 }
1387
1388 data->dready_trig->dev.parent = &client->dev;
1389 data->dready_trig->ops = &kxcjk1013_trigger_ops;
1390 iio_trigger_set_drvdata(data->dready_trig, indio_dev);
1391 indio_dev->trig = data->dready_trig;
1392 iio_trigger_get(indio_dev->trig);
1393 ret = iio_trigger_register(data->dready_trig);
1394 if (ret)
1395 goto err_poweroff;
1396
1397 data->motion_trig->dev.parent = &client->dev;
1398 data->motion_trig->ops = &kxcjk1013_trigger_ops;
1399 iio_trigger_set_drvdata(data->motion_trig, indio_dev);
1400 ret = iio_trigger_register(data->motion_trig);
1401 if (ret) {
1402 data->motion_trig = NULL;
1403 goto err_trigger_unregister;
1404 }
1405 }
1406
1407 ret = iio_triggered_buffer_setup(indio_dev,
1408 &iio_pollfunc_store_time,
1409 kxcjk1013_trigger_handler,
1410 &kxcjk1013_buffer_setup_ops);
1411 if (ret < 0) {
1412 dev_err(&client->dev, "iio triggered buffer setup failed\n");
1413 goto err_trigger_unregister;
1414 }
1415
1416 ret = pm_runtime_set_active(&client->dev);
1417 if (ret)
1418 goto err_buffer_cleanup;
1419
1420 pm_runtime_enable(&client->dev);
1421 pm_runtime_set_autosuspend_delay(&client->dev,
1422 KXCJK1013_SLEEP_DELAY_MS);
1423 pm_runtime_use_autosuspend(&client->dev);
1424
1425 ret = iio_device_register(indio_dev);
1426 if (ret < 0) {
1427 dev_err(&client->dev, "unable to register iio device\n");
1428 goto err_buffer_cleanup;
1429 }
1430
1431 return 0;
1432
1433err_buffer_cleanup:
1434 if (data->dready_trig)
1435 iio_triggered_buffer_cleanup(indio_dev);
1436err_trigger_unregister:
1437 if (data->dready_trig)
1438 iio_trigger_unregister(data->dready_trig);
1439 if (data->motion_trig)
1440 iio_trigger_unregister(data->motion_trig);
1441err_poweroff:
1442 kxcjk1013_set_mode(data, STANDBY);
1443
1444 return ret;
1445}
1446
1447static int kxcjk1013_remove(struct i2c_client *client)
1448{
1449 struct iio_dev *indio_dev = i2c_get_clientdata(client);
1450 struct kxcjk1013_data *data = iio_priv(indio_dev);
1451
1452 iio_device_unregister(indio_dev);
1453
1454 pm_runtime_disable(&client->dev);
1455 pm_runtime_set_suspended(&client->dev);
1456 pm_runtime_put_noidle(&client->dev);
1457
1458 if (data->dready_trig) {
1459 iio_triggered_buffer_cleanup(indio_dev);
1460 iio_trigger_unregister(data->dready_trig);
1461 iio_trigger_unregister(data->motion_trig);
1462 }
1463
1464 mutex_lock(&data->mutex);
1465 kxcjk1013_set_mode(data, STANDBY);
1466 mutex_unlock(&data->mutex);
1467
1468 return 0;
1469}
1470
1471#ifdef CONFIG_PM_SLEEP
1472static int kxcjk1013_suspend(struct device *dev)
1473{
1474 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
1475 struct kxcjk1013_data *data = iio_priv(indio_dev);
1476 int ret;
1477
1478 mutex_lock(&data->mutex);
1479 ret = kxcjk1013_set_mode(data, STANDBY);
1480 mutex_unlock(&data->mutex);
1481
1482 return ret;
1483}
1484
1485static int kxcjk1013_resume(struct device *dev)
1486{
1487 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
1488 struct kxcjk1013_data *data = iio_priv(indio_dev);
1489 int ret = 0;
1490
1491 mutex_lock(&data->mutex);
1492 ret = kxcjk1013_set_mode(data, OPERATION);
1493 if (ret == 0)
1494 ret = kxcjk1013_set_range(data, data->range);
1495 mutex_unlock(&data->mutex);
1496
1497 return ret;
1498}
1499#endif
1500
1501#ifdef CONFIG_PM
1502static int kxcjk1013_runtime_suspend(struct device *dev)
1503{
1504 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
1505 struct kxcjk1013_data *data = iio_priv(indio_dev);
1506 int ret;
1507
1508 ret = kxcjk1013_set_mode(data, STANDBY);
1509 if (ret < 0) {
1510 dev_err(&data->client->dev, "powering off device failed\n");
1511 return -EAGAIN;
1512 }
1513 return 0;
1514}
1515
1516static int kxcjk1013_runtime_resume(struct device *dev)
1517{
1518 struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
1519 struct kxcjk1013_data *data = iio_priv(indio_dev);
1520 int ret;
1521 int sleep_val;
1522
1523 ret = kxcjk1013_set_mode(data, OPERATION);
1524 if (ret < 0)
1525 return ret;
1526
1527 sleep_val = kxcjk1013_get_startup_times(data);
1528 if (sleep_val < 20000)
1529 usleep_range(sleep_val, 20000);
1530 else
1531 msleep_interruptible(sleep_val/1000);
1532
1533 return 0;
1534}
1535#endif
1536
1537static const struct dev_pm_ops kxcjk1013_pm_ops = {
1538 SET_SYSTEM_SLEEP_PM_OPS(kxcjk1013_suspend, kxcjk1013_resume)
1539 SET_RUNTIME_PM_OPS(kxcjk1013_runtime_suspend,
1540 kxcjk1013_runtime_resume, NULL)
1541};
1542
1543static const struct acpi_device_id kx_acpi_match[] = {
1544 {"KXCJ1013", KXCJK1013},
1545 {"KXCJ1008", KXCJ91008},
1546 {"KXCJ9000", KXCJ91008},
1547 {"KIOX0008", KXCJ91008},
1548 {"KIOX0009", KXTJ21009},
1549 {"KIOX000A", KXCJ91008},
1550 {"KIOX010A", KXCJ91008},
1551 {"KIOX020A", KXCJ91008},
1552 {"KXTJ1009", KXTJ21009},
1553 {"KXJ2109", KXTJ21009},
1554 {"SMO8500", KXCJ91008},
1555 { },
1556};
1557MODULE_DEVICE_TABLE(acpi, kx_acpi_match);
1558
1559static const struct i2c_device_id kxcjk1013_id[] = {
1560 {"kxcjk1013", KXCJK1013},
1561 {"kxcj91008", KXCJ91008},
1562 {"kxtj21009", KXTJ21009},
1563 {"kxtf9", KXTF9},
1564 {"SMO8500", KXCJ91008},
1565 {}
1566};
1567
1568MODULE_DEVICE_TABLE(i2c, kxcjk1013_id);
1569
1570static const struct of_device_id kxcjk1013_of_match[] = {
1571 { .compatible = "kionix,kxcjk1013", },
1572 { .compatible = "kionix,kxcj91008", },
1573 { .compatible = "kionix,kxtj21009", },
1574 { .compatible = "kionix,kxtf9", },
1575 { }
1576};
1577MODULE_DEVICE_TABLE(of, kxcjk1013_of_match);
1578
1579static struct i2c_driver kxcjk1013_driver = {
1580 .driver = {
1581 .name = KXCJK1013_DRV_NAME,
1582 .acpi_match_table = ACPI_PTR(kx_acpi_match),
1583 .of_match_table = kxcjk1013_of_match,
1584 .pm = &kxcjk1013_pm_ops,
1585 },
1586 .probe = kxcjk1013_probe,
1587 .remove = kxcjk1013_remove,
1588 .id_table = kxcjk1013_id,
1589};
1590module_i2c_driver(kxcjk1013_driver);
1591
1592MODULE_AUTHOR("Srinivas Pandruvada <srinivas.pandruvada@linux.intel.com>");
1593MODULE_LICENSE("GPL v2");
1594MODULE_DESCRIPTION("KXCJK1013 accelerometer driver");
1595
