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
36#include <linux/iio/iio.h>
37#include <linux/iio/sysfs.h>
38
39
40
41
42#define AK8975_REG_WIA 0x00
43#define AK8975_DEVICE_ID 0x48
44
45#define AK8975_REG_INFO 0x01
46
47#define AK8975_REG_ST1 0x02
48#define AK8975_REG_ST1_DRDY_SHIFT 0
49#define AK8975_REG_ST1_DRDY_MASK (1 << AK8975_REG_ST1_DRDY_SHIFT)
50
51#define AK8975_REG_HXL 0x03
52#define AK8975_REG_HXH 0x04
53#define AK8975_REG_HYL 0x05
54#define AK8975_REG_HYH 0x06
55#define AK8975_REG_HZL 0x07
56#define AK8975_REG_HZH 0x08
57#define AK8975_REG_ST2 0x09
58#define AK8975_REG_ST2_DERR_SHIFT 2
59#define AK8975_REG_ST2_DERR_MASK (1 << AK8975_REG_ST2_DERR_SHIFT)
60
61#define AK8975_REG_ST2_HOFL_SHIFT 3
62#define AK8975_REG_ST2_HOFL_MASK (1 << AK8975_REG_ST2_HOFL_SHIFT)
63
64#define AK8975_REG_CNTL 0x0A
65#define AK8975_REG_CNTL_MODE_SHIFT 0
66#define AK8975_REG_CNTL_MODE_MASK (0xF << AK8975_REG_CNTL_MODE_SHIFT)
67#define AK8975_REG_CNTL_MODE_POWER_DOWN 0x00
68#define AK8975_REG_CNTL_MODE_ONCE 0x01
69#define AK8975_REG_CNTL_MODE_SELF_TEST 0x08
70#define AK8975_REG_CNTL_MODE_FUSE_ROM 0x0F
71
72#define AK8975_REG_RSVC 0x0B
73#define AK8975_REG_ASTC 0x0C
74#define AK8975_REG_TS1 0x0D
75#define AK8975_REG_TS2 0x0E
76#define AK8975_REG_I2CDIS 0x0F
77#define AK8975_REG_ASAX 0x10
78#define AK8975_REG_ASAY 0x11
79#define AK8975_REG_ASAZ 0x12
80
81#define AK8975_MAX_REGS AK8975_REG_ASAZ
82
83
84
85
86#define AK09912_REG_WIA1 0x00
87#define AK09912_REG_WIA2 0x01
88#define AK09912_DEVICE_ID 0x04
89#define AK09911_DEVICE_ID 0x05
90
91#define AK09911_REG_INFO1 0x02
92#define AK09911_REG_INFO2 0x03
93
94#define AK09912_REG_ST1 0x10
95
96#define AK09912_REG_ST1_DRDY_SHIFT 0
97#define AK09912_REG_ST1_DRDY_MASK (1 << AK09912_REG_ST1_DRDY_SHIFT)
98
99#define AK09912_REG_HXL 0x11
100#define AK09912_REG_HXH 0x12
101#define AK09912_REG_HYL 0x13
102#define AK09912_REG_HYH 0x14
103#define AK09912_REG_HZL 0x15
104#define AK09912_REG_HZH 0x16
105#define AK09912_REG_TMPS 0x17
106
107#define AK09912_REG_ST2 0x18
108#define AK09912_REG_ST2_HOFL_SHIFT 3
109#define AK09912_REG_ST2_HOFL_MASK (1 << AK09912_REG_ST2_HOFL_SHIFT)
110
111#define AK09912_REG_CNTL1 0x30
112
113#define AK09912_REG_CNTL2 0x31
114#define AK09912_REG_CNTL_MODE_POWER_DOWN 0x00
115#define AK09912_REG_CNTL_MODE_ONCE 0x01
116#define AK09912_REG_CNTL_MODE_SELF_TEST 0x10
117#define AK09912_REG_CNTL_MODE_FUSE_ROM 0x1F
118#define AK09912_REG_CNTL2_MODE_SHIFT 0
119#define AK09912_REG_CNTL2_MODE_MASK (0x1F << AK09912_REG_CNTL2_MODE_SHIFT)
120
121#define AK09912_REG_CNTL3 0x32
122
123#define AK09912_REG_TS1 0x33
124#define AK09912_REG_TS2 0x34
125#define AK09912_REG_TS3 0x35
126#define AK09912_REG_I2CDIS 0x36
127#define AK09912_REG_TS4 0x37
128
129#define AK09912_REG_ASAX 0x60
130#define AK09912_REG_ASAY 0x61
131#define AK09912_REG_ASAZ 0x62
132
133#define AK09912_MAX_REGS AK09912_REG_ASAZ
134
135
136
137
138#define AK8975_MAX_CONVERSION_TIMEOUT 500
139#define AK8975_CONVERSION_DONE_POLL_TIME 10
140#define AK8975_DATA_READY_TIMEOUT ((100*HZ)/1000)
141
142
143
144
145
146
147
148
149
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
179static long ak8975_raw_to_gauss(u16 data)
180{
181 return (((long)data + 128) * 3000) / 256;
182}
183
184
185
186
187
188
189
190
191
192
193static long ak8963_09911_raw_to_gauss(u16 data)
194{
195 return (((long)data + 128) * 6000) / 256;
196}
197
198
199
200
201
202
203
204
205
206static long ak09912_raw_to_gauss(u16 data)
207{
208 return (((long)data + 128) * 1500) / 256;
209}
210
211
212enum asahi_compass_chipset {
213 AK8975,
214 AK8963,
215 AK09911,
216 AK09912,
217 AK_MAX_TYPE
218};
219
220enum ak_ctrl_reg_addr {
221 ST1,
222 ST2,
223 CNTL,
224 ASA_BASE,
225 MAX_REGS,
226 REGS_END,
227};
228
229enum ak_ctrl_reg_mask {
230 ST1_DRDY,
231 ST2_HOFL,
232 ST2_DERR,
233 CNTL_MODE,
234 MASK_END,
235};
236
237enum ak_ctrl_mode {
238 POWER_DOWN,
239 MODE_ONCE,
240 SELF_TEST,
241 FUSE_ROM,
242 MODE_END,
243};
244
245struct ak_def {
246 enum asahi_compass_chipset type;
247 long (*raw_to_gauss)(u16 data);
248 u16 range;
249 u8 ctrl_regs[REGS_END];
250 u8 ctrl_masks[MASK_END];
251 u8 ctrl_modes[MODE_END];
252 u8 data_regs[3];
253};
254
255static const struct ak_def ak_def_array[AK_MAX_TYPE] = {
256 {
257 .type = AK8975,
258 .raw_to_gauss = ak8975_raw_to_gauss,
259 .range = 4096,
260 .ctrl_regs = {
261 AK8975_REG_ST1,
262 AK8975_REG_ST2,
263 AK8975_REG_CNTL,
264 AK8975_REG_ASAX,
265 AK8975_MAX_REGS},
266 .ctrl_masks = {
267 AK8975_REG_ST1_DRDY_MASK,
268 AK8975_REG_ST2_HOFL_MASK,
269 AK8975_REG_ST2_DERR_MASK,
270 AK8975_REG_CNTL_MODE_MASK},
271 .ctrl_modes = {
272 AK8975_REG_CNTL_MODE_POWER_DOWN,
273 AK8975_REG_CNTL_MODE_ONCE,
274 AK8975_REG_CNTL_MODE_SELF_TEST,
275 AK8975_REG_CNTL_MODE_FUSE_ROM},
276 .data_regs = {
277 AK8975_REG_HXL,
278 AK8975_REG_HYL,
279 AK8975_REG_HZL},
280 },
281 {
282 .type = AK8963,
283 .raw_to_gauss = ak8963_09911_raw_to_gauss,
284 .range = 8190,
285 .ctrl_regs = {
286 AK8975_REG_ST1,
287 AK8975_REG_ST2,
288 AK8975_REG_CNTL,
289 AK8975_REG_ASAX,
290 AK8975_MAX_REGS},
291 .ctrl_masks = {
292 AK8975_REG_ST1_DRDY_MASK,
293 AK8975_REG_ST2_HOFL_MASK,
294 0,
295 AK8975_REG_CNTL_MODE_MASK},
296 .ctrl_modes = {
297 AK8975_REG_CNTL_MODE_POWER_DOWN,
298 AK8975_REG_CNTL_MODE_ONCE,
299 AK8975_REG_CNTL_MODE_SELF_TEST,
300 AK8975_REG_CNTL_MODE_FUSE_ROM},
301 .data_regs = {
302 AK8975_REG_HXL,
303 AK8975_REG_HYL,
304 AK8975_REG_HZL},
305 },
306 {
307 .type = AK09911,
308 .raw_to_gauss = ak8963_09911_raw_to_gauss,
309 .range = 8192,
310 .ctrl_regs = {
311 AK09912_REG_ST1,
312 AK09912_REG_ST2,
313 AK09912_REG_CNTL2,
314 AK09912_REG_ASAX,
315 AK09912_MAX_REGS},
316 .ctrl_masks = {
317 AK09912_REG_ST1_DRDY_MASK,
318 AK09912_REG_ST2_HOFL_MASK,
319 0,
320 AK09912_REG_CNTL2_MODE_MASK},
321 .ctrl_modes = {
322 AK09912_REG_CNTL_MODE_POWER_DOWN,
323 AK09912_REG_CNTL_MODE_ONCE,
324 AK09912_REG_CNTL_MODE_SELF_TEST,
325 AK09912_REG_CNTL_MODE_FUSE_ROM},
326 .data_regs = {
327 AK09912_REG_HXL,
328 AK09912_REG_HYL,
329 AK09912_REG_HZL},
330 },
331 {
332 .type = AK09912,
333 .raw_to_gauss = ak09912_raw_to_gauss,
334 .range = 32752,
335 .ctrl_regs = {
336 AK09912_REG_ST1,
337 AK09912_REG_ST2,
338 AK09912_REG_CNTL2,
339 AK09912_REG_ASAX,
340 AK09912_MAX_REGS},
341 .ctrl_masks = {
342 AK09912_REG_ST1_DRDY_MASK,
343 AK09912_REG_ST2_HOFL_MASK,
344 0,
345 AK09912_REG_CNTL2_MODE_MASK},
346 .ctrl_modes = {
347 AK09912_REG_CNTL_MODE_POWER_DOWN,
348 AK09912_REG_CNTL_MODE_ONCE,
349 AK09912_REG_CNTL_MODE_SELF_TEST,
350 AK09912_REG_CNTL_MODE_FUSE_ROM},
351 .data_regs = {
352 AK09912_REG_HXL,
353 AK09912_REG_HYL,
354 AK09912_REG_HZL},
355 }
356};
357
358
359
360
361struct ak8975_data {
362 struct i2c_client *client;
363 const struct ak_def *def;
364 struct attribute_group attrs;
365 struct mutex lock;
366 u8 asa[3];
367 long raw_to_gauss[3];
368 int eoc_gpio;
369 int eoc_irq;
370 wait_queue_head_t data_ready_queue;
371 unsigned long flags;
372 u8 cntl_cache;
373};
374
375
376
377
378
379static int ak8975_who_i_am(struct i2c_client *client,
380 enum asahi_compass_chipset type)
381{
382 u8 wia_val[2];
383 int ret;
384
385
386
387
388
389
390
391
392
393 ret = i2c_smbus_read_i2c_block_data(client, AK09912_REG_WIA1,
394 2, wia_val);
395 if (ret < 0) {
396 dev_err(&client->dev, "Error reading WIA\n");
397 return ret;
398 }
399
400 if (wia_val[0] != AK8975_DEVICE_ID)
401 return -ENODEV;
402
403 switch (type) {
404 case AK8975:
405 case AK8963:
406 return 0;
407 case AK09911:
408 if (wia_val[1] == AK09911_DEVICE_ID)
409 return 0;
410 break;
411 case AK09912:
412 if (wia_val[1] == AK09912_DEVICE_ID)
413 return 0;
414 break;
415 default:
416 dev_err(&client->dev, "Type %d unknown\n", type);
417 }
418 return -ENODEV;
419}
420
421
422
423
424static int ak8975_set_mode(struct ak8975_data *data, enum ak_ctrl_mode mode)
425{
426 u8 regval;
427 int ret;
428
429 regval = (data->cntl_cache & ~data->def->ctrl_masks[CNTL_MODE]) |
430 data->def->ctrl_modes[mode];
431 ret = i2c_smbus_write_byte_data(data->client,
432 data->def->ctrl_regs[CNTL], regval);
433 if (ret < 0) {
434 return ret;
435 }
436 data->cntl_cache = regval;
437
438 usleep_range(100, 500);
439
440 return 0;
441}
442
443
444
445
446static irqreturn_t ak8975_irq_handler(int irq, void *data)
447{
448 struct ak8975_data *ak8975 = data;
449
450 set_bit(0, &ak8975->flags);
451 wake_up(&ak8975->data_ready_queue);
452
453 return IRQ_HANDLED;
454}
455
456
457
458
459static int ak8975_setup_irq(struct ak8975_data *data)
460{
461 struct i2c_client *client = data->client;
462 int rc;
463 int irq;
464
465 init_waitqueue_head(&data->data_ready_queue);
466 clear_bit(0, &data->flags);
467 if (client->irq)
468 irq = client->irq;
469 else
470 irq = gpio_to_irq(data->eoc_gpio);
471
472 rc = devm_request_irq(&client->dev, irq, ak8975_irq_handler,
473 IRQF_TRIGGER_RISING | IRQF_ONESHOT,
474 dev_name(&client->dev), data);
475 if (rc < 0) {
476 dev_err(&client->dev,
477 "irq %d request failed, (gpio %d): %d\n",
478 irq, data->eoc_gpio, rc);
479 return rc;
480 }
481
482 data->eoc_irq = irq;
483
484 return rc;
485}
486
487
488
489
490
491
492static int ak8975_setup(struct i2c_client *client)
493{
494 struct iio_dev *indio_dev = i2c_get_clientdata(client);
495 struct ak8975_data *data = iio_priv(indio_dev);
496 int ret;
497
498
499 ret = ak8975_set_mode(data, FUSE_ROM);
500 if (ret < 0) {
501 dev_err(&client->dev, "Error in setting fuse access mode\n");
502 return ret;
503 }
504
505
506 ret = i2c_smbus_read_i2c_block_data(client,
507 data->def->ctrl_regs[ASA_BASE],
508 3, data->asa);
509 if (ret < 0) {
510 dev_err(&client->dev, "Not able to read asa data\n");
511 return ret;
512 }
513
514
515 ret = ak8975_set_mode(data, POWER_DOWN);
516 if (ret < 0) {
517 dev_err(&client->dev, "Error in setting power-down mode\n");
518 return ret;
519 }
520
521 if (data->eoc_gpio > 0 || client->irq > 0) {
522 ret = ak8975_setup_irq(data);
523 if (ret < 0) {
524 dev_err(&client->dev,
525 "Error setting data ready interrupt\n");
526 return ret;
527 }
528 }
529
530 data->raw_to_gauss[0] = data->def->raw_to_gauss(data->asa[0]);
531 data->raw_to_gauss[1] = data->def->raw_to_gauss(data->asa[1]);
532 data->raw_to_gauss[2] = data->def->raw_to_gauss(data->asa[2]);
533
534 return 0;
535}
536
537static int wait_conversion_complete_gpio(struct ak8975_data *data)
538{
539 struct i2c_client *client = data->client;
540 u32 timeout_ms = AK8975_MAX_CONVERSION_TIMEOUT;
541 int ret;
542
543
544 while (timeout_ms) {
545 msleep(AK8975_CONVERSION_DONE_POLL_TIME);
546 if (gpio_get_value(data->eoc_gpio))
547 break;
548 timeout_ms -= AK8975_CONVERSION_DONE_POLL_TIME;
549 }
550 if (!timeout_ms) {
551 dev_err(&client->dev, "Conversion timeout happened\n");
552 return -EINVAL;
553 }
554
555 ret = i2c_smbus_read_byte_data(client, data->def->ctrl_regs[ST1]);
556 if (ret < 0)
557 dev_err(&client->dev, "Error in reading ST1\n");
558
559 return ret;
560}
561
562static int wait_conversion_complete_polled(struct ak8975_data *data)
563{
564 struct i2c_client *client = data->client;
565 u8 read_status;
566 u32 timeout_ms = AK8975_MAX_CONVERSION_TIMEOUT;
567 int ret;
568
569
570 while (timeout_ms) {
571 msleep(AK8975_CONVERSION_DONE_POLL_TIME);
572 ret = i2c_smbus_read_byte_data(client,
573 data->def->ctrl_regs[ST1]);
574 if (ret < 0) {
575 dev_err(&client->dev, "Error in reading ST1\n");
576 return ret;
577 }
578 read_status = ret;
579 if (read_status)
580 break;
581 timeout_ms -= AK8975_CONVERSION_DONE_POLL_TIME;
582 }
583 if (!timeout_ms) {
584 dev_err(&client->dev, "Conversion timeout happened\n");
585 return -EINVAL;
586 }
587
588 return read_status;
589}
590
591
592static int wait_conversion_complete_interrupt(struct ak8975_data *data)
593{
594 int ret;
595
596 ret = wait_event_timeout(data->data_ready_queue,
597 test_bit(0, &data->flags),
598 AK8975_DATA_READY_TIMEOUT);
599 clear_bit(0, &data->flags);
600
601 return ret > 0 ? 0 : -ETIME;
602}
603
604
605
606
607static int ak8975_read_axis(struct iio_dev *indio_dev, int index, int *val)
608{
609 struct ak8975_data *data = iio_priv(indio_dev);
610 struct i2c_client *client = data->client;
611 int ret;
612
613 mutex_lock(&data->lock);
614
615
616 ret = ak8975_set_mode(data, MODE_ONCE);
617 if (ret < 0) {
618 dev_err(&client->dev, "Error in setting operating mode\n");
619 goto exit;
620 }
621
622
623 if (data->eoc_irq)
624 ret = wait_conversion_complete_interrupt(data);
625 else if (gpio_is_valid(data->eoc_gpio))
626 ret = wait_conversion_complete_gpio(data);
627 else
628 ret = wait_conversion_complete_polled(data);
629 if (ret < 0)
630 goto exit;
631
632
633 if (ret & data->def->ctrl_masks[ST1_DRDY]) {
634 ret = i2c_smbus_read_byte_data(client,
635 data->def->ctrl_regs[ST2]);
636 if (ret < 0) {
637 dev_err(&client->dev, "Error in reading ST2\n");
638 goto exit;
639 }
640 if (ret & (data->def->ctrl_masks[ST2_DERR] |
641 data->def->ctrl_masks[ST2_HOFL])) {
642 dev_err(&client->dev, "ST2 status error 0x%x\n", ret);
643 ret = -EINVAL;
644 goto exit;
645 }
646 }
647
648
649
650 ret = i2c_smbus_read_word_data(client, data->def->data_regs[index]);
651 if (ret < 0) {
652 dev_err(&client->dev, "Read axis data fails\n");
653 goto exit;
654 }
655
656 mutex_unlock(&data->lock);
657
658
659 *val = clamp_t(s16, ret, -data->def->range, data->def->range);
660 return IIO_VAL_INT;
661
662exit:
663 mutex_unlock(&data->lock);
664 return ret;
665}
666
667static int ak8975_read_raw(struct iio_dev *indio_dev,
668 struct iio_chan_spec const *chan,
669 int *val, int *val2,
670 long mask)
671{
672 struct ak8975_data *data = iio_priv(indio_dev);
673
674 switch (mask) {
675 case IIO_CHAN_INFO_RAW:
676 return ak8975_read_axis(indio_dev, chan->address, val);
677 case IIO_CHAN_INFO_SCALE:
678 *val = 0;
679 *val2 = data->raw_to_gauss[chan->address];
680 return IIO_VAL_INT_PLUS_MICRO;
681 }
682 return -EINVAL;
683}
684
685#define AK8975_CHANNEL(axis, index) \
686 { \
687 .type = IIO_MAGN, \
688 .modified = 1, \
689 .channel2 = IIO_MOD_##axis, \
690 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
691 BIT(IIO_CHAN_INFO_SCALE), \
692 .address = index, \
693 }
694
695static const struct iio_chan_spec ak8975_channels[] = {
696 AK8975_CHANNEL(X, 0), AK8975_CHANNEL(Y, 1), AK8975_CHANNEL(Z, 2),
697};
698
699static const struct iio_info ak8975_info = {
700 .read_raw = &ak8975_read_raw,
701 .driver_module = THIS_MODULE,
702};
703
704static const struct acpi_device_id ak_acpi_match[] = {
705 {"AK8975", AK8975},
706 {"AK8963", AK8963},
707 {"INVN6500", AK8963},
708 {"AK09911", AK09911},
709 {"AK09912", AK09912},
710 { },
711};
712MODULE_DEVICE_TABLE(acpi, ak_acpi_match);
713
714static const char *ak8975_match_acpi_device(struct device *dev,
715 enum asahi_compass_chipset *chipset)
716{
717 const struct acpi_device_id *id;
718
719 id = acpi_match_device(dev->driver->acpi_match_table, dev);
720 if (!id)
721 return NULL;
722 *chipset = (int)id->driver_data;
723
724 return dev_name(dev);
725}
726
727static int ak8975_probe(struct i2c_client *client,
728 const struct i2c_device_id *id)
729{
730 struct ak8975_data *data;
731 struct iio_dev *indio_dev;
732 int eoc_gpio;
733 int err;
734 const char *name = NULL;
735 enum asahi_compass_chipset chipset = AK_MAX_TYPE;
736
737
738 if (client->dev.platform_data)
739 eoc_gpio = *(int *)(client->dev.platform_data);
740 else if (client->dev.of_node)
741 eoc_gpio = of_get_gpio(client->dev.of_node, 0);
742 else
743 eoc_gpio = -1;
744
745 if (eoc_gpio == -EPROBE_DEFER)
746 return -EPROBE_DEFER;
747
748
749
750 if (gpio_is_valid(eoc_gpio)) {
751 err = devm_gpio_request_one(&client->dev, eoc_gpio,
752 GPIOF_IN, "ak_8975");
753 if (err < 0) {
754 dev_err(&client->dev,
755 "failed to request GPIO %d, error %d\n",
756 eoc_gpio, err);
757 return err;
758 }
759 }
760
761
762 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
763 if (indio_dev == NULL)
764 return -ENOMEM;
765
766 data = iio_priv(indio_dev);
767 i2c_set_clientdata(client, indio_dev);
768
769 data->client = client;
770 data->eoc_gpio = eoc_gpio;
771 data->eoc_irq = 0;
772
773
774 if (id) {
775 chipset = (enum asahi_compass_chipset)(id->driver_data);
776 name = id->name;
777 } else if (ACPI_HANDLE(&client->dev))
778 name = ak8975_match_acpi_device(&client->dev, &chipset);
779 else
780 return -ENOSYS;
781
782 if (chipset >= AK_MAX_TYPE) {
783 dev_err(&client->dev, "AKM device type unsupported: %d\n",
784 chipset);
785 return -ENODEV;
786 }
787
788 data->def = &ak_def_array[chipset];
789 err = ak8975_who_i_am(client, data->def->type);
790 if (err < 0) {
791 dev_err(&client->dev, "Unexpected device\n");
792 return err;
793 }
794 dev_dbg(&client->dev, "Asahi compass chip %s\n", name);
795
796
797 err = ak8975_setup(client);
798 if (err < 0) {
799 dev_err(&client->dev, "%s initialization fails\n", name);
800 return err;
801 }
802
803 mutex_init(&data->lock);
804 indio_dev->dev.parent = &client->dev;
805 indio_dev->channels = ak8975_channels;
806 indio_dev->num_channels = ARRAY_SIZE(ak8975_channels);
807 indio_dev->info = &ak8975_info;
808 indio_dev->modes = INDIO_DIRECT_MODE;
809 indio_dev->name = name;
810 return devm_iio_device_register(&client->dev, indio_dev);
811}
812
813static const struct i2c_device_id ak8975_id[] = {
814 {"ak8975", AK8975},
815 {"ak8963", AK8963},
816 {"AK8963", AK8963},
817 {"ak09911", AK09911},
818 {"ak09912", AK09912},
819 {}
820};
821
822MODULE_DEVICE_TABLE(i2c, ak8975_id);
823
824static const struct of_device_id ak8975_of_match[] = {
825 { .compatible = "asahi-kasei,ak8975", },
826 { .compatible = "ak8975", },
827 { .compatible = "asahi-kasei,ak8963", },
828 { .compatible = "ak8963", },
829 { .compatible = "asahi-kasei,ak09911", },
830 { .compatible = "ak09911", },
831 { .compatible = "asahi-kasei,ak09912", },
832 { .compatible = "ak09912", },
833 {}
834};
835MODULE_DEVICE_TABLE(of, ak8975_of_match);
836
837static struct i2c_driver ak8975_driver = {
838 .driver = {
839 .name = "ak8975",
840 .of_match_table = of_match_ptr(ak8975_of_match),
841 .acpi_match_table = ACPI_PTR(ak_acpi_match),
842 },
843 .probe = ak8975_probe,
844 .id_table = ak8975_id,
845};
846module_i2c_driver(ak8975_driver);
847
848MODULE_AUTHOR("Laxman Dewangan <ldewangan@nvidia.com>");
849MODULE_DESCRIPTION("AK8975 magnetometer driver");
850MODULE_LICENSE("GPL");
851