1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * KMX61 - Kionix 6-axis Accelerometer/Magnetometer
4 *
5 * Copyright (c) 2014, Intel Corporation.
6 *
7 * IIO driver for KMX61 (7-bit I2C slave address 0x0E or 0x0F).
8 */
9
10 #include <linux/cleanup.h>
11 #include <linux/i2c.h>
12 #include <linux/interrupt.h>
13 #include <linux/module.h>
14 #include <linux/pm.h>
15 #include <linux/pm_runtime.h>
16
17 #include <linux/iio/iio.h>
18 #include <linux/iio/sysfs.h>
19 #include <linux/iio/events.h>
20 #include <linux/iio/trigger.h>
21 #include <linux/iio/buffer.h>
22 #include <linux/iio/triggered_buffer.h>
23 #include <linux/iio/trigger_consumer.h>
24
25 #define KMX61_REG_WHO_AM_I 0x00
26 #define KMX61_REG_INS1 0x01
27 #define KMX61_REG_INS2 0x02
28
29 /*
30 * three 16-bit accelerometer output registers for X/Y/Z axis
31 * we use only XOUT_L as a base register, all other addresses
32 * can be obtained by applying an offset and are provided here
33 * only for clarity.
34 */
35 #define KMX61_ACC_XOUT_L 0x0A
36 #define KMX61_ACC_XOUT_H 0x0B
37 #define KMX61_ACC_YOUT_L 0x0C
38 #define KMX61_ACC_YOUT_H 0x0D
39 #define KMX61_ACC_ZOUT_L 0x0E
40 #define KMX61_ACC_ZOUT_H 0x0F
41
42 /*
43 * one 16-bit temperature output register
44 */
45 #define KMX61_TEMP_L 0x10
46 #define KMX61_TEMP_H 0x11
47
48 /*
49 * three 16-bit magnetometer output registers for X/Y/Z axis
50 */
51 #define KMX61_MAG_XOUT_L 0x12
52 #define KMX61_MAG_XOUT_H 0x13
53 #define KMX61_MAG_YOUT_L 0x14
54 #define KMX61_MAG_YOUT_H 0x15
55 #define KMX61_MAG_ZOUT_L 0x16
56 #define KMX61_MAG_ZOUT_H 0x17
57
58 #define KMX61_REG_INL 0x28
59 #define KMX61_REG_STBY 0x29
60 #define KMX61_REG_CTRL1 0x2A
61 #define KMX61_REG_CTRL2 0x2B
62 #define KMX61_REG_ODCNTL 0x2C
63 #define KMX61_REG_INC1 0x2D
64
65 #define KMX61_REG_WUF_THRESH 0x3D
66 #define KMX61_REG_WUF_TIMER 0x3E
67
68 #define KMX61_ACC_STBY_BIT BIT(0)
69 #define KMX61_MAG_STBY_BIT BIT(1)
70 #define KMX61_ACT_STBY_BIT BIT(7)
71
72 #define KMX61_ALL_STBY (KMX61_ACC_STBY_BIT | KMX61_MAG_STBY_BIT)
73
74 #define KMX61_REG_INS1_BIT_WUFS BIT(1)
75
76 #define KMX61_REG_INS2_BIT_ZP BIT(0)
77 #define KMX61_REG_INS2_BIT_ZN BIT(1)
78 #define KMX61_REG_INS2_BIT_YP BIT(2)
79 #define KMX61_REG_INS2_BIT_YN BIT(3)
80 #define KMX61_REG_INS2_BIT_XP BIT(4)
81 #define KMX61_REG_INS2_BIT_XN BIT(5)
82
83 #define KMX61_REG_CTRL1_GSEL_MASK 0x03
84
85 #define KMX61_REG_CTRL1_BIT_RES BIT(4)
86 #define KMX61_REG_CTRL1_BIT_DRDYE BIT(5)
87 #define KMX61_REG_CTRL1_BIT_WUFE BIT(6)
88 #define KMX61_REG_CTRL1_BIT_BTSE BIT(7)
89
90 #define KMX61_REG_INC1_BIT_WUFS BIT(0)
91 #define KMX61_REG_INC1_BIT_DRDYM BIT(1)
92 #define KMX61_REG_INC1_BIT_DRDYA BIT(2)
93 #define KMX61_REG_INC1_BIT_IEN BIT(5)
94
95 #define KMX61_ACC_ODR_SHIFT 0
96 #define KMX61_MAG_ODR_SHIFT 4
97 #define KMX61_ACC_ODR_MASK 0x0F
98 #define KMX61_MAG_ODR_MASK 0xF0
99
100 #define KMX61_OWUF_MASK 0x7
101
102 #define KMX61_DEFAULT_WAKE_THRESH 1
103 #define KMX61_DEFAULT_WAKE_DURATION 1
104
105 #define KMX61_SLEEP_DELAY_MS 2000
106
107 #define KMX61_CHIP_ID 0x12
108
109 /* KMX61 devices */
110 #define KMX61_ACC 0x01
111 #define KMX61_MAG 0x02
112
113 struct kmx61_data {
114 struct i2c_client *client;
115
116 /* serialize access to non-atomic ops, e.g set_mode */
117 struct mutex lock;
118
119 /* standby state */
120 bool acc_stby;
121 bool mag_stby;
122
123 /* power state */
124 bool acc_ps;
125 bool mag_ps;
126
127 /* config bits */
128 u8 range;
129 u8 odr_bits;
130 u8 wake_thresh;
131 u8 wake_duration;
132
133 /* accelerometer specific data */
134 struct iio_dev *acc_indio_dev;
135 struct iio_trigger *acc_dready_trig;
136 struct iio_trigger *motion_trig;
137 bool acc_dready_trig_on;
138 bool motion_trig_on;
139 bool ev_enable_state;
140
141 /* magnetometer specific data */
142 struct iio_dev *mag_indio_dev;
143 struct iio_trigger *mag_dready_trig;
144 bool mag_dready_trig_on;
145 };
146
147 enum kmx61_range {
148 KMX61_RANGE_2G,
149 KMX61_RANGE_4G,
150 KMX61_RANGE_8G,
151 };
152
153 enum kmx61_axis {
154 KMX61_AXIS_X,
155 KMX61_AXIS_Y,
156 KMX61_AXIS_Z,
157 };
158
159 static const u16 kmx61_uscale_table[] = {9582, 19163, 38326};
160
161 static const struct {
162 int val;
163 int val2;
164 } kmx61_samp_freq_table[] = { {12, 500000},
165 {25, 0},
166 {50, 0},
167 {100, 0},
168 {200, 0},
169 {400, 0},
170 {800, 0},
171 {1600, 0},
172 {0, 781000},
173 {1, 563000},
174 {3, 125000},
175 {6, 250000} };
176
177 static const struct {
178 int val;
179 int val2;
180 int odr_bits;
181 } kmx61_wake_up_odr_table[] = { {0, 781000, 0x00},
182 {1, 563000, 0x01},
183 {3, 125000, 0x02},
184 {6, 250000, 0x03},
185 {12, 500000, 0x04},
186 {25, 0, 0x05},
187 {50, 0, 0x06},
188 {100, 0, 0x06},
189 {200, 0, 0x06},
190 {400, 0, 0x06},
191 {800, 0, 0x06},
192 {1600, 0, 0x06} };
193
194 static IIO_CONST_ATTR(accel_scale_available, "0.009582 0.019163 0.038326");
195 static IIO_CONST_ATTR(magn_scale_available, "0.001465");
196 static IIO_CONST_ATTR_SAMP_FREQ_AVAIL(
197 "0.781000 1.563000 3.125000 6.250000 12.500000 25 50 100 200 400 800");
198
199 static struct attribute *kmx61_acc_attributes[] = {
200 &iio_const_attr_accel_scale_available.dev_attr.attr,
201 &iio_const_attr_sampling_frequency_available.dev_attr.attr,
202 NULL,
203 };
204
205 static struct attribute *kmx61_mag_attributes[] = {
206 &iio_const_attr_magn_scale_available.dev_attr.attr,
207 &iio_const_attr_sampling_frequency_available.dev_attr.attr,
208 NULL,
209 };
210
211 static const struct attribute_group kmx61_acc_attribute_group = {
212 .attrs = kmx61_acc_attributes,
213 };
214
215 static const struct attribute_group kmx61_mag_attribute_group = {
216 .attrs = kmx61_mag_attributes,
217 };
218
219 static const struct iio_event_spec kmx61_event = {
220 .type = IIO_EV_TYPE_THRESH,
221 .dir = IIO_EV_DIR_EITHER,
222 .mask_separate = BIT(IIO_EV_INFO_VALUE) |
223 BIT(IIO_EV_INFO_ENABLE) |
224 BIT(IIO_EV_INFO_PERIOD),
225 };
226
227 #define KMX61_ACC_CHAN(_axis) { \
228 .type = IIO_ACCEL, \
229 .modified = 1, \
230 .channel2 = IIO_MOD_ ## _axis, \
231 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
232 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
233 BIT(IIO_CHAN_INFO_SAMP_FREQ), \
234 .address = KMX61_ACC, \
235 .scan_index = KMX61_AXIS_ ## _axis, \
236 .scan_type = { \
237 .sign = 's', \
238 .realbits = 12, \
239 .storagebits = 16, \
240 .shift = 4, \
241 .endianness = IIO_LE, \
242 }, \
243 .event_spec = &kmx61_event, \
244 .num_event_specs = 1 \
245 }
246
247 #define KMX61_MAG_CHAN(_axis) { \
248 .type = IIO_MAGN, \
249 .modified = 1, \
250 .channel2 = IIO_MOD_ ## _axis, \
251 .address = KMX61_MAG, \
252 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
253 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
254 BIT(IIO_CHAN_INFO_SAMP_FREQ), \
255 .scan_index = KMX61_AXIS_ ## _axis, \
256 .scan_type = { \
257 .sign = 's', \
258 .realbits = 14, \
259 .storagebits = 16, \
260 .shift = 2, \
261 .endianness = IIO_LE, \
262 }, \
263 }
264
265 static const struct iio_chan_spec kmx61_acc_channels[] = {
266 KMX61_ACC_CHAN(X),
267 KMX61_ACC_CHAN(Y),
268 KMX61_ACC_CHAN(Z),
269 };
270
271 static const struct iio_chan_spec kmx61_mag_channels[] = {
272 KMX61_MAG_CHAN(X),
273 KMX61_MAG_CHAN(Y),
274 KMX61_MAG_CHAN(Z),
275 };
276
kmx61_set_data(struct iio_dev * indio_dev,struct kmx61_data * data)277 static void kmx61_set_data(struct iio_dev *indio_dev, struct kmx61_data *data)
278 {
279 struct kmx61_data **priv = iio_priv(indio_dev);
280
281 *priv = data;
282 }
283
kmx61_get_data(struct iio_dev * indio_dev)284 static struct kmx61_data *kmx61_get_data(struct iio_dev *indio_dev)
285 {
286 return *(struct kmx61_data **)iio_priv(indio_dev);
287 }
288
kmx61_convert_freq_to_bit(int val,int val2)289 static int kmx61_convert_freq_to_bit(int val, int val2)
290 {
291 int i;
292
293 for (i = 0; i < ARRAY_SIZE(kmx61_samp_freq_table); i++)
294 if (val == kmx61_samp_freq_table[i].val &&
295 val2 == kmx61_samp_freq_table[i].val2)
296 return i;
297 return -EINVAL;
298 }
299
kmx61_convert_wake_up_odr_to_bit(int val,int val2)300 static int kmx61_convert_wake_up_odr_to_bit(int val, int val2)
301 {
302 int i;
303
304 for (i = 0; i < ARRAY_SIZE(kmx61_wake_up_odr_table); ++i)
305 if (kmx61_wake_up_odr_table[i].val == val &&
306 kmx61_wake_up_odr_table[i].val2 == val2)
307 return kmx61_wake_up_odr_table[i].odr_bits;
308 return -EINVAL;
309 }
310
311 /**
312 * kmx61_set_mode() - set KMX61 device operating mode
313 * @data: kmx61 device private data pointer
314 * @mode: bitmask, indicating operating mode for @device
315 * @device: bitmask, indicating device for which @mode needs to be set
316 * @update: update stby bits stored in device's private @data
317 *
318 * For each sensor (accelerometer/magnetometer) there are two operating modes
319 * STANDBY and OPERATION. Neither accel nor magn can be disabled independently
320 * if they are both enabled. Internal sensors state is saved in acc_stby and
321 * mag_stby members of driver's private @data.
322 */
kmx61_set_mode(struct kmx61_data * data,u8 mode,u8 device,bool update)323 static int kmx61_set_mode(struct kmx61_data *data, u8 mode, u8 device,
324 bool update)
325 {
326 int ret;
327 int acc_stby = -1, mag_stby = -1;
328
329 ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_STBY);
330 if (ret < 0) {
331 dev_err(&data->client->dev, "Error reading reg_stby\n");
332 return ret;
333 }
334 if (device & KMX61_ACC) {
335 if (mode & KMX61_ACC_STBY_BIT) {
336 ret |= KMX61_ACC_STBY_BIT;
337 acc_stby = 1;
338 } else {
339 ret &= ~KMX61_ACC_STBY_BIT;
340 acc_stby = 0;
341 }
342 }
343
344 if (device & KMX61_MAG) {
345 if (mode & KMX61_MAG_STBY_BIT) {
346 ret |= KMX61_MAG_STBY_BIT;
347 mag_stby = 1;
348 } else {
349 ret &= ~KMX61_MAG_STBY_BIT;
350 mag_stby = 0;
351 }
352 }
353
354 if (mode & KMX61_ACT_STBY_BIT)
355 ret |= KMX61_ACT_STBY_BIT;
356
357 ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_STBY, ret);
358 if (ret < 0) {
359 dev_err(&data->client->dev, "Error writing reg_stby\n");
360 return ret;
361 }
362
363 if (acc_stby != -1 && update)
364 data->acc_stby = acc_stby;
365 if (mag_stby != -1 && update)
366 data->mag_stby = mag_stby;
367
368 return 0;
369 }
370
kmx61_get_mode(struct kmx61_data * data,u8 * mode,u8 device)371 static int kmx61_get_mode(struct kmx61_data *data, u8 *mode, u8 device)
372 {
373 int ret;
374
375 ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_STBY);
376 if (ret < 0) {
377 dev_err(&data->client->dev, "Error reading reg_stby\n");
378 return ret;
379 }
380 *mode = 0;
381
382 if (device & KMX61_ACC) {
383 if (ret & KMX61_ACC_STBY_BIT)
384 *mode |= KMX61_ACC_STBY_BIT;
385 else
386 *mode &= ~KMX61_ACC_STBY_BIT;
387 }
388
389 if (device & KMX61_MAG) {
390 if (ret & KMX61_MAG_STBY_BIT)
391 *mode |= KMX61_MAG_STBY_BIT;
392 else
393 *mode &= ~KMX61_MAG_STBY_BIT;
394 }
395
396 return 0;
397 }
398
kmx61_set_wake_up_odr(struct kmx61_data * data,int val,int val2)399 static int kmx61_set_wake_up_odr(struct kmx61_data *data, int val, int val2)
400 {
401 int ret, odr_bits;
402
403 odr_bits = kmx61_convert_wake_up_odr_to_bit(val, val2);
404 if (odr_bits < 0)
405 return odr_bits;
406
407 ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_CTRL2,
408 odr_bits);
409 if (ret < 0)
410 dev_err(&data->client->dev, "Error writing reg_ctrl2\n");
411 return ret;
412 }
413
kmx61_set_odr(struct kmx61_data * data,int val,int val2,u8 device)414 static int kmx61_set_odr(struct kmx61_data *data, int val, int val2, u8 device)
415 {
416 int ret;
417 u8 mode;
418 int lodr_bits, odr_bits;
419
420 ret = kmx61_get_mode(data, &mode, KMX61_ACC | KMX61_MAG);
421 if (ret < 0)
422 return ret;
423
424 lodr_bits = kmx61_convert_freq_to_bit(val, val2);
425 if (lodr_bits < 0)
426 return lodr_bits;
427
428 /* To change ODR, accel and magn must be in STDBY */
429 ret = kmx61_set_mode(data, KMX61_ALL_STBY, KMX61_ACC | KMX61_MAG,
430 true);
431 if (ret < 0)
432 return ret;
433
434 odr_bits = 0;
435 if (device & KMX61_ACC)
436 odr_bits |= lodr_bits << KMX61_ACC_ODR_SHIFT;
437 if (device & KMX61_MAG)
438 odr_bits |= lodr_bits << KMX61_MAG_ODR_SHIFT;
439
440 ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_ODCNTL,
441 odr_bits);
442 if (ret < 0)
443 return ret;
444
445 data->odr_bits = odr_bits;
446
447 if (device & KMX61_ACC) {
448 ret = kmx61_set_wake_up_odr(data, val, val2);
449 if (ret)
450 return ret;
451 }
452
453 return kmx61_set_mode(data, mode, KMX61_ACC | KMX61_MAG, true);
454 }
455
kmx61_get_odr(struct kmx61_data * data,int * val,int * val2,u8 device)456 static int kmx61_get_odr(struct kmx61_data *data, int *val, int *val2,
457 u8 device)
458 {
459 u8 lodr_bits;
460
461 if (device & KMX61_ACC)
462 lodr_bits = (data->odr_bits >> KMX61_ACC_ODR_SHIFT) &
463 KMX61_ACC_ODR_MASK;
464 else if (device & KMX61_MAG)
465 lodr_bits = (data->odr_bits >> KMX61_MAG_ODR_SHIFT) &
466 KMX61_MAG_ODR_MASK;
467 else
468 return -EINVAL;
469
470 if (lodr_bits >= ARRAY_SIZE(kmx61_samp_freq_table))
471 return -EINVAL;
472
473 *val = kmx61_samp_freq_table[lodr_bits].val;
474 *val2 = kmx61_samp_freq_table[lodr_bits].val2;
475
476 return 0;
477 }
478
kmx61_set_range(struct kmx61_data * data,u8 range)479 static int kmx61_set_range(struct kmx61_data *data, u8 range)
480 {
481 int ret;
482
483 ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_CTRL1);
484 if (ret < 0) {
485 dev_err(&data->client->dev, "Error reading reg_ctrl1\n");
486 return ret;
487 }
488
489 ret &= ~KMX61_REG_CTRL1_GSEL_MASK;
490 ret |= range & KMX61_REG_CTRL1_GSEL_MASK;
491
492 ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_CTRL1, ret);
493 if (ret < 0) {
494 dev_err(&data->client->dev, "Error writing reg_ctrl1\n");
495 return ret;
496 }
497
498 data->range = range;
499
500 return 0;
501 }
502
kmx61_set_scale(struct kmx61_data * data,u16 uscale)503 static int kmx61_set_scale(struct kmx61_data *data, u16 uscale)
504 {
505 int ret, i;
506 u8 mode;
507
508 for (i = 0; i < ARRAY_SIZE(kmx61_uscale_table); i++) {
509 if (kmx61_uscale_table[i] == uscale) {
510 ret = kmx61_get_mode(data, &mode,
511 KMX61_ACC | KMX61_MAG);
512 if (ret < 0)
513 return ret;
514
515 ret = kmx61_set_mode(data, KMX61_ALL_STBY,
516 KMX61_ACC | KMX61_MAG, true);
517 if (ret < 0)
518 return ret;
519
520 ret = kmx61_set_range(data, i);
521 if (ret < 0)
522 return ret;
523
524 return kmx61_set_mode(data, mode,
525 KMX61_ACC | KMX61_MAG, true);
526 }
527 }
528 return -EINVAL;
529 }
530
kmx61_chip_init(struct kmx61_data * data)531 static int kmx61_chip_init(struct kmx61_data *data)
532 {
533 int ret, val, val2;
534
535 ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_WHO_AM_I);
536 if (ret < 0) {
537 dev_err(&data->client->dev, "Error reading who_am_i\n");
538 return ret;
539 }
540
541 if (ret != KMX61_CHIP_ID) {
542 dev_err(&data->client->dev,
543 "Wrong chip id, got %x expected %x\n",
544 ret, KMX61_CHIP_ID);
545 return -EINVAL;
546 }
547
548 /* set accel 12bit, 4g range */
549 ret = kmx61_set_range(data, KMX61_RANGE_4G);
550 if (ret < 0)
551 return ret;
552
553 ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_ODCNTL);
554 if (ret < 0) {
555 dev_err(&data->client->dev, "Error reading reg_odcntl\n");
556 return ret;
557 }
558 data->odr_bits = ret;
559
560 /*
561 * set output data rate for wake up (motion detection) function
562 * to match data rate for accelerometer sampling
563 */
564 ret = kmx61_get_odr(data, &val, &val2, KMX61_ACC);
565 if (ret < 0)
566 return ret;
567
568 ret = kmx61_set_wake_up_odr(data, val, val2);
569 if (ret < 0)
570 return ret;
571
572 /* set acc/magn to OPERATION mode */
573 ret = kmx61_set_mode(data, 0, KMX61_ACC | KMX61_MAG, true);
574 if (ret < 0)
575 return ret;
576
577 data->wake_thresh = KMX61_DEFAULT_WAKE_THRESH;
578 data->wake_duration = KMX61_DEFAULT_WAKE_DURATION;
579
580 return 0;
581 }
582
kmx61_setup_new_data_interrupt(struct kmx61_data * data,bool status,u8 device)583 static int kmx61_setup_new_data_interrupt(struct kmx61_data *data,
584 bool status, u8 device)
585 {
586 u8 mode;
587 int ret;
588
589 ret = kmx61_get_mode(data, &mode, KMX61_ACC | KMX61_MAG);
590 if (ret < 0)
591 return ret;
592
593 ret = kmx61_set_mode(data, KMX61_ALL_STBY, KMX61_ACC | KMX61_MAG, true);
594 if (ret < 0)
595 return ret;
596
597 ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_INC1);
598 if (ret < 0) {
599 dev_err(&data->client->dev, "Error reading reg_ctrl1\n");
600 return ret;
601 }
602
603 if (status) {
604 ret |= KMX61_REG_INC1_BIT_IEN;
605 if (device & KMX61_ACC)
606 ret |= KMX61_REG_INC1_BIT_DRDYA;
607 if (device & KMX61_MAG)
608 ret |= KMX61_REG_INC1_BIT_DRDYM;
609 } else {
610 ret &= ~KMX61_REG_INC1_BIT_IEN;
611 if (device & KMX61_ACC)
612 ret &= ~KMX61_REG_INC1_BIT_DRDYA;
613 if (device & KMX61_MAG)
614 ret &= ~KMX61_REG_INC1_BIT_DRDYM;
615 }
616 ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_INC1, ret);
617 if (ret < 0) {
618 dev_err(&data->client->dev, "Error writing reg_int_ctrl1\n");
619 return ret;
620 }
621
622 ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_CTRL1);
623 if (ret < 0) {
624 dev_err(&data->client->dev, "Error reading reg_ctrl1\n");
625 return ret;
626 }
627
628 if (status)
629 ret |= KMX61_REG_CTRL1_BIT_DRDYE;
630 else
631 ret &= ~KMX61_REG_CTRL1_BIT_DRDYE;
632
633 ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_CTRL1, ret);
634 if (ret < 0) {
635 dev_err(&data->client->dev, "Error writing reg_ctrl1\n");
636 return ret;
637 }
638
639 return kmx61_set_mode(data, mode, KMX61_ACC | KMX61_MAG, true);
640 }
641
kmx61_chip_update_thresholds(struct kmx61_data * data)642 static int kmx61_chip_update_thresholds(struct kmx61_data *data)
643 {
644 int ret;
645
646 ret = i2c_smbus_write_byte_data(data->client,
647 KMX61_REG_WUF_TIMER,
648 data->wake_duration);
649 if (ret < 0) {
650 dev_err(&data->client->dev, "Error writing reg_wuf_timer\n");
651 return ret;
652 }
653
654 ret = i2c_smbus_write_byte_data(data->client,
655 KMX61_REG_WUF_THRESH,
656 data->wake_thresh);
657 if (ret < 0)
658 dev_err(&data->client->dev, "Error writing reg_wuf_thresh\n");
659
660 return ret;
661 }
662
kmx61_setup_any_motion_interrupt(struct kmx61_data * data,bool status)663 static int kmx61_setup_any_motion_interrupt(struct kmx61_data *data,
664 bool status)
665 {
666 u8 mode;
667 int ret;
668
669 ret = kmx61_get_mode(data, &mode, KMX61_ACC | KMX61_MAG);
670 if (ret < 0)
671 return ret;
672
673 ret = kmx61_set_mode(data, KMX61_ALL_STBY, KMX61_ACC | KMX61_MAG, true);
674 if (ret < 0)
675 return ret;
676
677 ret = kmx61_chip_update_thresholds(data);
678 if (ret < 0)
679 return ret;
680
681 ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_INC1);
682 if (ret < 0) {
683 dev_err(&data->client->dev, "Error reading reg_inc1\n");
684 return ret;
685 }
686 if (status)
687 ret |= (KMX61_REG_INC1_BIT_IEN | KMX61_REG_INC1_BIT_WUFS);
688 else
689 ret &= ~(KMX61_REG_INC1_BIT_IEN | KMX61_REG_INC1_BIT_WUFS);
690
691 ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_INC1, ret);
692 if (ret < 0) {
693 dev_err(&data->client->dev, "Error writing reg_inc1\n");
694 return ret;
695 }
696
697 ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_CTRL1);
698 if (ret < 0) {
699 dev_err(&data->client->dev, "Error reading reg_ctrl1\n");
700 return ret;
701 }
702
703 if (status)
704 ret |= KMX61_REG_CTRL1_BIT_WUFE | KMX61_REG_CTRL1_BIT_BTSE;
705 else
706 ret &= ~(KMX61_REG_CTRL1_BIT_WUFE | KMX61_REG_CTRL1_BIT_BTSE);
707
708 ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_CTRL1, ret);
709 if (ret < 0) {
710 dev_err(&data->client->dev, "Error writing reg_ctrl1\n");
711 return ret;
712 }
713 mode |= KMX61_ACT_STBY_BIT;
714 return kmx61_set_mode(data, mode, KMX61_ACC | KMX61_MAG, true);
715 }
716
717 /**
718 * kmx61_set_power_state() - set power state for kmx61 @device
719 * @data: kmx61 device private pointer
720 * @on: power state to be set for @device
721 * @device: bitmask indicating device for which @on state needs to be set
722 *
723 * Notice that when ACC power state needs to be set to ON and MAG is in
724 * OPERATION then we know that kmx61_runtime_resume was already called
725 * so we must set ACC OPERATION mode here. The same happens when MAG power
726 * state needs to be set to ON and ACC is in OPERATION.
727 */
kmx61_set_power_state(struct kmx61_data * data,bool on,u8 device)728 static int kmx61_set_power_state(struct kmx61_data *data, bool on, u8 device)
729 {
730 #ifdef CONFIG_PM
731 int ret;
732
733 if (device & KMX61_ACC) {
734 if (on && !data->acc_ps && !data->mag_stby) {
735 ret = kmx61_set_mode(data, 0, KMX61_ACC, true);
736 if (ret < 0)
737 return ret;
738 }
739 data->acc_ps = on;
740 }
741 if (device & KMX61_MAG) {
742 if (on && !data->mag_ps && !data->acc_stby) {
743 ret = kmx61_set_mode(data, 0, KMX61_MAG, true);
744 if (ret < 0)
745 return ret;
746 }
747 data->mag_ps = on;
748 }
749
750 if (on)
751 ret = pm_runtime_resume_and_get(&data->client->dev);
752 else
753 ret = pm_runtime_put_autosuspend(&data->client->dev);
754 if (ret < 0) {
755 dev_err(&data->client->dev,
756 "Failed: kmx61_set_power_state for %d, ret %d\n",
757 on, ret);
758
759 return ret;
760 }
761 #endif
762 return 0;
763 }
764
kmx61_read_measurement(struct kmx61_data * data,u8 base,u8 offset)765 static int kmx61_read_measurement(struct kmx61_data *data, u8 base, u8 offset)
766 {
767 int ret;
768 u8 reg = base + offset * 2;
769
770 ret = i2c_smbus_read_word_data(data->client, reg);
771 if (ret < 0)
772 dev_err(&data->client->dev, "failed to read reg at %x\n", reg);
773
774 return ret;
775 }
776
kmx61_read_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int * val,int * val2,long mask)777 static int kmx61_read_raw(struct iio_dev *indio_dev,
778 struct iio_chan_spec const *chan, int *val,
779 int *val2, long mask)
780 {
781 int ret;
782 u8 base_reg;
783 struct kmx61_data *data = kmx61_get_data(indio_dev);
784
785 switch (mask) {
786 case IIO_CHAN_INFO_RAW: {
787 switch (chan->type) {
788 case IIO_ACCEL:
789 base_reg = KMX61_ACC_XOUT_L;
790 break;
791 case IIO_MAGN:
792 base_reg = KMX61_MAG_XOUT_L;
793 break;
794 default:
795 return -EINVAL;
796 }
797 guard(mutex)(&data->lock);
798
799 ret = kmx61_set_power_state(data, true, chan->address);
800 if (ret)
801 return ret;
802
803 ret = kmx61_read_measurement(data, base_reg, chan->scan_index);
804 if (ret < 0) {
805 kmx61_set_power_state(data, false, chan->address);
806 return ret;
807 }
808 *val = sign_extend32(ret >> chan->scan_type.shift,
809 chan->scan_type.realbits - 1);
810 ret = kmx61_set_power_state(data, false, chan->address);
811 if (ret)
812 return ret;
813 return IIO_VAL_INT;
814 }
815 case IIO_CHAN_INFO_SCALE:
816 switch (chan->type) {
817 case IIO_ACCEL:
818 *val = 0;
819 *val2 = kmx61_uscale_table[data->range];
820 return IIO_VAL_INT_PLUS_MICRO;
821 case IIO_MAGN:
822 /* 14 bits res, 1465 microGauss per magn count */
823 *val = 0;
824 *val2 = 1465;
825 return IIO_VAL_INT_PLUS_MICRO;
826 default:
827 return -EINVAL;
828 }
829 case IIO_CHAN_INFO_SAMP_FREQ: {
830 if (chan->type != IIO_ACCEL && chan->type != IIO_MAGN)
831 return -EINVAL;
832
833 guard(mutex)(&data->lock);
834
835 ret = kmx61_get_odr(data, val, val2, chan->address);
836 if (ret)
837 return -EINVAL;
838 return IIO_VAL_INT_PLUS_MICRO;
839 }
840 default:
841 return -EINVAL;
842 }
843 }
844
kmx61_write_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int val,int val2,long mask)845 static int kmx61_write_raw(struct iio_dev *indio_dev,
846 struct iio_chan_spec const *chan, int val,
847 int val2, long mask)
848 {
849 struct kmx61_data *data = kmx61_get_data(indio_dev);
850
851 switch (mask) {
852 case IIO_CHAN_INFO_SAMP_FREQ: {
853 if (chan->type != IIO_ACCEL && chan->type != IIO_MAGN)
854 return -EINVAL;
855
856 guard(mutex)(&data->lock);
857
858 return kmx61_set_odr(data, val, val2, chan->address);
859 }
860 case IIO_CHAN_INFO_SCALE:
861 switch (chan->type) {
862 case IIO_ACCEL: {
863 if (val != 0)
864 return -EINVAL;
865 guard(mutex)(&data->lock);
866
867 return kmx61_set_scale(data, val2);
868 }
869 default:
870 return -EINVAL;
871 }
872 default:
873 return -EINVAL;
874 }
875 }
876
kmx61_read_event(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,enum iio_event_type type,enum iio_event_direction dir,enum iio_event_info info,int * val,int * val2)877 static int kmx61_read_event(struct iio_dev *indio_dev,
878 const struct iio_chan_spec *chan,
879 enum iio_event_type type,
880 enum iio_event_direction dir,
881 enum iio_event_info info,
882 int *val, int *val2)
883 {
884 struct kmx61_data *data = kmx61_get_data(indio_dev);
885
886 *val2 = 0;
887 switch (info) {
888 case IIO_EV_INFO_VALUE:
889 *val = data->wake_thresh;
890 return IIO_VAL_INT;
891 case IIO_EV_INFO_PERIOD:
892 *val = data->wake_duration;
893 return IIO_VAL_INT;
894 default:
895 return -EINVAL;
896 }
897 }
898
kmx61_write_event(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,enum iio_event_type type,enum iio_event_direction dir,enum iio_event_info info,int val,int val2)899 static int kmx61_write_event(struct iio_dev *indio_dev,
900 const struct iio_chan_spec *chan,
901 enum iio_event_type type,
902 enum iio_event_direction dir,
903 enum iio_event_info info,
904 int val, int val2)
905 {
906 struct kmx61_data *data = kmx61_get_data(indio_dev);
907
908 if (data->ev_enable_state)
909 return -EBUSY;
910
911 switch (info) {
912 case IIO_EV_INFO_VALUE:
913 data->wake_thresh = val;
914 return IIO_VAL_INT;
915 case IIO_EV_INFO_PERIOD:
916 data->wake_duration = val;
917 return IIO_VAL_INT;
918 default:
919 return -EINVAL;
920 }
921 }
922
kmx61_read_event_config(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,enum iio_event_type type,enum iio_event_direction dir)923 static int kmx61_read_event_config(struct iio_dev *indio_dev,
924 const struct iio_chan_spec *chan,
925 enum iio_event_type type,
926 enum iio_event_direction dir)
927 {
928 struct kmx61_data *data = kmx61_get_data(indio_dev);
929
930 return data->ev_enable_state;
931 }
932
kmx61_write_event_config(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,enum iio_event_type type,enum iio_event_direction dir,bool state)933 static int kmx61_write_event_config(struct iio_dev *indio_dev,
934 const struct iio_chan_spec *chan,
935 enum iio_event_type type,
936 enum iio_event_direction dir,
937 bool state)
938 {
939 struct kmx61_data *data = kmx61_get_data(indio_dev);
940 int ret = 0;
941
942 if (state && data->ev_enable_state)
943 return 0;
944
945 guard(mutex)(&data->lock);
946
947 if (!state && data->motion_trig_on) {
948 data->ev_enable_state = false;
949 return ret;
950 }
951
952 ret = kmx61_set_power_state(data, state, KMX61_ACC);
953 if (ret < 0)
954 return ret;
955
956 ret = kmx61_setup_any_motion_interrupt(data, state);
957 if (ret < 0) {
958 kmx61_set_power_state(data, false, KMX61_ACC);
959 return ret;
960 }
961
962 data->ev_enable_state = state;
963
964 return 0;
965 }
966
kmx61_acc_validate_trigger(struct iio_dev * indio_dev,struct iio_trigger * trig)967 static int kmx61_acc_validate_trigger(struct iio_dev *indio_dev,
968 struct iio_trigger *trig)
969 {
970 struct kmx61_data *data = kmx61_get_data(indio_dev);
971
972 if (data->acc_dready_trig != trig && data->motion_trig != trig)
973 return -EINVAL;
974
975 return 0;
976 }
977
kmx61_mag_validate_trigger(struct iio_dev * indio_dev,struct iio_trigger * trig)978 static int kmx61_mag_validate_trigger(struct iio_dev *indio_dev,
979 struct iio_trigger *trig)
980 {
981 struct kmx61_data *data = kmx61_get_data(indio_dev);
982
983 if (data->mag_dready_trig != trig)
984 return -EINVAL;
985
986 return 0;
987 }
988
989 static const struct iio_info kmx61_acc_info = {
990 .read_raw = kmx61_read_raw,
991 .write_raw = kmx61_write_raw,
992 .attrs = &kmx61_acc_attribute_group,
993 .read_event_value = kmx61_read_event,
994 .write_event_value = kmx61_write_event,
995 .read_event_config = kmx61_read_event_config,
996 .write_event_config = kmx61_write_event_config,
997 .validate_trigger = kmx61_acc_validate_trigger,
998 };
999
1000 static const struct iio_info kmx61_mag_info = {
1001 .read_raw = kmx61_read_raw,
1002 .write_raw = kmx61_write_raw,
1003 .attrs = &kmx61_mag_attribute_group,
1004 .validate_trigger = kmx61_mag_validate_trigger,
1005 };
1006
1007
kmx61_data_rdy_trigger_set_state(struct iio_trigger * trig,bool state)1008 static int kmx61_data_rdy_trigger_set_state(struct iio_trigger *trig,
1009 bool state)
1010 {
1011 int ret = 0;
1012 u8 device;
1013
1014 struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
1015 struct kmx61_data *data = kmx61_get_data(indio_dev);
1016
1017 guard(mutex)(&data->lock);
1018
1019 if (!state && data->ev_enable_state && data->motion_trig_on) {
1020 data->motion_trig_on = false;
1021 return ret;
1022 }
1023
1024 if (data->acc_dready_trig == trig || data->motion_trig == trig)
1025 device = KMX61_ACC;
1026 else
1027 device = KMX61_MAG;
1028
1029 ret = kmx61_set_power_state(data, state, device);
1030 if (ret < 0)
1031 return ret;
1032
1033 if (data->acc_dready_trig == trig || data->mag_dready_trig == trig)
1034 ret = kmx61_setup_new_data_interrupt(data, state, device);
1035 else
1036 ret = kmx61_setup_any_motion_interrupt(data, state);
1037 if (ret < 0) {
1038 kmx61_set_power_state(data, false, device);
1039 return ret;
1040 }
1041
1042 if (data->acc_dready_trig == trig)
1043 data->acc_dready_trig_on = state;
1044 else if (data->mag_dready_trig == trig)
1045 data->mag_dready_trig_on = state;
1046 else
1047 data->motion_trig_on = state;
1048
1049 return 0;
1050 }
1051
kmx61_trig_reenable(struct iio_trigger * trig)1052 static void kmx61_trig_reenable(struct iio_trigger *trig)
1053 {
1054 struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
1055 struct kmx61_data *data = kmx61_get_data(indio_dev);
1056 int ret;
1057
1058 ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_INL);
1059 if (ret < 0)
1060 dev_err(&data->client->dev, "Error reading reg_inl\n");
1061 }
1062
1063 static const struct iio_trigger_ops kmx61_trigger_ops = {
1064 .set_trigger_state = kmx61_data_rdy_trigger_set_state,
1065 .reenable = kmx61_trig_reenable,
1066 };
1067
kmx61_event_handler(int irq,void * private)1068 static irqreturn_t kmx61_event_handler(int irq, void *private)
1069 {
1070 struct kmx61_data *data = private;
1071 struct iio_dev *indio_dev = data->acc_indio_dev;
1072 int ret;
1073
1074 ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_INS1);
1075 if (ret < 0) {
1076 dev_err(&data->client->dev, "Error reading reg_ins1\n");
1077 goto ack_intr;
1078 }
1079
1080 if (ret & KMX61_REG_INS1_BIT_WUFS) {
1081 ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_INS2);
1082 if (ret < 0) {
1083 dev_err(&data->client->dev, "Error reading reg_ins2\n");
1084 goto ack_intr;
1085 }
1086
1087 if (ret & KMX61_REG_INS2_BIT_XN)
1088 iio_push_event(indio_dev,
1089 IIO_MOD_EVENT_CODE(IIO_ACCEL,
1090 0,
1091 IIO_MOD_X,
1092 IIO_EV_TYPE_THRESH,
1093 IIO_EV_DIR_FALLING),
1094 0);
1095
1096 if (ret & KMX61_REG_INS2_BIT_XP)
1097 iio_push_event(indio_dev,
1098 IIO_MOD_EVENT_CODE(IIO_ACCEL,
1099 0,
1100 IIO_MOD_X,
1101 IIO_EV_TYPE_THRESH,
1102 IIO_EV_DIR_RISING),
1103 0);
1104
1105 if (ret & KMX61_REG_INS2_BIT_YN)
1106 iio_push_event(indio_dev,
1107 IIO_MOD_EVENT_CODE(IIO_ACCEL,
1108 0,
1109 IIO_MOD_Y,
1110 IIO_EV_TYPE_THRESH,
1111 IIO_EV_DIR_FALLING),
1112 0);
1113
1114 if (ret & KMX61_REG_INS2_BIT_YP)
1115 iio_push_event(indio_dev,
1116 IIO_MOD_EVENT_CODE(IIO_ACCEL,
1117 0,
1118 IIO_MOD_Y,
1119 IIO_EV_TYPE_THRESH,
1120 IIO_EV_DIR_RISING),
1121 0);
1122
1123 if (ret & KMX61_REG_INS2_BIT_ZN)
1124 iio_push_event(indio_dev,
1125 IIO_MOD_EVENT_CODE(IIO_ACCEL,
1126 0,
1127 IIO_MOD_Z,
1128 IIO_EV_TYPE_THRESH,
1129 IIO_EV_DIR_FALLING),
1130 0);
1131
1132 if (ret & KMX61_REG_INS2_BIT_ZP)
1133 iio_push_event(indio_dev,
1134 IIO_MOD_EVENT_CODE(IIO_ACCEL,
1135 0,
1136 IIO_MOD_Z,
1137 IIO_EV_TYPE_THRESH,
1138 IIO_EV_DIR_RISING),
1139 0);
1140 }
1141
1142 ack_intr:
1143 ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_CTRL1);
1144 if (ret < 0)
1145 dev_err(&data->client->dev, "Error reading reg_ctrl1\n");
1146
1147 ret |= KMX61_REG_CTRL1_BIT_RES;
1148 ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_CTRL1, ret);
1149 if (ret < 0)
1150 dev_err(&data->client->dev, "Error writing reg_ctrl1\n");
1151
1152 ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_INL);
1153 if (ret < 0)
1154 dev_err(&data->client->dev, "Error reading reg_inl\n");
1155
1156 return IRQ_HANDLED;
1157 }
1158
kmx61_data_rdy_trig_poll(int irq,void * private)1159 static irqreturn_t kmx61_data_rdy_trig_poll(int irq, void *private)
1160 {
1161 struct kmx61_data *data = private;
1162
1163 if (data->acc_dready_trig_on)
1164 iio_trigger_poll(data->acc_dready_trig);
1165 if (data->mag_dready_trig_on)
1166 iio_trigger_poll(data->mag_dready_trig);
1167
1168 if (data->motion_trig_on)
1169 iio_trigger_poll(data->motion_trig);
1170
1171 if (data->ev_enable_state)
1172 return IRQ_WAKE_THREAD;
1173 return IRQ_HANDLED;
1174 }
1175
1176 /**
1177 * kmx61_read_for_each_active_channel() - Read each active channel into a buffer
1178 *
1179 * @indio_dev: IIO Device struct to read from
1180 * @buffer: Destination buffer to write to, the array must be of at least size 8
1181 *
1182 * Return:
1183 * 0 on success, negative errno on failure.
1184 */
kmx61_read_for_each_active_channel(struct iio_dev * indio_dev,s16 * buffer)1185 static int kmx61_read_for_each_active_channel(struct iio_dev *indio_dev, s16 *buffer)
1186 {
1187 struct kmx61_data *data = kmx61_get_data(indio_dev);
1188 u8 base;
1189 int ret, bit;
1190 int i = 0;
1191
1192 if (indio_dev == data->acc_indio_dev)
1193 base = KMX61_ACC_XOUT_L;
1194 else
1195 base = KMX61_MAG_XOUT_L;
1196
1197 guard(mutex)(&data->lock);
1198
1199 iio_for_each_active_channel(indio_dev, bit) {
1200 ret = kmx61_read_measurement(data, base, bit);
1201 if (ret < 0)
1202 return ret;
1203 buffer[i++] = ret;
1204 }
1205
1206 return 0;
1207 }
1208
kmx61_trigger_handler(int irq,void * p)1209 static irqreturn_t kmx61_trigger_handler(int irq, void *p)
1210 {
1211 struct iio_poll_func *pf = p;
1212 struct iio_dev *indio_dev = pf->indio_dev;
1213 int ret;
1214 s16 buffer[8] = { };
1215
1216 ret = kmx61_read_for_each_active_channel(indio_dev, buffer);
1217 if (ret < 0)
1218 goto err;
1219
1220 iio_push_to_buffers(indio_dev, buffer);
1221 err:
1222 iio_trigger_notify_done(indio_dev->trig);
1223
1224 return IRQ_HANDLED;
1225 }
1226
kmx61_indiodev_setup(struct kmx61_data * data,const struct iio_info * info,const struct iio_chan_spec * chan,int num_channels,const char * name)1227 static struct iio_dev *kmx61_indiodev_setup(struct kmx61_data *data,
1228 const struct iio_info *info,
1229 const struct iio_chan_spec *chan,
1230 int num_channels,
1231 const char *name)
1232 {
1233 struct iio_dev *indio_dev;
1234
1235 indio_dev = devm_iio_device_alloc(&data->client->dev, sizeof(data));
1236 if (!indio_dev)
1237 return ERR_PTR(-ENOMEM);
1238
1239 kmx61_set_data(indio_dev, data);
1240
1241 indio_dev->channels = chan;
1242 indio_dev->num_channels = num_channels;
1243 indio_dev->name = name;
1244 indio_dev->modes = INDIO_DIRECT_MODE;
1245 indio_dev->info = info;
1246
1247 return indio_dev;
1248 }
1249
kmx61_trigger_setup(struct kmx61_data * data,struct iio_dev * indio_dev,const char * tag)1250 static struct iio_trigger *kmx61_trigger_setup(struct kmx61_data *data,
1251 struct iio_dev *indio_dev,
1252 const char *tag)
1253 {
1254 struct iio_trigger *trig;
1255 int ret;
1256
1257 trig = devm_iio_trigger_alloc(&data->client->dev,
1258 "%s-%s-dev%d",
1259 indio_dev->name,
1260 tag,
1261 iio_device_id(indio_dev));
1262 if (!trig)
1263 return ERR_PTR(-ENOMEM);
1264
1265 trig->ops = &kmx61_trigger_ops;
1266 iio_trigger_set_drvdata(trig, indio_dev);
1267
1268 ret = iio_trigger_register(trig);
1269 if (ret)
1270 return ERR_PTR(ret);
1271
1272 return trig;
1273 }
1274
kmx61_probe(struct i2c_client * client)1275 static int kmx61_probe(struct i2c_client *client)
1276 {
1277 const struct i2c_device_id *id = i2c_client_get_device_id(client);
1278 int ret;
1279 struct kmx61_data *data;
1280 const char *name = NULL;
1281
1282 data = devm_kzalloc(&client->dev, sizeof(*data), GFP_KERNEL);
1283 if (!data)
1284 return -ENOMEM;
1285
1286 i2c_set_clientdata(client, data);
1287 data->client = client;
1288
1289 mutex_init(&data->lock);
1290
1291 if (id)
1292 name = id->name;
1293 else
1294 return -ENODEV;
1295
1296 data->acc_indio_dev =
1297 kmx61_indiodev_setup(data, &kmx61_acc_info,
1298 kmx61_acc_channels,
1299 ARRAY_SIZE(kmx61_acc_channels),
1300 name);
1301 if (IS_ERR(data->acc_indio_dev))
1302 return PTR_ERR(data->acc_indio_dev);
1303
1304 data->mag_indio_dev =
1305 kmx61_indiodev_setup(data, &kmx61_mag_info,
1306 kmx61_mag_channels,
1307 ARRAY_SIZE(kmx61_mag_channels),
1308 name);
1309 if (IS_ERR(data->mag_indio_dev))
1310 return PTR_ERR(data->mag_indio_dev);
1311
1312 ret = kmx61_chip_init(data);
1313 if (ret < 0)
1314 return ret;
1315
1316 if (client->irq > 0) {
1317 ret = devm_request_threaded_irq(&client->dev, client->irq,
1318 kmx61_data_rdy_trig_poll,
1319 kmx61_event_handler,
1320 IRQF_TRIGGER_RISING,
1321 "kmx61_event",
1322 data);
1323 if (ret)
1324 goto err_chip_uninit;
1325
1326 data->acc_dready_trig =
1327 kmx61_trigger_setup(data, data->acc_indio_dev,
1328 "dready");
1329 if (IS_ERR(data->acc_dready_trig)) {
1330 ret = PTR_ERR(data->acc_dready_trig);
1331 goto err_chip_uninit;
1332 }
1333
1334 data->mag_dready_trig =
1335 kmx61_trigger_setup(data, data->mag_indio_dev,
1336 "dready");
1337 if (IS_ERR(data->mag_dready_trig)) {
1338 ret = PTR_ERR(data->mag_dready_trig);
1339 goto err_trigger_unregister_acc_dready;
1340 }
1341
1342 data->motion_trig =
1343 kmx61_trigger_setup(data, data->acc_indio_dev,
1344 "any-motion");
1345 if (IS_ERR(data->motion_trig)) {
1346 ret = PTR_ERR(data->motion_trig);
1347 goto err_trigger_unregister_mag_dready;
1348 }
1349
1350 ret = iio_triggered_buffer_setup(data->acc_indio_dev,
1351 &iio_pollfunc_store_time,
1352 kmx61_trigger_handler,
1353 NULL);
1354 if (ret < 0) {
1355 dev_err(&data->client->dev,
1356 "Failed to setup acc triggered buffer\n");
1357 goto err_trigger_unregister_motion;
1358 }
1359
1360 ret = iio_triggered_buffer_setup(data->mag_indio_dev,
1361 &iio_pollfunc_store_time,
1362 kmx61_trigger_handler,
1363 NULL);
1364 if (ret < 0) {
1365 dev_err(&data->client->dev,
1366 "Failed to setup mag triggered buffer\n");
1367 goto err_buffer_cleanup_acc;
1368 }
1369 }
1370
1371 ret = pm_runtime_set_active(&client->dev);
1372 if (ret < 0)
1373 goto err_buffer_cleanup_mag;
1374
1375 pm_runtime_enable(&client->dev);
1376 pm_runtime_set_autosuspend_delay(&client->dev, KMX61_SLEEP_DELAY_MS);
1377 pm_runtime_use_autosuspend(&client->dev);
1378
1379 ret = iio_device_register(data->acc_indio_dev);
1380 if (ret < 0) {
1381 dev_err(&client->dev, "Failed to register acc iio device\n");
1382 goto err_pm_cleanup;
1383 }
1384
1385 ret = iio_device_register(data->mag_indio_dev);
1386 if (ret < 0) {
1387 dev_err(&client->dev, "Failed to register mag iio device\n");
1388 goto err_iio_unregister_acc;
1389 }
1390
1391 return 0;
1392
1393 err_iio_unregister_acc:
1394 iio_device_unregister(data->acc_indio_dev);
1395 err_pm_cleanup:
1396 pm_runtime_dont_use_autosuspend(&client->dev);
1397 pm_runtime_disable(&client->dev);
1398 err_buffer_cleanup_mag:
1399 if (client->irq > 0)
1400 iio_triggered_buffer_cleanup(data->mag_indio_dev);
1401 err_buffer_cleanup_acc:
1402 if (client->irq > 0)
1403 iio_triggered_buffer_cleanup(data->acc_indio_dev);
1404 err_trigger_unregister_motion:
1405 iio_trigger_unregister(data->motion_trig);
1406 err_trigger_unregister_mag_dready:
1407 iio_trigger_unregister(data->mag_dready_trig);
1408 err_trigger_unregister_acc_dready:
1409 iio_trigger_unregister(data->acc_dready_trig);
1410 err_chip_uninit:
1411 kmx61_set_mode(data, KMX61_ALL_STBY, KMX61_ACC | KMX61_MAG, true);
1412 return ret;
1413 }
1414
kmx61_remove(struct i2c_client * client)1415 static void kmx61_remove(struct i2c_client *client)
1416 {
1417 struct kmx61_data *data = i2c_get_clientdata(client);
1418
1419 iio_device_unregister(data->acc_indio_dev);
1420 iio_device_unregister(data->mag_indio_dev);
1421
1422 pm_runtime_disable(&client->dev);
1423 pm_runtime_set_suspended(&client->dev);
1424
1425 if (client->irq > 0) {
1426 iio_triggered_buffer_cleanup(data->acc_indio_dev);
1427 iio_triggered_buffer_cleanup(data->mag_indio_dev);
1428 iio_trigger_unregister(data->acc_dready_trig);
1429 iio_trigger_unregister(data->mag_dready_trig);
1430 iio_trigger_unregister(data->motion_trig);
1431 }
1432
1433 guard(mutex)(&data->lock);
1434
1435 kmx61_set_mode(data, KMX61_ALL_STBY, KMX61_ACC | KMX61_MAG, true);
1436 }
1437
kmx61_suspend(struct device * dev)1438 static int kmx61_suspend(struct device *dev)
1439 {
1440 struct kmx61_data *data = i2c_get_clientdata(to_i2c_client(dev));
1441
1442 guard(mutex)(&data->lock);
1443
1444 return kmx61_set_mode(data, KMX61_ALL_STBY, KMX61_ACC | KMX61_MAG, false);
1445 }
1446
kmx61_resume(struct device * dev)1447 static int kmx61_resume(struct device *dev)
1448 {
1449 u8 stby = 0;
1450 struct kmx61_data *data = i2c_get_clientdata(to_i2c_client(dev));
1451
1452 if (data->acc_stby)
1453 stby |= KMX61_ACC_STBY_BIT;
1454 if (data->mag_stby)
1455 stby |= KMX61_MAG_STBY_BIT;
1456
1457 return kmx61_set_mode(data, stby, KMX61_ACC | KMX61_MAG, true);
1458 }
1459
kmx61_runtime_suspend(struct device * dev)1460 static int kmx61_runtime_suspend(struct device *dev)
1461 {
1462 struct kmx61_data *data = i2c_get_clientdata(to_i2c_client(dev));
1463
1464 guard(mutex)(&data->lock);
1465
1466 return kmx61_set_mode(data, KMX61_ALL_STBY, KMX61_ACC | KMX61_MAG, true);
1467 }
1468
kmx61_runtime_resume(struct device * dev)1469 static int kmx61_runtime_resume(struct device *dev)
1470 {
1471 struct kmx61_data *data = i2c_get_clientdata(to_i2c_client(dev));
1472 u8 stby = 0;
1473
1474 if (!data->acc_ps)
1475 stby |= KMX61_ACC_STBY_BIT;
1476 if (!data->mag_ps)
1477 stby |= KMX61_MAG_STBY_BIT;
1478
1479 return kmx61_set_mode(data, stby, KMX61_ACC | KMX61_MAG, true);
1480 }
1481
1482 static const struct dev_pm_ops kmx61_pm_ops = {
1483 SYSTEM_SLEEP_PM_OPS(kmx61_suspend, kmx61_resume)
1484 RUNTIME_PM_OPS(kmx61_runtime_suspend, kmx61_runtime_resume, NULL)
1485 };
1486
1487 static const struct i2c_device_id kmx61_id[] = {
1488 { .name = "kmx611021" },
1489 { }
1490 };
1491
1492 MODULE_DEVICE_TABLE(i2c, kmx61_id);
1493
1494 static struct i2c_driver kmx61_driver = {
1495 .driver = {
1496 .name = "kmx61",
1497 .pm = pm_ptr(&kmx61_pm_ops),
1498 },
1499 .probe = kmx61_probe,
1500 .remove = kmx61_remove,
1501 .id_table = kmx61_id,
1502 };
1503
1504 module_i2c_driver(kmx61_driver);
1505
1506 MODULE_AUTHOR("Daniel Baluta <daniel.baluta@intel.com>");
1507 MODULE_DESCRIPTION("KMX61 accelerometer/magnetometer driver");
1508 MODULE_LICENSE("GPL v2");
1509