1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * PNI RM3100 3-axis geomagnetic sensor driver core. 4 * 5 * Copyright (C) 2018 Song Qiang <songqiang1304521@gmail.com> 6 * 7 * User Manual available at 8 * <https://www.pnicorp.com/download/rm3100-user-manual/> 9 * 10 * TODO: event generation, pm. 11 */ 12 13 #include <linux/delay.h> 14 #include <linux/interrupt.h> 15 #include <linux/module.h> 16 #include <linux/slab.h> 17 18 #include <linux/iio/buffer.h> 19 #include <linux/iio/iio.h> 20 #include <linux/iio/sysfs.h> 21 #include <linux/iio/trigger.h> 22 #include <linux/iio/triggered_buffer.h> 23 #include <linux/iio/trigger_consumer.h> 24 25 #include <linux/unaligned.h> 26 27 #include "rm3100.h" 28 29 /* Cycle Count Registers. */ 30 #define RM3100_REG_CC_X 0x05 31 #define RM3100_REG_CC_Y 0x07 32 #define RM3100_REG_CC_Z 0x09 33 34 /* Poll Measurement Mode register. */ 35 #define RM3100_REG_POLL 0x00 36 #define RM3100_POLL_X BIT(4) 37 #define RM3100_POLL_Y BIT(5) 38 #define RM3100_POLL_Z BIT(6) 39 40 /* Continuous Measurement Mode register. */ 41 #define RM3100_REG_CMM 0x01 42 #define RM3100_CMM_START BIT(0) 43 #define RM3100_CMM_X BIT(4) 44 #define RM3100_CMM_Y BIT(5) 45 #define RM3100_CMM_Z BIT(6) 46 47 /* TiMe Rate Configuration register. */ 48 #define RM3100_REG_TMRC 0x0B 49 #define RM3100_TMRC_OFFSET 0x92 50 51 /* Result Status register. */ 52 #define RM3100_REG_STATUS 0x34 53 #define RM3100_STATUS_DRDY BIT(7) 54 55 /* Measurement result registers. */ 56 #define RM3100_REG_MX2 0x24 57 #define RM3100_REG_MY2 0x27 58 #define RM3100_REG_MZ2 0x2a 59 60 #define RM3100_W_REG_START RM3100_REG_POLL 61 #define RM3100_W_REG_END RM3100_REG_TMRC 62 #define RM3100_R_REG_START RM3100_REG_POLL 63 #define RM3100_R_REG_END RM3100_REG_STATUS 64 #define RM3100_V_REG_START RM3100_REG_POLL 65 #define RM3100_V_REG_END RM3100_REG_STATUS 66 67 /* 68 * This is computed by hand, is the sum of channel storage bits and padding 69 * bits, which is 4+4+4+12=24 in here. 70 */ 71 #define RM3100_SCAN_BYTES 24 72 73 #define RM3100_CMM_AXIS_SHIFT 4 74 75 struct rm3100_data { 76 struct regmap *regmap; 77 struct completion measuring_done; 78 bool use_interrupt; 79 int conversion_time; 80 int scale; 81 /* Ensure naturally aligned timestamp */ 82 u8 buffer[RM3100_SCAN_BYTES] __aligned(8); 83 struct iio_trigger *drdy_trig; 84 85 /* 86 * This lock is for protecting the consistency of series of i2c 87 * operations, that is, to make sure a measurement process will 88 * not be interrupted by a set frequency operation, which should 89 * be taken where a series of i2c operation starts, released where 90 * the operation ends. 91 */ 92 struct mutex lock; 93 }; 94 95 static const struct regmap_range rm3100_readable_ranges[] = { 96 regmap_reg_range(RM3100_R_REG_START, RM3100_R_REG_END), 97 }; 98 99 const struct regmap_access_table rm3100_readable_table = { 100 .yes_ranges = rm3100_readable_ranges, 101 .n_yes_ranges = ARRAY_SIZE(rm3100_readable_ranges), 102 }; 103 EXPORT_SYMBOL_NS_GPL(rm3100_readable_table, "IIO_RM3100"); 104 105 static const struct regmap_range rm3100_writable_ranges[] = { 106 regmap_reg_range(RM3100_W_REG_START, RM3100_W_REG_END), 107 }; 108 109 const struct regmap_access_table rm3100_writable_table = { 110 .yes_ranges = rm3100_writable_ranges, 111 .n_yes_ranges = ARRAY_SIZE(rm3100_writable_ranges), 112 }; 113 EXPORT_SYMBOL_NS_GPL(rm3100_writable_table, "IIO_RM3100"); 114 115 static const struct regmap_range rm3100_volatile_ranges[] = { 116 regmap_reg_range(RM3100_V_REG_START, RM3100_V_REG_END), 117 }; 118 119 const struct regmap_access_table rm3100_volatile_table = { 120 .yes_ranges = rm3100_volatile_ranges, 121 .n_yes_ranges = ARRAY_SIZE(rm3100_volatile_ranges), 122 }; 123 EXPORT_SYMBOL_NS_GPL(rm3100_volatile_table, "IIO_RM3100"); 124 125 static irqreturn_t rm3100_thread_fn(int irq, void *d) 126 { 127 struct iio_dev *indio_dev = d; 128 struct rm3100_data *data = iio_priv(indio_dev); 129 130 /* 131 * Write operation to any register or read operation 132 * to first byte of results will clear the interrupt. 133 */ 134 regmap_write(data->regmap, RM3100_REG_POLL, 0); 135 136 return IRQ_HANDLED; 137 } 138 139 static irqreturn_t rm3100_irq_handler(int irq, void *d) 140 { 141 struct iio_dev *indio_dev = d; 142 struct rm3100_data *data = iio_priv(indio_dev); 143 144 if (!iio_buffer_enabled(indio_dev)) 145 complete(&data->measuring_done); 146 else 147 iio_trigger_poll(data->drdy_trig); 148 149 return IRQ_WAKE_THREAD; 150 } 151 152 static int rm3100_wait_measurement(struct rm3100_data *data) 153 { 154 struct regmap *regmap = data->regmap; 155 unsigned int val; 156 int tries = 20; 157 int ret; 158 159 /* 160 * A read cycle of 400kbits i2c bus is about 20us, plus the time 161 * used for scheduling, a read cycle of fast mode of this device 162 * can reach 1.7ms, it may be possible for data to arrive just 163 * after we check the RM3100_REG_STATUS. In this case, irq_handler is 164 * called before measuring_done is reinitialized, it will wait 165 * forever for data that has already been ready. 166 * Reinitialize measuring_done before looking up makes sure we 167 * will always capture interrupt no matter when it happens. 168 */ 169 if (data->use_interrupt) 170 reinit_completion(&data->measuring_done); 171 172 ret = regmap_read(regmap, RM3100_REG_STATUS, &val); 173 if (ret < 0) 174 return ret; 175 176 if ((val & RM3100_STATUS_DRDY) != RM3100_STATUS_DRDY) { 177 if (data->use_interrupt) { 178 ret = wait_for_completion_timeout(&data->measuring_done, 179 msecs_to_jiffies(data->conversion_time)); 180 if (!ret) 181 return -ETIMEDOUT; 182 } else { 183 do { 184 usleep_range(1000, 5000); 185 186 ret = regmap_read(regmap, RM3100_REG_STATUS, 187 &val); 188 if (ret < 0) 189 return ret; 190 191 if (val & RM3100_STATUS_DRDY) 192 break; 193 } while (--tries); 194 if (!tries) 195 return -ETIMEDOUT; 196 } 197 } 198 return 0; 199 } 200 201 static int rm3100_read_mag(struct rm3100_data *data, int idx, int *val) 202 { 203 struct regmap *regmap = data->regmap; 204 u8 buffer[3]; 205 int ret; 206 207 mutex_lock(&data->lock); 208 ret = regmap_write(regmap, RM3100_REG_POLL, BIT(4 + idx)); 209 if (ret < 0) 210 goto unlock_return; 211 212 ret = rm3100_wait_measurement(data); 213 if (ret < 0) 214 goto unlock_return; 215 216 ret = regmap_bulk_read(regmap, RM3100_REG_MX2 + 3 * idx, buffer, 3); 217 if (ret < 0) 218 goto unlock_return; 219 mutex_unlock(&data->lock); 220 221 *val = sign_extend32(get_unaligned_be24(&buffer[0]), 23); 222 223 return IIO_VAL_INT; 224 225 unlock_return: 226 mutex_unlock(&data->lock); 227 return ret; 228 } 229 230 #define RM3100_CHANNEL(axis, idx) \ 231 { \ 232 .type = IIO_MAGN, \ 233 .modified = 1, \ 234 .channel2 = IIO_MOD_##axis, \ 235 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \ 236 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE) | \ 237 BIT(IIO_CHAN_INFO_SAMP_FREQ), \ 238 .scan_index = idx, \ 239 .scan_type = { \ 240 .sign = 's', \ 241 .realbits = 24, \ 242 .storagebits = 32, \ 243 .shift = 8, \ 244 .endianness = IIO_BE, \ 245 }, \ 246 } 247 248 static const struct iio_chan_spec rm3100_channels[] = { 249 RM3100_CHANNEL(X, 0), 250 RM3100_CHANNEL(Y, 1), 251 RM3100_CHANNEL(Z, 2), 252 IIO_CHAN_SOFT_TIMESTAMP(3), 253 }; 254 255 static IIO_CONST_ATTR_SAMP_FREQ_AVAIL( 256 "600 300 150 75 37 18 9 4.5 2.3 1.2 0.6 0.3 0.015 0.075" 257 ); 258 259 static struct attribute *rm3100_attributes[] = { 260 &iio_const_attr_sampling_frequency_available.dev_attr.attr, 261 NULL, 262 }; 263 264 static const struct attribute_group rm3100_attribute_group = { 265 .attrs = rm3100_attributes, 266 }; 267 268 #define RM3100_SAMP_NUM 14 269 270 /* 271 * Frequency : rm3100_samp_rates[][0].rm3100_samp_rates[][1]Hz. 272 * Time between reading: rm3100_sam_rates[][2]ms. 273 * The first one is actually 1.7ms. 274 */ 275 static const int rm3100_samp_rates[RM3100_SAMP_NUM][3] = { 276 {600, 0, 2}, {300, 0, 3}, {150, 0, 7}, {75, 0, 13}, {37, 0, 27}, 277 {18, 0, 55}, {9, 0, 110}, {4, 500000, 220}, {2, 300000, 440}, 278 {1, 200000, 800}, {0, 600000, 1600}, {0, 300000, 3300}, 279 {0, 15000, 6700}, {0, 75000, 13000} 280 }; 281 282 static int rm3100_get_samp_freq(struct rm3100_data *data, int *val, int *val2) 283 { 284 unsigned int tmp; 285 int ret; 286 287 mutex_lock(&data->lock); 288 ret = regmap_read(data->regmap, RM3100_REG_TMRC, &tmp); 289 mutex_unlock(&data->lock); 290 if (ret < 0) 291 return ret; 292 *val = rm3100_samp_rates[tmp - RM3100_TMRC_OFFSET][0]; 293 *val2 = rm3100_samp_rates[tmp - RM3100_TMRC_OFFSET][1]; 294 295 return IIO_VAL_INT_PLUS_MICRO; 296 } 297 298 static int rm3100_set_cycle_count(struct rm3100_data *data, int val) 299 { 300 int ret; 301 u8 i; 302 303 for (i = 0; i < 3; i++) { 304 ret = regmap_write(data->regmap, RM3100_REG_CC_X + 2 * i, val); 305 if (ret < 0) 306 return ret; 307 } 308 309 /* 310 * The scale of this sensor depends on the cycle count value, these 311 * three values are corresponding to the cycle count value 50, 100, 312 * 200. scale = output / gain * 10^4. 313 */ 314 switch (val) { 315 case 50: 316 data->scale = 500; 317 break; 318 case 100: 319 data->scale = 263; 320 break; 321 /* 322 * case 200: 323 * This function will never be called by users' code, so here we 324 * assume that it will never get a wrong parameter. 325 */ 326 default: 327 data->scale = 133; 328 } 329 330 return 0; 331 } 332 333 static int rm3100_set_samp_freq(struct iio_dev *indio_dev, int val, int val2) 334 { 335 struct rm3100_data *data = iio_priv(indio_dev); 336 struct regmap *regmap = data->regmap; 337 unsigned int cycle_count; 338 int ret; 339 int i; 340 341 mutex_lock(&data->lock); 342 /* All cycle count registers use the same value. */ 343 ret = regmap_read(regmap, RM3100_REG_CC_X, &cycle_count); 344 if (ret < 0) 345 goto unlock_return; 346 347 for (i = 0; i < RM3100_SAMP_NUM; i++) { 348 if (val == rm3100_samp_rates[i][0] && 349 val2 == rm3100_samp_rates[i][1]) 350 break; 351 } 352 if (i == RM3100_SAMP_NUM) { 353 ret = -EINVAL; 354 goto unlock_return; 355 } 356 357 ret = regmap_write(regmap, RM3100_REG_TMRC, i + RM3100_TMRC_OFFSET); 358 if (ret < 0) 359 goto unlock_return; 360 361 /* Checking if cycle count registers need changing. */ 362 if (val == 600 && cycle_count == 200) { 363 ret = rm3100_set_cycle_count(data, 100); 364 if (ret < 0) 365 goto unlock_return; 366 } else if (val != 600 && cycle_count == 100) { 367 ret = rm3100_set_cycle_count(data, 200); 368 if (ret < 0) 369 goto unlock_return; 370 } 371 372 if (iio_buffer_enabled(indio_dev)) { 373 /* Writing TMRC registers requires CMM reset. */ 374 ret = regmap_write(regmap, RM3100_REG_CMM, 0); 375 if (ret < 0) 376 goto unlock_return; 377 ret = regmap_write(data->regmap, RM3100_REG_CMM, 378 (*indio_dev->active_scan_mask & 0x7) << 379 RM3100_CMM_AXIS_SHIFT | RM3100_CMM_START); 380 if (ret < 0) 381 goto unlock_return; 382 } 383 mutex_unlock(&data->lock); 384 385 data->conversion_time = rm3100_samp_rates[i][2] * 2; 386 return 0; 387 388 unlock_return: 389 mutex_unlock(&data->lock); 390 return ret; 391 } 392 393 static int rm3100_read_raw(struct iio_dev *indio_dev, 394 const struct iio_chan_spec *chan, 395 int *val, int *val2, long mask) 396 { 397 struct rm3100_data *data = iio_priv(indio_dev); 398 int ret; 399 400 switch (mask) { 401 case IIO_CHAN_INFO_RAW: 402 if (!iio_device_claim_direct(indio_dev)) 403 return -EBUSY; 404 405 ret = rm3100_read_mag(data, chan->scan_index, val); 406 iio_device_release_direct(indio_dev); 407 408 return ret; 409 case IIO_CHAN_INFO_SCALE: 410 *val = 0; 411 *val2 = data->scale; 412 413 return IIO_VAL_INT_PLUS_MICRO; 414 case IIO_CHAN_INFO_SAMP_FREQ: 415 return rm3100_get_samp_freq(data, val, val2); 416 default: 417 return -EINVAL; 418 } 419 } 420 421 static int rm3100_write_raw(struct iio_dev *indio_dev, 422 struct iio_chan_spec const *chan, 423 int val, int val2, long mask) 424 { 425 switch (mask) { 426 case IIO_CHAN_INFO_SAMP_FREQ: 427 return rm3100_set_samp_freq(indio_dev, val, val2); 428 default: 429 return -EINVAL; 430 } 431 } 432 433 static const struct iio_info rm3100_info = { 434 .attrs = &rm3100_attribute_group, 435 .read_raw = rm3100_read_raw, 436 .write_raw = rm3100_write_raw, 437 }; 438 439 static int rm3100_buffer_preenable(struct iio_dev *indio_dev) 440 { 441 struct rm3100_data *data = iio_priv(indio_dev); 442 443 /* Starting channels enabled. */ 444 return regmap_write(data->regmap, RM3100_REG_CMM, 445 (*indio_dev->active_scan_mask & 0x7) << RM3100_CMM_AXIS_SHIFT | 446 RM3100_CMM_START); 447 } 448 449 static int rm3100_buffer_postdisable(struct iio_dev *indio_dev) 450 { 451 struct rm3100_data *data = iio_priv(indio_dev); 452 453 return regmap_write(data->regmap, RM3100_REG_CMM, 0); 454 } 455 456 static const struct iio_buffer_setup_ops rm3100_buffer_ops = { 457 .preenable = rm3100_buffer_preenable, 458 .postdisable = rm3100_buffer_postdisable, 459 }; 460 461 static irqreturn_t rm3100_trigger_handler(int irq, void *p) 462 { 463 struct iio_poll_func *pf = p; 464 struct iio_dev *indio_dev = pf->indio_dev; 465 unsigned long scan_mask = *indio_dev->active_scan_mask; 466 unsigned int mask_len = iio_get_masklength(indio_dev); 467 struct rm3100_data *data = iio_priv(indio_dev); 468 struct regmap *regmap = data->regmap; 469 int ret, i, bit; 470 471 mutex_lock(&data->lock); 472 switch (scan_mask) { 473 case BIT(0) | BIT(1) | BIT(2): 474 ret = regmap_bulk_read(regmap, RM3100_REG_MX2, data->buffer, 9); 475 mutex_unlock(&data->lock); 476 if (ret < 0) 477 goto done; 478 /* Convert XXXYYYZZZxxx to XXXxYYYxZZZx. x for paddings. */ 479 for (i = 2; i > 0; i--) 480 memmove(data->buffer + i * 4, data->buffer + i * 3, 3); 481 break; 482 case BIT(0) | BIT(1): 483 ret = regmap_bulk_read(regmap, RM3100_REG_MX2, data->buffer, 6); 484 mutex_unlock(&data->lock); 485 if (ret < 0) 486 goto done; 487 memmove(data->buffer + 4, data->buffer + 3, 3); 488 break; 489 case BIT(1) | BIT(2): 490 ret = regmap_bulk_read(regmap, RM3100_REG_MY2, data->buffer, 6); 491 mutex_unlock(&data->lock); 492 if (ret < 0) 493 goto done; 494 memmove(data->buffer + 4, data->buffer + 3, 3); 495 break; 496 case BIT(0) | BIT(2): 497 ret = regmap_bulk_read(regmap, RM3100_REG_MX2, data->buffer, 9); 498 mutex_unlock(&data->lock); 499 if (ret < 0) 500 goto done; 501 memmove(data->buffer + 4, data->buffer + 6, 3); 502 break; 503 default: 504 for_each_set_bit(bit, &scan_mask, mask_len) { 505 ret = regmap_bulk_read(regmap, RM3100_REG_MX2 + 3 * bit, 506 data->buffer, 3); 507 if (ret < 0) { 508 mutex_unlock(&data->lock); 509 goto done; 510 } 511 } 512 mutex_unlock(&data->lock); 513 } 514 /* 515 * Always using the same buffer so that we wouldn't need to set the 516 * paddings to 0 in case of leaking any data. 517 */ 518 iio_push_to_buffers_with_ts(indio_dev, data->buffer, sizeof(data->buffer), 519 pf->timestamp); 520 done: 521 iio_trigger_notify_done(indio_dev->trig); 522 523 return IRQ_HANDLED; 524 } 525 526 int rm3100_common_probe(struct device *dev, struct regmap *regmap, int irq) 527 { 528 struct iio_dev *indio_dev; 529 struct rm3100_data *data; 530 unsigned int tmp; 531 int ret; 532 int samp_rate_index; 533 534 indio_dev = devm_iio_device_alloc(dev, sizeof(*data)); 535 if (!indio_dev) 536 return -ENOMEM; 537 538 data = iio_priv(indio_dev); 539 data->regmap = regmap; 540 541 mutex_init(&data->lock); 542 543 indio_dev->name = "rm3100"; 544 indio_dev->info = &rm3100_info; 545 indio_dev->channels = rm3100_channels; 546 indio_dev->num_channels = ARRAY_SIZE(rm3100_channels); 547 indio_dev->modes = INDIO_DIRECT_MODE; 548 549 if (!irq) 550 data->use_interrupt = false; 551 else { 552 data->use_interrupt = true; 553 554 init_completion(&data->measuring_done); 555 ret = devm_request_threaded_irq(dev, 556 irq, 557 rm3100_irq_handler, 558 rm3100_thread_fn, 559 IRQF_TRIGGER_HIGH | 560 IRQF_ONESHOT, 561 indio_dev->name, 562 indio_dev); 563 if (ret < 0) { 564 dev_err(dev, "request irq line failed.\n"); 565 return ret; 566 } 567 568 data->drdy_trig = devm_iio_trigger_alloc(dev, "%s-drdy%d", 569 indio_dev->name, 570 iio_device_id(indio_dev)); 571 if (!data->drdy_trig) 572 return -ENOMEM; 573 574 ret = devm_iio_trigger_register(dev, data->drdy_trig); 575 if (ret < 0) 576 return ret; 577 } 578 579 ret = devm_iio_triggered_buffer_setup(dev, indio_dev, 580 &iio_pollfunc_store_time, 581 rm3100_trigger_handler, 582 &rm3100_buffer_ops); 583 if (ret < 0) 584 return ret; 585 586 ret = regmap_read(regmap, RM3100_REG_TMRC, &tmp); 587 if (ret < 0) 588 return ret; 589 590 samp_rate_index = tmp - RM3100_TMRC_OFFSET; 591 if (samp_rate_index < 0 || samp_rate_index >= RM3100_SAMP_NUM) { 592 dev_err(dev, "The value read from RM3100_REG_TMRC is invalid!\n"); 593 return -EINVAL; 594 } 595 /* Initializing max wait time, which is double conversion time. */ 596 data->conversion_time = rm3100_samp_rates[samp_rate_index][2] * 2; 597 598 /* Cycle count values may not be what we want. */ 599 if ((tmp - RM3100_TMRC_OFFSET) == 0) 600 rm3100_set_cycle_count(data, 100); 601 else 602 rm3100_set_cycle_count(data, 200); 603 604 return devm_iio_device_register(dev, indio_dev); 605 } 606 EXPORT_SYMBOL_NS_GPL(rm3100_common_probe, "IIO_RM3100"); 607 608 MODULE_AUTHOR("Song Qiang <songqiang1304521@gmail.com>"); 609 MODULE_DESCRIPTION("PNI RM3100 3-axis magnetometer i2c driver"); 610 MODULE_LICENSE("GPL v2"); 611