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/i2c.h>
11 #include <linux/interrupt.h>
12 #include <linux/mod_devicetable.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 pm_runtime_mark_last_busy(&data->client->dev);
754 ret = pm_runtime_put_autosuspend(&data->client->dev);
755 }
756 if (ret < 0) {
757 dev_err(&data->client->dev,
758 "Failed: kmx61_set_power_state for %d, ret %d\n",
759 on, ret);
760
761 return ret;
762 }
763 #endif
764 return 0;
765 }
766
kmx61_read_measurement(struct kmx61_data * data,u8 base,u8 offset)767 static int kmx61_read_measurement(struct kmx61_data *data, u8 base, u8 offset)
768 {
769 int ret;
770 u8 reg = base + offset * 2;
771
772 ret = i2c_smbus_read_word_data(data->client, reg);
773 if (ret < 0)
774 dev_err(&data->client->dev, "failed to read reg at %x\n", reg);
775
776 return ret;
777 }
778
kmx61_read_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int * val,int * val2,long mask)779 static int kmx61_read_raw(struct iio_dev *indio_dev,
780 struct iio_chan_spec const *chan, int *val,
781 int *val2, long mask)
782 {
783 int ret;
784 u8 base_reg;
785 struct kmx61_data *data = kmx61_get_data(indio_dev);
786
787 switch (mask) {
788 case IIO_CHAN_INFO_RAW:
789 switch (chan->type) {
790 case IIO_ACCEL:
791 base_reg = KMX61_ACC_XOUT_L;
792 break;
793 case IIO_MAGN:
794 base_reg = KMX61_MAG_XOUT_L;
795 break;
796 default:
797 return -EINVAL;
798 }
799 mutex_lock(&data->lock);
800
801 ret = kmx61_set_power_state(data, true, chan->address);
802 if (ret) {
803 mutex_unlock(&data->lock);
804 return ret;
805 }
806
807 ret = kmx61_read_measurement(data, base_reg, chan->scan_index);
808 if (ret < 0) {
809 kmx61_set_power_state(data, false, chan->address);
810 mutex_unlock(&data->lock);
811 return ret;
812 }
813 *val = sign_extend32(ret >> chan->scan_type.shift,
814 chan->scan_type.realbits - 1);
815 ret = kmx61_set_power_state(data, false, chan->address);
816
817 mutex_unlock(&data->lock);
818 if (ret)
819 return ret;
820 return IIO_VAL_INT;
821 case IIO_CHAN_INFO_SCALE:
822 switch (chan->type) {
823 case IIO_ACCEL:
824 *val = 0;
825 *val2 = kmx61_uscale_table[data->range];
826 return IIO_VAL_INT_PLUS_MICRO;
827 case IIO_MAGN:
828 /* 14 bits res, 1465 microGauss per magn count */
829 *val = 0;
830 *val2 = 1465;
831 return IIO_VAL_INT_PLUS_MICRO;
832 default:
833 return -EINVAL;
834 }
835 case IIO_CHAN_INFO_SAMP_FREQ:
836 if (chan->type != IIO_ACCEL && chan->type != IIO_MAGN)
837 return -EINVAL;
838
839 mutex_lock(&data->lock);
840 ret = kmx61_get_odr(data, val, val2, chan->address);
841 mutex_unlock(&data->lock);
842 if (ret)
843 return -EINVAL;
844 return IIO_VAL_INT_PLUS_MICRO;
845 }
846 return -EINVAL;
847 }
848
kmx61_write_raw(struct iio_dev * indio_dev,struct iio_chan_spec const * chan,int val,int val2,long mask)849 static int kmx61_write_raw(struct iio_dev *indio_dev,
850 struct iio_chan_spec const *chan, int val,
851 int val2, long mask)
852 {
853 int ret;
854 struct kmx61_data *data = kmx61_get_data(indio_dev);
855
856 switch (mask) {
857 case IIO_CHAN_INFO_SAMP_FREQ:
858 if (chan->type != IIO_ACCEL && chan->type != IIO_MAGN)
859 return -EINVAL;
860
861 mutex_lock(&data->lock);
862 ret = kmx61_set_odr(data, val, val2, chan->address);
863 mutex_unlock(&data->lock);
864 return ret;
865 case IIO_CHAN_INFO_SCALE:
866 switch (chan->type) {
867 case IIO_ACCEL:
868 if (val != 0)
869 return -EINVAL;
870 mutex_lock(&data->lock);
871 ret = kmx61_set_scale(data, val2);
872 mutex_unlock(&data->lock);
873 return ret;
874 default:
875 return -EINVAL;
876 }
877 default:
878 return -EINVAL;
879 }
880 }
881
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)882 static int kmx61_read_event(struct iio_dev *indio_dev,
883 const struct iio_chan_spec *chan,
884 enum iio_event_type type,
885 enum iio_event_direction dir,
886 enum iio_event_info info,
887 int *val, int *val2)
888 {
889 struct kmx61_data *data = kmx61_get_data(indio_dev);
890
891 *val2 = 0;
892 switch (info) {
893 case IIO_EV_INFO_VALUE:
894 *val = data->wake_thresh;
895 return IIO_VAL_INT;
896 case IIO_EV_INFO_PERIOD:
897 *val = data->wake_duration;
898 return IIO_VAL_INT;
899 default:
900 return -EINVAL;
901 }
902 }
903
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)904 static int kmx61_write_event(struct iio_dev *indio_dev,
905 const struct iio_chan_spec *chan,
906 enum iio_event_type type,
907 enum iio_event_direction dir,
908 enum iio_event_info info,
909 int val, int val2)
910 {
911 struct kmx61_data *data = kmx61_get_data(indio_dev);
912
913 if (data->ev_enable_state)
914 return -EBUSY;
915
916 switch (info) {
917 case IIO_EV_INFO_VALUE:
918 data->wake_thresh = val;
919 return IIO_VAL_INT;
920 case IIO_EV_INFO_PERIOD:
921 data->wake_duration = val;
922 return IIO_VAL_INT;
923 default:
924 return -EINVAL;
925 }
926 }
927
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)928 static int kmx61_read_event_config(struct iio_dev *indio_dev,
929 const struct iio_chan_spec *chan,
930 enum iio_event_type type,
931 enum iio_event_direction dir)
932 {
933 struct kmx61_data *data = kmx61_get_data(indio_dev);
934
935 return data->ev_enable_state;
936 }
937
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)938 static int kmx61_write_event_config(struct iio_dev *indio_dev,
939 const struct iio_chan_spec *chan,
940 enum iio_event_type type,
941 enum iio_event_direction dir,
942 bool state)
943 {
944 struct kmx61_data *data = kmx61_get_data(indio_dev);
945 int ret = 0;
946
947 if (state && data->ev_enable_state)
948 return 0;
949
950 mutex_lock(&data->lock);
951
952 if (!state && data->motion_trig_on) {
953 data->ev_enable_state = false;
954 goto err_unlock;
955 }
956
957 ret = kmx61_set_power_state(data, state, KMX61_ACC);
958 if (ret < 0)
959 goto err_unlock;
960
961 ret = kmx61_setup_any_motion_interrupt(data, state);
962 if (ret < 0) {
963 kmx61_set_power_state(data, false, KMX61_ACC);
964 goto err_unlock;
965 }
966
967 data->ev_enable_state = state;
968
969 err_unlock:
970 mutex_unlock(&data->lock);
971
972 return ret;
973 }
974
kmx61_acc_validate_trigger(struct iio_dev * indio_dev,struct iio_trigger * trig)975 static int kmx61_acc_validate_trigger(struct iio_dev *indio_dev,
976 struct iio_trigger *trig)
977 {
978 struct kmx61_data *data = kmx61_get_data(indio_dev);
979
980 if (data->acc_dready_trig != trig && data->motion_trig != trig)
981 return -EINVAL;
982
983 return 0;
984 }
985
kmx61_mag_validate_trigger(struct iio_dev * indio_dev,struct iio_trigger * trig)986 static int kmx61_mag_validate_trigger(struct iio_dev *indio_dev,
987 struct iio_trigger *trig)
988 {
989 struct kmx61_data *data = kmx61_get_data(indio_dev);
990
991 if (data->mag_dready_trig != trig)
992 return -EINVAL;
993
994 return 0;
995 }
996
997 static const struct iio_info kmx61_acc_info = {
998 .read_raw = kmx61_read_raw,
999 .write_raw = kmx61_write_raw,
1000 .attrs = &kmx61_acc_attribute_group,
1001 .read_event_value = kmx61_read_event,
1002 .write_event_value = kmx61_write_event,
1003 .read_event_config = kmx61_read_event_config,
1004 .write_event_config = kmx61_write_event_config,
1005 .validate_trigger = kmx61_acc_validate_trigger,
1006 };
1007
1008 static const struct iio_info kmx61_mag_info = {
1009 .read_raw = kmx61_read_raw,
1010 .write_raw = kmx61_write_raw,
1011 .attrs = &kmx61_mag_attribute_group,
1012 .validate_trigger = kmx61_mag_validate_trigger,
1013 };
1014
1015
kmx61_data_rdy_trigger_set_state(struct iio_trigger * trig,bool state)1016 static int kmx61_data_rdy_trigger_set_state(struct iio_trigger *trig,
1017 bool state)
1018 {
1019 int ret = 0;
1020 u8 device;
1021
1022 struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
1023 struct kmx61_data *data = kmx61_get_data(indio_dev);
1024
1025 mutex_lock(&data->lock);
1026
1027 if (!state && data->ev_enable_state && data->motion_trig_on) {
1028 data->motion_trig_on = false;
1029 goto err_unlock;
1030 }
1031
1032 if (data->acc_dready_trig == trig || data->motion_trig == trig)
1033 device = KMX61_ACC;
1034 else
1035 device = KMX61_MAG;
1036
1037 ret = kmx61_set_power_state(data, state, device);
1038 if (ret < 0)
1039 goto err_unlock;
1040
1041 if (data->acc_dready_trig == trig || data->mag_dready_trig == trig)
1042 ret = kmx61_setup_new_data_interrupt(data, state, device);
1043 else
1044 ret = kmx61_setup_any_motion_interrupt(data, state);
1045 if (ret < 0) {
1046 kmx61_set_power_state(data, false, device);
1047 goto err_unlock;
1048 }
1049
1050 if (data->acc_dready_trig == trig)
1051 data->acc_dready_trig_on = state;
1052 else if (data->mag_dready_trig == trig)
1053 data->mag_dready_trig_on = state;
1054 else
1055 data->motion_trig_on = state;
1056 err_unlock:
1057 mutex_unlock(&data->lock);
1058
1059 return ret;
1060 }
1061
kmx61_trig_reenable(struct iio_trigger * trig)1062 static void kmx61_trig_reenable(struct iio_trigger *trig)
1063 {
1064 struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
1065 struct kmx61_data *data = kmx61_get_data(indio_dev);
1066 int ret;
1067
1068 ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_INL);
1069 if (ret < 0)
1070 dev_err(&data->client->dev, "Error reading reg_inl\n");
1071 }
1072
1073 static const struct iio_trigger_ops kmx61_trigger_ops = {
1074 .set_trigger_state = kmx61_data_rdy_trigger_set_state,
1075 .reenable = kmx61_trig_reenable,
1076 };
1077
kmx61_event_handler(int irq,void * private)1078 static irqreturn_t kmx61_event_handler(int irq, void *private)
1079 {
1080 struct kmx61_data *data = private;
1081 struct iio_dev *indio_dev = data->acc_indio_dev;
1082 int ret;
1083
1084 ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_INS1);
1085 if (ret < 0) {
1086 dev_err(&data->client->dev, "Error reading reg_ins1\n");
1087 goto ack_intr;
1088 }
1089
1090 if (ret & KMX61_REG_INS1_BIT_WUFS) {
1091 ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_INS2);
1092 if (ret < 0) {
1093 dev_err(&data->client->dev, "Error reading reg_ins2\n");
1094 goto ack_intr;
1095 }
1096
1097 if (ret & KMX61_REG_INS2_BIT_XN)
1098 iio_push_event(indio_dev,
1099 IIO_MOD_EVENT_CODE(IIO_ACCEL,
1100 0,
1101 IIO_MOD_X,
1102 IIO_EV_TYPE_THRESH,
1103 IIO_EV_DIR_FALLING),
1104 0);
1105
1106 if (ret & KMX61_REG_INS2_BIT_XP)
1107 iio_push_event(indio_dev,
1108 IIO_MOD_EVENT_CODE(IIO_ACCEL,
1109 0,
1110 IIO_MOD_X,
1111 IIO_EV_TYPE_THRESH,
1112 IIO_EV_DIR_RISING),
1113 0);
1114
1115 if (ret & KMX61_REG_INS2_BIT_YN)
1116 iio_push_event(indio_dev,
1117 IIO_MOD_EVENT_CODE(IIO_ACCEL,
1118 0,
1119 IIO_MOD_Y,
1120 IIO_EV_TYPE_THRESH,
1121 IIO_EV_DIR_FALLING),
1122 0);
1123
1124 if (ret & KMX61_REG_INS2_BIT_YP)
1125 iio_push_event(indio_dev,
1126 IIO_MOD_EVENT_CODE(IIO_ACCEL,
1127 0,
1128 IIO_MOD_Y,
1129 IIO_EV_TYPE_THRESH,
1130 IIO_EV_DIR_RISING),
1131 0);
1132
1133 if (ret & KMX61_REG_INS2_BIT_ZN)
1134 iio_push_event(indio_dev,
1135 IIO_MOD_EVENT_CODE(IIO_ACCEL,
1136 0,
1137 IIO_MOD_Z,
1138 IIO_EV_TYPE_THRESH,
1139 IIO_EV_DIR_FALLING),
1140 0);
1141
1142 if (ret & KMX61_REG_INS2_BIT_ZP)
1143 iio_push_event(indio_dev,
1144 IIO_MOD_EVENT_CODE(IIO_ACCEL,
1145 0,
1146 IIO_MOD_Z,
1147 IIO_EV_TYPE_THRESH,
1148 IIO_EV_DIR_RISING),
1149 0);
1150 }
1151
1152 ack_intr:
1153 ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_CTRL1);
1154 if (ret < 0)
1155 dev_err(&data->client->dev, "Error reading reg_ctrl1\n");
1156
1157 ret |= KMX61_REG_CTRL1_BIT_RES;
1158 ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_CTRL1, ret);
1159 if (ret < 0)
1160 dev_err(&data->client->dev, "Error writing reg_ctrl1\n");
1161
1162 ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_INL);
1163 if (ret < 0)
1164 dev_err(&data->client->dev, "Error reading reg_inl\n");
1165
1166 return IRQ_HANDLED;
1167 }
1168
kmx61_data_rdy_trig_poll(int irq,void * private)1169 static irqreturn_t kmx61_data_rdy_trig_poll(int irq, void *private)
1170 {
1171 struct kmx61_data *data = private;
1172
1173 if (data->acc_dready_trig_on)
1174 iio_trigger_poll(data->acc_dready_trig);
1175 if (data->mag_dready_trig_on)
1176 iio_trigger_poll(data->mag_dready_trig);
1177
1178 if (data->motion_trig_on)
1179 iio_trigger_poll(data->motion_trig);
1180
1181 if (data->ev_enable_state)
1182 return IRQ_WAKE_THREAD;
1183 return IRQ_HANDLED;
1184 }
1185
kmx61_trigger_handler(int irq,void * p)1186 static irqreturn_t kmx61_trigger_handler(int irq, void *p)
1187 {
1188 struct iio_poll_func *pf = p;
1189 struct iio_dev *indio_dev = pf->indio_dev;
1190 struct kmx61_data *data = kmx61_get_data(indio_dev);
1191 int bit, ret, i = 0;
1192 u8 base;
1193 s16 buffer[8] = { };
1194
1195 if (indio_dev == data->acc_indio_dev)
1196 base = KMX61_ACC_XOUT_L;
1197 else
1198 base = KMX61_MAG_XOUT_L;
1199
1200 mutex_lock(&data->lock);
1201 iio_for_each_active_channel(indio_dev, bit) {
1202 ret = kmx61_read_measurement(data, base, bit);
1203 if (ret < 0) {
1204 mutex_unlock(&data->lock);
1205 goto err;
1206 }
1207 buffer[i++] = ret;
1208 }
1209 mutex_unlock(&data->lock);
1210
1211 iio_push_to_buffers(indio_dev, buffer);
1212 err:
1213 iio_trigger_notify_done(indio_dev->trig);
1214
1215 return IRQ_HANDLED;
1216 }
1217
kmx61_indiodev_setup(struct kmx61_data * data,const struct iio_info * info,const struct iio_chan_spec * chan,int num_channels,const char * name)1218 static struct iio_dev *kmx61_indiodev_setup(struct kmx61_data *data,
1219 const struct iio_info *info,
1220 const struct iio_chan_spec *chan,
1221 int num_channels,
1222 const char *name)
1223 {
1224 struct iio_dev *indio_dev;
1225
1226 indio_dev = devm_iio_device_alloc(&data->client->dev, sizeof(data));
1227 if (!indio_dev)
1228 return ERR_PTR(-ENOMEM);
1229
1230 kmx61_set_data(indio_dev, data);
1231
1232 indio_dev->channels = chan;
1233 indio_dev->num_channels = num_channels;
1234 indio_dev->name = name;
1235 indio_dev->modes = INDIO_DIRECT_MODE;
1236 indio_dev->info = info;
1237
1238 return indio_dev;
1239 }
1240
kmx61_trigger_setup(struct kmx61_data * data,struct iio_dev * indio_dev,const char * tag)1241 static struct iio_trigger *kmx61_trigger_setup(struct kmx61_data *data,
1242 struct iio_dev *indio_dev,
1243 const char *tag)
1244 {
1245 struct iio_trigger *trig;
1246 int ret;
1247
1248 trig = devm_iio_trigger_alloc(&data->client->dev,
1249 "%s-%s-dev%d",
1250 indio_dev->name,
1251 tag,
1252 iio_device_id(indio_dev));
1253 if (!trig)
1254 return ERR_PTR(-ENOMEM);
1255
1256 trig->ops = &kmx61_trigger_ops;
1257 iio_trigger_set_drvdata(trig, indio_dev);
1258
1259 ret = iio_trigger_register(trig);
1260 if (ret)
1261 return ERR_PTR(ret);
1262
1263 return trig;
1264 }
1265
kmx61_probe(struct i2c_client * client)1266 static int kmx61_probe(struct i2c_client *client)
1267 {
1268 const struct i2c_device_id *id = i2c_client_get_device_id(client);
1269 int ret;
1270 struct kmx61_data *data;
1271 const char *name = NULL;
1272
1273 data = devm_kzalloc(&client->dev, sizeof(*data), GFP_KERNEL);
1274 if (!data)
1275 return -ENOMEM;
1276
1277 i2c_set_clientdata(client, data);
1278 data->client = client;
1279
1280 mutex_init(&data->lock);
1281
1282 if (id)
1283 name = id->name;
1284 else
1285 return -ENODEV;
1286
1287 data->acc_indio_dev =
1288 kmx61_indiodev_setup(data, &kmx61_acc_info,
1289 kmx61_acc_channels,
1290 ARRAY_SIZE(kmx61_acc_channels),
1291 name);
1292 if (IS_ERR(data->acc_indio_dev))
1293 return PTR_ERR(data->acc_indio_dev);
1294
1295 data->mag_indio_dev =
1296 kmx61_indiodev_setup(data, &kmx61_mag_info,
1297 kmx61_mag_channels,
1298 ARRAY_SIZE(kmx61_mag_channels),
1299 name);
1300 if (IS_ERR(data->mag_indio_dev))
1301 return PTR_ERR(data->mag_indio_dev);
1302
1303 ret = kmx61_chip_init(data);
1304 if (ret < 0)
1305 return ret;
1306
1307 if (client->irq > 0) {
1308 ret = devm_request_threaded_irq(&client->dev, client->irq,
1309 kmx61_data_rdy_trig_poll,
1310 kmx61_event_handler,
1311 IRQF_TRIGGER_RISING,
1312 "kmx61_event",
1313 data);
1314 if (ret)
1315 goto err_chip_uninit;
1316
1317 data->acc_dready_trig =
1318 kmx61_trigger_setup(data, data->acc_indio_dev,
1319 "dready");
1320 if (IS_ERR(data->acc_dready_trig)) {
1321 ret = PTR_ERR(data->acc_dready_trig);
1322 goto err_chip_uninit;
1323 }
1324
1325 data->mag_dready_trig =
1326 kmx61_trigger_setup(data, data->mag_indio_dev,
1327 "dready");
1328 if (IS_ERR(data->mag_dready_trig)) {
1329 ret = PTR_ERR(data->mag_dready_trig);
1330 goto err_trigger_unregister_acc_dready;
1331 }
1332
1333 data->motion_trig =
1334 kmx61_trigger_setup(data, data->acc_indio_dev,
1335 "any-motion");
1336 if (IS_ERR(data->motion_trig)) {
1337 ret = PTR_ERR(data->motion_trig);
1338 goto err_trigger_unregister_mag_dready;
1339 }
1340
1341 ret = iio_triggered_buffer_setup(data->acc_indio_dev,
1342 &iio_pollfunc_store_time,
1343 kmx61_trigger_handler,
1344 NULL);
1345 if (ret < 0) {
1346 dev_err(&data->client->dev,
1347 "Failed to setup acc triggered buffer\n");
1348 goto err_trigger_unregister_motion;
1349 }
1350
1351 ret = iio_triggered_buffer_setup(data->mag_indio_dev,
1352 &iio_pollfunc_store_time,
1353 kmx61_trigger_handler,
1354 NULL);
1355 if (ret < 0) {
1356 dev_err(&data->client->dev,
1357 "Failed to setup mag triggered buffer\n");
1358 goto err_buffer_cleanup_acc;
1359 }
1360 }
1361
1362 ret = pm_runtime_set_active(&client->dev);
1363 if (ret < 0)
1364 goto err_buffer_cleanup_mag;
1365
1366 pm_runtime_enable(&client->dev);
1367 pm_runtime_set_autosuspend_delay(&client->dev, KMX61_SLEEP_DELAY_MS);
1368 pm_runtime_use_autosuspend(&client->dev);
1369
1370 ret = iio_device_register(data->acc_indio_dev);
1371 if (ret < 0) {
1372 dev_err(&client->dev, "Failed to register acc iio device\n");
1373 goto err_pm_cleanup;
1374 }
1375
1376 ret = iio_device_register(data->mag_indio_dev);
1377 if (ret < 0) {
1378 dev_err(&client->dev, "Failed to register mag iio device\n");
1379 goto err_iio_unregister_acc;
1380 }
1381
1382 return 0;
1383
1384 err_iio_unregister_acc:
1385 iio_device_unregister(data->acc_indio_dev);
1386 err_pm_cleanup:
1387 pm_runtime_dont_use_autosuspend(&client->dev);
1388 pm_runtime_disable(&client->dev);
1389 err_buffer_cleanup_mag:
1390 if (client->irq > 0)
1391 iio_triggered_buffer_cleanup(data->mag_indio_dev);
1392 err_buffer_cleanup_acc:
1393 if (client->irq > 0)
1394 iio_triggered_buffer_cleanup(data->acc_indio_dev);
1395 err_trigger_unregister_motion:
1396 iio_trigger_unregister(data->motion_trig);
1397 err_trigger_unregister_mag_dready:
1398 iio_trigger_unregister(data->mag_dready_trig);
1399 err_trigger_unregister_acc_dready:
1400 iio_trigger_unregister(data->acc_dready_trig);
1401 err_chip_uninit:
1402 kmx61_set_mode(data, KMX61_ALL_STBY, KMX61_ACC | KMX61_MAG, true);
1403 return ret;
1404 }
1405
kmx61_remove(struct i2c_client * client)1406 static void kmx61_remove(struct i2c_client *client)
1407 {
1408 struct kmx61_data *data = i2c_get_clientdata(client);
1409
1410 iio_device_unregister(data->acc_indio_dev);
1411 iio_device_unregister(data->mag_indio_dev);
1412
1413 pm_runtime_disable(&client->dev);
1414 pm_runtime_set_suspended(&client->dev);
1415
1416 if (client->irq > 0) {
1417 iio_triggered_buffer_cleanup(data->acc_indio_dev);
1418 iio_triggered_buffer_cleanup(data->mag_indio_dev);
1419 iio_trigger_unregister(data->acc_dready_trig);
1420 iio_trigger_unregister(data->mag_dready_trig);
1421 iio_trigger_unregister(data->motion_trig);
1422 }
1423
1424 mutex_lock(&data->lock);
1425 kmx61_set_mode(data, KMX61_ALL_STBY, KMX61_ACC | KMX61_MAG, true);
1426 mutex_unlock(&data->lock);
1427 }
1428
kmx61_suspend(struct device * dev)1429 static int kmx61_suspend(struct device *dev)
1430 {
1431 int ret;
1432 struct kmx61_data *data = i2c_get_clientdata(to_i2c_client(dev));
1433
1434 mutex_lock(&data->lock);
1435 ret = kmx61_set_mode(data, KMX61_ALL_STBY, KMX61_ACC | KMX61_MAG,
1436 false);
1437 mutex_unlock(&data->lock);
1438
1439 return ret;
1440 }
1441
kmx61_resume(struct device * dev)1442 static int kmx61_resume(struct device *dev)
1443 {
1444 u8 stby = 0;
1445 struct kmx61_data *data = i2c_get_clientdata(to_i2c_client(dev));
1446
1447 if (data->acc_stby)
1448 stby |= KMX61_ACC_STBY_BIT;
1449 if (data->mag_stby)
1450 stby |= KMX61_MAG_STBY_BIT;
1451
1452 return kmx61_set_mode(data, stby, KMX61_ACC | KMX61_MAG, true);
1453 }
1454
kmx61_runtime_suspend(struct device * dev)1455 static int kmx61_runtime_suspend(struct device *dev)
1456 {
1457 struct kmx61_data *data = i2c_get_clientdata(to_i2c_client(dev));
1458 int ret;
1459
1460 mutex_lock(&data->lock);
1461 ret = kmx61_set_mode(data, KMX61_ALL_STBY, KMX61_ACC | KMX61_MAG, true);
1462 mutex_unlock(&data->lock);
1463
1464 return ret;
1465 }
1466
kmx61_runtime_resume(struct device * dev)1467 static int kmx61_runtime_resume(struct device *dev)
1468 {
1469 struct kmx61_data *data = i2c_get_clientdata(to_i2c_client(dev));
1470 u8 stby = 0;
1471
1472 if (!data->acc_ps)
1473 stby |= KMX61_ACC_STBY_BIT;
1474 if (!data->mag_ps)
1475 stby |= KMX61_MAG_STBY_BIT;
1476
1477 return kmx61_set_mode(data, stby, KMX61_ACC | KMX61_MAG, true);
1478 }
1479
1480 static const struct dev_pm_ops kmx61_pm_ops = {
1481 SYSTEM_SLEEP_PM_OPS(kmx61_suspend, kmx61_resume)
1482 RUNTIME_PM_OPS(kmx61_runtime_suspend, kmx61_runtime_resume, NULL)
1483 };
1484
1485 static const struct i2c_device_id kmx61_id[] = {
1486 { "kmx611021" },
1487 { }
1488 };
1489
1490 MODULE_DEVICE_TABLE(i2c, kmx61_id);
1491
1492 static struct i2c_driver kmx61_driver = {
1493 .driver = {
1494 .name = "kmx61",
1495 .pm = pm_ptr(&kmx61_pm_ops),
1496 },
1497 .probe = kmx61_probe,
1498 .remove = kmx61_remove,
1499 .id_table = kmx61_id,
1500 };
1501
1502 module_i2c_driver(kmx61_driver);
1503
1504 MODULE_AUTHOR("Daniel Baluta <daniel.baluta@intel.com>");
1505 MODULE_DESCRIPTION("KMX61 accelerometer/magnetometer driver");
1506 MODULE_LICENSE("GPL v2");
1507