3e29562ce374ffec9f213555f1360bed9b03d46a
[sfrench/cifs-2.6.git] / drivers / iio / health / max30102.c
1 /*
2  * max30102.c - Support for MAX30102 heart rate and pulse oximeter sensor
3  *
4  * Copyright (C) 2017 Matt Ranostay <matt@ranostay.consulting>
5  *
6  * Support for MAX30105 optical particle sensor
7  * Copyright (C) 2017 Peter Meerwald-Stadler <pmeerw@pmeerw.net>
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17  * GNU General Public License for more details.
18  *
19  * 7-bit I2C chip address: 0x57
20  * TODO: proximity power saving feature
21  */
22
23 #include <linux/module.h>
24 #include <linux/init.h>
25 #include <linux/interrupt.h>
26 #include <linux/delay.h>
27 #include <linux/err.h>
28 #include <linux/irq.h>
29 #include <linux/i2c.h>
30 #include <linux/mutex.h>
31 #include <linux/of.h>
32 #include <linux/regmap.h>
33 #include <linux/iio/iio.h>
34 #include <linux/iio/buffer.h>
35 #include <linux/iio/kfifo_buf.h>
36
37 #define MAX30102_REGMAP_NAME    "max30102_regmap"
38 #define MAX30102_DRV_NAME       "max30102"
39 #define MAX30102_PART_NUMBER    0x15
40
41 enum max30102_chip_id {
42         max30102,
43         max30105,
44 };
45
46 enum max3012_led_idx {
47         MAX30102_LED_RED,
48         MAX30102_LED_IR,
49         MAX30105_LED_GREEN,
50 };
51
52 #define MAX30102_REG_INT_STATUS                 0x00
53 #define MAX30102_REG_INT_STATUS_PWR_RDY         BIT(0)
54 #define MAX30102_REG_INT_STATUS_PROX_INT        BIT(4)
55 #define MAX30102_REG_INT_STATUS_ALC_OVF         BIT(5)
56 #define MAX30102_REG_INT_STATUS_PPG_RDY         BIT(6)
57 #define MAX30102_REG_INT_STATUS_FIFO_RDY        BIT(7)
58
59 #define MAX30102_REG_INT_ENABLE                 0x02
60 #define MAX30102_REG_INT_ENABLE_PROX_INT_EN     BIT(4)
61 #define MAX30102_REG_INT_ENABLE_ALC_OVF_EN      BIT(5)
62 #define MAX30102_REG_INT_ENABLE_PPG_EN          BIT(6)
63 #define MAX30102_REG_INT_ENABLE_FIFO_EN         BIT(7)
64 #define MAX30102_REG_INT_ENABLE_MASK            0xf0
65 #define MAX30102_REG_INT_ENABLE_MASK_SHIFT      4
66
67 #define MAX30102_REG_FIFO_WR_PTR                0x04
68 #define MAX30102_REG_FIFO_OVR_CTR               0x05
69 #define MAX30102_REG_FIFO_RD_PTR                0x06
70 #define MAX30102_REG_FIFO_DATA                  0x07
71 #define MAX30102_REG_FIFO_DATA_BYTES            3
72
73 #define MAX30102_REG_FIFO_CONFIG                0x08
74 #define MAX30102_REG_FIFO_CONFIG_AVG_4SAMPLES   BIT(1)
75 #define MAX30102_REG_FIFO_CONFIG_AVG_SHIFT      5
76 #define MAX30102_REG_FIFO_CONFIG_AFULL          BIT(0)
77
78 #define MAX30102_REG_MODE_CONFIG                0x09
79 #define MAX30102_REG_MODE_CONFIG_MODE_NONE      0x00
80 #define MAX30102_REG_MODE_CONFIG_MODE_HR        0x02 /* red LED */
81 #define MAX30102_REG_MODE_CONFIG_MODE_HR_SPO2   0x03 /* red + IR LED */
82 #define MAX30102_REG_MODE_CONFIG_MODE_MULTI     0x07 /* multi-LED mode */
83 #define MAX30102_REG_MODE_CONFIG_MODE_MASK      GENMASK(2, 0)
84 #define MAX30102_REG_MODE_CONFIG_PWR            BIT(7)
85
86 #define MAX30102_REG_MODE_CONTROL_SLOT21        0x11 /* multi-LED control */
87 #define MAX30102_REG_MODE_CONTROL_SLOT43        0x12
88 #define MAX30102_REG_MODE_CONTROL_SLOT_MASK     (GENMASK(6, 4) | GENMASK(2, 0))
89 #define MAX30102_REG_MODE_CONTROL_SLOT_SHIFT    4
90
91 #define MAX30102_REG_SPO2_CONFIG                0x0a
92 #define MAX30102_REG_SPO2_CONFIG_PULSE_411_US   0x03
93 #define MAX30102_REG_SPO2_CONFIG_SR_400HZ       0x03
94 #define MAX30102_REG_SPO2_CONFIG_SR_MASK        0x07
95 #define MAX30102_REG_SPO2_CONFIG_SR_MASK_SHIFT  2
96 #define MAX30102_REG_SPO2_CONFIG_ADC_4096_STEPS BIT(0)
97 #define MAX30102_REG_SPO2_CONFIG_ADC_MASK_SHIFT 5
98
99 #define MAX30102_REG_RED_LED_CONFIG             0x0c
100 #define MAX30102_REG_IR_LED_CONFIG              0x0d
101 #define MAX30105_REG_GREEN_LED_CONFIG           0x0e
102
103 #define MAX30102_REG_TEMP_CONFIG                0x21
104 #define MAX30102_REG_TEMP_CONFIG_TEMP_EN        BIT(0)
105
106 #define MAX30102_REG_TEMP_INTEGER               0x1f
107 #define MAX30102_REG_TEMP_FRACTION              0x20
108
109 #define MAX30102_REG_REV_ID                     0xfe
110 #define MAX30102_REG_PART_ID                    0xff
111
112 struct max30102_data {
113         struct i2c_client *client;
114         struct iio_dev *indio_dev;
115         struct mutex lock;
116         struct regmap *regmap;
117         enum max30102_chip_id chip_id;
118
119         u8 buffer[12];
120         __be32 processed_buffer[3]; /* 3 x 18-bit (padded to 32-bits) */
121 };
122
123 static const struct regmap_config max30102_regmap_config = {
124         .name = MAX30102_REGMAP_NAME,
125
126         .reg_bits = 8,
127         .val_bits = 8,
128 };
129
130 static const unsigned long max30102_scan_masks[] = {
131         BIT(MAX30102_LED_RED) | BIT(MAX30102_LED_IR),
132         0
133 };
134
135 static const unsigned long max30105_scan_masks[] = {
136         BIT(MAX30102_LED_RED) | BIT(MAX30102_LED_IR),
137         BIT(MAX30102_LED_RED) | BIT(MAX30102_LED_IR) |
138                 BIT(MAX30105_LED_GREEN),
139         0
140 };
141
142 #define MAX30102_INTENSITY_CHANNEL(_si, _mod) { \
143                 .type = IIO_INTENSITY, \
144                 .channel2 = _mod, \
145                 .modified = 1, \
146                 .scan_index = _si, \
147                 .scan_type = { \
148                         .sign = 'u', \
149                         .shift = 8, \
150                         .realbits = 18, \
151                         .storagebits = 32, \
152                         .endianness = IIO_BE, \
153                 }, \
154         }
155
156 static const struct iio_chan_spec max30102_channels[] = {
157         MAX30102_INTENSITY_CHANNEL(MAX30102_LED_RED, IIO_MOD_LIGHT_RED),
158         MAX30102_INTENSITY_CHANNEL(MAX30102_LED_IR, IIO_MOD_LIGHT_IR),
159         {
160                 .type = IIO_TEMP,
161                 .info_mask_separate =
162                         BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
163                 .scan_index = -1,
164         },
165 };
166
167 static const struct iio_chan_spec max30105_channels[] = {
168         MAX30102_INTENSITY_CHANNEL(MAX30102_LED_RED, IIO_MOD_LIGHT_RED),
169         MAX30102_INTENSITY_CHANNEL(MAX30102_LED_IR, IIO_MOD_LIGHT_IR),
170         MAX30102_INTENSITY_CHANNEL(MAX30105_LED_GREEN, IIO_MOD_LIGHT_GREEN),
171         {
172                 .type = IIO_TEMP,
173                 .info_mask_separate =
174                         BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
175                 .scan_index = -1,
176         },
177 };
178
179 static int max30102_set_power(struct max30102_data *data, bool en)
180 {
181         return regmap_update_bits(data->regmap, MAX30102_REG_MODE_CONFIG,
182                                   MAX30102_REG_MODE_CONFIG_PWR,
183                                   en ? 0 : MAX30102_REG_MODE_CONFIG_PWR);
184 }
185
186 static int max30102_set_powermode(struct max30102_data *data, u8 mode, bool en)
187 {
188         u8 reg = mode;
189
190         if (!en)
191                 reg |= MAX30102_REG_MODE_CONFIG_PWR;
192
193         return regmap_update_bits(data->regmap, MAX30102_REG_MODE_CONFIG,
194                                   MAX30102_REG_MODE_CONFIG_PWR |
195                                   MAX30102_REG_MODE_CONFIG_MODE_MASK, reg);
196 }
197
198 #define MAX30102_MODE_CONTROL_LED_SLOTS(slot2, slot1) \
199         ((slot2 << MAX30102_REG_MODE_CONTROL_SLOT_SHIFT) | slot1)
200
201 static int max30102_buffer_postenable(struct iio_dev *indio_dev)
202 {
203         struct max30102_data *data = iio_priv(indio_dev);
204         int ret;
205         u8 reg;
206
207         switch (*indio_dev->active_scan_mask) {
208         case BIT(MAX30102_LED_RED) | BIT(MAX30102_LED_IR):
209                 reg = MAX30102_REG_MODE_CONFIG_MODE_HR_SPO2;
210                 break;
211         case BIT(MAX30102_LED_RED) | BIT(MAX30102_LED_IR) |
212              BIT(MAX30105_LED_GREEN):
213                 ret = regmap_update_bits(data->regmap,
214                                          MAX30102_REG_MODE_CONTROL_SLOT21,
215                                          MAX30102_REG_MODE_CONTROL_SLOT_MASK,
216                                          MAX30102_MODE_CONTROL_LED_SLOTS(2, 1));
217                 if (ret)
218                         return ret;
219
220                 ret = regmap_update_bits(data->regmap,
221                                          MAX30102_REG_MODE_CONTROL_SLOT43,
222                                          MAX30102_REG_MODE_CONTROL_SLOT_MASK,
223                                          MAX30102_MODE_CONTROL_LED_SLOTS(0, 3));
224                 if (ret)
225                         return ret;
226
227                 reg = MAX30102_REG_MODE_CONFIG_MODE_MULTI;
228                 break;
229         default:
230                 return -EINVAL;
231         }
232
233         return max30102_set_powermode(data, reg, true);
234 }
235
236 static int max30102_buffer_predisable(struct iio_dev *indio_dev)
237 {
238         struct max30102_data *data = iio_priv(indio_dev);
239
240         return max30102_set_powermode(data, MAX30102_REG_MODE_CONFIG_MODE_NONE,
241                                       false);
242 }
243
244 static const struct iio_buffer_setup_ops max30102_buffer_setup_ops = {
245         .postenable = max30102_buffer_postenable,
246         .predisable = max30102_buffer_predisable,
247 };
248
249 static inline int max30102_fifo_count(struct max30102_data *data)
250 {
251         unsigned int val;
252         int ret;
253
254         ret = regmap_read(data->regmap, MAX30102_REG_INT_STATUS, &val);
255         if (ret)
256                 return ret;
257
258         /* FIFO has one sample slot left */
259         if (val & MAX30102_REG_INT_STATUS_FIFO_RDY)
260                 return 1;
261
262         return 0;
263 }
264
265 #define MAX30102_COPY_DATA(i) \
266         memcpy(&data->processed_buffer[(i)], \
267                &buffer[(i) * MAX30102_REG_FIFO_DATA_BYTES], \
268                MAX30102_REG_FIFO_DATA_BYTES)
269
270 static int max30102_read_measurement(struct max30102_data *data,
271                                      unsigned int measurements)
272 {
273         int ret;
274         u8 *buffer = (u8 *) &data->buffer;
275
276         ret = i2c_smbus_read_i2c_block_data(data->client,
277                                             MAX30102_REG_FIFO_DATA,
278                                             measurements *
279                                             MAX30102_REG_FIFO_DATA_BYTES,
280                                             buffer);
281
282         switch (measurements) {
283         case 3:
284                 MAX30102_COPY_DATA(2);
285                 /* fall through */
286         case 2:
287                 MAX30102_COPY_DATA(1);
288                 /* fall through */
289         case 1:
290                 MAX30102_COPY_DATA(0);
291                 break;
292         default:
293                 return -EINVAL;
294         }
295
296         return (ret == measurements * MAX30102_REG_FIFO_DATA_BYTES) ?
297                0 : -EINVAL;
298 }
299
300 static irqreturn_t max30102_interrupt_handler(int irq, void *private)
301 {
302         struct iio_dev *indio_dev = private;
303         struct max30102_data *data = iio_priv(indio_dev);
304         unsigned int measurements = bitmap_weight(indio_dev->active_scan_mask,
305                                                   indio_dev->masklength);
306         int ret, cnt = 0;
307
308         mutex_lock(&data->lock);
309
310         while (cnt || (cnt = max30102_fifo_count(data)) > 0) {
311                 ret = max30102_read_measurement(data, measurements);
312                 if (ret)
313                         break;
314
315                 iio_push_to_buffers(data->indio_dev, data->processed_buffer);
316                 cnt--;
317         }
318
319         mutex_unlock(&data->lock);
320
321         return IRQ_HANDLED;
322 }
323
324 static int max30102_get_current_idx(unsigned int val, int *reg)
325 {
326         /* each step is 0.200 mA */
327         *reg = val / 200;
328
329         return *reg > 0xff ? -EINVAL : 0;
330 }
331
332 static int max30102_led_init(struct max30102_data *data)
333 {
334         struct device *dev = &data->client->dev;
335         struct device_node *np = dev->of_node;
336         unsigned int val;
337         int reg, ret;
338
339         ret = of_property_read_u32(np, "maxim,red-led-current-microamp", &val);
340         if (ret) {
341                 dev_info(dev, "no red-led-current-microamp set\n");
342
343                 /* Default to 7 mA RED LED */
344                 val = 7000;
345         }
346
347         ret = max30102_get_current_idx(val, &reg);
348         if (ret) {
349                 dev_err(dev, "invalid RED LED current setting %d\n", val);
350                 return ret;
351         }
352
353         ret = regmap_write(data->regmap, MAX30102_REG_RED_LED_CONFIG, reg);
354         if (ret)
355                 return ret;
356
357         if (data->chip_id == max30105) {
358                 ret = of_property_read_u32(np,
359                         "maxim,green-led-current-microamp", &val);
360                 if (ret) {
361                         dev_info(dev, "no green-led-current-microamp set\n");
362
363                         /* Default to 7 mA green LED */
364                         val = 7000;
365                 }
366
367                 ret = max30102_get_current_idx(val, &reg);
368                 if (ret) {
369                         dev_err(dev, "invalid green LED current setting %d\n",
370                                 val);
371                         return ret;
372                 }
373
374                 ret = regmap_write(data->regmap, MAX30105_REG_GREEN_LED_CONFIG,
375                                    reg);
376                 if (ret)
377                         return ret;
378         }
379
380         ret = of_property_read_u32(np, "maxim,ir-led-current-microamp", &val);
381         if (ret) {
382                 dev_info(dev, "no ir-led-current-microamp set\n");
383
384                 /* Default to 7 mA IR LED */
385                 val = 7000;
386         }
387
388         ret = max30102_get_current_idx(val, &reg);
389         if (ret) {
390                 dev_err(dev, "invalid IR LED current setting %d\n", val);
391                 return ret;
392         }
393
394         return regmap_write(data->regmap, MAX30102_REG_IR_LED_CONFIG, reg);
395 }
396
397 static int max30102_chip_init(struct max30102_data *data)
398 {
399         int ret;
400
401         /* setup LED current settings */
402         ret = max30102_led_init(data);
403         if (ret)
404                 return ret;
405
406         /* configure 18-bit HR + SpO2 readings at 400Hz */
407         ret = regmap_write(data->regmap, MAX30102_REG_SPO2_CONFIG,
408                                 (MAX30102_REG_SPO2_CONFIG_ADC_4096_STEPS
409                                  << MAX30102_REG_SPO2_CONFIG_ADC_MASK_SHIFT) |
410                                 (MAX30102_REG_SPO2_CONFIG_SR_400HZ
411                                  << MAX30102_REG_SPO2_CONFIG_SR_MASK_SHIFT) |
412                                  MAX30102_REG_SPO2_CONFIG_PULSE_411_US);
413         if (ret)
414                 return ret;
415
416         /* average 4 samples + generate FIFO interrupt */
417         ret = regmap_write(data->regmap, MAX30102_REG_FIFO_CONFIG,
418                                 (MAX30102_REG_FIFO_CONFIG_AVG_4SAMPLES
419                                  << MAX30102_REG_FIFO_CONFIG_AVG_SHIFT) |
420                                  MAX30102_REG_FIFO_CONFIG_AFULL);
421         if (ret)
422                 return ret;
423
424         /* enable FIFO interrupt */
425         return regmap_update_bits(data->regmap, MAX30102_REG_INT_ENABLE,
426                                  MAX30102_REG_INT_ENABLE_MASK,
427                                  MAX30102_REG_INT_ENABLE_FIFO_EN);
428 }
429
430 static int max30102_read_temp(struct max30102_data *data, int *val)
431 {
432         int ret;
433         unsigned int reg;
434
435         ret = regmap_read(data->regmap, MAX30102_REG_TEMP_INTEGER, &reg);
436         if (ret < 0)
437                 return ret;
438         *val = reg << 4;
439
440         ret = regmap_read(data->regmap, MAX30102_REG_TEMP_FRACTION, &reg);
441         if (ret < 0)
442                 return ret;
443
444         *val |= reg & 0xf;
445         *val = sign_extend32(*val, 11);
446
447         return 0;
448 }
449
450 static int max30102_get_temp(struct max30102_data *data, int *val, bool en)
451 {
452         int ret;
453
454         if (en) {
455                 ret = max30102_set_power(data, true);
456                 if (ret)
457                         return ret;
458         }
459
460         /* start acquisition */
461         ret = regmap_update_bits(data->regmap, MAX30102_REG_TEMP_CONFIG,
462                                  MAX30102_REG_TEMP_CONFIG_TEMP_EN,
463                                  MAX30102_REG_TEMP_CONFIG_TEMP_EN);
464         if (ret)
465                 goto out;
466
467         msleep(35);
468         ret = max30102_read_temp(data, val);
469
470 out:
471         if (en)
472                 max30102_set_power(data, false);
473
474         return ret;
475 }
476
477 static int max30102_read_raw(struct iio_dev *indio_dev,
478                              struct iio_chan_spec const *chan,
479                              int *val, int *val2, long mask)
480 {
481         struct max30102_data *data = iio_priv(indio_dev);
482         int ret = -EINVAL;
483
484         switch (mask) {
485         case IIO_CHAN_INFO_RAW:
486                 /*
487                  * Temperature reading can only be acquired when not in
488                  * shutdown; leave shutdown briefly when buffer not running
489                  */
490                 mutex_lock(&indio_dev->mlock);
491                 if (!iio_buffer_enabled(indio_dev))
492                         ret = max30102_get_temp(data, val, true);
493                 else
494                         ret = max30102_get_temp(data, val, false);
495                 mutex_unlock(&indio_dev->mlock);
496                 if (ret)
497                         return ret;
498
499                 ret = IIO_VAL_INT;
500                 break;
501         case IIO_CHAN_INFO_SCALE:
502                 *val = 1000;  /* 62.5 */
503                 *val2 = 16;
504                 ret = IIO_VAL_FRACTIONAL;
505                 break;
506         }
507
508         return ret;
509 }
510
511 static const struct iio_info max30102_info = {
512         .read_raw = max30102_read_raw,
513 };
514
515 static int max30102_probe(struct i2c_client *client,
516                           const struct i2c_device_id *id)
517 {
518         struct max30102_data *data;
519         struct iio_buffer *buffer;
520         struct iio_dev *indio_dev;
521         int ret;
522         unsigned int reg;
523
524         indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
525         if (!indio_dev)
526                 return -ENOMEM;
527
528         buffer = devm_iio_kfifo_allocate(&client->dev);
529         if (!buffer)
530                 return -ENOMEM;
531
532         iio_device_attach_buffer(indio_dev, buffer);
533
534         indio_dev->name = MAX30102_DRV_NAME;
535         indio_dev->info = &max30102_info;
536         indio_dev->modes = (INDIO_BUFFER_SOFTWARE | INDIO_DIRECT_MODE);
537         indio_dev->setup_ops = &max30102_buffer_setup_ops;
538         indio_dev->dev.parent = &client->dev;
539
540         data = iio_priv(indio_dev);
541         data->indio_dev = indio_dev;
542         data->client = client;
543         data->chip_id = id->driver_data;
544
545         mutex_init(&data->lock);
546         i2c_set_clientdata(client, indio_dev);
547
548         switch (data->chip_id) {
549         case max30105:
550                 indio_dev->channels = max30105_channels;
551                 indio_dev->num_channels = ARRAY_SIZE(max30105_channels);
552                 indio_dev->available_scan_masks = max30105_scan_masks;
553                 break;
554         case max30102:
555                 indio_dev->channels = max30102_channels;
556                 indio_dev->num_channels = ARRAY_SIZE(max30102_channels);
557                 indio_dev->available_scan_masks = max30102_scan_masks;
558                 break;
559         default:
560                 return -ENODEV;
561         }
562
563         data->regmap = devm_regmap_init_i2c(client, &max30102_regmap_config);
564         if (IS_ERR(data->regmap)) {
565                 dev_err(&client->dev, "regmap initialization failed\n");
566                 return PTR_ERR(data->regmap);
567         }
568
569         /* check part ID */
570         ret = regmap_read(data->regmap, MAX30102_REG_PART_ID, &reg);
571         if (ret)
572                 return ret;
573         if (reg != MAX30102_PART_NUMBER)
574                 return -ENODEV;
575
576         /* show revision ID */
577         ret = regmap_read(data->regmap, MAX30102_REG_REV_ID, &reg);
578         if (ret)
579                 return ret;
580         dev_dbg(&client->dev, "max3010x revision %02x\n", reg);
581
582         /* clear mode setting, chip shutdown */
583         ret = max30102_set_powermode(data, MAX30102_REG_MODE_CONFIG_MODE_NONE,
584                                      false);
585         if (ret)
586                 return ret;
587
588         ret = max30102_chip_init(data);
589         if (ret)
590                 return ret;
591
592         if (client->irq <= 0) {
593                 dev_err(&client->dev, "no valid irq defined\n");
594                 return -EINVAL;
595         }
596
597         ret = devm_request_threaded_irq(&client->dev, client->irq,
598                                         NULL, max30102_interrupt_handler,
599                                         IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
600                                         "max30102_irq", indio_dev);
601         if (ret) {
602                 dev_err(&client->dev, "request irq (%d) failed\n", client->irq);
603                 return ret;
604         }
605
606         return iio_device_register(indio_dev);
607 }
608
609 static int max30102_remove(struct i2c_client *client)
610 {
611         struct iio_dev *indio_dev = i2c_get_clientdata(client);
612         struct max30102_data *data = iio_priv(indio_dev);
613
614         iio_device_unregister(indio_dev);
615         max30102_set_power(data, false);
616
617         return 0;
618 }
619
620 static const struct i2c_device_id max30102_id[] = {
621         { "max30102", max30102 },
622         { "max30105", max30105 },
623         {}
624 };
625 MODULE_DEVICE_TABLE(i2c, max30102_id);
626
627 static const struct of_device_id max30102_dt_ids[] = {
628         { .compatible = "maxim,max30102" },
629         { .compatible = "maxim,max30105" },
630         { }
631 };
632 MODULE_DEVICE_TABLE(of, max30102_dt_ids);
633
634 static struct i2c_driver max30102_driver = {
635         .driver = {
636                 .name   = MAX30102_DRV_NAME,
637                 .of_match_table = of_match_ptr(max30102_dt_ids),
638         },
639         .probe          = max30102_probe,
640         .remove         = max30102_remove,
641         .id_table       = max30102_id,
642 };
643 module_i2c_driver(max30102_driver);
644
645 MODULE_AUTHOR("Matt Ranostay <matt@ranostay.consulting>");
646 MODULE_DESCRIPTION("MAX30102 heart rate/pulse oximeter and MAX30105 particle sensor driver");
647 MODULE_LICENSE("GPL");