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 #include <linux/acpi.h> 35 36 #include <linux/iio/iio.h> 37 #include <linux/iio/sysfs.h> 38 /* 39 * Register definitions, as well as various shifts and masks to get at the 40 * individual fields of the registers. 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 * AK09912 Register definitions 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 * Miscellaneous values. 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 * Precalculate scale factor (in Gauss units) for each axis and 144 * store in the device data. 145 * 146 * This scale factor is axis-dependent, and is derived from 3 calibration 147 * factors ASA(x), ASA(y), and ASA(z). 148 * 149 * These ASA values are read from the sensor device at start of day, and 150 * cached in the device context struct. 151 * 152 * Adjusting the flux value with the sensitivity adjustment value should be 153 * done via the following formula: 154 * 155 * Hadj = H * ( ( ( (ASA-128)*0.5 ) / 128 ) + 1 ) 156 * where H is the raw value, ASA is the sensitivity adjustment, and Hadj 157 * is the resultant adjusted value. 158 * 159 * We reduce the formula to: 160 * 161 * Hadj = H * (ASA + 128) / 256 162 * 163 * H is in the range of -4096 to 4095. The magnetometer has a range of 164 * +-1229uT. To go from the raw value to uT is: 165 * 166 * HuT = H * 1229/4096, or roughly, 3/10. 167 * 168 * Since 1uT = 0.01 gauss, our final scale factor becomes: 169 * 170 * Hadj = H * ((ASA + 128) / 256) * 3/10 * 1/100 171 * Hadj = H * ((ASA + 128) * 0.003) / 256 172 * 173 * Since ASA doesn't change, we cache the resultant scale factor into the 174 * device context in ak8975_setup(). 175 * 176 * Given we use IIO_VAL_INT_PLUS_MICRO bit when displaying the scale, we 177 * multiply the stored scale value by 1e6. 178 */ 179 static long ak8975_raw_to_gauss(u16 data) 180 { 181 return (((long)data + 128) * 3000) / 256; 182 } 183 184 /* 185 * For AK8963 and AK09911, same calculation, but the device is less sensitive: 186 * 187 * H is in the range of +-8190. The magnetometer has a range of 188 * +-4912uT. To go from the raw value to uT is: 189 * 190 * HuT = H * 4912/8190, or roughly, 6/10, instead of 3/10. 191 */ 192 193 static long ak8963_09911_raw_to_gauss(u16 data) 194 { 195 return (((long)data + 128) * 6000) / 256; 196 } 197 198 /* 199 * For AK09912, same calculation, except the device is more sensitive: 200 * 201 * H is in the range of -32752 to 32752. The magnetometer has a range of 202 * +-4912uT. To go from the raw value to uT is: 203 * 204 * HuT = H * 4912/32752, or roughly, 3/20, instead of 3/10. 205 */ 206 static long ak09912_raw_to_gauss(u16 data) 207 { 208 return (((long)data + 128) * 1500) / 256; 209 } 210 211 /* Compatible Asahi Kasei Compass parts */ 212 enum asahi_compass_chipset { 213 AK8975, 214 AK8963, 215 AK09911, 216 AK09912, 217 AK_MAX_TYPE 218 }; 219 220 enum ak_ctrl_reg_addr { 221 ST1, 222 ST2, 223 CNTL, 224 ASA_BASE, 225 MAX_REGS, 226 REGS_END, 227 }; 228 229 enum ak_ctrl_reg_mask { 230 ST1_DRDY, 231 ST2_HOFL, 232 ST2_DERR, 233 CNTL_MODE, 234 MASK_END, 235 }; 236 237 enum ak_ctrl_mode { 238 POWER_DOWN, 239 MODE_ONCE, 240 SELF_TEST, 241 FUSE_ROM, 242 MODE_END, 243 }; 244 245 struct 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 255 static 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 * Per-instance context data for the device. 360 */ 361 struct ak8975_data { 362 struct i2c_client *client; 363 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 * Return 0 if the i2c device is the one we expect. 377 * return a negative error number otherwise 378 */ 379 static 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 * Signature for each device: 387 * Device | WIA1 | WIA2 388 * AK09912 | DEVICE_ID | AK09912_DEVICE_ID 389 * AK09911 | DEVICE_ID | AK09911_DEVICE_ID 390 * AK8975 | DEVICE_ID | NA 391 * AK8963 | DEVICE_ID | NA 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 * Helper function to write to CNTL register. 423 */ 424 static 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 /* After mode change wait atleast 100us */ 438 usleep_range(100, 500); 439 440 return 0; 441 } 442 443 /* 444 * Handle data ready irq 445 */ 446 static 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 * Install data ready interrupt handler 458 */ 459 static int ak8975_setup_irq(struct ak8975_data *data) 460 { 461 struct i2c_client *client = data->client; 462 int rc; 463 int irq; 464 465 if (client->irq) 466 irq = client->irq; 467 else 468 irq = gpio_to_irq(data->eoc_gpio); 469 470 rc = devm_request_irq(&client->dev, irq, ak8975_irq_handler, 471 IRQF_TRIGGER_RISING | IRQF_ONESHOT, 472 dev_name(&client->dev), data); 473 if (rc < 0) { 474 dev_err(&client->dev, 475 "irq %d request failed, (gpio %d): %d\n", 476 irq, data->eoc_gpio, rc); 477 return rc; 478 } 479 480 init_waitqueue_head(&data->data_ready_queue); 481 clear_bit(0, &data->flags); 482 data->eoc_irq = irq; 483 484 return rc; 485 } 486 487 488 /* 489 * Perform some start-of-day setup, including reading the asa calibration 490 * values and caching them. 491 */ 492 static 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 /* Write the fused rom access mode. */ 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 /* Get asa data and store in the device data. */ 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 /* After reading fuse ROM data set power-down mode */ 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 537 static 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 /* Wait for the conversion to complete. */ 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 562 static 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 /* Wait for the conversion to complete. */ 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 /* Returns 0 if the end of conversion interrupt occured or -ETIME otherwise */ 592 static 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 * Emits the raw flux value for the x, y, or z axis. 606 */ 607 static 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 /* Set up the device for taking a sample. */ 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 /* Wait for the conversion to complete. */ 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 /* This will be executed only for non-interrupt based waiting case */ 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 /* Read the flux value from the appropriate register 649 (the register is specified in the iio device attributes). */ 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 /* Clamp to valid range. */ 659 *val = clamp_t(s16, ret, -data->def->range, data->def->range); 660 return IIO_VAL_INT; 661 662 exit: 663 mutex_unlock(&data->lock); 664 return ret; 665 } 666 667 static 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 695 static const struct iio_chan_spec ak8975_channels[] = { 696 AK8975_CHANNEL(X, 0), AK8975_CHANNEL(Y, 1), AK8975_CHANNEL(Z, 2), 697 }; 698 699 static const struct iio_info ak8975_info = { 700 .read_raw = &ak8975_read_raw, 701 .driver_module = THIS_MODULE, 702 }; 703 704 static 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 }; 712 MODULE_DEVICE_TABLE(acpi, ak_acpi_match); 713 714 static 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 727 static 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; 736 737 /* Grab and set up the supplied GPIO. */ 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 /* We may not have a GPIO based IRQ to scan, that is fine, we will 749 poll if so */ 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 /* Register with IIO */ 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 /* id will be NULL when enumerated via ACPI */ 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 /* Perform some basic start-of-day setup of the device. */ 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 813 static 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 822 MODULE_DEVICE_TABLE(i2c, ak8975_id); 823 824 static 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 }; 835 MODULE_DEVICE_TABLE(of, ak8975_of_match); 836 837 static 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 }; 846 module_i2c_driver(ak8975_driver); 847 848 MODULE_AUTHOR("Laxman Dewangan <ldewangan@nvidia.com>"); 849 MODULE_DESCRIPTION("AK8975 magnetometer driver"); 850 MODULE_LICENSE("GPL"); 851