1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * mag3110.c - Support for Freescale MAG3110 magnetometer sensor 4 * 5 * Copyright (c) 2013 Peter Meerwald <pmeerw@pmeerw.net> 6 * 7 * (7-bit I2C slave address 0x0e) 8 * 9 * TODO: irq, user offset, oversampling, continuous mode 10 */ 11 12 #include <linux/cleanup.h> 13 #include <linux/module.h> 14 #include <linux/i2c.h> 15 #include <linux/iio/iio.h> 16 #include <linux/iio/sysfs.h> 17 #include <linux/iio/trigger_consumer.h> 18 #include <linux/iio/buffer.h> 19 #include <linux/iio/triggered_buffer.h> 20 #include <linux/delay.h> 21 #include <linux/regulator/consumer.h> 22 23 #define MAG3110_STATUS 0x00 24 #define MAG3110_OUT_X 0x01 /* MSB first */ 25 #define MAG3110_OUT_Y 0x03 26 #define MAG3110_OUT_Z 0x05 27 #define MAG3110_WHO_AM_I 0x07 28 #define MAG3110_SYSMOD 0x08 29 #define MAG3110_OFF_X 0x09 /* MSB first */ 30 #define MAG3110_OFF_Y 0x0b 31 #define MAG3110_OFF_Z 0x0d 32 #define MAG3110_DIE_TEMP 0x0f 33 #define MAG3110_CTRL_REG1 0x10 34 #define MAG3110_CTRL_REG2 0x11 35 36 #define MAG3110_STATUS_DRDY (BIT(2) | BIT(1) | BIT(0)) 37 38 #define MAG3110_CTRL_DR_MASK (BIT(7) | BIT(6) | BIT(5)) 39 #define MAG3110_CTRL_DR_SHIFT 5 40 #define MAG3110_CTRL_DR_DEFAULT 0 41 42 #define MAG3110_SYSMOD_MODE_MASK GENMASK(1, 0) 43 44 #define MAG3110_CTRL_TM BIT(1) /* trigger single measurement */ 45 #define MAG3110_CTRL_AC BIT(0) /* continuous measurements */ 46 47 #define MAG3110_CTRL_AUTO_MRST_EN BIT(7) /* magnetic auto-reset */ 48 #define MAG3110_CTRL_RAW BIT(5) /* measurements not user-offset corrected */ 49 50 #define MAG3110_DEVICE_ID 0xc4 51 52 /* Each client has this additional data */ 53 struct mag3110_data { 54 struct i2c_client *client; 55 struct mutex lock; 56 u8 ctrl_reg1; 57 int sleep_val; 58 struct regulator *vdd_reg; 59 struct regulator *vddio_reg; 60 /* Ensure natural alignment of timestamp */ 61 struct { 62 __be16 channels[3]; 63 u8 temperature; 64 aligned_s64 ts; 65 } scan; 66 }; 67 68 static int mag3110_request(struct mag3110_data *data) 69 { 70 int ret, tries = 150; 71 72 if ((data->ctrl_reg1 & MAG3110_CTRL_AC) == 0) { 73 /* trigger measurement */ 74 ret = i2c_smbus_write_byte_data(data->client, MAG3110_CTRL_REG1, 75 data->ctrl_reg1 | MAG3110_CTRL_TM); 76 if (ret < 0) 77 return ret; 78 } 79 80 while (tries-- > 0) { 81 ret = i2c_smbus_read_byte_data(data->client, MAG3110_STATUS); 82 if (ret < 0) 83 return ret; 84 /* wait for data ready */ 85 if ((ret & MAG3110_STATUS_DRDY) == MAG3110_STATUS_DRDY) 86 break; 87 88 if (data->sleep_val <= 20) 89 usleep_range(data->sleep_val * 250, data->sleep_val * 500); 90 else 91 msleep(20); 92 } 93 94 if (tries < 0) { 95 dev_err(&data->client->dev, "data not ready\n"); 96 return -EIO; 97 } 98 99 return 0; 100 } 101 102 static int mag3110_read(struct mag3110_data *data, __be16 buf[3]) 103 { 104 int ret; 105 106 guard(mutex)(&data->lock); 107 ret = mag3110_request(data); 108 if (ret < 0) 109 return ret; 110 return i2c_smbus_read_i2c_block_data(data->client, MAG3110_OUT_X, 111 3 * sizeof(__be16), (u8 *) buf); 112 } 113 114 static ssize_t mag3110_show_int_plus_micros(char *buf, 115 const int (*vals)[2], int n) 116 { 117 size_t len = 0; 118 119 while (n-- > 0) 120 len += scnprintf(buf + len, PAGE_SIZE - len, 121 "%d.%06d ", vals[n][0], vals[n][1]); 122 123 /* replace trailing space by newline */ 124 buf[len - 1] = '\n'; 125 126 return len; 127 } 128 129 static int mag3110_get_int_plus_micros_index(const int (*vals)[2], int n, 130 int val, int val2) 131 { 132 while (n-- > 0) 133 if (val == vals[n][0] && val2 == vals[n][1]) 134 return n; 135 136 return -EINVAL; 137 } 138 139 static const int mag3110_samp_freq[8][2] = { 140 {80, 0}, {40, 0}, {20, 0}, {10, 0}, {5, 0}, {2, 500000}, 141 {1, 250000}, {0, 625000} 142 }; 143 144 static ssize_t mag3110_show_samp_freq_avail(struct device *dev, 145 struct device_attribute *attr, char *buf) 146 { 147 return mag3110_show_int_plus_micros(buf, mag3110_samp_freq, 8); 148 } 149 150 static IIO_DEV_ATTR_SAMP_FREQ_AVAIL(mag3110_show_samp_freq_avail); 151 152 static int mag3110_get_samp_freq_index(struct mag3110_data *data, 153 int val, int val2) 154 { 155 return mag3110_get_int_plus_micros_index(mag3110_samp_freq, 8, val, 156 val2); 157 } 158 159 static int mag3110_calculate_sleep(struct mag3110_data *data) 160 { 161 int ret, i = data->ctrl_reg1 >> MAG3110_CTRL_DR_SHIFT; 162 163 if (mag3110_samp_freq[i][0] > 0) 164 ret = 1000 / mag3110_samp_freq[i][0]; 165 else 166 ret = 1000; 167 168 return ret == 0 ? 1 : ret; 169 } 170 171 static int mag3110_standby(struct mag3110_data *data) 172 { 173 return i2c_smbus_write_byte_data(data->client, MAG3110_CTRL_REG1, 174 data->ctrl_reg1 & ~MAG3110_CTRL_AC); 175 } 176 177 static int mag3110_wait_standby(struct mag3110_data *data) 178 { 179 int ret, tries = 30; 180 181 /* 182 * Takes up to 1/ODR to come out of active mode into stby 183 * Longest expected period is 12.5seconds. 184 * We'll sleep for 500ms between checks 185 */ 186 while (tries-- > 0) { 187 ret = i2c_smbus_read_byte_data(data->client, MAG3110_SYSMOD); 188 if (ret < 0) { 189 dev_err(&data->client->dev, "i2c error\n"); 190 return ret; 191 } 192 /* wait for standby */ 193 if ((ret & MAG3110_SYSMOD_MODE_MASK) == 0) 194 break; 195 196 msleep_interruptible(500); 197 } 198 199 if (tries < 0) { 200 dev_err(&data->client->dev, "device not entering standby mode\n"); 201 return -EIO; 202 } 203 204 return 0; 205 } 206 207 static int mag3110_active(struct mag3110_data *data) 208 { 209 return i2c_smbus_write_byte_data(data->client, MAG3110_CTRL_REG1, 210 data->ctrl_reg1); 211 } 212 213 /* returns >0 if active, 0 if in standby and <0 on error */ 214 static int mag3110_is_active(struct mag3110_data *data) 215 { 216 int reg; 217 218 reg = i2c_smbus_read_byte_data(data->client, MAG3110_CTRL_REG1); 219 if (reg < 0) 220 return reg; 221 222 return reg & MAG3110_CTRL_AC; 223 } 224 225 static int mag3110_change_config(struct mag3110_data *data, u8 reg, u8 val) 226 { 227 int ret; 228 int is_active; 229 230 guard(mutex)(&data->lock); 231 232 is_active = mag3110_is_active(data); 233 if (is_active < 0) 234 return is_active; 235 236 /* config can only be changed when in standby */ 237 if (is_active > 0) { 238 ret = mag3110_standby(data); 239 if (ret < 0) 240 return ret; 241 } 242 243 /* 244 * After coming out of active we must wait for the part 245 * to transition to STBY. This can take up to 1 /ODR to occur 246 */ 247 ret = mag3110_wait_standby(data); 248 if (ret < 0) 249 return ret; 250 251 ret = i2c_smbus_write_byte_data(data->client, reg, val); 252 if (ret < 0) 253 return ret; 254 255 if (is_active > 0) { 256 ret = mag3110_active(data); 257 if (ret < 0) 258 return ret; 259 } 260 261 return 0; 262 } 263 264 static int __mag3110_read_info_raw(struct mag3110_data *data, 265 struct iio_chan_spec const *chan, 266 int *val) 267 { 268 __be16 buffer[3]; 269 int ret; 270 271 switch (chan->type) { 272 case IIO_MAGN: /* in 0.1 uT / LSB */ 273 ret = mag3110_read(data, buffer); 274 if (ret < 0) 275 return ret; 276 *val = sign_extend32(be16_to_cpu(buffer[chan->scan_index]), 277 chan->scan_type.realbits - 1); 278 return IIO_VAL_INT; 279 280 case IIO_TEMP: { /* in 1 C / LSB */ 281 guard(mutex)(&data->lock); 282 ret = mag3110_request(data); 283 if (ret < 0) 284 return ret; 285 ret = i2c_smbus_read_byte_data(data->client, 286 MAG3110_DIE_TEMP); 287 if (ret < 0) 288 return ret; 289 *val = sign_extend32(ret, chan->scan_type.realbits - 1); 290 return IIO_VAL_INT; 291 } 292 default: 293 return -EINVAL; 294 } 295 } 296 297 static int mag3110_read_raw(struct iio_dev *indio_dev, 298 struct iio_chan_spec const *chan, 299 int *val, int *val2, long mask) 300 { 301 struct mag3110_data *data = iio_priv(indio_dev); 302 int i, ret; 303 304 switch (mask) { 305 case IIO_CHAN_INFO_RAW: 306 if (!iio_device_claim_direct(indio_dev)) 307 return -EBUSY; 308 ret = __mag3110_read_info_raw(data, chan, val); 309 iio_device_release_direct(indio_dev); 310 return ret; 311 312 case IIO_CHAN_INFO_SCALE: 313 switch (chan->type) { 314 case IIO_MAGN: 315 *val = 0; 316 *val2 = 1000; 317 return IIO_VAL_INT_PLUS_MICRO; 318 case IIO_TEMP: 319 *val = 1000; 320 return IIO_VAL_INT; 321 default: 322 return -EINVAL; 323 } 324 case IIO_CHAN_INFO_SAMP_FREQ: 325 i = data->ctrl_reg1 >> MAG3110_CTRL_DR_SHIFT; 326 *val = mag3110_samp_freq[i][0]; 327 *val2 = mag3110_samp_freq[i][1]; 328 return IIO_VAL_INT_PLUS_MICRO; 329 case IIO_CHAN_INFO_CALIBBIAS: 330 ret = i2c_smbus_read_word_swapped(data->client, 331 MAG3110_OFF_X + 2 * chan->scan_index); 332 if (ret < 0) 333 return ret; 334 *val = sign_extend32(ret >> 1, 14); 335 return IIO_VAL_INT; 336 } 337 return -EINVAL; 338 } 339 340 static int __mag3110_write_raw(struct mag3110_data *data, 341 struct iio_chan_spec const *chan, 342 int val, int val2, long mask) 343 { 344 int rate; 345 346 switch (mask) { 347 case IIO_CHAN_INFO_SAMP_FREQ: 348 rate = mag3110_get_samp_freq_index(data, val, val2); 349 if (rate < 0) 350 return -EINVAL; 351 352 data->ctrl_reg1 &= 0xff & ~MAG3110_CTRL_DR_MASK 353 & ~MAG3110_CTRL_AC; 354 data->ctrl_reg1 |= rate << MAG3110_CTRL_DR_SHIFT; 355 data->sleep_val = mag3110_calculate_sleep(data); 356 if (data->sleep_val < 40) 357 data->ctrl_reg1 |= MAG3110_CTRL_AC; 358 359 return mag3110_change_config(data, MAG3110_CTRL_REG1, 360 data->ctrl_reg1); 361 362 case IIO_CHAN_INFO_CALIBBIAS: 363 if (val < -10000 || val > 10000) 364 return -EINVAL; 365 366 return i2c_smbus_write_word_swapped(data->client, 367 MAG3110_OFF_X + 2 * chan->scan_index, val << 1); 368 default: 369 return -EINVAL; 370 } 371 } 372 373 static int mag3110_write_raw(struct iio_dev *indio_dev, 374 struct iio_chan_spec const *chan, 375 int val, int val2, long mask) 376 { 377 struct mag3110_data *data = iio_priv(indio_dev); 378 int ret; 379 380 if (!iio_device_claim_direct(indio_dev)) 381 return -EBUSY; 382 ret = __mag3110_write_raw(data, chan, val, val2, mask); 383 iio_device_release_direct(indio_dev); 384 385 return ret; 386 } 387 388 static irqreturn_t mag3110_trigger_handler(int irq, void *p) 389 { 390 struct iio_poll_func *pf = p; 391 struct iio_dev *indio_dev = pf->indio_dev; 392 struct mag3110_data *data = iio_priv(indio_dev); 393 int ret; 394 395 ret = mag3110_read(data, data->scan.channels); 396 if (ret < 0) 397 goto done; 398 399 if (test_bit(3, indio_dev->active_scan_mask)) { 400 ret = i2c_smbus_read_byte_data(data->client, 401 MAG3110_DIE_TEMP); 402 if (ret < 0) 403 goto done; 404 data->scan.temperature = ret; 405 } 406 407 iio_push_to_buffers_with_ts(indio_dev, &data->scan, sizeof(data->scan), 408 iio_get_time_ns(indio_dev)); 409 410 done: 411 iio_trigger_notify_done(indio_dev->trig); 412 return IRQ_HANDLED; 413 } 414 415 #define MAG3110_CHANNEL(axis, idx) { \ 416 .type = IIO_MAGN, \ 417 .modified = 1, \ 418 .channel2 = IIO_MOD_##axis, \ 419 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \ 420 BIT(IIO_CHAN_INFO_CALIBBIAS), \ 421 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SAMP_FREQ) | \ 422 BIT(IIO_CHAN_INFO_SCALE), \ 423 .scan_index = idx, \ 424 .scan_type = { \ 425 .sign = 's', \ 426 .realbits = 16, \ 427 .storagebits = 16, \ 428 .endianness = IIO_BE, \ 429 }, \ 430 } 431 432 static const struct iio_chan_spec mag3110_channels[] = { 433 MAG3110_CHANNEL(X, 0), 434 MAG3110_CHANNEL(Y, 1), 435 MAG3110_CHANNEL(Z, 2), 436 { 437 .type = IIO_TEMP, 438 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 439 BIT(IIO_CHAN_INFO_SCALE), 440 .scan_index = 3, 441 .scan_type = { 442 .sign = 's', 443 .realbits = 8, 444 .storagebits = 8, 445 }, 446 }, 447 IIO_CHAN_SOFT_TIMESTAMP(4), 448 }; 449 450 static struct attribute *mag3110_attributes[] = { 451 &iio_dev_attr_sampling_frequency_available.dev_attr.attr, 452 NULL 453 }; 454 455 static const struct attribute_group mag3110_group = { 456 .attrs = mag3110_attributes, 457 }; 458 459 static const struct iio_info mag3110_info = { 460 .attrs = &mag3110_group, 461 .read_raw = &mag3110_read_raw, 462 .write_raw = &mag3110_write_raw, 463 }; 464 465 static const unsigned long mag3110_scan_masks[] = {0x7, 0xf, 0}; 466 467 static int mag3110_probe(struct i2c_client *client) 468 { 469 const struct i2c_device_id *id = i2c_client_get_device_id(client); 470 struct mag3110_data *data; 471 struct iio_dev *indio_dev; 472 int ret; 473 474 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data)); 475 if (!indio_dev) 476 return -ENOMEM; 477 478 data = iio_priv(indio_dev); 479 480 data->vdd_reg = devm_regulator_get(&client->dev, "vdd"); 481 if (IS_ERR(data->vdd_reg)) 482 return dev_err_probe(&client->dev, PTR_ERR(data->vdd_reg), 483 "failed to get VDD regulator!\n"); 484 485 data->vddio_reg = devm_regulator_get(&client->dev, "vddio"); 486 if (IS_ERR(data->vddio_reg)) 487 return dev_err_probe(&client->dev, PTR_ERR(data->vddio_reg), 488 "failed to get VDDIO regulator!\n"); 489 490 ret = regulator_enable(data->vdd_reg); 491 if (ret) { 492 dev_err(&client->dev, "failed to enable VDD regulator!\n"); 493 return ret; 494 } 495 496 ret = regulator_enable(data->vddio_reg); 497 if (ret) { 498 dev_err(&client->dev, "failed to enable VDDIO regulator!\n"); 499 goto disable_regulator_vdd; 500 } 501 502 ret = i2c_smbus_read_byte_data(client, MAG3110_WHO_AM_I); 503 if (ret < 0) 504 goto disable_regulators; 505 if (ret != MAG3110_DEVICE_ID) { 506 ret = -ENODEV; 507 goto disable_regulators; 508 } 509 510 data->client = client; 511 mutex_init(&data->lock); 512 513 i2c_set_clientdata(client, indio_dev); 514 indio_dev->info = &mag3110_info; 515 indio_dev->name = id->name; 516 indio_dev->modes = INDIO_DIRECT_MODE; 517 indio_dev->channels = mag3110_channels; 518 indio_dev->num_channels = ARRAY_SIZE(mag3110_channels); 519 indio_dev->available_scan_masks = mag3110_scan_masks; 520 521 data->ctrl_reg1 = MAG3110_CTRL_DR_DEFAULT << MAG3110_CTRL_DR_SHIFT; 522 data->sleep_val = mag3110_calculate_sleep(data); 523 if (data->sleep_val < 40) 524 data->ctrl_reg1 |= MAG3110_CTRL_AC; 525 526 ret = mag3110_change_config(data, MAG3110_CTRL_REG1, data->ctrl_reg1); 527 if (ret < 0) 528 goto disable_regulators; 529 530 ret = i2c_smbus_write_byte_data(client, MAG3110_CTRL_REG2, 531 MAG3110_CTRL_AUTO_MRST_EN); 532 if (ret < 0) 533 goto standby_on_error; 534 535 ret = iio_triggered_buffer_setup(indio_dev, NULL, 536 mag3110_trigger_handler, NULL); 537 if (ret < 0) 538 goto standby_on_error; 539 540 ret = iio_device_register(indio_dev); 541 if (ret < 0) 542 goto buffer_cleanup; 543 return 0; 544 545 buffer_cleanup: 546 iio_triggered_buffer_cleanup(indio_dev); 547 standby_on_error: 548 mag3110_standby(iio_priv(indio_dev)); 549 disable_regulators: 550 regulator_disable(data->vddio_reg); 551 disable_regulator_vdd: 552 regulator_disable(data->vdd_reg); 553 554 return ret; 555 } 556 557 static void mag3110_remove(struct i2c_client *client) 558 { 559 struct iio_dev *indio_dev = i2c_get_clientdata(client); 560 struct mag3110_data *data = iio_priv(indio_dev); 561 562 iio_device_unregister(indio_dev); 563 iio_triggered_buffer_cleanup(indio_dev); 564 mag3110_standby(iio_priv(indio_dev)); 565 regulator_disable(data->vddio_reg); 566 regulator_disable(data->vdd_reg); 567 } 568 569 static int mag3110_suspend(struct device *dev) 570 { 571 struct mag3110_data *data = iio_priv(i2c_get_clientdata( 572 to_i2c_client(dev))); 573 int ret; 574 575 ret = mag3110_standby(iio_priv(i2c_get_clientdata( 576 to_i2c_client(dev)))); 577 if (ret) 578 return ret; 579 580 ret = regulator_disable(data->vddio_reg); 581 if (ret) { 582 dev_err(dev, "failed to disable VDDIO regulator\n"); 583 return ret; 584 } 585 586 ret = regulator_disable(data->vdd_reg); 587 if (ret) { 588 dev_err(dev, "failed to disable VDD regulator\n"); 589 return ret; 590 } 591 592 return 0; 593 } 594 595 static int mag3110_resume(struct device *dev) 596 { 597 struct mag3110_data *data = iio_priv(i2c_get_clientdata( 598 to_i2c_client(dev))); 599 int ret; 600 601 ret = regulator_enable(data->vdd_reg); 602 if (ret) { 603 dev_err(dev, "failed to enable VDD regulator\n"); 604 return ret; 605 } 606 607 ret = regulator_enable(data->vddio_reg); 608 if (ret) { 609 dev_err(dev, "failed to enable VDDIO regulator\n"); 610 regulator_disable(data->vdd_reg); 611 return ret; 612 } 613 614 return i2c_smbus_write_byte_data(data->client, MAG3110_CTRL_REG1, 615 data->ctrl_reg1); 616 } 617 618 static DEFINE_SIMPLE_DEV_PM_OPS(mag3110_pm_ops, mag3110_suspend, 619 mag3110_resume); 620 621 static const struct i2c_device_id mag3110_id[] = { 622 { "mag3110" }, 623 { } 624 }; 625 MODULE_DEVICE_TABLE(i2c, mag3110_id); 626 627 static const struct of_device_id mag3110_of_match[] = { 628 { .compatible = "fsl,mag3110" }, 629 { } 630 }; 631 MODULE_DEVICE_TABLE(of, mag3110_of_match); 632 633 static struct i2c_driver mag3110_driver = { 634 .driver = { 635 .name = "mag3110", 636 .of_match_table = mag3110_of_match, 637 .pm = pm_sleep_ptr(&mag3110_pm_ops), 638 }, 639 .probe = mag3110_probe, 640 .remove = mag3110_remove, 641 .id_table = mag3110_id, 642 }; 643 module_i2c_driver(mag3110_driver); 644 645 MODULE_AUTHOR("Peter Meerwald <pmeerw@pmeerw.net>"); 646 MODULE_DESCRIPTION("Freescale MAG3110 magnetometer driver"); 647 MODULE_LICENSE("GPL"); 648