1 /* 2 * A sensor driver for the magnetometer AK8975. 3 * 4 * Magnetic compass sensor driver for monitoring magnetic flux information. 5 * 6 * Copyright (c) 2010, NVIDIA Corporation. 7 * 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. 12 * 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 16 * more details. 17 * 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. 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 35 #include <linux/iio/iio.h> 36 #include <linux/iio/sysfs.h> 37 /* 38 * Register definitions, as well as various shifts and masks to get at the 39 * individual fields of the registers. 40 */ 41 #define AK8975_REG_WIA 0x00 42 #define AK8975_DEVICE_ID 0x48 43 44 #define AK8975_REG_INFO 0x01 45 46 #define AK8975_REG_ST1 0x02 47 #define AK8975_REG_ST1_DRDY_SHIFT 0 48 #define AK8975_REG_ST1_DRDY_MASK (1 << AK8975_REG_ST1_DRDY_SHIFT) 49 50 #define AK8975_REG_HXL 0x03 51 #define AK8975_REG_HXH 0x04 52 #define AK8975_REG_HYL 0x05 53 #define AK8975_REG_HYH 0x06 54 #define AK8975_REG_HZL 0x07 55 #define AK8975_REG_HZH 0x08 56 #define AK8975_REG_ST2 0x09 57 #define AK8975_REG_ST2_DERR_SHIFT 2 58 #define AK8975_REG_ST2_DERR_MASK (1 << AK8975_REG_ST2_DERR_SHIFT) 59 60 #define AK8975_REG_ST2_HOFL_SHIFT 3 61 #define AK8975_REG_ST2_HOFL_MASK (1 << AK8975_REG_ST2_HOFL_SHIFT) 62 63 #define AK8975_REG_CNTL 0x0A 64 #define AK8975_REG_CNTL_MODE_SHIFT 0 65 #define AK8975_REG_CNTL_MODE_MASK (0xF << AK8975_REG_CNTL_MODE_SHIFT) 66 #define AK8975_REG_CNTL_MODE_POWER_DOWN 0 67 #define AK8975_REG_CNTL_MODE_ONCE 1 68 #define AK8975_REG_CNTL_MODE_SELF_TEST 8 69 #define AK8975_REG_CNTL_MODE_FUSE_ROM 0xF 70 71 #define AK8975_REG_RSVC 0x0B 72 #define AK8975_REG_ASTC 0x0C 73 #define AK8975_REG_TS1 0x0D 74 #define AK8975_REG_TS2 0x0E 75 #define AK8975_REG_I2CDIS 0x0F 76 #define AK8975_REG_ASAX 0x10 77 #define AK8975_REG_ASAY 0x11 78 #define AK8975_REG_ASAZ 0x12 79 80 #define AK8975_MAX_REGS AK8975_REG_ASAZ 81 82 /* 83 * Miscellaneous values. 84 */ 85 #define AK8975_MAX_CONVERSION_TIMEOUT 500 86 #define AK8975_CONVERSION_DONE_POLL_TIME 10 87 #define AK8975_DATA_READY_TIMEOUT ((100*HZ)/1000) 88 #define RAW_TO_GAUSS(asa) ((((asa) + 128) * 3000) / 256) 89 90 /* 91 * Per-instance context data for the device. 92 */ 93 struct ak8975_data { 94 struct i2c_client *client; 95 struct attribute_group attrs; 96 struct mutex lock; 97 u8 asa[3]; 98 long raw_to_gauss[3]; 99 u8 reg_cache[AK8975_MAX_REGS]; 100 int eoc_gpio; 101 int eoc_irq; 102 wait_queue_head_t data_ready_queue; 103 unsigned long flags; 104 }; 105 106 static const int ak8975_index_to_reg[] = { 107 AK8975_REG_HXL, AK8975_REG_HYL, AK8975_REG_HZL, 108 }; 109 110 /* 111 * Helper function to write to the I2C device's registers. 112 */ 113 static int ak8975_write_data(struct i2c_client *client, 114 u8 reg, u8 val, u8 mask, u8 shift) 115 { 116 struct iio_dev *indio_dev = i2c_get_clientdata(client); 117 struct ak8975_data *data = iio_priv(indio_dev); 118 u8 regval; 119 int ret; 120 121 regval = (data->reg_cache[reg] & ~mask) | (val << shift); 122 ret = i2c_smbus_write_byte_data(client, reg, regval); 123 if (ret < 0) { 124 dev_err(&client->dev, "Write to device fails status %x\n", ret); 125 return ret; 126 } 127 data->reg_cache[reg] = regval; 128 129 return 0; 130 } 131 132 /* 133 * Handle data ready irq 134 */ 135 static irqreturn_t ak8975_irq_handler(int irq, void *data) 136 { 137 struct ak8975_data *ak8975 = data; 138 139 set_bit(0, &ak8975->flags); 140 wake_up(&ak8975->data_ready_queue); 141 142 return IRQ_HANDLED; 143 } 144 145 /* 146 * Install data ready interrupt handler 147 */ 148 static int ak8975_setup_irq(struct ak8975_data *data) 149 { 150 struct i2c_client *client = data->client; 151 int rc; 152 int irq; 153 154 if (client->irq) 155 irq = client->irq; 156 else 157 irq = gpio_to_irq(data->eoc_gpio); 158 159 rc = request_irq(irq, ak8975_irq_handler, 160 IRQF_TRIGGER_RISING | IRQF_ONESHOT, 161 dev_name(&client->dev), data); 162 if (rc < 0) { 163 dev_err(&client->dev, 164 "irq %d request failed, (gpio %d): %d\n", 165 irq, data->eoc_gpio, rc); 166 return rc; 167 } 168 169 init_waitqueue_head(&data->data_ready_queue); 170 clear_bit(0, &data->flags); 171 data->eoc_irq = irq; 172 173 return rc; 174 } 175 176 177 /* 178 * Perform some start-of-day setup, including reading the asa calibration 179 * values and caching them. 180 */ 181 static int ak8975_setup(struct i2c_client *client) 182 { 183 struct iio_dev *indio_dev = i2c_get_clientdata(client); 184 struct ak8975_data *data = iio_priv(indio_dev); 185 u8 device_id; 186 int ret; 187 188 /* Confirm that the device we're talking to is really an AK8975. */ 189 ret = i2c_smbus_read_byte_data(client, AK8975_REG_WIA); 190 if (ret < 0) { 191 dev_err(&client->dev, "Error reading WIA\n"); 192 return ret; 193 } 194 device_id = ret; 195 if (device_id != AK8975_DEVICE_ID) { 196 dev_err(&client->dev, "Device ak8975 not found\n"); 197 return -ENODEV; 198 } 199 200 /* Write the fused rom access mode. */ 201 ret = ak8975_write_data(client, 202 AK8975_REG_CNTL, 203 AK8975_REG_CNTL_MODE_FUSE_ROM, 204 AK8975_REG_CNTL_MODE_MASK, 205 AK8975_REG_CNTL_MODE_SHIFT); 206 if (ret < 0) { 207 dev_err(&client->dev, "Error in setting fuse access mode\n"); 208 return ret; 209 } 210 211 /* Get asa data and store in the device data. */ 212 ret = i2c_smbus_read_i2c_block_data(client, AK8975_REG_ASAX, 213 3, data->asa); 214 if (ret < 0) { 215 dev_err(&client->dev, "Not able to read asa data\n"); 216 return ret; 217 } 218 219 /* After reading fuse ROM data set power-down mode */ 220 ret = ak8975_write_data(client, 221 AK8975_REG_CNTL, 222 AK8975_REG_CNTL_MODE_POWER_DOWN, 223 AK8975_REG_CNTL_MODE_MASK, 224 AK8975_REG_CNTL_MODE_SHIFT); 225 226 if (data->eoc_gpio > 0 || client->irq) { 227 ret = ak8975_setup_irq(data); 228 if (ret < 0) { 229 dev_err(&client->dev, 230 "Error setting data ready interrupt\n"); 231 return ret; 232 } 233 } 234 235 if (ret < 0) { 236 dev_err(&client->dev, "Error in setting power-down mode\n"); 237 return ret; 238 } 239 240 /* 241 * Precalculate scale factor (in Gauss units) for each axis and 242 * store in the device data. 243 * 244 * This scale factor is axis-dependent, and is derived from 3 calibration 245 * factors ASA(x), ASA(y), and ASA(z). 246 * 247 * These ASA values are read from the sensor device at start of day, and 248 * cached in the device context struct. 249 * 250 * Adjusting the flux value with the sensitivity adjustment value should be 251 * done via the following formula: 252 * 253 * Hadj = H * ( ( ( (ASA-128)*0.5 ) / 128 ) + 1 ) 254 * 255 * where H is the raw value, ASA is the sensitivity adjustment, and Hadj 256 * is the resultant adjusted value. 257 * 258 * We reduce the formula to: 259 * 260 * Hadj = H * (ASA + 128) / 256 261 * 262 * H is in the range of -4096 to 4095. The magnetometer has a range of 263 * +-1229uT. To go from the raw value to uT is: 264 * 265 * HuT = H * 1229/4096, or roughly, 3/10. 266 * 267 * Since 1uT = 0.01 gauss, our final scale factor becomes: 268 * 269 * Hadj = H * ((ASA + 128) / 256) * 3/10 * 1/100 270 * Hadj = H * ((ASA + 128) * 0.003) / 256 271 * 272 * Since ASA doesn't change, we cache the resultant scale factor into the 273 * device context in ak8975_setup(). 274 */ 275 data->raw_to_gauss[0] = RAW_TO_GAUSS(data->asa[0]); 276 data->raw_to_gauss[1] = RAW_TO_GAUSS(data->asa[1]); 277 data->raw_to_gauss[2] = RAW_TO_GAUSS(data->asa[2]); 278 279 return 0; 280 } 281 282 static int wait_conversion_complete_gpio(struct ak8975_data *data) 283 { 284 struct i2c_client *client = data->client; 285 u32 timeout_ms = AK8975_MAX_CONVERSION_TIMEOUT; 286 int ret; 287 288 /* Wait for the conversion to complete. */ 289 while (timeout_ms) { 290 msleep(AK8975_CONVERSION_DONE_POLL_TIME); 291 if (gpio_get_value(data->eoc_gpio)) 292 break; 293 timeout_ms -= AK8975_CONVERSION_DONE_POLL_TIME; 294 } 295 if (!timeout_ms) { 296 dev_err(&client->dev, "Conversion timeout happened\n"); 297 return -EINVAL; 298 } 299 300 ret = i2c_smbus_read_byte_data(client, AK8975_REG_ST1); 301 if (ret < 0) 302 dev_err(&client->dev, "Error in reading ST1\n"); 303 304 return ret; 305 } 306 307 static int wait_conversion_complete_polled(struct ak8975_data *data) 308 { 309 struct i2c_client *client = data->client; 310 u8 read_status; 311 u32 timeout_ms = AK8975_MAX_CONVERSION_TIMEOUT; 312 int ret; 313 314 /* Wait for the conversion to complete. */ 315 while (timeout_ms) { 316 msleep(AK8975_CONVERSION_DONE_POLL_TIME); 317 ret = i2c_smbus_read_byte_data(client, AK8975_REG_ST1); 318 if (ret < 0) { 319 dev_err(&client->dev, "Error in reading ST1\n"); 320 return ret; 321 } 322 read_status = ret; 323 if (read_status) 324 break; 325 timeout_ms -= AK8975_CONVERSION_DONE_POLL_TIME; 326 } 327 if (!timeout_ms) { 328 dev_err(&client->dev, "Conversion timeout happened\n"); 329 return -EINVAL; 330 } 331 332 return read_status; 333 } 334 335 /* Returns 0 if the end of conversion interrupt occured or -ETIME otherwise */ 336 static int wait_conversion_complete_interrupt(struct ak8975_data *data) 337 { 338 int ret; 339 340 ret = wait_event_timeout(data->data_ready_queue, 341 test_bit(0, &data->flags), 342 AK8975_DATA_READY_TIMEOUT); 343 clear_bit(0, &data->flags); 344 345 return ret > 0 ? 0 : -ETIME; 346 } 347 348 /* 349 * Emits the raw flux value for the x, y, or z axis. 350 */ 351 static int ak8975_read_axis(struct iio_dev *indio_dev, int index, int *val) 352 { 353 struct ak8975_data *data = iio_priv(indio_dev); 354 struct i2c_client *client = data->client; 355 u16 meas_reg; 356 s16 raw; 357 int ret; 358 359 mutex_lock(&data->lock); 360 361 /* Set up the device for taking a sample. */ 362 ret = ak8975_write_data(client, 363 AK8975_REG_CNTL, 364 AK8975_REG_CNTL_MODE_ONCE, 365 AK8975_REG_CNTL_MODE_MASK, 366 AK8975_REG_CNTL_MODE_SHIFT); 367 if (ret < 0) { 368 dev_err(&client->dev, "Error in setting operating mode\n"); 369 goto exit; 370 } 371 372 /* Wait for the conversion to complete. */ 373 if (data->eoc_irq) 374 ret = wait_conversion_complete_interrupt(data); 375 else if (gpio_is_valid(data->eoc_gpio)) 376 ret = wait_conversion_complete_gpio(data); 377 else 378 ret = wait_conversion_complete_polled(data); 379 if (ret < 0) 380 goto exit; 381 382 /* This will be executed only for non-interrupt based waiting case */ 383 if (ret & AK8975_REG_ST1_DRDY_MASK) { 384 ret = i2c_smbus_read_byte_data(client, AK8975_REG_ST2); 385 if (ret < 0) { 386 dev_err(&client->dev, "Error in reading ST2\n"); 387 goto exit; 388 } 389 if (ret & (AK8975_REG_ST2_DERR_MASK | 390 AK8975_REG_ST2_HOFL_MASK)) { 391 dev_err(&client->dev, "ST2 status error 0x%x\n", ret); 392 ret = -EINVAL; 393 goto exit; 394 } 395 } 396 397 /* Read the flux value from the appropriate register 398 (the register is specified in the iio device attributes). */ 399 ret = i2c_smbus_read_word_data(client, ak8975_index_to_reg[index]); 400 if (ret < 0) { 401 dev_err(&client->dev, "Read axis data fails\n"); 402 goto exit; 403 } 404 meas_reg = ret; 405 406 mutex_unlock(&data->lock); 407 408 /* Endian conversion of the measured values. */ 409 raw = (s16) (le16_to_cpu(meas_reg)); 410 411 /* Clamp to valid range. */ 412 raw = clamp_t(s16, raw, -4096, 4095); 413 *val = raw; 414 return IIO_VAL_INT; 415 416 exit: 417 mutex_unlock(&data->lock); 418 return ret; 419 } 420 421 static int ak8975_read_raw(struct iio_dev *indio_dev, 422 struct iio_chan_spec const *chan, 423 int *val, int *val2, 424 long mask) 425 { 426 struct ak8975_data *data = iio_priv(indio_dev); 427 428 switch (mask) { 429 case IIO_CHAN_INFO_RAW: 430 return ak8975_read_axis(indio_dev, chan->address, val); 431 case IIO_CHAN_INFO_SCALE: 432 *val = 0; 433 *val2 = data->raw_to_gauss[chan->address]; 434 return IIO_VAL_INT_PLUS_MICRO; 435 } 436 return -EINVAL; 437 } 438 439 #define AK8975_CHANNEL(axis, index) \ 440 { \ 441 .type = IIO_MAGN, \ 442 .modified = 1, \ 443 .channel2 = IIO_MOD_##axis, \ 444 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \ 445 BIT(IIO_CHAN_INFO_SCALE), \ 446 .address = index, \ 447 } 448 449 static const struct iio_chan_spec ak8975_channels[] = { 450 AK8975_CHANNEL(X, 0), AK8975_CHANNEL(Y, 1), AK8975_CHANNEL(Z, 2), 451 }; 452 453 static const struct iio_info ak8975_info = { 454 .read_raw = &ak8975_read_raw, 455 .driver_module = THIS_MODULE, 456 }; 457 458 static int ak8975_probe(struct i2c_client *client, 459 const struct i2c_device_id *id) 460 { 461 struct ak8975_data *data; 462 struct iio_dev *indio_dev; 463 int eoc_gpio; 464 int err; 465 466 /* Grab and set up the supplied GPIO. */ 467 if (client->dev.platform_data) 468 eoc_gpio = *(int *)(client->dev.platform_data); 469 else if (client->dev.of_node) 470 eoc_gpio = of_get_gpio(client->dev.of_node, 0); 471 else 472 eoc_gpio = -1; 473 474 if (eoc_gpio == -EPROBE_DEFER) 475 return -EPROBE_DEFER; 476 477 /* We may not have a GPIO based IRQ to scan, that is fine, we will 478 poll if so */ 479 if (gpio_is_valid(eoc_gpio)) { 480 err = gpio_request_one(eoc_gpio, GPIOF_IN, "ak_8975"); 481 if (err < 0) { 482 dev_err(&client->dev, 483 "failed to request GPIO %d, error %d\n", 484 eoc_gpio, err); 485 goto exit; 486 } 487 } 488 489 /* Register with IIO */ 490 indio_dev = iio_device_alloc(sizeof(*data)); 491 if (indio_dev == NULL) { 492 err = -ENOMEM; 493 goto exit_gpio; 494 } 495 data = iio_priv(indio_dev); 496 i2c_set_clientdata(client, indio_dev); 497 498 data->client = client; 499 data->eoc_gpio = eoc_gpio; 500 data->eoc_irq = 0; 501 502 /* Perform some basic start-of-day setup of the device. */ 503 err = ak8975_setup(client); 504 if (err < 0) { 505 dev_err(&client->dev, "AK8975 initialization fails\n"); 506 goto exit_free_iio; 507 } 508 509 data->client = client; 510 mutex_init(&data->lock); 511 data->eoc_gpio = eoc_gpio; 512 indio_dev->dev.parent = &client->dev; 513 indio_dev->channels = ak8975_channels; 514 indio_dev->num_channels = ARRAY_SIZE(ak8975_channels); 515 indio_dev->info = &ak8975_info; 516 indio_dev->name = id->name; 517 indio_dev->modes = INDIO_DIRECT_MODE; 518 519 err = iio_device_register(indio_dev); 520 if (err < 0) 521 goto exit_free_iio; 522 523 return 0; 524 525 exit_free_iio: 526 iio_device_free(indio_dev); 527 if (data->eoc_irq) 528 free_irq(data->eoc_irq, data); 529 exit_gpio: 530 if (gpio_is_valid(eoc_gpio)) 531 gpio_free(eoc_gpio); 532 exit: 533 return err; 534 } 535 536 static int ak8975_remove(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 541 iio_device_unregister(indio_dev); 542 543 if (data->eoc_irq) 544 free_irq(data->eoc_irq, data); 545 546 if (gpio_is_valid(data->eoc_gpio)) 547 gpio_free(data->eoc_gpio); 548 549 iio_device_free(indio_dev); 550 551 return 0; 552 } 553 554 static const struct i2c_device_id ak8975_id[] = { 555 {"ak8975", 0}, 556 {} 557 }; 558 559 MODULE_DEVICE_TABLE(i2c, ak8975_id); 560 561 static const struct of_device_id ak8975_of_match[] = { 562 { .compatible = "asahi-kasei,ak8975", }, 563 { .compatible = "ak8975", }, 564 { } 565 }; 566 MODULE_DEVICE_TABLE(of, ak8975_of_match); 567 568 static struct i2c_driver ak8975_driver = { 569 .driver = { 570 .name = "ak8975", 571 .of_match_table = ak8975_of_match, 572 }, 573 .probe = ak8975_probe, 574 .remove = ak8975_remove, 575 .id_table = ak8975_id, 576 }; 577 module_i2c_driver(ak8975_driver); 578 579 MODULE_AUTHOR("Laxman Dewangan <ldewangan@nvidia.com>"); 580 MODULE_DESCRIPTION("AK8975 magnetometer driver"); 581 MODULE_LICENSE("GPL"); 582