2 * A sensor driver for the magnetometer AK8975.
4 * Magnetic compass sensor driver for monitoring magnetic flux information.
6 * Copyright (c) 2010, NVIDIA Corporation.
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful, but WITHOUT
14 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
18 * You should have received a copy of the GNU General Public License along
19 * with this program; if not, write to the Free Software Foundation, Inc.,
20 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
23 #include <linux/module.h>
24 #include <linux/kernel.h>
25 #include <linux/slab.h>
26 #include <linux/i2c.h>
27 #include <linux/err.h>
28 #include <linux/mutex.h>
29 #include <linux/delay.h>
31 #include <linux/gpio.h>
32 #include <linux/of_gpio.h>
34 #include <linux/iio/iio.h>
35 #include <linux/iio/sysfs.h>
37 * Register definitions, as well as various shifts and masks to get at the
38 * individual fields of the registers.
40 #define AK8975_REG_WIA 0x00
41 #define AK8975_DEVICE_ID 0x48
43 #define AK8975_REG_INFO 0x01
45 #define AK8975_REG_ST1 0x02
46 #define AK8975_REG_ST1_DRDY_SHIFT 0
47 #define AK8975_REG_ST1_DRDY_MASK (1 << AK8975_REG_ST1_DRDY_SHIFT)
49 #define AK8975_REG_HXL 0x03
50 #define AK8975_REG_HXH 0x04
51 #define AK8975_REG_HYL 0x05
52 #define AK8975_REG_HYH 0x06
53 #define AK8975_REG_HZL 0x07
54 #define AK8975_REG_HZH 0x08
55 #define AK8975_REG_ST2 0x09
56 #define AK8975_REG_ST2_DERR_SHIFT 2
57 #define AK8975_REG_ST2_DERR_MASK (1 << AK8975_REG_ST2_DERR_SHIFT)
59 #define AK8975_REG_ST2_HOFL_SHIFT 3
60 #define AK8975_REG_ST2_HOFL_MASK (1 << AK8975_REG_ST2_HOFL_SHIFT)
62 #define AK8975_REG_CNTL 0x0A
63 #define AK8975_REG_CNTL_MODE_SHIFT 0
64 #define AK8975_REG_CNTL_MODE_MASK (0xF << AK8975_REG_CNTL_MODE_SHIFT)
65 #define AK8975_REG_CNTL_MODE_POWER_DOWN 0
66 #define AK8975_REG_CNTL_MODE_ONCE 1
67 #define AK8975_REG_CNTL_MODE_SELF_TEST 8
68 #define AK8975_REG_CNTL_MODE_FUSE_ROM 0xF
70 #define AK8975_REG_RSVC 0x0B
71 #define AK8975_REG_ASTC 0x0C
72 #define AK8975_REG_TS1 0x0D
73 #define AK8975_REG_TS2 0x0E
74 #define AK8975_REG_I2CDIS 0x0F
75 #define AK8975_REG_ASAX 0x10
76 #define AK8975_REG_ASAY 0x11
77 #define AK8975_REG_ASAZ 0x12
79 #define AK8975_MAX_REGS AK8975_REG_ASAZ
82 * Miscellaneous values.
84 #define AK8975_MAX_CONVERSION_TIMEOUT 500
85 #define AK8975_CONVERSION_DONE_POLL_TIME 10
88 * Per-instance context data for the device.
91 struct i2c_client
*client
;
92 struct attribute_group attrs
;
96 u8 reg_cache
[AK8975_MAX_REGS
];
100 static const int ak8975_index_to_reg
[] = {
101 AK8975_REG_HXL
, AK8975_REG_HYL
, AK8975_REG_HZL
,
105 * Helper function to write to the I2C device's registers.
107 static int ak8975_write_data(struct i2c_client
*client
,
108 u8 reg
, u8 val
, u8 mask
, u8 shift
)
110 struct iio_dev
*indio_dev
= i2c_get_clientdata(client
);
111 struct ak8975_data
*data
= iio_priv(indio_dev
);
115 regval
= (data
->reg_cache
[reg
] & ~mask
) | (val
<< shift
);
116 ret
= i2c_smbus_write_byte_data(client
, reg
, regval
);
118 dev_err(&client
->dev
, "Write to device fails status %x\n", ret
);
121 data
->reg_cache
[reg
] = regval
;
127 * Perform some start-of-day setup, including reading the asa calibration
128 * values and caching them.
130 static int ak8975_setup(struct i2c_client
*client
)
132 struct iio_dev
*indio_dev
= i2c_get_clientdata(client
);
133 struct ak8975_data
*data
= iio_priv(indio_dev
);
137 /* Confirm that the device we're talking to is really an AK8975. */
138 ret
= i2c_smbus_read_byte_data(client
, AK8975_REG_WIA
);
140 dev_err(&client
->dev
, "Error reading WIA\n");
144 if (device_id
!= AK8975_DEVICE_ID
) {
145 dev_err(&client
->dev
, "Device ak8975 not found\n");
149 /* Write the fused rom access mode. */
150 ret
= ak8975_write_data(client
,
152 AK8975_REG_CNTL_MODE_FUSE_ROM
,
153 AK8975_REG_CNTL_MODE_MASK
,
154 AK8975_REG_CNTL_MODE_SHIFT
);
156 dev_err(&client
->dev
, "Error in setting fuse access mode\n");
160 /* Get asa data and store in the device data. */
161 ret
= i2c_smbus_read_i2c_block_data(client
, AK8975_REG_ASAX
,
164 dev_err(&client
->dev
, "Not able to read asa data\n");
168 /* After reading fuse ROM data set power-down mode */
169 ret
= ak8975_write_data(client
,
171 AK8975_REG_CNTL_MODE_POWER_DOWN
,
172 AK8975_REG_CNTL_MODE_MASK
,
173 AK8975_REG_CNTL_MODE_SHIFT
);
175 dev_err(&client
->dev
, "Error in setting power-down mode\n");
180 * Precalculate scale factor (in Gauss units) for each axis and
181 * store in the device data.
183 * This scale factor is axis-dependent, and is derived from 3 calibration
184 * factors ASA(x), ASA(y), and ASA(z).
186 * These ASA values are read from the sensor device at start of day, and
187 * cached in the device context struct.
189 * Adjusting the flux value with the sensitivity adjustment value should be
190 * done via the following formula:
192 * Hadj = H * ( ( ( (ASA-128)*0.5 ) / 128 ) + 1 )
194 * where H is the raw value, ASA is the sensitivity adjustment, and Hadj
195 * is the resultant adjusted value.
197 * We reduce the formula to:
199 * Hadj = H * (ASA + 128) / 256
201 * H is in the range of -4096 to 4095. The magnetometer has a range of
202 * +-1229uT. To go from the raw value to uT is:
204 * HuT = H * 1229/4096, or roughly, 3/10.
206 * Since 1uT = 100 gauss, our final scale factor becomes:
208 * Hadj = H * ((ASA + 128) / 256) * 3/10 * 100
209 * Hadj = H * ((ASA + 128) * 30 / 256
211 * Since ASA doesn't change, we cache the resultant scale factor into the
212 * device context in ak8975_setup().
214 data
->raw_to_gauss
[0] = ((data
->asa
[0] + 128) * 30) >> 8;
215 data
->raw_to_gauss
[1] = ((data
->asa
[1] + 128) * 30) >> 8;
216 data
->raw_to_gauss
[2] = ((data
->asa
[2] + 128) * 30) >> 8;
221 static int wait_conversion_complete_gpio(struct ak8975_data
*data
)
223 struct i2c_client
*client
= data
->client
;
224 u32 timeout_ms
= AK8975_MAX_CONVERSION_TIMEOUT
;
227 /* Wait for the conversion to complete. */
229 msleep(AK8975_CONVERSION_DONE_POLL_TIME
);
230 if (gpio_get_value(data
->eoc_gpio
))
232 timeout_ms
-= AK8975_CONVERSION_DONE_POLL_TIME
;
235 dev_err(&client
->dev
, "Conversion timeout happened\n");
239 ret
= i2c_smbus_read_byte_data(client
, AK8975_REG_ST1
);
241 dev_err(&client
->dev
, "Error in reading ST1\n");
246 static int wait_conversion_complete_polled(struct ak8975_data
*data
)
248 struct i2c_client
*client
= data
->client
;
250 u32 timeout_ms
= AK8975_MAX_CONVERSION_TIMEOUT
;
253 /* Wait for the conversion to complete. */
255 msleep(AK8975_CONVERSION_DONE_POLL_TIME
);
256 ret
= i2c_smbus_read_byte_data(client
, AK8975_REG_ST1
);
258 dev_err(&client
->dev
, "Error in reading ST1\n");
264 timeout_ms
-= AK8975_CONVERSION_DONE_POLL_TIME
;
267 dev_err(&client
->dev
, "Conversion timeout happened\n");
274 * Emits the raw flux value for the x, y, or z axis.
276 static int ak8975_read_axis(struct iio_dev
*indio_dev
, int index
, int *val
)
278 struct ak8975_data
*data
= iio_priv(indio_dev
);
279 struct i2c_client
*client
= data
->client
;
284 mutex_lock(&data
->lock
);
286 /* Set up the device for taking a sample. */
287 ret
= ak8975_write_data(client
,
289 AK8975_REG_CNTL_MODE_ONCE
,
290 AK8975_REG_CNTL_MODE_MASK
,
291 AK8975_REG_CNTL_MODE_SHIFT
);
293 dev_err(&client
->dev
, "Error in setting operating mode\n");
297 /* Wait for the conversion to complete. */
298 if (gpio_is_valid(data
->eoc_gpio
))
299 ret
= wait_conversion_complete_gpio(data
);
301 ret
= wait_conversion_complete_polled(data
);
305 if (ret
& AK8975_REG_ST1_DRDY_MASK
) {
306 ret
= i2c_smbus_read_byte_data(client
, AK8975_REG_ST2
);
308 dev_err(&client
->dev
, "Error in reading ST2\n");
311 if (ret
& (AK8975_REG_ST2_DERR_MASK
|
312 AK8975_REG_ST2_HOFL_MASK
)) {
313 dev_err(&client
->dev
, "ST2 status error 0x%x\n", ret
);
319 /* Read the flux value from the appropriate register
320 (the register is specified in the iio device attributes). */
321 ret
= i2c_smbus_read_word_data(client
, ak8975_index_to_reg
[index
]);
323 dev_err(&client
->dev
, "Read axis data fails\n");
328 mutex_unlock(&data
->lock
);
330 /* Endian conversion of the measured values. */
331 raw
= (s16
) (le16_to_cpu(meas_reg
));
333 /* Clamp to valid range. */
334 raw
= clamp_t(s16
, raw
, -4096, 4095);
339 mutex_unlock(&data
->lock
);
343 static int ak8975_read_raw(struct iio_dev
*indio_dev
,
344 struct iio_chan_spec
const *chan
,
348 struct ak8975_data
*data
= iio_priv(indio_dev
);
351 case IIO_CHAN_INFO_RAW
:
352 return ak8975_read_axis(indio_dev
, chan
->address
, val
);
353 case IIO_CHAN_INFO_SCALE
:
354 *val
= data
->raw_to_gauss
[chan
->address
];
360 #define AK8975_CHANNEL(axis, index) \
364 .channel2 = IIO_MOD_##axis, \
365 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
366 BIT(IIO_CHAN_INFO_SCALE), \
370 static const struct iio_chan_spec ak8975_channels
[] = {
371 AK8975_CHANNEL(X
, 0), AK8975_CHANNEL(Y
, 1), AK8975_CHANNEL(Z
, 2),
374 static const struct iio_info ak8975_info
= {
375 .read_raw
= &ak8975_read_raw
,
376 .driver_module
= THIS_MODULE
,
379 static int ak8975_probe(struct i2c_client
*client
,
380 const struct i2c_device_id
*id
)
382 struct ak8975_data
*data
;
383 struct iio_dev
*indio_dev
;
387 /* Grab and set up the supplied GPIO. */
388 if (client
->dev
.platform_data
)
389 eoc_gpio
= *(int *)(client
->dev
.platform_data
);
390 else if (client
->dev
.of_node
)
391 eoc_gpio
= of_get_gpio(client
->dev
.of_node
, 0);
395 if (eoc_gpio
== -EPROBE_DEFER
)
396 return -EPROBE_DEFER
;
398 /* We may not have a GPIO based IRQ to scan, that is fine, we will
400 if (gpio_is_valid(eoc_gpio
)) {
401 err
= gpio_request_one(eoc_gpio
, GPIOF_IN
, "ak_8975");
403 dev_err(&client
->dev
,
404 "failed to request GPIO %d, error %d\n",
410 /* Register with IIO */
411 indio_dev
= iio_device_alloc(sizeof(*data
));
412 if (indio_dev
== NULL
) {
416 data
= iio_priv(indio_dev
);
417 i2c_set_clientdata(client
, indio_dev
);
418 /* Perform some basic start-of-day setup of the device. */
419 err
= ak8975_setup(client
);
421 dev_err(&client
->dev
, "AK8975 initialization fails\n");
425 data
->client
= client
;
426 mutex_init(&data
->lock
);
427 data
->eoc_gpio
= eoc_gpio
;
428 indio_dev
->dev
.parent
= &client
->dev
;
429 indio_dev
->channels
= ak8975_channels
;
430 indio_dev
->num_channels
= ARRAY_SIZE(ak8975_channels
);
431 indio_dev
->info
= &ak8975_info
;
432 indio_dev
->modes
= INDIO_DIRECT_MODE
;
434 err
= iio_device_register(indio_dev
);
441 iio_device_free(indio_dev
);
443 if (gpio_is_valid(eoc_gpio
))
449 static int ak8975_remove(struct i2c_client
*client
)
451 struct iio_dev
*indio_dev
= i2c_get_clientdata(client
);
452 struct ak8975_data
*data
= iio_priv(indio_dev
);
454 iio_device_unregister(indio_dev
);
456 if (gpio_is_valid(data
->eoc_gpio
))
457 gpio_free(data
->eoc_gpio
);
459 iio_device_free(indio_dev
);
464 static const struct i2c_device_id ak8975_id
[] = {
469 MODULE_DEVICE_TABLE(i2c
, ak8975_id
);
471 static const struct of_device_id ak8975_of_match
[] = {
472 { .compatible
= "asahi-kasei,ak8975", },
473 { .compatible
= "ak8975", },
476 MODULE_DEVICE_TABLE(of
, ak8975_of_match
);
478 static struct i2c_driver ak8975_driver
= {
481 .of_match_table
= ak8975_of_match
,
483 .probe
= ak8975_probe
,
484 .remove
= ak8975_remove
,
485 .id_table
= ak8975_id
,
487 module_i2c_driver(ak8975_driver
);
489 MODULE_AUTHOR("Laxman Dewangan <ldewangan@nvidia.com>");
490 MODULE_DESCRIPTION("AK8975 magnetometer driver");
491 MODULE_LICENSE("GPL");