1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * max30100.c - Support for MAX30100 heart rate and pulse oximeter sensor 4 * 5 * Copyright (C) 2015, 2018 6 * Author: Matt Ranostay <matt.ranostay@konsulko.com> 7 * 8 * TODO: enable pulse length controls via device tree properties 9 */ 10 11 #include <linux/module.h> 12 #include <linux/init.h> 13 #include <linux/interrupt.h> 14 #include <linux/delay.h> 15 #include <linux/err.h> 16 #include <linux/irq.h> 17 #include <linux/i2c.h> 18 #include <linux/mutex.h> 19 #include <linux/property.h> 20 #include <linux/regmap.h> 21 #include <linux/iio/iio.h> 22 #include <linux/iio/buffer.h> 23 #include <linux/iio/kfifo_buf.h> 24 25 #define MAX30100_DRV_NAME "max30100" 26 27 #define MAX30100_REG_INT_STATUS 0x00 28 #define MAX30100_REG_INT_STATUS_PWR_RDY BIT(0) 29 #define MAX30100_REG_INT_STATUS_SPO2_RDY BIT(4) 30 #define MAX30100_REG_INT_STATUS_HR_RDY BIT(5) 31 #define MAX30100_REG_INT_STATUS_FIFO_RDY BIT(7) 32 33 #define MAX30100_REG_INT_ENABLE 0x01 34 #define MAX30100_REG_INT_ENABLE_SPO2_EN BIT(0) 35 #define MAX30100_REG_INT_ENABLE_HR_EN BIT(1) 36 #define MAX30100_REG_INT_ENABLE_FIFO_EN BIT(3) 37 #define MAX30100_REG_INT_ENABLE_MASK 0xf0 38 #define MAX30100_REG_INT_ENABLE_MASK_SHIFT 4 39 40 #define MAX30100_REG_FIFO_WR_PTR 0x02 41 #define MAX30100_REG_FIFO_OVR_CTR 0x03 42 #define MAX30100_REG_FIFO_RD_PTR 0x04 43 #define MAX30100_REG_FIFO_DATA 0x05 44 #define MAX30100_REG_FIFO_DATA_ENTRY_COUNT 16 45 #define MAX30100_REG_FIFO_DATA_ENTRY_LEN 4 46 47 #define MAX30100_REG_MODE_CONFIG 0x06 48 #define MAX30100_REG_MODE_CONFIG_MODE_SPO2_EN BIT(0) 49 #define MAX30100_REG_MODE_CONFIG_MODE_HR_EN BIT(1) 50 #define MAX30100_REG_MODE_CONFIG_MODE_MASK 0x03 51 #define MAX30100_REG_MODE_CONFIG_TEMP_EN BIT(3) 52 #define MAX30100_REG_MODE_CONFIG_PWR BIT(7) 53 54 #define MAX30100_REG_SPO2_CONFIG 0x07 55 #define MAX30100_REG_SPO2_CONFIG_100HZ BIT(2) 56 #define MAX30100_REG_SPO2_CONFIG_HI_RES_EN BIT(6) 57 #define MAX30100_REG_SPO2_CONFIG_1600US 0x3 58 59 #define MAX30100_REG_LED_CONFIG 0x09 60 #define MAX30100_REG_LED_CONFIG_LED_MASK 0x0f 61 #define MAX30100_REG_LED_CONFIG_RED_LED_SHIFT 4 62 63 #define MAX30100_REG_LED_CONFIG_24MA 0x07 64 #define MAX30100_REG_LED_CONFIG_50MA 0x0f 65 66 #define MAX30100_REG_TEMP_INTEGER 0x16 67 #define MAX30100_REG_TEMP_FRACTION 0x17 68 69 struct max30100_data { 70 struct i2c_client *client; 71 struct iio_dev *indio_dev; 72 struct mutex lock; 73 struct regmap *regmap; 74 75 __be16 buffer[2]; /* 2 16-bit channels */ 76 }; 77 78 static bool max30100_is_volatile_reg(struct device *dev, unsigned int reg) 79 { 80 switch (reg) { 81 case MAX30100_REG_INT_STATUS: 82 case MAX30100_REG_MODE_CONFIG: 83 case MAX30100_REG_FIFO_WR_PTR: 84 case MAX30100_REG_FIFO_OVR_CTR: 85 case MAX30100_REG_FIFO_RD_PTR: 86 case MAX30100_REG_FIFO_DATA: 87 case MAX30100_REG_TEMP_INTEGER: 88 case MAX30100_REG_TEMP_FRACTION: 89 return true; 90 default: 91 return false; 92 } 93 } 94 95 static const struct regmap_config max30100_regmap_config = { 96 .name = "max30100_regmap", 97 98 .reg_bits = 8, 99 .val_bits = 8, 100 101 .max_register = MAX30100_REG_TEMP_FRACTION, 102 .cache_type = REGCACHE_FLAT, 103 104 .volatile_reg = max30100_is_volatile_reg, 105 }; 106 107 static const unsigned int max30100_led_current_mapping[] = { 108 4400, 7600, 11000, 14200, 17400, 109 20800, 24000, 27100, 30600, 33800, 110 37000, 40200, 43600, 46800, 50000 111 }; 112 113 static const unsigned long max30100_scan_masks[] = {0x3, 0}; 114 115 static const struct iio_chan_spec max30100_channels[] = { 116 { 117 .type = IIO_INTENSITY, 118 .channel2 = IIO_MOD_LIGHT_IR, 119 .modified = 1, 120 121 .scan_index = 0, 122 .scan_type = { 123 .sign = 'u', 124 .realbits = 16, 125 .storagebits = 16, 126 .endianness = IIO_BE, 127 }, 128 }, 129 { 130 .type = IIO_INTENSITY, 131 .channel2 = IIO_MOD_LIGHT_RED, 132 .modified = 1, 133 134 .scan_index = 1, 135 .scan_type = { 136 .sign = 'u', 137 .realbits = 16, 138 .storagebits = 16, 139 .endianness = IIO_BE, 140 }, 141 }, 142 { 143 .type = IIO_TEMP, 144 .info_mask_separate = 145 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE), 146 .scan_index = -1, 147 }, 148 }; 149 150 static int max30100_set_powermode(struct max30100_data *data, bool state) 151 { 152 return regmap_update_bits(data->regmap, MAX30100_REG_MODE_CONFIG, 153 MAX30100_REG_MODE_CONFIG_PWR, 154 state ? 0 : MAX30100_REG_MODE_CONFIG_PWR); 155 } 156 157 static int max30100_clear_fifo(struct max30100_data *data) 158 { 159 int ret; 160 161 ret = regmap_write(data->regmap, MAX30100_REG_FIFO_WR_PTR, 0); 162 if (ret) 163 return ret; 164 165 ret = regmap_write(data->regmap, MAX30100_REG_FIFO_OVR_CTR, 0); 166 if (ret) 167 return ret; 168 169 return regmap_write(data->regmap, MAX30100_REG_FIFO_RD_PTR, 0); 170 } 171 172 static int max30100_buffer_postenable(struct iio_dev *indio_dev) 173 { 174 struct max30100_data *data = iio_priv(indio_dev); 175 int ret; 176 177 ret = max30100_set_powermode(data, true); 178 if (ret) 179 return ret; 180 181 return max30100_clear_fifo(data); 182 } 183 184 static int max30100_buffer_predisable(struct iio_dev *indio_dev) 185 { 186 struct max30100_data *data = iio_priv(indio_dev); 187 188 return max30100_set_powermode(data, false); 189 } 190 191 static const struct iio_buffer_setup_ops max30100_buffer_setup_ops = { 192 .postenable = max30100_buffer_postenable, 193 .predisable = max30100_buffer_predisable, 194 }; 195 196 static inline int max30100_fifo_count(struct max30100_data *data) 197 { 198 unsigned int val; 199 int ret; 200 201 ret = regmap_read(data->regmap, MAX30100_REG_INT_STATUS, &val); 202 if (ret) 203 return ret; 204 205 /* FIFO is almost full */ 206 if (val & MAX30100_REG_INT_STATUS_FIFO_RDY) 207 return MAX30100_REG_FIFO_DATA_ENTRY_COUNT - 1; 208 209 return 0; 210 } 211 212 static int max30100_read_measurement(struct max30100_data *data) 213 { 214 int ret; 215 216 ret = i2c_smbus_read_i2c_block_data(data->client, 217 MAX30100_REG_FIFO_DATA, 218 MAX30100_REG_FIFO_DATA_ENTRY_LEN, 219 (u8 *) &data->buffer); 220 221 return (ret == MAX30100_REG_FIFO_DATA_ENTRY_LEN) ? 0 : ret; 222 } 223 224 static irqreturn_t max30100_interrupt_handler(int irq, void *private) 225 { 226 struct iio_dev *indio_dev = private; 227 struct max30100_data *data = iio_priv(indio_dev); 228 int ret, cnt = 0; 229 230 mutex_lock(&data->lock); 231 232 while (cnt || (cnt = max30100_fifo_count(data)) > 0) { 233 ret = max30100_read_measurement(data); 234 if (ret) 235 break; 236 237 iio_push_to_buffers(data->indio_dev, data->buffer); 238 cnt--; 239 } 240 241 mutex_unlock(&data->lock); 242 243 return IRQ_HANDLED; 244 } 245 246 static int max30100_get_current_idx(unsigned int val, int *reg) 247 { 248 int idx; 249 250 /* LED turned off */ 251 if (val == 0) { 252 *reg = 0; 253 return 0; 254 } 255 256 for (idx = 0; idx < ARRAY_SIZE(max30100_led_current_mapping); idx++) { 257 if (max30100_led_current_mapping[idx] == val) { 258 *reg = idx + 1; 259 return 0; 260 } 261 } 262 263 return -EINVAL; 264 } 265 266 static int max30100_led_init(struct max30100_data *data) 267 { 268 struct device *dev = &data->client->dev; 269 unsigned int val[2]; 270 int reg, ret; 271 272 ret = device_property_read_u32_array(dev, "maxim,led-current-microamp", 273 (unsigned int *) &val, 2); 274 if (ret) { 275 /* Default to 24 mA RED LED, 50 mA IR LED */ 276 reg = (MAX30100_REG_LED_CONFIG_24MA << 277 MAX30100_REG_LED_CONFIG_RED_LED_SHIFT) | 278 MAX30100_REG_LED_CONFIG_50MA; 279 dev_warn(dev, "no led-current-microamp set"); 280 281 return regmap_write(data->regmap, MAX30100_REG_LED_CONFIG, reg); 282 } 283 284 /* RED LED current */ 285 ret = max30100_get_current_idx(val[0], ®); 286 if (ret) { 287 dev_err(dev, "invalid RED current setting %d", val[0]); 288 return ret; 289 } 290 291 ret = regmap_update_bits(data->regmap, MAX30100_REG_LED_CONFIG, 292 MAX30100_REG_LED_CONFIG_LED_MASK << 293 MAX30100_REG_LED_CONFIG_RED_LED_SHIFT, 294 reg << MAX30100_REG_LED_CONFIG_RED_LED_SHIFT); 295 if (ret) 296 return ret; 297 298 /* IR LED current */ 299 ret = max30100_get_current_idx(val[1], ®); 300 if (ret) { 301 dev_err(dev, "invalid IR current setting %d", val[1]); 302 return ret; 303 } 304 305 return regmap_update_bits(data->regmap, MAX30100_REG_LED_CONFIG, 306 MAX30100_REG_LED_CONFIG_LED_MASK, reg); 307 } 308 309 static int max30100_chip_init(struct max30100_data *data) 310 { 311 int ret; 312 313 /* setup LED current settings */ 314 ret = max30100_led_init(data); 315 if (ret) 316 return ret; 317 318 /* enable hi-res SPO2 readings at 100Hz */ 319 ret = regmap_write(data->regmap, MAX30100_REG_SPO2_CONFIG, 320 MAX30100_REG_SPO2_CONFIG_HI_RES_EN | 321 MAX30100_REG_SPO2_CONFIG_100HZ); 322 if (ret) 323 return ret; 324 325 /* enable SPO2 mode */ 326 ret = regmap_update_bits(data->regmap, MAX30100_REG_MODE_CONFIG, 327 MAX30100_REG_MODE_CONFIG_MODE_MASK, 328 MAX30100_REG_MODE_CONFIG_MODE_HR_EN | 329 MAX30100_REG_MODE_CONFIG_MODE_SPO2_EN); 330 if (ret) 331 return ret; 332 333 /* enable FIFO interrupt */ 334 return regmap_update_bits(data->regmap, MAX30100_REG_INT_ENABLE, 335 MAX30100_REG_INT_ENABLE_MASK, 336 MAX30100_REG_INT_ENABLE_FIFO_EN 337 << MAX30100_REG_INT_ENABLE_MASK_SHIFT); 338 } 339 340 static int max30100_read_temp(struct max30100_data *data, int *val) 341 { 342 int ret; 343 unsigned int reg; 344 345 ret = regmap_read(data->regmap, MAX30100_REG_TEMP_INTEGER, ®); 346 if (ret < 0) 347 return ret; 348 *val = reg << 4; 349 350 ret = regmap_read(data->regmap, MAX30100_REG_TEMP_FRACTION, ®); 351 if (ret < 0) 352 return ret; 353 354 *val |= reg & 0xf; 355 *val = sign_extend32(*val, 11); 356 357 return 0; 358 } 359 360 static int max30100_get_temp(struct max30100_data *data, int *val) 361 { 362 int ret; 363 364 /* start acquisition */ 365 ret = regmap_set_bits(data->regmap, MAX30100_REG_MODE_CONFIG, 366 MAX30100_REG_MODE_CONFIG_TEMP_EN); 367 if (ret) 368 return ret; 369 370 msleep(35); 371 372 return max30100_read_temp(data, val); 373 } 374 375 static int max30100_read_raw(struct iio_dev *indio_dev, 376 struct iio_chan_spec const *chan, 377 int *val, int *val2, long mask) 378 { 379 struct max30100_data *data = iio_priv(indio_dev); 380 int ret = -EINVAL; 381 382 switch (mask) { 383 case IIO_CHAN_INFO_RAW: 384 /* 385 * Temperature reading can only be acquired while engine 386 * is running 387 */ 388 if (iio_device_claim_buffer_mode(indio_dev)) { 389 /* 390 * Replacing -EBUSY or other error code 391 * returned by iio_device_claim_buffer_mode() 392 * because user space may rely on the current 393 * one. 394 */ 395 ret = -EAGAIN; 396 } else { 397 ret = max30100_get_temp(data, val); 398 if (!ret) 399 ret = IIO_VAL_INT; 400 401 iio_device_release_buffer_mode(indio_dev); 402 } 403 break; 404 case IIO_CHAN_INFO_SCALE: 405 *val = 1; /* 0.0625 */ 406 *val2 = 16; 407 ret = IIO_VAL_FRACTIONAL; 408 break; 409 } 410 411 return ret; 412 } 413 414 static const struct iio_info max30100_info = { 415 .read_raw = max30100_read_raw, 416 }; 417 418 static int max30100_probe(struct i2c_client *client) 419 { 420 struct max30100_data *data; 421 struct iio_dev *indio_dev; 422 int ret; 423 424 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data)); 425 if (!indio_dev) 426 return -ENOMEM; 427 428 indio_dev->name = MAX30100_DRV_NAME; 429 indio_dev->channels = max30100_channels; 430 indio_dev->info = &max30100_info; 431 indio_dev->num_channels = ARRAY_SIZE(max30100_channels); 432 indio_dev->available_scan_masks = max30100_scan_masks; 433 indio_dev->modes = INDIO_DIRECT_MODE; 434 435 ret = devm_iio_kfifo_buffer_setup(&client->dev, indio_dev, 436 &max30100_buffer_setup_ops); 437 if (ret) 438 return ret; 439 440 data = iio_priv(indio_dev); 441 data->indio_dev = indio_dev; 442 data->client = client; 443 444 mutex_init(&data->lock); 445 i2c_set_clientdata(client, indio_dev); 446 447 data->regmap = devm_regmap_init_i2c(client, &max30100_regmap_config); 448 if (IS_ERR(data->regmap)) { 449 dev_err(&client->dev, "regmap initialization failed.\n"); 450 return PTR_ERR(data->regmap); 451 } 452 max30100_set_powermode(data, false); 453 454 ret = max30100_chip_init(data); 455 if (ret) 456 return ret; 457 458 if (client->irq <= 0) { 459 dev_err(&client->dev, "no valid irq defined\n"); 460 return -EINVAL; 461 } 462 ret = devm_request_threaded_irq(&client->dev, client->irq, 463 NULL, max30100_interrupt_handler, 464 IRQF_TRIGGER_FALLING | IRQF_ONESHOT, 465 "max30100_irq", indio_dev); 466 if (ret) { 467 dev_err(&client->dev, "request irq (%d) failed\n", client->irq); 468 return ret; 469 } 470 471 return iio_device_register(indio_dev); 472 } 473 474 static void max30100_remove(struct i2c_client *client) 475 { 476 struct iio_dev *indio_dev = i2c_get_clientdata(client); 477 struct max30100_data *data = iio_priv(indio_dev); 478 479 iio_device_unregister(indio_dev); 480 max30100_set_powermode(data, false); 481 } 482 483 static const struct i2c_device_id max30100_id[] = { 484 { "max30100" }, 485 { } 486 }; 487 MODULE_DEVICE_TABLE(i2c, max30100_id); 488 489 static const struct of_device_id max30100_dt_ids[] = { 490 { .compatible = "maxim,max30100" }, 491 { } 492 }; 493 MODULE_DEVICE_TABLE(of, max30100_dt_ids); 494 495 static struct i2c_driver max30100_driver = { 496 .driver = { 497 .name = MAX30100_DRV_NAME, 498 .of_match_table = max30100_dt_ids, 499 }, 500 .probe = max30100_probe, 501 .remove = max30100_remove, 502 .id_table = max30100_id, 503 }; 504 module_i2c_driver(max30100_driver); 505 506 MODULE_AUTHOR("Matt Ranostay <matt.ranostay@konsulko.com>"); 507 MODULE_DESCRIPTION("MAX30100 heart rate and pulse oximeter sensor"); 508 MODULE_LICENSE("GPL"); 509