]> git.proxmox.com Git - mirror_ubuntu-zesty-kernel.git/blame - drivers/iio/imu/kmx61.c
projects / mirror_ubuntu-zesty-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
iio: imu: kmx61: Add PM runtime support
[mirror_ubuntu-zesty-kernel.git] / drivers / iio / imu / kmx61.c
CommitLineData
20ffac27
DB		 1/*
2 * KMX61 - Kionix 6-axis Accelerometer/Magnetometer
3 *
4 * Copyright (c) 2014, Intel Corporation.
5 *
6 * This file is subject to the terms and conditions of version 2 of
7 * the GNU General Public License. See the file COPYING in the main
8 * directory of this archive for more details.
9 *
10 * IIO driver for KMX61 (7-bit I2C slave address 0x0E or 0x0F).
11 *
12 */
13
14#include <linux/module.h>
15#include <linux/i2c.h>
b25862c5
DB		 16#include <linux/acpi.h>
17#include <linux/gpio/consumer.h>
aff8609a
DB		 18#include <linux/interrupt.h>
19#include <linux/pm_runtime.h>
20ffac27
DB		 20#include <linux/iio/iio.h>
21#include <linux/iio/sysfs.h>
22
23#define KMX61_DRV_NAME "kmx61"
b25862c5 24#define KMX61_GPIO_NAME "kmx61_int"
20ffac27
DB		 25
26#define KMX61_REG_WHO_AM_I 0x00
27
28/*
29 * three 16-bit accelerometer output registers for X/Y/Z axis
30 * we use only XOUT_L as a base register, all other addresses
31 * can be obtained by applying an offset and are provided here
32 * only for clarity.
33 */
34#define KMX61_ACC_XOUT_L 0x0A
35#define KMX61_ACC_XOUT_H 0x0B
36#define KMX61_ACC_YOUT_L 0x0C
37#define KMX61_ACC_YOUT_H 0x0D
38#define KMX61_ACC_ZOUT_L 0x0E
39#define KMX61_ACC_ZOUT_H 0x0F
40
41/*
42 * one 16-bit temperature output register
43 */
44#define KMX61_TEMP_L 0x10
45#define KMX61_TEMP_H 0x11
46
47/*
48 * three 16-bit magnetometer output registers for X/Y/Z axis
49 */
50#define KMX61_MAG_XOUT_L 0x12
51#define KMX61_MAG_XOUT_H 0x13
52#define KMX61_MAG_YOUT_L 0x14
53#define KMX61_MAG_YOUT_H 0x15
54#define KMX61_MAG_ZOUT_L 0x16
55#define KMX61_MAG_ZOUT_H 0x17
56
57#define KMX61_REG_STBY 0x29
58#define KMX61_REG_CTRL1 0x2A
59#define KMX61_REG_ODCNTL 0x2C
60
61#define KMX61_ACC_STBY_BIT BIT(0)
62#define KMX61_MAG_STBY_BIT BIT(1)
63#define KMX61_ACT_STBY_BIT BIT(7)
64
65#define KMX61_ALL_STBY (KMX61_ACC_STBY_BIT | KMX61_MAG_STBY_BIT)
66
67#define KMX61_REG_CTRL1_GSEL_MASK 0x03
68
69#define KMX61_ACC_ODR_SHIFT 0
70#define KMX61_MAG_ODR_SHIFT 4
71#define KMX61_ACC_ODR_MASK 0x0F
72#define KMX61_MAG_ODR_MASK 0xF0
73
aff8609a
DB		 74#define KMX61_SLEEP_DELAY_MS 2000
75
20ffac27
DB		 76#define KMX61_CHIP_ID 0x12
77
78/* KMX61 devices */
79#define KMX61_ACC 0x01
80#define KMX61_MAG 0x02
81
82struct kmx61_data {
83 struct i2c_client *client;
84
85 /* serialize access to non-atomic ops, e.g set_mode */
86 struct mutex lock;
87
88 /* standby state */
89 bool acc_stby;
90 bool mag_stby;
91
aff8609a
DB		 92 /* power state */
93 bool acc_ps;
94 bool mag_ps;
95
20ffac27
DB		 96 /* config bits */
97 u8 range;
98 u8 odr_bits;
99
100 /* accelerometer specific data */
101 struct iio_dev *acc_indio_dev;
102
103 /* magnetometer specific data */
104 struct iio_dev *mag_indio_dev;
105};
106
107enum kmx61_range {
108 KMX61_RANGE_2G,
109 KMX61_RANGE_4G,
110 KMX61_RANGE_8G,
111};
112
113enum kmx61_axis {
114 KMX61_AXIS_X,
115 KMX61_AXIS_Y,
116 KMX61_AXIS_Z,
117};
118
119static const u16 kmx61_uscale_table[] = {9582, 19163, 38326};
120
121static const struct {
122 int val;
123 int val2;
124 u8 odr_bits;
125} kmx61_samp_freq_table[] = { {12, 500000, 0x00},
126 {25, 0, 0x01},
127 {50, 0, 0x02},
128 {100, 0, 0x03},
129 {200, 0, 0x04},
130 {400, 0, 0x05},
131 {800, 0, 0x06},
132 {1600, 0, 0x07},
133 {0, 781000, 0x08},
134 {1, 563000, 0x09},
135 {3, 125000, 0x0A},
136 {6, 250000, 0x0B} };
137
138static IIO_CONST_ATTR(accel_scale_available, "0.009582 0.019163 0.038326");
139static IIO_CONST_ATTR(magn_scale_available, "0.001465");
140static IIO_CONST_ATTR_SAMP_FREQ_AVAIL(
141 "0.781000 1.563000 3.125000 6.250000 12.500000 25 50 100 200 400 800");
142
143static struct attribute *kmx61_acc_attributes[] = {
144 &iio_const_attr_accel_scale_available.dev_attr.attr,
145 &iio_const_attr_sampling_frequency_available.dev_attr.attr,
146 NULL,
147};
148
149static struct attribute *kmx61_mag_attributes[] = {
150 &iio_const_attr_magn_scale_available.dev_attr.attr,
151 &iio_const_attr_sampling_frequency_available.dev_attr.attr,
152 NULL,
153};
154
155static const struct attribute_group kmx61_acc_attribute_group = {
156 .attrs = kmx61_acc_attributes,
157};
158
159static const struct attribute_group kmx61_mag_attribute_group = {
160 .attrs = kmx61_mag_attributes,
161};
162
163#define KMX61_ACC_CHAN(_axis) { \
164 .type = IIO_ACCEL, \
165 .modified = 1, \
166 .channel2 = IIO_MOD_ ## _axis, \
167 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
168 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
169 BIT(IIO_CHAN_INFO_SAMP_FREQ), \
170 .address = KMX61_ACC, \
171 .scan_index = KMX61_AXIS_ ## _axis, \
172 .scan_type = { \
173 .sign = 's', \
174 .realbits = 12, \
175 .storagebits = 16, \
176 .shift = 4, \
177 .endianness = IIO_LE, \
178 }, \
179}
180
181#define KMX61_MAG_CHAN(_axis) { \
182 .type = IIO_MAGN, \
183 .modified = 1, \
184 .channel2 = IIO_MOD_ ## _axis, \
185 .address = KMX61_MAG, \
186 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \
187 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \
188 BIT(IIO_CHAN_INFO_SAMP_FREQ), \
189 .scan_index = KMX61_AXIS_ ## _axis, \
190 .scan_type = { \
191 .sign = 's', \
192 .realbits = 14, \
193 .storagebits = 16, \
194 .shift = 2, \
195 .endianness = IIO_LE, \
196 }, \
197}
198
199static const struct iio_chan_spec kmx61_acc_channels[] = {
200 KMX61_ACC_CHAN(X),
201 KMX61_ACC_CHAN(Y),
202 KMX61_ACC_CHAN(Z),
203};
204
205static const struct iio_chan_spec kmx61_mag_channels[] = {
206 KMX61_MAG_CHAN(X),
207 KMX61_MAG_CHAN(Y),
208 KMX61_MAG_CHAN(Z),
209};
210
211static void kmx61_set_data(struct iio_dev *indio_dev, struct kmx61_data *data)
212{
213 struct kmx61_data **priv = iio_priv(indio_dev);
214
215 *priv = data;
216}
217
218static struct kmx61_data *kmx61_get_data(struct iio_dev *indio_dev)
219{
220 return *(struct kmx61_data **)iio_priv(indio_dev);
221}
222
223static int kmx61_convert_freq_to_bit(int val, int val2)
224{
225 int i;
226
227 for (i = 0; i < ARRAY_SIZE(kmx61_samp_freq_table); i++)
228 if (val == kmx61_samp_freq_table[i].val &&
229 val2 == kmx61_samp_freq_table[i].val2)
230 return kmx61_samp_freq_table[i].odr_bits;
231 return -EINVAL;
232}
233
234/**
235 * kmx61_set_mode() - set KMX61 device operating mode
236 * @data - kmx61 device private data pointer
237 * @mode - bitmask, indicating operating mode for @device
238 * @device - bitmask, indicating device for which @mode needs to be set
239 * @update - update stby bits stored in device's private @data
240 *
241 * For each sensor (accelerometer/magnetometer) there are two operating modes
242 * STANDBY and OPERATION. Neither accel nor magn can be disabled independently
243 * if they are both enabled. Internal sensors state is saved in acc_stby and
244 * mag_stby members of driver's private @data.
245 */
246static int kmx61_set_mode(struct kmx61_data *data, u8 mode, u8 device,
247 bool update)
248{
249 int ret;
250 int acc_stby = -1, mag_stby = -1;
251
252 ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_STBY);
253 if (ret < 0) {
254 dev_err(&data->client->dev, "Error reading reg_stby\n");
255 return ret;
256 }
257 if (device & KMX61_ACC) {
258 if (mode & KMX61_ACC_STBY_BIT) {
259 ret |= KMX61_ACC_STBY_BIT;
260 acc_stby = 1;
261 } else {
262 ret &= ~KMX61_ACC_STBY_BIT;
263 acc_stby = 0;
264 }
265 }
266
267 if (device & KMX61_MAG) {
268 if (mode & KMX61_MAG_STBY_BIT) {
269 ret |= KMX61_MAG_STBY_BIT;
270 mag_stby = 1;
271 } else {
272 ret &= ~KMX61_MAG_STBY_BIT;
273 mag_stby = 0;
274 }
275 }
276
277 if (mode & KMX61_ACT_STBY_BIT)
278 ret |= KMX61_ACT_STBY_BIT;
279
280 ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_STBY, ret);
281 if (ret < 0) {
282 dev_err(&data->client->dev, "Error writing reg_stby\n");
283 return ret;
284 }
285
286 if (acc_stby != -1 && update)
287 data->acc_stby = acc_stby;
288 if (mag_stby != -1 && update)
289 data->mag_stby = mag_stby;
290
291 return 0;
292}
293
294static int kmx61_get_mode(struct kmx61_data *data, u8 *mode, u8 device)
295{
296 int ret;
297
298 ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_STBY);
299 if (ret < 0) {
300 dev_err(&data->client->dev, "Error reading reg_stby\n");
301 return ret;
302 }
303 *mode = 0;
304
305 if (device & KMX61_ACC) {
306 if (ret & KMX61_ACC_STBY_BIT)
307 *mode |= KMX61_ACC_STBY_BIT;
308 else
309 *mode &= ~KMX61_ACC_STBY_BIT;
310 }
311
312 if (device & KMX61_MAG) {
313 if (ret & KMX61_MAG_STBY_BIT)
314 *mode |= KMX61_MAG_STBY_BIT;
315 else
316 *mode &= ~KMX61_MAG_STBY_BIT;
317 }
318
319 return 0;
320}
321
322static int kmx61_set_odr(struct kmx61_data *data, int val, int val2, u8 device)
323{
324 int ret;
325 u8 mode;
326 int lodr_bits, odr_bits;
327
328 ret = kmx61_get_mode(data, &mode, KMX61_ACC | KMX61_MAG);
329 if (ret < 0)
330 return ret;
331
332 lodr_bits = kmx61_convert_freq_to_bit(val, val2);
333 if (lodr_bits < 0)
334 return lodr_bits;
335
336 /* To change ODR, accel and magn must be in STDBY */
337 ret = kmx61_set_mode(data, KMX61_ALL_STBY, KMX61_ACC | KMX61_MAG,
338 true);
339 if (ret < 0)
340 return ret;
341
342 odr_bits = 0;
343 if (device & KMX61_ACC)
344 odr_bits |= lodr_bits << KMX61_ACC_ODR_SHIFT;
345 if (device & KMX61_MAG)
346 odr_bits |= lodr_bits << KMX61_MAG_ODR_SHIFT;
347
348 ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_ODCNTL,
349 odr_bits);
350 if (ret < 0)
351 return ret;
352
353 return kmx61_set_mode(data, mode, KMX61_ACC | KMX61_MAG, true);
354}
355
356static int kmx61_get_odr(struct kmx61_data *data, int *val, int *val2,
357 u8 device)
358{ int i;
359 u8 lodr_bits;
360
361 if (device & KMX61_ACC)
362 lodr_bits = (data->odr_bits >> KMX61_ACC_ODR_SHIFT) &
363 KMX61_ACC_ODR_MASK;
364 else if (device & KMX61_MAG)
365 lodr_bits = (data->odr_bits >> KMX61_MAG_ODR_SHIFT) &
366 KMX61_MAG_ODR_MASK;
367 else
368 return -EINVAL;
369
370 for (i = 0; i < ARRAY_SIZE(kmx61_samp_freq_table); i++)
371 if (lodr_bits == kmx61_samp_freq_table[i].odr_bits) {
372 *val = kmx61_samp_freq_table[i].val;
373 *val2 = kmx61_samp_freq_table[i].val2;
374 return 0;
375 }
376 return -EINVAL;
377}
378
379static int kmx61_set_range(struct kmx61_data *data, u8 range)
380{
381 int ret;
382
383 ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_CTRL1);
384 if (ret < 0) {
385 dev_err(&data->client->dev, "Error reading reg_ctrl1\n");
386 return ret;
387 }
388
389 ret &= ~KMX61_REG_CTRL1_GSEL_MASK;
390 ret |= range & KMX61_REG_CTRL1_GSEL_MASK;
391
392 ret = i2c_smbus_write_byte_data(data->client, KMX61_REG_CTRL1, ret);
393 if (ret < 0) {
394 dev_err(&data->client->dev, "Error writing reg_ctrl1\n");
395 return ret;
396 }
397
398 data->range = range;
399
400 return 0;
401}
402
403static int kmx61_set_scale(struct kmx61_data *data, u16 uscale)
404{
405 int ret, i;
406 u8 mode;
407
408 for (i = 0; i < ARRAY_SIZE(kmx61_uscale_table); i++) {
409 if (kmx61_uscale_table[i] == uscale) {
410 ret = kmx61_get_mode(data, &mode,
411 KMX61_ACC | KMX61_MAG);
412 if (ret < 0)
413 return ret;
414
415 ret = kmx61_set_mode(data, KMX61_ALL_STBY,
416 KMX61_ACC | KMX61_MAG, true);
417 if (ret < 0)
418 return ret;
419
420 ret = kmx61_set_range(data, i);
421 if (ret < 0)
422 return ret;
423
424 return kmx61_set_mode(data, mode,
425 KMX61_ACC | KMX61_MAG, true);
426 }
427 }
428 return -EINVAL;
429}
430
431static int kmx61_chip_init(struct kmx61_data *data)
432{
433 int ret;
434
435 ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_WHO_AM_I);
436 if (ret < 0) {
437 dev_err(&data->client->dev, "Error reading who_am_i\n");
438 return ret;
439 }
440
441 if (ret != KMX61_CHIP_ID) {
442 dev_err(&data->client->dev,
443 "Wrong chip id, got %x expected %x\n",
444 ret, KMX61_CHIP_ID);
445 return -EINVAL;
446 }
447
448 /* set accel 12bit, 4g range */
449 ret = kmx61_set_range(data, KMX61_RANGE_4G);
450 if (ret < 0)
451 return ret;
452
453 ret = i2c_smbus_read_byte_data(data->client, KMX61_REG_ODCNTL);
454 if (ret < 0) {
455 dev_err(&data->client->dev, "Error reading reg_odcntl\n");
456 return ret;
457 }
458 data->odr_bits = ret;
459
460 /* set acc/magn to OPERATION mode */
461 ret = kmx61_set_mode(data, 0, KMX61_ACC | KMX61_MAG, true);
462 if (ret < 0)
463 return ret;
464
465 return 0;
466}
467
aff8609a
DB		 468/**
469 * kmx61_set_power_state() - set power state for kmx61 @device
470 * @data - kmx61 device private pointer
471 * @on - power state to be set for @device
472 * @device - bitmask indicating device for which @on state needs to be set
473 *
474 * Notice that when ACC power state needs to be set to ON and MAG is in
475 * OPERATION then we know that kmx61_runtime_resume was already called
476 * so we must set ACC OPERATION mode here. The same happens when MAG power
477 * state needs to be set to ON and ACC is in OPERATION.
478 */
479static int kmx61_set_power_state(struct kmx61_data *data, bool on, u8 device)
480{
481#ifdef CONFIG_PM_RUNTIME
482 int ret;
483
484 if (device & KMX61_ACC) {
485 if (on && !data->acc_ps && !data->mag_stby) {
486 ret = kmx61_set_mode(data, 0, KMX61_ACC, true);
487 if (ret < 0)
488 return ret;
489 }
490 data->acc_ps = on;
491 }
492 if (device & KMX61_MAG) {
493 if (on && !data->mag_ps && !data->acc_stby) {
494 ret = kmx61_set_mode(data, 0, KMX61_MAG, true);
495 if (ret < 0)
496 return ret;
497 }
498 data->mag_ps = on;
499 }
500
501 if (on) {
502 ret = pm_runtime_get_sync(&data->client->dev);
503 } else {
504 pm_runtime_mark_last_busy(&data->client->dev);
505 ret = pm_runtime_put_autosuspend(&data->client->dev);
506 }
507 if (ret < 0) {
508 dev_err(&data->client->dev,
509 "Failed: kmx61_set_power_state for %d, ret %d\n",
510 on, ret);
511 if (on)
512 pm_runtime_put_noidle(&data->client->dev);
513
514 return ret;
515 }
516#endif
517 return 0;
518}
519
20ffac27
DB		 520static int kmx61_read_measurement(struct kmx61_data *data, u8 base, u8 offset)
521{
522 int ret;
523 u8 reg = base + offset * 2;
524
525 ret = i2c_smbus_read_word_data(data->client, reg);
526 if (ret < 0)
527 dev_err(&data->client->dev, "failed to read reg at %x\n", reg);
528
529 return ret;
530}
531
532static int kmx61_read_raw(struct iio_dev *indio_dev,
533 struct iio_chan_spec const *chan, int *val,
534 int *val2, long mask)
535{
536 int ret;
537 u8 base_reg;
538 struct kmx61_data *data = kmx61_get_data(indio_dev);
539
540 switch (mask) {
541 case IIO_CHAN_INFO_RAW:
542 switch (chan->type) {
543 case IIO_ACCEL:
544 base_reg = KMX61_ACC_XOUT_L;
545 break;
546 case IIO_MAGN:
547 base_reg = KMX61_MAG_XOUT_L;
548 break;
549 default:
550 return -EINVAL;
551 }
552 mutex_lock(&data->lock);
553
aff8609a 554 kmx61_set_power_state(data, true, chan->address);
20ffac27
DB		 555 ret = kmx61_read_measurement(data, base_reg, chan->scan_index);
556 if (ret < 0) {
aff8609a 557 kmx61_set_power_state(data, false, chan->address);
20ffac27
DB		 558 mutex_unlock(&data->lock);
559 return ret;
560 }
561 *val = sign_extend32(ret >> chan->scan_type.shift,
562 chan->scan_type.realbits - 1);
aff8609a 563 kmx61_set_power_state(data, false, chan->address);
20ffac27
DB		 564
565 mutex_unlock(&data->lock);
566 return IIO_VAL_INT;
567 case IIO_CHAN_INFO_SCALE:
568 switch (chan->type) {
569 case IIO_ACCEL:
570 *val = 0;
571 *val2 = kmx61_uscale_table[data->range];
572 return IIO_VAL_INT_PLUS_MICRO;
573 case IIO_MAGN:
574 /* 14 bits res, 1465 microGauss per magn count */
575 *val = 0;
576 *val2 = 1465;
577 return IIO_VAL_INT_PLUS_MICRO;
578 default:
579 return -EINVAL;
580 }
581 case IIO_CHAN_INFO_SAMP_FREQ:
582 if (chan->type != IIO_ACCEL && chan->type != IIO_MAGN)
583 return -EINVAL;
584
585 mutex_lock(&data->lock);
586 ret = kmx61_get_odr(data, val, val2, chan->address);
587 mutex_unlock(&data->lock);
588 if (ret)
589 return -EINVAL;
590 return IIO_VAL_INT_PLUS_MICRO;
591 }
592 return -EINVAL;
593}
594
595static int kmx61_write_raw(struct iio_dev *indio_dev,
596 struct iio_chan_spec const *chan, int val,
597 int val2, long mask)
598{
599 int ret;
600 struct kmx61_data *data = kmx61_get_data(indio_dev);
601
602 switch (mask) {
603 case IIO_CHAN_INFO_SAMP_FREQ:
604 if (chan->type != IIO_ACCEL && chan->type != IIO_MAGN)
605 return -EINVAL;
606
607 mutex_lock(&data->lock);
608 ret = kmx61_set_odr(data, val, val2, chan->address);
609 mutex_unlock(&data->lock);
610 return ret;
611 case IIO_CHAN_INFO_SCALE:
612 switch (chan->type) {
613 case IIO_ACCEL:
614 if (val != 0)
615 return -EINVAL;
616 mutex_lock(&data->lock);
617 ret = kmx61_set_scale(data, val2);
618 mutex_unlock(&data->lock);
619 return ret;
620 default:
621 return -EINVAL;
622 }
623 default:
624 return -EINVAL;
625 }
626}
627
628static const struct iio_info kmx61_acc_info = {
629 .driver_module = THIS_MODULE,
630 .read_raw = kmx61_read_raw,
631 .write_raw = kmx61_write_raw,
632 .attrs = &kmx61_acc_attribute_group,
633};
634
635static const struct iio_info kmx61_mag_info = {
636 .driver_module = THIS_MODULE,
637 .read_raw = kmx61_read_raw,
638 .write_raw = kmx61_write_raw,
639 .attrs = &kmx61_mag_attribute_group,
640};
641
b25862c5
DB		 642static const char *kmx61_match_acpi_device(struct device *dev)
643{
644 const struct acpi_device_id *id;
645
646 id = acpi_match_device(dev->driver->acpi_match_table, dev);
647 if (!id)
648 return NULL;
649 return dev_name(dev);
650}
651
652static int kmx61_gpio_probe(struct i2c_client *client, struct kmx61_data *data)
653{
654 struct device *dev;
655 struct gpio_desc *gpio;
656 int ret;
657
658 if (!client)
659 return -EINVAL;
660
661 dev = &client->dev;
662
663 /* data ready gpio interrupt pin */
664 gpio = devm_gpiod_get_index(dev, KMX61_GPIO_NAME, 0);
665 if (IS_ERR(gpio)) {
666 dev_err(dev, "acpi gpio get index failed\n");
667 return PTR_ERR(gpio);
668 }
669
670 ret = gpiod_direction_input(gpio);
671 if (ret)
672 return ret;
673
674 ret = gpiod_to_irq(gpio);
675
676 dev_dbg(dev, "GPIO resource, no:%d irq:%d\n", desc_to_gpio(gpio), ret);
677 return ret;
678}
679
20ffac27
DB		 680static struct iio_dev *kmx61_indiodev_setup(struct kmx61_data *data,
681 const struct iio_info *info,
682 const struct iio_chan_spec *chan,
683 int num_channels,
684 const char *name)
685{
686 struct iio_dev *indio_dev;
687
688 indio_dev = devm_iio_device_alloc(&data->client->dev, sizeof(data));
689 if (!indio_dev)
690 return ERR_PTR(-ENOMEM);
691
692 kmx61_set_data(indio_dev, data);
693
694 indio_dev->dev.parent = &data->client->dev;
695 indio_dev->channels = chan;
696 indio_dev->num_channels = num_channels;
697 indio_dev->name = name;
698 indio_dev->modes = INDIO_DIRECT_MODE;
699 indio_dev->info = info;
700
701 return indio_dev;
702}
703
704static int kmx61_probe(struct i2c_client *client,
705 const struct i2c_device_id *id)
706{
707 int ret;
708 struct kmx61_data *data;
709 const char *name = NULL;
710
711 data = devm_kzalloc(&client->dev, sizeof(*data), GFP_KERNEL);
712 if (!data)
713 return -ENOMEM;
714
715 i2c_set_clientdata(client, data);
716 data->client = client;
717
718 mutex_init(&data->lock);
719
b25862c5
DB		 720 if (id)
721 name = id->name;
722 else if (ACPI_HANDLE(&client->dev))
723 name = kmx61_match_acpi_device(&client->dev);
724 else
725 return -ENODEV;
726
20ffac27
DB		 727 data->acc_indio_dev =
728 kmx61_indiodev_setup(data, &kmx61_acc_info,
729 kmx61_acc_channels,
730 ARRAY_SIZE(kmx61_acc_channels),
731 name);
732 if (IS_ERR(data->acc_indio_dev))
733 return PTR_ERR(data->acc_indio_dev);
734
735 data->mag_indio_dev =
736 kmx61_indiodev_setup(data, &kmx61_mag_info,
737 kmx61_mag_channels,
738 ARRAY_SIZE(kmx61_mag_channels),
739 name);
740 if (IS_ERR(data->mag_indio_dev))
741 return PTR_ERR(data->mag_indio_dev);
742
743 ret = kmx61_chip_init(data);
744 if (ret < 0)
745 return ret;
746
b25862c5
DB		 747 if (client->irq < 0)
748 client->irq = kmx61_gpio_probe(client, data);
749
20ffac27
DB		 750 ret = iio_device_register(data->acc_indio_dev);
751 if (ret < 0) {
752 dev_err(&client->dev, "Failed to register acc iio device\n");
753 goto err_chip_uninit;
754 }
755
756 ret = iio_device_register(data->mag_indio_dev);
757 if (ret < 0) {
758 dev_err(&client->dev, "Failed to register mag iio device\n");
aff8609a 759 goto err_iio_unregister_acc;
20ffac27
DB		 760 }
761
aff8609a
DB		 762 ret = pm_runtime_set_active(&client->dev);
763 if (ret < 0)
764 goto err_iio_unregister_mag;
765
766 pm_runtime_enable(&client->dev);
767 pm_runtime_set_autosuspend_delay(&client->dev, KMX61_SLEEP_DELAY_MS);
768 pm_runtime_use_autosuspend(&client->dev);
769
20ffac27
DB		 770 return 0;
771
aff8609a
DB		 772err_iio_unregister_mag:
773 iio_device_unregister(data->mag_indio_dev);
774err_iio_unregister_acc:
20ffac27
DB		 775 iio_device_unregister(data->acc_indio_dev);
776err_chip_uninit:
777 kmx61_set_mode(data, KMX61_ALL_STBY, KMX61_ACC | KMX61_MAG, true);
778 return ret;
779}
780
781static int kmx61_remove(struct i2c_client *client)
782{
783 struct kmx61_data *data = i2c_get_clientdata(client);
784
aff8609a
DB		 785 pm_runtime_disable(&client->dev);
786 pm_runtime_set_suspended(&client->dev);
787 pm_runtime_put_noidle(&client->dev);
788
20ffac27
DB		 789 iio_device_unregister(data->acc_indio_dev);
790 iio_device_unregister(data->mag_indio_dev);
791
792 mutex_lock(&data->lock);
793 kmx61_set_mode(data, KMX61_ALL_STBY, KMX61_ACC | KMX61_MAG, true);
794 mutex_unlock(&data->lock);
795
796 return 0;
797}
798
aff8609a
DB		 799
800#ifdef CONFIG_PM_RUNTIME
801static int kmx61_runtime_suspend(struct device *dev)
802{
803 struct kmx61_data *data = i2c_get_clientdata(to_i2c_client(dev));
804 int ret;
805
806 mutex_lock(&data->lock);
807 ret = kmx61_set_mode(data, KMX61_ALL_STBY, KMX61_ACC | KMX61_MAG, true);
808 mutex_unlock(&data->lock);
809
810 return ret;
811}
812
813static int kmx61_runtime_resume(struct device *dev)
814{
815 struct kmx61_data *data = i2c_get_clientdata(to_i2c_client(dev));
816 u8 stby = 0;
817
818 if (!data->acc_ps)
819 stby |= KMX61_ACC_STBY_BIT;
820 if (!data->mag_ps)
821 stby |= KMX61_MAG_STBY_BIT;
822
823 return kmx61_set_mode(data, stby, KMX61_ACC | KMX61_MAG, true);
824}
825#endif
826
827static const struct dev_pm_ops kmx61_pm_ops = {
828 SET_RUNTIME_PM_OPS(kmx61_runtime_suspend, kmx61_runtime_resume, NULL)
829};
830
b25862c5
DB		 831static const struct acpi_device_id kmx61_acpi_match[] = {
832 {"KMX61021", 0},
833 {}
834};
835
836MODULE_DEVICE_TABLE(acpi, kmx61_acpi_match);
837
20ffac27
DB		 838static const struct i2c_device_id kmx61_id[] = {
839 {"kmx611021", 0},
840 {}
841};
842
843MODULE_DEVICE_TABLE(i2c, kmx61_id);
844
845static struct i2c_driver kmx61_driver = {
846 .driver = {
847 .name = KMX61_DRV_NAME,
b25862c5 848 .acpi_match_table = ACPI_PTR(kmx61_acpi_match),
aff8609a 849 .pm = &kmx61_pm_ops,
20ffac27
DB		 850 },
851 .probe = kmx61_probe,
852 .remove = kmx61_remove,
853 .id_table = kmx61_id,
854};
855
856module_i2c_driver(kmx61_driver);
857
858MODULE_AUTHOR("Daniel Baluta <daniel.baluta@intel.com>");
859MODULE_DESCRIPTION("KMX61 accelerometer/magnetometer driver");
860MODULE_LICENSE("GPL v2");
ubuntu-zesty-kernel mirror