1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23#include <linux/module.h>
24#include <linux/kernel.h>
25#include <linux/slab.h>
26#include <linux/i2c.h>
27#include <linux/interrupt.h>
28#include <linux/err.h>
29#include <linux/mutex.h>
30#include <linux/delay.h>
31#include <linux/bitops.h>
32#include <linux/gpio.h>
33#include <linux/of_gpio.h>
34#include <linux/acpi.h>
35#include <linux/regulator/consumer.h>
36#include <linux/pm_runtime.h>
37
38#include <linux/iio/iio.h>
39#include <linux/iio/sysfs.h>
40#include <linux/iio/buffer.h>
41#include <linux/iio/trigger.h>
42#include <linux/iio/trigger_consumer.h>
43#include <linux/iio/triggered_buffer.h>
44
45#include <linux/iio/magnetometer/ak8975.h>
46
47
48
49
50
51#define AK8975_REG_WIA 0x00
52#define AK8975_DEVICE_ID 0x48
53
54#define AK8975_REG_INFO 0x01
55
56#define AK8975_REG_ST1 0x02
57#define AK8975_REG_ST1_DRDY_SHIFT 0
58#define AK8975_REG_ST1_DRDY_MASK (1 << AK8975_REG_ST1_DRDY_SHIFT)
59
60#define AK8975_REG_HXL 0x03
61#define AK8975_REG_HXH 0x04
62#define AK8975_REG_HYL 0x05
63#define AK8975_REG_HYH 0x06
64#define AK8975_REG_HZL 0x07
65#define AK8975_REG_HZH 0x08
66#define AK8975_REG_ST2 0x09
67#define AK8975_REG_ST2_DERR_SHIFT 2
68#define AK8975_REG_ST2_DERR_MASK (1 << AK8975_REG_ST2_DERR_SHIFT)
69
70#define AK8975_REG_ST2_HOFL_SHIFT 3
71#define AK8975_REG_ST2_HOFL_MASK (1 << AK8975_REG_ST2_HOFL_SHIFT)
72
73#define AK8975_REG_CNTL 0x0A
74#define AK8975_REG_CNTL_MODE_SHIFT 0
75#define AK8975_REG_CNTL_MODE_MASK (0xF << AK8975_REG_CNTL_MODE_SHIFT)
76#define AK8975_REG_CNTL_MODE_POWER_DOWN 0x00
77#define AK8975_REG_CNTL_MODE_ONCE 0x01
78#define AK8975_REG_CNTL_MODE_SELF_TEST 0x08
79#define AK8975_REG_CNTL_MODE_FUSE_ROM 0x0F
80
81#define AK8975_REG_RSVC 0x0B
82#define AK8975_REG_ASTC 0x0C
83#define AK8975_REG_TS1 0x0D
84#define AK8975_REG_TS2 0x0E
85#define AK8975_REG_I2CDIS 0x0F
86#define AK8975_REG_ASAX 0x10
87#define AK8975_REG_ASAY 0x11
88#define AK8975_REG_ASAZ 0x12
89
90#define AK8975_MAX_REGS AK8975_REG_ASAZ
91
92
93
94
95#define AK09912_REG_WIA1 0x00
96#define AK09912_REG_WIA2 0x01
97#define AK09912_DEVICE_ID 0x04
98#define AK09911_DEVICE_ID 0x05
99
100#define AK09911_REG_INFO1 0x02
101#define AK09911_REG_INFO2 0x03
102
103#define AK09912_REG_ST1 0x10
104
105#define AK09912_REG_ST1_DRDY_SHIFT 0
106#define AK09912_REG_ST1_DRDY_MASK (1 << AK09912_REG_ST1_DRDY_SHIFT)
107
108#define AK09912_REG_HXL 0x11
109#define AK09912_REG_HXH 0x12
110#define AK09912_REG_HYL 0x13
111#define AK09912_REG_HYH 0x14
112#define AK09912_REG_HZL 0x15
113#define AK09912_REG_HZH 0x16
114#define AK09912_REG_TMPS 0x17
115
116#define AK09912_REG_ST2 0x18
117#define AK09912_REG_ST2_HOFL_SHIFT 3
118#define AK09912_REG_ST2_HOFL_MASK (1 << AK09912_REG_ST2_HOFL_SHIFT)
119
120#define AK09912_REG_CNTL1 0x30
121
122#define AK09912_REG_CNTL2 0x31
123#define AK09912_REG_CNTL_MODE_POWER_DOWN 0x00
124#define AK09912_REG_CNTL_MODE_ONCE 0x01
125#define AK09912_REG_CNTL_MODE_SELF_TEST 0x10
126#define AK09912_REG_CNTL_MODE_FUSE_ROM 0x1F
127#define AK09912_REG_CNTL2_MODE_SHIFT 0
128#define AK09912_REG_CNTL2_MODE_MASK (0x1F << AK09912_REG_CNTL2_MODE_SHIFT)
129
130#define AK09912_REG_CNTL3 0x32
131
132#define AK09912_REG_TS1 0x33
133#define AK09912_REG_TS2 0x34
134#define AK09912_REG_TS3 0x35
135#define AK09912_REG_I2CDIS 0x36
136#define AK09912_REG_TS4 0x37
137
138#define AK09912_REG_ASAX 0x60
139#define AK09912_REG_ASAY 0x61
140#define AK09912_REG_ASAZ 0x62
141
142#define AK09912_MAX_REGS AK09912_REG_ASAZ
143
144
145
146
147#define AK8975_MAX_CONVERSION_TIMEOUT 500
148#define AK8975_CONVERSION_DONE_POLL_TIME 10
149#define AK8975_DATA_READY_TIMEOUT ((100*HZ)/1000)
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188static long ak8975_raw_to_gauss(u16 data)
189{
190 return (((long)data + 128) * 3000) / 256;
191}
192
193
194
195
196
197
198
199
200
201
202static long ak8963_09911_raw_to_gauss(u16 data)
203{
204 return (((long)data + 128) * 6000) / 256;
205}
206
207
208
209
210
211
212
213
214
215static long ak09912_raw_to_gauss(u16 data)
216{
217 return (((long)data + 128) * 1500) / 256;
218}
219
220
221enum asahi_compass_chipset {
222 AK8975,
223 AK8963,
224 AK09911,
225 AK09912,
226 AK_MAX_TYPE
227};
228
229enum ak_ctrl_reg_addr {
230 ST1,
231 ST2,
232 CNTL,
233 ASA_BASE,
234 MAX_REGS,
235 REGS_END,
236};
237
238enum ak_ctrl_reg_mask {
239 ST1_DRDY,
240 ST2_HOFL,
241 ST2_DERR,
242 CNTL_MODE,
243 MASK_END,
244};
245
246enum ak_ctrl_mode {
247 POWER_DOWN,
248 MODE_ONCE,
249 SELF_TEST,
250 FUSE_ROM,
251 MODE_END,
252};
253
254struct ak_def {
255 enum asahi_compass_chipset type;
256 long (*raw_to_gauss)(u16 data);
257 u16 range;
258 u8 ctrl_regs[REGS_END];
259 u8 ctrl_masks[MASK_END];
260 u8 ctrl_modes[MODE_END];
261 u8 data_regs[3];
262};
263
264static const struct ak_def ak_def_array[AK_MAX_TYPE] = {
265 {
266 .type = AK8975,
267 .raw_to_gauss = ak8975_raw_to_gauss,
268 .range = 4096,
269 .ctrl_regs = {
270 AK8975_REG_ST1,
271 AK8975_REG_ST2,
272 AK8975_REG_CNTL,
273 AK8975_REG_ASAX,
274 AK8975_MAX_REGS},
275 .ctrl_masks = {
276 AK8975_REG_ST1_DRDY_MASK,
277 AK8975_REG_ST2_HOFL_MASK,
278 AK8975_REG_ST2_DERR_MASK,
279 AK8975_REG_CNTL_MODE_MASK},
280 .ctrl_modes = {
281 AK8975_REG_CNTL_MODE_POWER_DOWN,
282 AK8975_REG_CNTL_MODE_ONCE,
283 AK8975_REG_CNTL_MODE_SELF_TEST,
284 AK8975_REG_CNTL_MODE_FUSE_ROM},
285 .data_regs = {
286 AK8975_REG_HXL,
287 AK8975_REG_HYL,
288 AK8975_REG_HZL},
289 },
290 {
291 .type = AK8963,
292 .raw_to_gauss = ak8963_09911_raw_to_gauss,
293 .range = 8190,
294 .ctrl_regs = {
295 AK8975_REG_ST1,
296 AK8975_REG_ST2,
297 AK8975_REG_CNTL,
298 AK8975_REG_ASAX,
299 AK8975_MAX_REGS},
300 .ctrl_masks = {
301 AK8975_REG_ST1_DRDY_MASK,
302 AK8975_REG_ST2_HOFL_MASK,
303 0,
304 AK8975_REG_CNTL_MODE_MASK},
305 .ctrl_modes = {
306 AK8975_REG_CNTL_MODE_POWER_DOWN,
307 AK8975_REG_CNTL_MODE_ONCE,
308 AK8975_REG_CNTL_MODE_SELF_TEST,
309 AK8975_REG_CNTL_MODE_FUSE_ROM},
310 .data_regs = {
311 AK8975_REG_HXL,
312 AK8975_REG_HYL,
313 AK8975_REG_HZL},
314 },
315 {
316 .type = AK09911,
317 .raw_to_gauss = ak8963_09911_raw_to_gauss,
318 .range = 8192,
319 .ctrl_regs = {
320 AK09912_REG_ST1,
321 AK09912_REG_ST2,
322 AK09912_REG_CNTL2,
323 AK09912_REG_ASAX,
324 AK09912_MAX_REGS},
325 .ctrl_masks = {
326 AK09912_REG_ST1_DRDY_MASK,
327 AK09912_REG_ST2_HOFL_MASK,
328 0,
329 AK09912_REG_CNTL2_MODE_MASK},
330 .ctrl_modes = {
331 AK09912_REG_CNTL_MODE_POWER_DOWN,
332 AK09912_REG_CNTL_MODE_ONCE,
333 AK09912_REG_CNTL_MODE_SELF_TEST,
334 AK09912_REG_CNTL_MODE_FUSE_ROM},
335 .data_regs = {
336 AK09912_REG_HXL,
337 AK09912_REG_HYL,
338 AK09912_REG_HZL},
339 },
340 {
341 .type = AK09912,
342 .raw_to_gauss = ak09912_raw_to_gauss,
343 .range = 32752,
344 .ctrl_regs = {
345 AK09912_REG_ST1,
346 AK09912_REG_ST2,
347 AK09912_REG_CNTL2,
348 AK09912_REG_ASAX,
349 AK09912_MAX_REGS},
350 .ctrl_masks = {
351 AK09912_REG_ST1_DRDY_MASK,
352 AK09912_REG_ST2_HOFL_MASK,
353 0,
354 AK09912_REG_CNTL2_MODE_MASK},
355 .ctrl_modes = {
356 AK09912_REG_CNTL_MODE_POWER_DOWN,
357 AK09912_REG_CNTL_MODE_ONCE,
358 AK09912_REG_CNTL_MODE_SELF_TEST,
359 AK09912_REG_CNTL_MODE_FUSE_ROM},
360 .data_regs = {
361 AK09912_REG_HXL,
362 AK09912_REG_HYL,
363 AK09912_REG_HZL},
364 }
365};
366
367
368
369
370struct ak8975_data {
371 struct i2c_client *client;
372 const struct ak_def *def;
373 struct mutex lock;
374 u8 asa[3];
375 long raw_to_gauss[3];
376 int eoc_gpio;
377 int eoc_irq;
378 wait_queue_head_t data_ready_queue;
379 unsigned long flags;
380 u8 cntl_cache;
381 struct iio_mount_matrix orientation;
382 struct regulator *vdd;
383 struct regulator *vid;
384};
385
386
387static int ak8975_power_on(const struct ak8975_data *data)
388{
389 int ret;
390
391 ret = regulator_enable(data->vdd);
392 if (ret) {
393 dev_warn(&data->client->dev,
394 "Failed to enable specified Vdd supply\n");
395 return ret;
396 }
397 ret = regulator_enable(data->vid);
398 if (ret) {
399 dev_warn(&data->client->dev,
400 "Failed to enable specified Vid supply\n");
401 return ret;
402 }
403
404
405
406
407
408 usleep_range(500, 1000);
409 return 0;
410}
411
412
413static void ak8975_power_off(const struct ak8975_data *data)
414{
415 regulator_disable(data->vid);
416 regulator_disable(data->vdd);
417}
418
419
420
421
422
423static int ak8975_who_i_am(struct i2c_client *client,
424 enum asahi_compass_chipset type)
425{
426 u8 wia_val[2];
427 int ret;
428
429
430
431
432
433
434
435
436
437 ret = i2c_smbus_read_i2c_block_data_or_emulated(
438 client, AK09912_REG_WIA1, 2, wia_val);
439 if (ret < 0) {
440 dev_err(&client->dev, "Error reading WIA\n");
441 return ret;
442 }
443
444 if (wia_val[0] != AK8975_DEVICE_ID)
445 return -ENODEV;
446
447 switch (type) {
448 case AK8975:
449 case AK8963:
450 return 0;
451 case AK09911:
452 if (wia_val[1] == AK09911_DEVICE_ID)
453 return 0;
454 break;
455 case AK09912:
456 if (wia_val[1] == AK09912_DEVICE_ID)
457 return 0;
458 break;
459 default:
460 dev_err(&client->dev, "Type %d unknown\n", type);
461 }
462 return -ENODEV;
463}
464
465
466
467
468static int ak8975_set_mode(struct ak8975_data *data, enum ak_ctrl_mode mode)
469{
470 u8 regval;
471 int ret;
472
473 regval = (data->cntl_cache & ~data->def->ctrl_masks[CNTL_MODE]) |
474 data->def->ctrl_modes[mode];
475 ret = i2c_smbus_write_byte_data(data->client,
476 data->def->ctrl_regs[CNTL], regval);
477 if (ret < 0) {
478 return ret;
479 }
480 data->cntl_cache = regval;
481
482 usleep_range(100, 500);
483
484 return 0;
485}
486
487
488
489
490static irqreturn_t ak8975_irq_handler(int irq, void *data)
491{
492 struct ak8975_data *ak8975 = data;
493
494 set_bit(0, &ak8975->flags);
495 wake_up(&ak8975->data_ready_queue);
496
497 return IRQ_HANDLED;
498}
499
500
501
502
503static int ak8975_setup_irq(struct ak8975_data *data)
504{
505 struct i2c_client *client = data->client;
506 int rc;
507 int irq;
508
509 init_waitqueue_head(&data->data_ready_queue);
510 clear_bit(0, &data->flags);
511 if (client->irq)
512 irq = client->irq;
513 else
514 irq = gpio_to_irq(data->eoc_gpio);
515
516 rc = devm_request_irq(&client->dev, irq, ak8975_irq_handler,
517 IRQF_TRIGGER_RISING | IRQF_ONESHOT,
518 dev_name(&client->dev), data);
519 if (rc < 0) {
520 dev_err(&client->dev,
521 "irq %d request failed, (gpio %d): %d\n",
522 irq, data->eoc_gpio, rc);
523 return rc;
524 }
525
526 data->eoc_irq = irq;
527
528 return rc;
529}
530
531
532
533
534
535
536static int ak8975_setup(struct i2c_client *client)
537{
538 struct iio_dev *indio_dev = i2c_get_clientdata(client);
539 struct ak8975_data *data = iio_priv(indio_dev);
540 int ret;
541
542
543 ret = ak8975_set_mode(data, FUSE_ROM);
544 if (ret < 0) {
545 dev_err(&client->dev, "Error in setting fuse access mode\n");
546 return ret;
547 }
548
549
550 ret = i2c_smbus_read_i2c_block_data_or_emulated(
551 client, data->def->ctrl_regs[ASA_BASE],
552 3, data->asa);
553 if (ret < 0) {
554 dev_err(&client->dev, "Not able to read asa data\n");
555 return ret;
556 }
557
558
559 ret = ak8975_set_mode(data, POWER_DOWN);
560 if (ret < 0) {
561 dev_err(&client->dev, "Error in setting power-down mode\n");
562 return ret;
563 }
564
565 if (data->eoc_gpio > 0 || client->irq > 0) {
566 ret = ak8975_setup_irq(data);
567 if (ret < 0) {
568 dev_err(&client->dev,
569 "Error setting data ready interrupt\n");
570 return ret;
571 }
572 }
573
574 data->raw_to_gauss[0] = data->def->raw_to_gauss(data->asa[0]);
575 data->raw_to_gauss[1] = data->def->raw_to_gauss(data->asa[1]);
576 data->raw_to_gauss[2] = data->def->raw_to_gauss(data->asa[2]);
577
578 return 0;
579}
580
581static int wait_conversion_complete_gpio(struct ak8975_data *data)
582{
583 struct i2c_client *client = data->client;
584 u32 timeout_ms = AK8975_MAX_CONVERSION_TIMEOUT;
585 int ret;
586
587
588 while (timeout_ms) {
589 msleep(AK8975_CONVERSION_DONE_POLL_TIME);
590 if (gpio_get_value(data->eoc_gpio))
591 break;
592 timeout_ms -= AK8975_CONVERSION_DONE_POLL_TIME;
593 }
594 if (!timeout_ms) {
595 dev_err(&client->dev, "Conversion timeout happened\n");
596 return -EINVAL;
597 }
598
599 ret = i2c_smbus_read_byte_data(client, data->def->ctrl_regs[ST1]);
600 if (ret < 0)
601 dev_err(&client->dev, "Error in reading ST1\n");
602
603 return ret;
604}
605
606static int wait_conversion_complete_polled(struct ak8975_data *data)
607{
608 struct i2c_client *client = data->client;
609 u8 read_status;
610 u32 timeout_ms = AK8975_MAX_CONVERSION_TIMEOUT;
611 int ret;
612
613
614 while (timeout_ms) {
615 msleep(AK8975_CONVERSION_DONE_POLL_TIME);
616 ret = i2c_smbus_read_byte_data(client,
617 data->def->ctrl_regs[ST1]);
618 if (ret < 0) {
619 dev_err(&client->dev, "Error in reading ST1\n");
620 return ret;
621 }
622 read_status = ret;
623 if (read_status)
624 break;
625 timeout_ms -= AK8975_CONVERSION_DONE_POLL_TIME;
626 }
627 if (!timeout_ms) {
628 dev_err(&client->dev, "Conversion timeout happened\n");
629 return -EINVAL;
630 }
631
632 return read_status;
633}
634
635
636static int wait_conversion_complete_interrupt(struct ak8975_data *data)
637{
638 int ret;
639
640 ret = wait_event_timeout(data->data_ready_queue,
641 test_bit(0, &data->flags),
642 AK8975_DATA_READY_TIMEOUT);
643 clear_bit(0, &data->flags);
644
645 return ret > 0 ? 0 : -ETIME;
646}
647
648static int ak8975_start_read_axis(struct ak8975_data *data,
649 const struct i2c_client *client)
650{
651
652 int ret = ak8975_set_mode(data, MODE_ONCE);
653
654 if (ret < 0) {
655 dev_err(&client->dev, "Error in setting operating mode\n");
656 return ret;
657 }
658
659
660 if (data->eoc_irq)
661 ret = wait_conversion_complete_interrupt(data);
662 else if (gpio_is_valid(data->eoc_gpio))
663 ret = wait_conversion_complete_gpio(data);
664 else
665 ret = wait_conversion_complete_polled(data);
666 if (ret < 0)
667 return ret;
668
669
670 if (ret & data->def->ctrl_masks[ST1_DRDY]) {
671 ret = i2c_smbus_read_byte_data(client,
672 data->def->ctrl_regs[ST2]);
673 if (ret < 0) {
674 dev_err(&client->dev, "Error in reading ST2\n");
675 return ret;
676 }
677 if (ret & (data->def->ctrl_masks[ST2_DERR] |
678 data->def->ctrl_masks[ST2_HOFL])) {
679 dev_err(&client->dev, "ST2 status error 0x%x\n", ret);
680 return -EINVAL;
681 }
682 }
683
684 return 0;
685}
686
687
688static int ak8975_read_axis(struct iio_dev *indio_dev, int index, int *val)
689{
690 struct ak8975_data *data = iio_priv(indio_dev);
691 const struct i2c_client *client = data->client;
692 const struct ak_def *def = data->def;
693 __le16 rval;
694 u16 buff;
695 int ret;
696
697 pm_runtime_get_sync(&data->client->dev);
698
699 mutex_lock(&data->lock);
700
701 ret = ak8975_start_read_axis(data, client);
702 if (ret)
703 goto exit;
704
705 ret = i2c_smbus_read_i2c_block_data_or_emulated(
706 client, def->data_regs[index],
707 sizeof(rval), (u8*)&rval);
708 if (ret < 0)
709 goto exit;
710
711 mutex_unlock(&data->lock);
712
713 pm_runtime_mark_last_busy(&data->client->dev);
714 pm_runtime_put_autosuspend(&data->client->dev);
715
716
717 buff = le16_to_cpu(rval);
718 *val = clamp_t(s16, buff, -def->range, def->range);
719 return IIO_VAL_INT;
720
721exit:
722 mutex_unlock(&data->lock);
723 dev_err(&client->dev, "Error in reading axis\n");
724 return ret;
725}
726
727static int ak8975_read_raw(struct iio_dev *indio_dev,
728 struct iio_chan_spec const *chan,
729 int *val, int *val2,
730 long mask)
731{
732 struct ak8975_data *data = iio_priv(indio_dev);
733
734 switch (mask) {
735 case IIO_CHAN_INFO_RAW:
736 return ak8975_read_axis(indio_dev, chan->address, val);
737 case IIO_CHAN_INFO_SCALE:
738 *val = 0;
739 *val2 = data->raw_to_gauss[chan->address];
740 return IIO_VAL_INT_PLUS_MICRO;
741 }
742 return -EINVAL;
743}
744
745static const struct iio_mount_matrix *
746ak8975_get_mount_matrix(const struct iio_dev *indio_dev,
747 const struct iio_chan_spec *chan)
748{
749 return &((struct ak8975_data *)iio_priv(indio_dev))->orientation;
750}
751
752static const struct iio_chan_spec_ext_info ak8975_ext_info[] = {
753 IIO_MOUNT_MATRIX(IIO_SHARED_BY_DIR, ak8975_get_mount_matrix),
754 { },
755};
756
757#define AK8975_CHANNEL(axis, index) \
758 { \
759 .type = IIO_MAGN, \
760 .modified = 1, \
761 .channel2 = IIO_MOD_##axis, \
762 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
763 BIT(IIO_CHAN_INFO_SCALE), \
764 .address = index, \
765 .scan_index = index, \
766 .scan_type = { \
767 .sign = 's', \
768 .realbits = 16, \
769 .storagebits = 16, \
770 .endianness = IIO_CPU \
771 }, \
772 .ext_info = ak8975_ext_info, \
773 }
774
775static const struct iio_chan_spec ak8975_channels[] = {
776 AK8975_CHANNEL(X, 0), AK8975_CHANNEL(Y, 1), AK8975_CHANNEL(Z, 2),
777 IIO_CHAN_SOFT_TIMESTAMP(3),
778};
779
780static const unsigned long ak8975_scan_masks[] = { 0x7, 0 };
781
782static const struct iio_info ak8975_info = {
783 .read_raw = &ak8975_read_raw,
784 .driver_module = THIS_MODULE,
785};
786
787static const struct acpi_device_id ak_acpi_match[] = {
788 {"AK8975", AK8975},
789 {"AK8963", AK8963},
790 {"INVN6500", AK8963},
791 {"AK09911", AK09911},
792 {"AK09912", AK09912},
793 { },
794};
795MODULE_DEVICE_TABLE(acpi, ak_acpi_match);
796
797static const char *ak8975_match_acpi_device(struct device *dev,
798 enum asahi_compass_chipset *chipset)
799{
800 const struct acpi_device_id *id;
801
802 id = acpi_match_device(dev->driver->acpi_match_table, dev);
803 if (!id)
804 return NULL;
805 *chipset = (int)id->driver_data;
806
807 return dev_name(dev);
808}
809
810static void ak8975_fill_buffer(struct iio_dev *indio_dev)
811{
812 struct ak8975_data *data = iio_priv(indio_dev);
813 const struct i2c_client *client = data->client;
814 const struct ak_def *def = data->def;
815 int ret;
816 s16 buff[8];
817 __le16 fval[3];
818
819 mutex_lock(&data->lock);
820
821 ret = ak8975_start_read_axis(data, client);
822 if (ret)
823 goto unlock;
824
825
826
827
828
829 ret = i2c_smbus_read_i2c_block_data_or_emulated(client,
830 def->data_regs[0],
831 3 * sizeof(fval[0]),
832 (u8 *)fval);
833 if (ret < 0)
834 goto unlock;
835
836 mutex_unlock(&data->lock);
837
838
839 buff[0] = clamp_t(s16, le16_to_cpu(fval[0]), -def->range, def->range);
840 buff[1] = clamp_t(s16, le16_to_cpu(fval[1]), -def->range, def->range);
841 buff[2] = clamp_t(s16, le16_to_cpu(fval[2]), -def->range, def->range);
842
843 iio_push_to_buffers_with_timestamp(indio_dev, buff,
844 iio_get_time_ns(indio_dev));
845 return;
846
847unlock:
848 mutex_unlock(&data->lock);
849 dev_err(&client->dev, "Error in reading axes block\n");
850}
851
852static irqreturn_t ak8975_handle_trigger(int irq, void *p)
853{
854 const struct iio_poll_func *pf = p;
855 struct iio_dev *indio_dev = pf->indio_dev;
856
857 ak8975_fill_buffer(indio_dev);
858 iio_trigger_notify_done(indio_dev->trig);
859 return IRQ_HANDLED;
860}
861
862static int ak8975_probe(struct i2c_client *client,
863 const struct i2c_device_id *id)
864{
865 struct ak8975_data *data;
866 struct iio_dev *indio_dev;
867 int eoc_gpio;
868 int err;
869 const char *name = NULL;
870 enum asahi_compass_chipset chipset = AK_MAX_TYPE;
871 const struct ak8975_platform_data *pdata =
872 dev_get_platdata(&client->dev);
873
874
875 if (pdata)
876 eoc_gpio = pdata->eoc_gpio;
877 else if (client->dev.of_node)
878 eoc_gpio = of_get_gpio(client->dev.of_node, 0);
879 else
880 eoc_gpio = -1;
881
882 if (eoc_gpio == -EPROBE_DEFER)
883 return -EPROBE_DEFER;
884
885
886
887 if (gpio_is_valid(eoc_gpio)) {
888 err = devm_gpio_request_one(&client->dev, eoc_gpio,
889 GPIOF_IN, "ak_8975");
890 if (err < 0) {
891 dev_err(&client->dev,
892 "failed to request GPIO %d, error %d\n",
893 eoc_gpio, err);
894 return err;
895 }
896 }
897
898
899 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
900 if (indio_dev == NULL)
901 return -ENOMEM;
902
903 data = iio_priv(indio_dev);
904 i2c_set_clientdata(client, indio_dev);
905
906 data->client = client;
907 data->eoc_gpio = eoc_gpio;
908 data->eoc_irq = 0;
909
910 if (!pdata) {
911 err = of_iio_read_mount_matrix(&client->dev,
912 "mount-matrix",
913 &data->orientation);
914 if (err)
915 return err;
916 } else
917 data->orientation = pdata->orientation;
918
919
920 if (id) {
921 chipset = (enum asahi_compass_chipset)(id->driver_data);
922 name = id->name;
923 } else if (ACPI_HANDLE(&client->dev)) {
924 name = ak8975_match_acpi_device(&client->dev, &chipset);
925 if (!name)
926 return -ENODEV;
927 } else
928 return -ENOSYS;
929
930 if (chipset >= AK_MAX_TYPE) {
931 dev_err(&client->dev, "AKM device type unsupported: %d\n",
932 chipset);
933 return -ENODEV;
934 }
935
936 data->def = &ak_def_array[chipset];
937
938
939 data->vdd = devm_regulator_get(&client->dev, "vdd");
940 if (IS_ERR(data->vdd))
941 return PTR_ERR(data->vdd);
942 data->vid = devm_regulator_get(&client->dev, "vid");
943 if (IS_ERR(data->vid))
944 return PTR_ERR(data->vid);
945
946 err = ak8975_power_on(data);
947 if (err)
948 return err;
949
950 err = ak8975_who_i_am(client, data->def->type);
951 if (err < 0) {
952 dev_err(&client->dev, "Unexpected device\n");
953 goto power_off;
954 }
955 dev_dbg(&client->dev, "Asahi compass chip %s\n", name);
956
957
958 err = ak8975_setup(client);
959 if (err < 0) {
960 dev_err(&client->dev, "%s initialization fails\n", name);
961 goto power_off;
962 }
963
964 mutex_init(&data->lock);
965 indio_dev->dev.parent = &client->dev;
966 indio_dev->channels = ak8975_channels;
967 indio_dev->num_channels = ARRAY_SIZE(ak8975_channels);
968 indio_dev->info = &ak8975_info;
969 indio_dev->available_scan_masks = ak8975_scan_masks;
970 indio_dev->modes = INDIO_DIRECT_MODE;
971 indio_dev->name = name;
972
973 err = iio_triggered_buffer_setup(indio_dev, NULL, ak8975_handle_trigger,
974 NULL);
975 if (err) {
976 dev_err(&client->dev, "triggered buffer setup failed\n");
977 goto power_off;
978 }
979
980 err = iio_device_register(indio_dev);
981 if (err) {
982 dev_err(&client->dev, "device register failed\n");
983 goto cleanup_buffer;
984 }
985
986
987 pm_runtime_get_noresume(&client->dev);
988 pm_runtime_set_active(&client->dev);
989 pm_runtime_enable(&client->dev);
990
991
992
993
994 pm_runtime_set_autosuspend_delay(&client->dev, 50);
995 pm_runtime_use_autosuspend(&client->dev);
996 pm_runtime_put(&client->dev);
997
998 return 0;
999
1000cleanup_buffer:
1001 iio_triggered_buffer_cleanup(indio_dev);
1002power_off:
1003 ak8975_power_off(data);
1004 return err;
1005}
1006
1007static int ak8975_remove(struct i2c_client *client)
1008{
1009 struct iio_dev *indio_dev = i2c_get_clientdata(client);
1010 struct ak8975_data *data = iio_priv(indio_dev);
1011
1012 pm_runtime_get_sync(&client->dev);
1013 pm_runtime_put_noidle(&client->dev);
1014 pm_runtime_disable(&client->dev);
1015 iio_device_unregister(indio_dev);
1016 iio_triggered_buffer_cleanup(indio_dev);
1017 ak8975_set_mode(data, POWER_DOWN);
1018 ak8975_power_off(data);
1019
1020 return 0;
1021}
1022
1023#ifdef CONFIG_PM
1024static int ak8975_runtime_suspend(struct device *dev)
1025{
1026 struct i2c_client *client = to_i2c_client(dev);
1027 struct iio_dev *indio_dev = i2c_get_clientdata(client);
1028 struct ak8975_data *data = iio_priv(indio_dev);
1029 int ret;
1030
1031
1032 ret = ak8975_set_mode(data, POWER_DOWN);
1033 if (ret < 0) {
1034 dev_err(&client->dev, "Error in setting power-down mode\n");
1035 return ret;
1036 }
1037
1038 ak8975_power_off(data);
1039
1040 return 0;
1041}
1042
1043static int ak8975_runtime_resume(struct device *dev)
1044{
1045 struct i2c_client *client = to_i2c_client(dev);
1046 struct iio_dev *indio_dev = i2c_get_clientdata(client);
1047 struct ak8975_data *data = iio_priv(indio_dev);
1048 int ret;
1049
1050
1051 ak8975_power_on(data);
1052
1053
1054
1055
1056 ret = ak8975_set_mode(data, POWER_DOWN);
1057 if (ret < 0) {
1058 dev_err(&client->dev, "Error in setting power-down mode\n");
1059 return ret;
1060 }
1061
1062 return 0;
1063}
1064#endif
1065
1066static const struct dev_pm_ops ak8975_dev_pm_ops = {
1067 SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
1068 pm_runtime_force_resume)
1069 SET_RUNTIME_PM_OPS(ak8975_runtime_suspend,
1070 ak8975_runtime_resume, NULL)
1071};
1072
1073static const struct i2c_device_id ak8975_id[] = {
1074 {"ak8975", AK8975},
1075 {"ak8963", AK8963},
1076 {"AK8963", AK8963},
1077 {"ak09911", AK09911},
1078 {"ak09912", AK09912},
1079 {}
1080};
1081
1082MODULE_DEVICE_TABLE(i2c, ak8975_id);
1083
1084static const struct of_device_id ak8975_of_match[] = {
1085 { .compatible = "asahi-kasei,ak8975", },
1086 { .compatible = "ak8975", },
1087 { .compatible = "asahi-kasei,ak8963", },
1088 { .compatible = "ak8963", },
1089 { .compatible = "asahi-kasei,ak09911", },
1090 { .compatible = "ak09911", },
1091 { .compatible = "asahi-kasei,ak09912", },
1092 { .compatible = "ak09912", },
1093 {}
1094};
1095MODULE_DEVICE_TABLE(of, ak8975_of_match);
1096
1097static struct i2c_driver ak8975_driver = {
1098 .driver = {
1099 .name = "ak8975",
1100 .pm = &ak8975_dev_pm_ops,
1101 .of_match_table = of_match_ptr(ak8975_of_match),
1102 .acpi_match_table = ACPI_PTR(ak_acpi_match),
1103 },
1104 .probe = ak8975_probe,
1105 .remove = ak8975_remove,
1106 .id_table = ak8975_id,
1107};
1108module_i2c_driver(ak8975_driver);
1109
1110MODULE_AUTHOR("Laxman Dewangan <ldewangan@nvidia.com>");
1111MODULE_DESCRIPTION("AK8975 magnetometer driver");
1112MODULE_LICENSE("GPL");
1113