1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * af8133j.c - Voltafield AF8133J magnetometer driver 4 * 5 * Copyright 2021 Icenowy Zheng <icenowy@aosc.io> 6 * Copyright 2024 Ondřej Jirman <megi@xff.cz> 7 */ 8 9 #include <linux/delay.h> 10 #include <linux/gpio/consumer.h> 11 #include <linux/i2c.h> 12 #include <linux/module.h> 13 #include <linux/pm_runtime.h> 14 #include <linux/regmap.h> 15 #include <linux/regulator/consumer.h> 16 17 #include <linux/iio/iio.h> 18 #include <linux/iio/trigger_consumer.h> 19 #include <linux/iio/triggered_buffer.h> 20 21 #define AF8133J_REG_OUT 0x03 22 #define AF8133J_REG_PCODE 0x00 23 #define AF8133J_REG_PCODE_VAL 0x5e 24 #define AF8133J_REG_STATUS 0x02 25 #define AF8133J_REG_STATUS_ACQ BIT(0) 26 #define AF8133J_REG_STATE 0x0a 27 #define AF8133J_REG_STATE_STBY 0x00 28 #define AF8133J_REG_STATE_WORK 0x01 29 #define AF8133J_REG_RANGE 0x0b 30 #define AF8133J_REG_RANGE_22G 0x12 31 #define AF8133J_REG_RANGE_12G 0x34 32 #define AF8133J_REG_SWR 0x11 33 #define AF8133J_REG_SWR_PERFORM 0x81 34 35 static const char * const af8133j_supply_names[] = { 36 "avdd", 37 "dvdd", 38 }; 39 40 struct af8133j_data { 41 struct i2c_client *client; 42 struct regmap *regmap; 43 /* 44 * Protect device internal state between starting a measurement 45 * and reading the result. 46 */ 47 struct mutex mutex; 48 struct iio_mount_matrix orientation; 49 50 struct gpio_desc *reset_gpiod; 51 struct regulator_bulk_data supplies[ARRAY_SIZE(af8133j_supply_names)]; 52 53 u8 range; 54 }; 55 56 enum af8133j_axis { 57 AXIS_X = 0, 58 AXIS_Y, 59 AXIS_Z, 60 }; 61 62 static struct iio_mount_matrix * 63 af8133j_get_mount_matrix(struct iio_dev *indio_dev, 64 const struct iio_chan_spec *chan) 65 { 66 struct af8133j_data *data = iio_priv(indio_dev); 67 68 return &data->orientation; 69 } 70 71 static const struct iio_chan_spec_ext_info af8133j_ext_info[] = { 72 IIO_MOUNT_MATRIX(IIO_SHARED_BY_DIR, af8133j_get_mount_matrix), 73 { } 74 }; 75 76 #define AF8133J_CHANNEL(_si, _axis) { \ 77 .type = IIO_MAGN, \ 78 .modified = 1, \ 79 .channel2 = IIO_MOD_ ## _axis, \ 80 .address = AXIS_ ## _axis, \ 81 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW), \ 82 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \ 83 .info_mask_shared_by_type_available = BIT(IIO_CHAN_INFO_SCALE), \ 84 .ext_info = af8133j_ext_info, \ 85 .scan_index = _si, \ 86 .scan_type = { \ 87 .sign = 's', \ 88 .realbits = 16, \ 89 .storagebits = 16, \ 90 .endianness = IIO_LE, \ 91 }, \ 92 } 93 94 static const struct iio_chan_spec af8133j_channels[] = { 95 AF8133J_CHANNEL(0, X), 96 AF8133J_CHANNEL(1, Y), 97 AF8133J_CHANNEL(2, Z), 98 IIO_CHAN_SOFT_TIMESTAMP(3), 99 }; 100 101 static int af8133j_product_check(struct af8133j_data *data) 102 { 103 struct device *dev = &data->client->dev; 104 unsigned int val; 105 int ret; 106 107 ret = regmap_read(data->regmap, AF8133J_REG_PCODE, &val); 108 if (ret) { 109 dev_err(dev, "Error reading product code (%d)\n", ret); 110 return ret; 111 } 112 113 if (val != AF8133J_REG_PCODE_VAL) { 114 dev_warn(dev, "Invalid product code (0x%02x)\n", val); 115 return 0; /* Allow unknown ID so fallback compatibles work */ 116 } 117 118 return 0; 119 } 120 121 static int af8133j_reset(struct af8133j_data *data) 122 { 123 struct device *dev = &data->client->dev; 124 int ret; 125 126 if (data->reset_gpiod) { 127 /* If we have GPIO reset line, use it */ 128 gpiod_set_value_cansleep(data->reset_gpiod, 1); 129 udelay(10); 130 gpiod_set_value_cansleep(data->reset_gpiod, 0); 131 } else { 132 /* Otherwise use software reset */ 133 ret = regmap_write(data->regmap, AF8133J_REG_SWR, 134 AF8133J_REG_SWR_PERFORM); 135 if (ret) { 136 dev_err(dev, "Failed to reset the chip\n"); 137 return ret; 138 } 139 } 140 141 /* Wait for reset to finish */ 142 usleep_range(1000, 1100); 143 144 /* Restore range setting */ 145 if (data->range == AF8133J_REG_RANGE_22G) { 146 ret = regmap_write(data->regmap, AF8133J_REG_RANGE, data->range); 147 if (ret) 148 return ret; 149 } 150 151 return 0; 152 } 153 154 static void af8133j_power_down(struct af8133j_data *data) 155 { 156 gpiod_set_value_cansleep(data->reset_gpiod, 1); 157 regulator_bulk_disable(ARRAY_SIZE(data->supplies), data->supplies); 158 } 159 160 static int af8133j_power_up(struct af8133j_data *data) 161 { 162 struct device *dev = &data->client->dev; 163 int ret; 164 165 ret = regulator_bulk_enable(ARRAY_SIZE(data->supplies), data->supplies); 166 if (ret) { 167 dev_err(dev, "Could not enable regulators\n"); 168 return ret; 169 } 170 171 gpiod_set_value_cansleep(data->reset_gpiod, 0); 172 173 /* Wait for power on reset */ 174 usleep_range(15000, 16000); 175 176 ret = af8133j_reset(data); 177 if (ret) { 178 af8133j_power_down(data); 179 return ret; 180 } 181 182 return 0; 183 } 184 185 static int af8133j_take_measurement(struct af8133j_data *data) 186 { 187 unsigned int val; 188 int ret; 189 190 ret = regmap_write(data->regmap, 191 AF8133J_REG_STATE, AF8133J_REG_STATE_WORK); 192 if (ret) 193 return ret; 194 195 /* The datasheet says "Mesaure Time <1.5ms" */ 196 ret = regmap_read_poll_timeout(data->regmap, AF8133J_REG_STATUS, val, 197 val & AF8133J_REG_STATUS_ACQ, 198 500, 1500); 199 if (ret) 200 return ret; 201 202 ret = regmap_write(data->regmap, 203 AF8133J_REG_STATE, AF8133J_REG_STATE_STBY); 204 if (ret) 205 return ret; 206 207 return 0; 208 } 209 210 static int af8133j_read_measurement(struct af8133j_data *data, __le16 buf[3]) 211 { 212 struct device *dev = &data->client->dev; 213 int ret; 214 215 ret = pm_runtime_resume_and_get(dev); 216 if (ret) { 217 /* 218 * Ignore EACCES because that happens when RPM is disabled 219 * during system sleep, while userspace leave eg. hrtimer 220 * trigger attached and IIO core keeps trying to do measurements. 221 */ 222 if (ret != -EACCES) 223 dev_err(dev, "Failed to power on (%d)\n", ret); 224 return ret; 225 } 226 227 scoped_guard(mutex, &data->mutex) { 228 ret = af8133j_take_measurement(data); 229 if (ret) 230 goto out_rpm_put; 231 232 ret = regmap_bulk_read(data->regmap, AF8133J_REG_OUT, 233 buf, sizeof(__le16) * 3); 234 } 235 236 out_rpm_put: 237 pm_runtime_mark_last_busy(dev); 238 pm_runtime_put_autosuspend(dev); 239 240 return ret; 241 } 242 243 static const int af8133j_scales[][2] = { 244 [0] = { 0, 366210 }, /* 12 gauss */ 245 [1] = { 0, 671386 }, /* 22 gauss */ 246 }; 247 248 static int af8133j_read_raw(struct iio_dev *indio_dev, 249 struct iio_chan_spec const *chan, int *val, 250 int *val2, long mask) 251 { 252 struct af8133j_data *data = iio_priv(indio_dev); 253 __le16 buf[3]; 254 int ret; 255 256 switch (mask) { 257 case IIO_CHAN_INFO_RAW: 258 ret = af8133j_read_measurement(data, buf); 259 if (ret) 260 return ret; 261 262 *val = sign_extend32(le16_to_cpu(buf[chan->address]), 263 chan->scan_type.realbits - 1); 264 return IIO_VAL_INT; 265 case IIO_CHAN_INFO_SCALE: 266 *val = 0; 267 268 if (data->range == AF8133J_REG_RANGE_12G) 269 *val2 = af8133j_scales[0][1]; 270 else 271 *val2 = af8133j_scales[1][1]; 272 273 return IIO_VAL_INT_PLUS_NANO; 274 default: 275 return -EINVAL; 276 } 277 } 278 279 static int af8133j_read_avail(struct iio_dev *indio_dev, 280 struct iio_chan_spec const *chan, 281 const int **vals, int *type, int *length, 282 long mask) 283 { 284 switch (mask) { 285 case IIO_CHAN_INFO_SCALE: 286 *vals = (const int *)af8133j_scales; 287 *length = ARRAY_SIZE(af8133j_scales) * 2; 288 *type = IIO_VAL_INT_PLUS_NANO; 289 return IIO_AVAIL_LIST; 290 default: 291 return -EINVAL; 292 } 293 } 294 295 static int af8133j_set_scale(struct af8133j_data *data, 296 unsigned int val, unsigned int val2) 297 { 298 struct device *dev = &data->client->dev; 299 u8 range; 300 int ret = 0; 301 302 if (af8133j_scales[0][0] == val && af8133j_scales[0][1] == val2) 303 range = AF8133J_REG_RANGE_12G; 304 else if (af8133j_scales[1][0] == val && af8133j_scales[1][1] == val2) 305 range = AF8133J_REG_RANGE_22G; 306 else 307 return -EINVAL; 308 309 pm_runtime_disable(dev); 310 311 /* 312 * When suspended, just store the new range to data->range to be 313 * applied later during power up. 314 */ 315 if (!pm_runtime_status_suspended(dev)) { 316 scoped_guard(mutex, &data->mutex) 317 ret = regmap_write(data->regmap, 318 AF8133J_REG_RANGE, range); 319 } 320 321 pm_runtime_enable(dev); 322 323 data->range = range; 324 return ret; 325 } 326 327 static int af8133j_write_raw(struct iio_dev *indio_dev, 328 struct iio_chan_spec const *chan, 329 int val, int val2, long mask) 330 { 331 struct af8133j_data *data = iio_priv(indio_dev); 332 333 switch (mask) { 334 case IIO_CHAN_INFO_SCALE: 335 return af8133j_set_scale(data, val, val2); 336 default: 337 return -EINVAL; 338 } 339 } 340 341 static int af8133j_write_raw_get_fmt(struct iio_dev *indio_dev, 342 struct iio_chan_spec const *chan, 343 long mask) 344 { 345 return IIO_VAL_INT_PLUS_NANO; 346 } 347 348 static const struct iio_info af8133j_info = { 349 .read_raw = af8133j_read_raw, 350 .read_avail = af8133j_read_avail, 351 .write_raw = af8133j_write_raw, 352 .write_raw_get_fmt = af8133j_write_raw_get_fmt, 353 }; 354 355 static irqreturn_t af8133j_trigger_handler(int irq, void *p) 356 { 357 struct iio_poll_func *pf = p; 358 struct iio_dev *indio_dev = pf->indio_dev; 359 struct af8133j_data *data = iio_priv(indio_dev); 360 s64 timestamp = iio_get_time_ns(indio_dev); 361 struct { 362 __le16 values[3]; 363 s64 timestamp __aligned(8); 364 } sample; 365 int ret; 366 367 memset(&sample, 0, sizeof(sample)); 368 369 ret = af8133j_read_measurement(data, sample.values); 370 if (ret) 371 goto out_done; 372 373 iio_push_to_buffers_with_timestamp(indio_dev, &sample, timestamp); 374 375 out_done: 376 iio_trigger_notify_done(indio_dev->trig); 377 378 return IRQ_HANDLED; 379 } 380 381 static const struct regmap_config af8133j_regmap_config = { 382 .name = "af8133j_regmap", 383 .reg_bits = 8, 384 .val_bits = 8, 385 .max_register = AF8133J_REG_SWR, 386 .cache_type = REGCACHE_NONE, 387 }; 388 389 static void af8133j_power_down_action(void *ptr) 390 { 391 struct af8133j_data *data = ptr; 392 393 if (!pm_runtime_status_suspended(&data->client->dev)) 394 af8133j_power_down(data); 395 } 396 397 static int af8133j_probe(struct i2c_client *client) 398 { 399 struct device *dev = &client->dev; 400 struct af8133j_data *data; 401 struct iio_dev *indio_dev; 402 struct regmap *regmap; 403 int ret, i; 404 405 indio_dev = devm_iio_device_alloc(dev, sizeof(*data)); 406 if (!indio_dev) 407 return -ENOMEM; 408 409 regmap = devm_regmap_init_i2c(client, &af8133j_regmap_config); 410 if (IS_ERR(regmap)) 411 return dev_err_probe(dev, PTR_ERR(regmap), 412 "regmap initialization failed\n"); 413 414 data = iio_priv(indio_dev); 415 i2c_set_clientdata(client, indio_dev); 416 data->client = client; 417 data->regmap = regmap; 418 data->range = AF8133J_REG_RANGE_12G; 419 mutex_init(&data->mutex); 420 421 data->reset_gpiod = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_HIGH); 422 if (IS_ERR(data->reset_gpiod)) 423 return dev_err_probe(dev, PTR_ERR(data->reset_gpiod), 424 "Failed to get reset gpio\n"); 425 426 for (i = 0; i < ARRAY_SIZE(af8133j_supply_names); i++) 427 data->supplies[i].supply = af8133j_supply_names[i]; 428 ret = devm_regulator_bulk_get(dev, ARRAY_SIZE(data->supplies), 429 data->supplies); 430 if (ret) 431 return ret; 432 433 ret = iio_read_mount_matrix(dev, &data->orientation); 434 if (ret) 435 return dev_err_probe(dev, ret, "Failed to read mount matrix\n"); 436 437 ret = af8133j_power_up(data); 438 if (ret) 439 return ret; 440 441 pm_runtime_set_active(dev); 442 443 ret = devm_add_action_or_reset(dev, af8133j_power_down_action, data); 444 if (ret) 445 return ret; 446 447 ret = af8133j_product_check(data); 448 if (ret) 449 return ret; 450 451 pm_runtime_get_noresume(dev); 452 pm_runtime_use_autosuspend(dev); 453 pm_runtime_set_autosuspend_delay(dev, 500); 454 ret = devm_pm_runtime_enable(dev); 455 if (ret) 456 return ret; 457 458 pm_runtime_put_autosuspend(dev); 459 460 indio_dev->info = &af8133j_info; 461 indio_dev->name = "af8133j"; 462 indio_dev->channels = af8133j_channels; 463 indio_dev->num_channels = ARRAY_SIZE(af8133j_channels); 464 indio_dev->modes = INDIO_DIRECT_MODE; 465 466 ret = devm_iio_triggered_buffer_setup(dev, indio_dev, NULL, 467 &af8133j_trigger_handler, NULL); 468 if (ret) 469 return dev_err_probe(&client->dev, ret, 470 "Failed to setup iio triggered buffer\n"); 471 472 ret = devm_iio_device_register(dev, indio_dev); 473 if (ret) 474 return dev_err_probe(dev, ret, "Failed to register iio device"); 475 476 return 0; 477 } 478 479 static int af8133j_runtime_suspend(struct device *dev) 480 { 481 struct iio_dev *indio_dev = dev_get_drvdata(dev); 482 struct af8133j_data *data = iio_priv(indio_dev); 483 484 af8133j_power_down(data); 485 486 return 0; 487 } 488 489 static int af8133j_runtime_resume(struct device *dev) 490 { 491 struct iio_dev *indio_dev = dev_get_drvdata(dev); 492 struct af8133j_data *data = iio_priv(indio_dev); 493 494 return af8133j_power_up(data); 495 } 496 497 static const struct dev_pm_ops af8133j_pm_ops = { 498 SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend, pm_runtime_force_resume) 499 RUNTIME_PM_OPS(af8133j_runtime_suspend, af8133j_runtime_resume, NULL) 500 }; 501 502 static const struct of_device_id af8133j_of_match[] = { 503 { .compatible = "voltafield,af8133j", }, 504 { } 505 }; 506 MODULE_DEVICE_TABLE(of, af8133j_of_match); 507 508 static const struct i2c_device_id af8133j_id[] = { 509 { "af8133j" }, 510 { } 511 }; 512 MODULE_DEVICE_TABLE(i2c, af8133j_id); 513 514 static struct i2c_driver af8133j_driver = { 515 .driver = { 516 .name = "af8133j", 517 .of_match_table = af8133j_of_match, 518 .pm = pm_ptr(&af8133j_pm_ops), 519 }, 520 .probe = af8133j_probe, 521 .id_table = af8133j_id, 522 }; 523 524 module_i2c_driver(af8133j_driver); 525 526 MODULE_AUTHOR("Icenowy Zheng <icenowy@aosc.io>"); 527 MODULE_AUTHOR("Ondřej Jirman <megi@xff.cz>"); 528 MODULE_DESCRIPTION("Voltafield AF8133J magnetic sensor driver"); 529 MODULE_LICENSE("GPL"); 530