1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Driver for the Allegro MicroSystems ALS31300 3-D Linear Hall Effect Sensor 4 * 5 * Copyright (c) 2024 Linaro Limited 6 */ 7 8 #include <linux/bits.h> 9 #include <linux/bitfield.h> 10 #include <linux/delay.h> 11 #include <linux/module.h> 12 #include <linux/i2c.h> 13 #include <linux/regmap.h> 14 #include <linux/pm.h> 15 #include <linux/pm_runtime.h> 16 #include <linux/regulator/consumer.h> 17 #include <linux/types.h> 18 #include <linux/units.h> 19 20 #include <linux/iio/buffer.h> 21 #include <linux/iio/iio.h> 22 #include <linux/iio/trigger_consumer.h> 23 #include <linux/iio/triggered_buffer.h> 24 25 /* 26 * The Allegro MicroSystems ALS31300 has an EEPROM space to configure how 27 * the device works and how the interrupt line behaves. 28 * Only the default setup with external trigger is supported. 29 * 30 * While the bindings supports declaring an interrupt line, those 31 * events are not supported. 32 * 33 * It should be possible to adapt the driver to the current 34 * device EEPROM setup at runtime. 35 */ 36 37 #define ALS31300_EEPROM_CONFIG 0x02 38 #define ALS31300_EEPROM_INTERRUPT 0x03 39 #define ALS31300_EEPROM_CUSTOMER_1 0x0d 40 #define ALS31300_EEPROM_CUSTOMER_2 0x0e 41 #define ALS31300_EEPROM_CUSTOMER_3 0x0f 42 #define ALS31300_VOL_MODE 0x27 43 #define ALS31300_VOL_MODE_LPDCM GENMASK(6, 4) 44 #define ALS31300_LPDCM_INACTIVE_0_5_MS 0 45 #define ALS31300_LPDCM_INACTIVE_1_0_MS 1 46 #define ALS31300_LPDCM_INACTIVE_5_0_MS 2 47 #define ALS31300_LPDCM_INACTIVE_10_0_MS 3 48 #define ALS31300_LPDCM_INACTIVE_50_0_MS 4 49 #define ALS31300_LPDCM_INACTIVE_100_0_MS 5 50 #define ALS31300_LPDCM_INACTIVE_500_0_MS 6 51 #define ALS31300_LPDCM_INACTIVE_1000_0_MS 7 52 #define ALS31300_VOL_MODE_SLEEP GENMASK(1, 0) 53 #define ALS31300_VOL_MODE_ACTIVE_MODE 0 54 #define ALS31300_VOL_MODE_SLEEP_MODE 1 55 #define ALS31300_VOL_MODE_LPDCM_MODE 2 56 #define ALS31300_VOL_MSB 0x28 57 #define ALS31300_VOL_MSB_TEMPERATURE GENMASK(5, 0) 58 #define ALS31300_VOL_MSB_INTERRUPT BIT(6) 59 #define ALS31300_VOL_MSB_NEW_DATA BIT(7) 60 #define ALS31300_VOL_MSB_Z_AXIS GENMASK(15, 8) 61 #define ALS31300_VOL_MSB_Y_AXIS GENMASK(23, 16) 62 #define ALS31300_VOL_MSB_X_AXIS GENMASK(31, 24) 63 #define ALS31300_VOL_LSB 0x29 64 #define ALS31300_VOL_LSB_TEMPERATURE GENMASK(5, 0) 65 #define ALS31300_VOL_LSB_HALL_STATUS GENMASK(7, 7) 66 #define ALS31300_VOL_LSB_Z_AXIS GENMASK(11, 8) 67 #define ALS31300_VOL_LSB_Y_AXIS GENMASK(15, 12) 68 #define ALS31300_VOL_LSB_X_AXIS GENMASK(19, 16) 69 #define ALS31300_VOL_LSB_INTERRUPT_WRITE BIT(20) 70 #define ALS31300_CUSTOMER_ACCESS 0x35 71 72 #define ALS31300_DATA_X_GET(b) \ 73 sign_extend32(FIELD_GET(ALS31300_VOL_MSB_X_AXIS, b[0]) << 4 | \ 74 FIELD_GET(ALS31300_VOL_LSB_X_AXIS, b[1]), 11) 75 #define ALS31300_DATA_Y_GET(b) \ 76 sign_extend32(FIELD_GET(ALS31300_VOL_MSB_Y_AXIS, b[0]) << 4 | \ 77 FIELD_GET(ALS31300_VOL_LSB_Y_AXIS, b[1]), 11) 78 #define ALS31300_DATA_Z_GET(b) \ 79 sign_extend32(FIELD_GET(ALS31300_VOL_MSB_Z_AXIS, b[0]) << 4 | \ 80 FIELD_GET(ALS31300_VOL_LSB_Z_AXIS, b[1]), 11) 81 #define ALS31300_TEMPERATURE_GET(b) \ 82 (FIELD_GET(ALS31300_VOL_MSB_TEMPERATURE, b[0]) << 6 | \ 83 FIELD_GET(ALS31300_VOL_LSB_TEMPERATURE, b[1])) 84 85 enum als31300_channels { 86 TEMPERATURE = 0, 87 AXIS_X, 88 AXIS_Y, 89 AXIS_Z, 90 }; 91 92 struct als31300_variant_info { 93 u8 sensitivity; 94 }; 95 96 struct als31300_data { 97 struct device *dev; 98 /* protects power on/off the device and access HW */ 99 struct mutex mutex; 100 const struct als31300_variant_info *variant_info; 101 struct regmap *map; 102 }; 103 104 /* The whole measure is split into 2x32-bit registers, we need to read them both at once */ 105 static int als31300_get_measure(struct als31300_data *data, 106 u16 *t, s16 *x, s16 *y, s16 *z) 107 { 108 u32 buf[2]; 109 int ret, err; 110 111 guard(mutex)(&data->mutex); 112 113 ret = pm_runtime_resume_and_get(data->dev); 114 if (ret) 115 return ret; 116 117 /* 118 * Loop until data is valid, new data should have the 119 * ALS31300_VOL_MSB_NEW_DATA bit set to 1. 120 * Max update rate is 2KHz, wait up to 1ms. 121 */ 122 ret = read_poll_timeout(regmap_bulk_read, err, 123 err || FIELD_GET(ALS31300_VOL_MSB_NEW_DATA, buf[0]), 124 20, USEC_PER_MSEC, false, 125 data->map, ALS31300_VOL_MSB, buf, ARRAY_SIZE(buf)); 126 /* Bail out on read_poll_timeout() error */ 127 if (ret) 128 goto out; 129 130 /* Bail out on regmap_bulk_read() error */ 131 if (err) { 132 dev_err(data->dev, "read data failed, error %d\n", ret); 133 ret = err; 134 goto out; 135 } 136 137 *t = ALS31300_TEMPERATURE_GET(buf); 138 *x = ALS31300_DATA_X_GET(buf); 139 *y = ALS31300_DATA_Y_GET(buf); 140 *z = ALS31300_DATA_Z_GET(buf); 141 142 out: 143 pm_runtime_put_autosuspend(data->dev); 144 145 return ret; 146 } 147 148 static int als31300_read_raw(struct iio_dev *indio_dev, 149 const struct iio_chan_spec *chan, int *val, 150 int *val2, long mask) 151 { 152 struct als31300_data *data = iio_priv(indio_dev); 153 s16 x, y, z; 154 u16 t; 155 int ret; 156 157 switch (mask) { 158 case IIO_CHAN_INFO_RAW: 159 ret = als31300_get_measure(data, &t, &x, &y, &z); 160 if (ret) 161 return ret; 162 163 switch (chan->address) { 164 case TEMPERATURE: 165 *val = t; 166 return IIO_VAL_INT; 167 case AXIS_X: 168 *val = x; 169 return IIO_VAL_INT; 170 case AXIS_Y: 171 *val = y; 172 return IIO_VAL_INT; 173 case AXIS_Z: 174 *val = z; 175 return IIO_VAL_INT; 176 default: 177 return -EINVAL; 178 } 179 case IIO_CHAN_INFO_SCALE: 180 switch (chan->type) { 181 case IIO_TEMP: 182 /* 183 * Fractional part of: 184 * 1000 * 302 * (value - 1708) 185 * temp = ---------------------------- 186 * 4096 187 * to convert temperature in millicelcius. 188 */ 189 *val = MILLI * 302; 190 *val2 = 4096; 191 return IIO_VAL_FRACTIONAL; 192 case IIO_MAGN: 193 /* 194 * Devices are configured in factory 195 * with different sensitivities: 196 * - 500 GAUSS <-> 4 LSB/Gauss 197 * - 1000 GAUSS <-> 2 LSB/Gauss 198 * - 2000 GAUSS <-> 1 LSB/Gauss 199 * with translates by a division of the returned 200 * value to get Gauss value. 201 * The sensitivity cannot be read at runtime 202 * so the value depends on the model compatible 203 * or device id. 204 */ 205 *val = 1; 206 *val2 = data->variant_info->sensitivity; 207 return IIO_VAL_FRACTIONAL; 208 default: 209 return -EINVAL; 210 } 211 case IIO_CHAN_INFO_OFFSET: 212 switch (chan->type) { 213 case IIO_TEMP: 214 *val = -1708; 215 return IIO_VAL_INT; 216 default: 217 return -EINVAL; 218 } 219 default: 220 return -EINVAL; 221 } 222 } 223 224 static irqreturn_t als31300_trigger_handler(int irq, void *p) 225 { 226 struct iio_poll_func *pf = p; 227 struct iio_dev *indio_dev = pf->indio_dev; 228 struct als31300_data *data = iio_priv(indio_dev); 229 struct { 230 u16 temperature; 231 s16 channels[3]; 232 aligned_s64 timestamp; 233 } scan; 234 s16 x, y, z; 235 int ret; 236 u16 t; 237 238 ret = als31300_get_measure(data, &t, &x, &y, &z); 239 if (ret) 240 goto trigger_out; 241 242 scan.temperature = t; 243 scan.channels[0] = x; 244 scan.channels[1] = y; 245 scan.channels[2] = z; 246 iio_push_to_buffers_with_ts(indio_dev, &scan, sizeof(scan), pf->timestamp); 247 248 trigger_out: 249 iio_trigger_notify_done(indio_dev->trig); 250 251 return IRQ_HANDLED; 252 } 253 254 #define ALS31300_AXIS_CHANNEL(axis, index) \ 255 { \ 256 .type = IIO_MAGN, \ 257 .modified = 1, \ 258 .channel2 = IIO_MOD_##axis, \ 259 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \ 260 BIT(IIO_CHAN_INFO_SCALE), \ 261 .address = index, \ 262 .scan_index = index, \ 263 .scan_type = { \ 264 .sign = 's', \ 265 .realbits = 12, \ 266 .storagebits = 16, \ 267 .endianness = IIO_CPU, \ 268 }, \ 269 } 270 271 static const struct iio_chan_spec als31300_channels[] = { 272 { 273 .type = IIO_TEMP, 274 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | 275 BIT(IIO_CHAN_INFO_SCALE) | 276 BIT(IIO_CHAN_INFO_OFFSET), 277 .address = TEMPERATURE, 278 .scan_index = TEMPERATURE, 279 .scan_type = { 280 .sign = 'u', 281 .realbits = 16, 282 .storagebits = 16, 283 .endianness = IIO_CPU, 284 }, 285 }, 286 ALS31300_AXIS_CHANNEL(X, AXIS_X), 287 ALS31300_AXIS_CHANNEL(Y, AXIS_Y), 288 ALS31300_AXIS_CHANNEL(Z, AXIS_Z), 289 IIO_CHAN_SOFT_TIMESTAMP(4), 290 }; 291 292 static const struct iio_info als31300_info = { 293 .read_raw = als31300_read_raw, 294 }; 295 296 static int als31300_set_operating_mode(struct als31300_data *data, 297 unsigned int val) 298 { 299 int ret; 300 301 ret = regmap_update_bits(data->map, ALS31300_VOL_MODE, 302 ALS31300_VOL_MODE_SLEEP, val); 303 if (ret) { 304 dev_err(data->dev, "failed to set operating mode (%pe)\n", ERR_PTR(ret)); 305 return ret; 306 } 307 308 /* The time it takes to exit sleep mode is equivalent to Power-On Delay Time */ 309 if (val == ALS31300_VOL_MODE_ACTIVE_MODE) 310 fsleep(600); 311 312 return 0; 313 } 314 315 static void als31300_power_down(void *data) 316 { 317 als31300_set_operating_mode(data, ALS31300_VOL_MODE_SLEEP_MODE); 318 } 319 320 static const struct iio_buffer_setup_ops als31300_setup_ops = {}; 321 322 static const unsigned long als31300_scan_masks[] = { GENMASK(3, 0), 0 }; 323 324 static bool als31300_volatile_reg(struct device *dev, unsigned int reg) 325 { 326 return reg == ALS31300_VOL_MSB || reg == ALS31300_VOL_LSB; 327 } 328 329 static const struct regmap_config als31300_regmap_config = { 330 .reg_bits = 8, 331 .val_bits = 32, 332 .max_register = ALS31300_CUSTOMER_ACCESS, 333 .volatile_reg = als31300_volatile_reg, 334 }; 335 336 static int als31300_probe(struct i2c_client *i2c) 337 { 338 struct device *dev = &i2c->dev; 339 struct als31300_data *data; 340 struct iio_dev *indio_dev; 341 int ret; 342 343 indio_dev = devm_iio_device_alloc(dev, sizeof(*data)); 344 if (!indio_dev) 345 return -ENOMEM; 346 347 data = iio_priv(indio_dev); 348 data->dev = dev; 349 i2c_set_clientdata(i2c, indio_dev); 350 351 ret = devm_mutex_init(dev, &data->mutex); 352 if (ret) 353 return ret; 354 355 data->variant_info = i2c_get_match_data(i2c); 356 if (!data->variant_info) 357 return -EINVAL; 358 359 data->map = devm_regmap_init_i2c(i2c, &als31300_regmap_config); 360 if (IS_ERR(data->map)) 361 return dev_err_probe(dev, PTR_ERR(data->map), 362 "failed to allocate register map\n"); 363 364 ret = devm_regulator_get_enable(dev, "vcc"); 365 if (ret) 366 return dev_err_probe(dev, ret, "failed to enable regulator\n"); 367 368 ret = als31300_set_operating_mode(data, ALS31300_VOL_MODE_ACTIVE_MODE); 369 if (ret) 370 return dev_err_probe(dev, ret, "failed to power on device\n"); 371 372 ret = devm_add_action_or_reset(dev, als31300_power_down, data); 373 if (ret) 374 return ret; 375 376 indio_dev->info = &als31300_info; 377 indio_dev->modes = INDIO_DIRECT_MODE; 378 indio_dev->name = i2c->name; 379 indio_dev->channels = als31300_channels; 380 indio_dev->num_channels = ARRAY_SIZE(als31300_channels); 381 indio_dev->available_scan_masks = als31300_scan_masks; 382 383 ret = devm_iio_triggered_buffer_setup(dev, indio_dev, 384 iio_pollfunc_store_time, 385 als31300_trigger_handler, 386 &als31300_setup_ops); 387 if (ret < 0) 388 return dev_err_probe(dev, ret, "iio triggered buffer setup failed\n"); 389 390 ret = pm_runtime_set_active(dev); 391 if (ret < 0) 392 return ret; 393 394 ret = devm_pm_runtime_enable(dev); 395 if (ret) 396 return ret; 397 398 pm_runtime_get_noresume(dev); 399 pm_runtime_set_autosuspend_delay(dev, 200); 400 pm_runtime_use_autosuspend(dev); 401 402 pm_runtime_put_autosuspend(dev); 403 404 ret = devm_iio_device_register(dev, indio_dev); 405 if (ret) 406 return dev_err_probe(dev, ret, "device register failed\n"); 407 408 return 0; 409 } 410 411 static int als31300_runtime_suspend(struct device *dev) 412 { 413 struct iio_dev *indio_dev = dev_get_drvdata(dev); 414 struct als31300_data *data = iio_priv(indio_dev); 415 416 return als31300_set_operating_mode(data, ALS31300_VOL_MODE_SLEEP_MODE); 417 } 418 419 static int als31300_runtime_resume(struct device *dev) 420 { 421 struct iio_dev *indio_dev = dev_get_drvdata(dev); 422 struct als31300_data *data = iio_priv(indio_dev); 423 424 return als31300_set_operating_mode(data, ALS31300_VOL_MODE_ACTIVE_MODE); 425 } 426 427 static DEFINE_RUNTIME_DEV_PM_OPS(als31300_pm_ops, 428 als31300_runtime_suspend, als31300_runtime_resume, 429 NULL); 430 431 static const struct als31300_variant_info al31300_variant_500 = { 432 .sensitivity = 4, 433 }; 434 435 static const struct als31300_variant_info al31300_variant_1000 = { 436 .sensitivity = 2, 437 }; 438 439 static const struct als31300_variant_info al31300_variant_2000 = { 440 .sensitivity = 1, 441 }; 442 443 static const struct i2c_device_id als31300_id[] = { 444 { 445 .name = "als31300-500", 446 .driver_data = (kernel_ulong_t)&al31300_variant_500, 447 }, 448 { 449 .name = "als31300-1000", 450 .driver_data = (kernel_ulong_t)&al31300_variant_1000, 451 }, 452 { 453 .name = "als31300-2000", 454 .driver_data = (kernel_ulong_t)&al31300_variant_2000, 455 }, 456 { } 457 }; 458 MODULE_DEVICE_TABLE(i2c, als31300_id); 459 460 static const struct of_device_id als31300_of_match[] = { 461 { 462 .compatible = "allegromicro,als31300-500", 463 .data = &al31300_variant_500, 464 }, 465 { 466 .compatible = "allegromicro,als31300-1000", 467 .data = &al31300_variant_1000, 468 }, 469 { 470 .compatible = "allegromicro,als31300-2000", 471 .data = &al31300_variant_2000, 472 }, 473 { } 474 }; 475 MODULE_DEVICE_TABLE(of, als31300_of_match); 476 477 static struct i2c_driver als31300_driver = { 478 .driver = { 479 .name = "als31300", 480 .of_match_table = als31300_of_match, 481 .pm = pm_ptr(&als31300_pm_ops), 482 }, 483 .probe = als31300_probe, 484 .id_table = als31300_id, 485 }; 486 module_i2c_driver(als31300_driver); 487 488 MODULE_LICENSE("GPL"); 489 MODULE_DESCRIPTION("ALS31300 3-D Linear Hall Effect Driver"); 490 MODULE_AUTHOR("Neil Armstrong <neil.armstrong@linaro.org>"); 491