drivers/iio/health/afe4404.c

   1 /*
   2  * AFE4404 Heart Rate Monitors and Low-Cost Pulse Oximeters
   3  *
   4  * Copyright (C) 2015-2016 Texas Instruments Incorporated - http://www.ti.com/
   5  *      Andrew F. Davis <afd@ti.com>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2 as
   9  * published by the Free Software Foundation.
  10  *
  11  * This program is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  */
  16
  17 #include <linux/device.h>
  18 #include <linux/err.h>
  19 #include <linux/interrupt.h>
  20 #include <linux/i2c.h>
  21 #include <linux/kernel.h>
  22 #include <linux/module.h>
  23 #include <linux/regmap.h>
  24 #include <linux/sysfs.h>
  25 #include <linux/regulator/consumer.h>
  26
  27 #include <linux/iio/iio.h>
  28 #include <linux/iio/sysfs.h>
  29 #include <linux/iio/buffer.h>
  30 #include <linux/iio/trigger.h>
  31 #include <linux/iio/triggered_buffer.h>
  32 #include <linux/iio/trigger_consumer.h>
  33
  34 #include "afe440x.h"
  35
  36 #define AFE4404_DRIVER_NAME             "afe4404"
  37
  38 /* AFE4404 registers */
  39 #define AFE4404_TIA_GAIN_SEP            0x20
  40 #define AFE4404_TIA_GAIN                0x21
  41 #define AFE4404_PROG_TG_STC             0x34
  42 #define AFE4404_PROG_TG_ENDC            0x35
  43 #define AFE4404_LED3LEDSTC              0x36
  44 #define AFE4404_LED3LEDENDC             0x37
  45 #define AFE4404_CLKDIV_PRF              0x39
  46 #define AFE4404_OFFDAC                  0x3a
  47 #define AFE4404_DEC                     0x3d
  48 #define AFE4404_AVG_LED2_ALED2VAL       0x3f
  49 #define AFE4404_AVG_LED1_ALED1VAL       0x40
  50
  51 /* AFE4404 CONTROL2 register fields */
  52 #define AFE440X_CONTROL2_OSC_ENABLE     BIT(9)
  53
  54 enum afe4404_fields {
  55         /* Gains */
  56         F_TIA_GAIN_SEP, F_TIA_CF_SEP,
  57         F_TIA_GAIN, TIA_CF,
  58
  59         /* LED Current */
  60         F_ILED1, F_ILED2, F_ILED3,
  61
  62         /* Offset DAC */
  63         F_OFFDAC_AMB2, F_OFFDAC_LED1, F_OFFDAC_AMB1, F_OFFDAC_LED2,
  64
  65         /* sentinel */
  66         F_MAX_FIELDS
  67 };
  68
  69 static const struct reg_field afe4404_reg_fields[] = {
  70         /* Gains */
  71         [F_TIA_GAIN_SEP]        = REG_FIELD(AFE4404_TIA_GAIN_SEP, 0, 2),
  72         [F_TIA_CF_SEP]          = REG_FIELD(AFE4404_TIA_GAIN_SEP, 3, 5),
  73         [F_TIA_GAIN]            = REG_FIELD(AFE4404_TIA_GAIN, 0, 2),
  74         [TIA_CF]                = REG_FIELD(AFE4404_TIA_GAIN, 3, 5),
  75         /* LED Current */
  76         [F_ILED1]               = REG_FIELD(AFE440X_LEDCNTRL, 0, 5),
  77         [F_ILED2]               = REG_FIELD(AFE440X_LEDCNTRL, 6, 11),
  78         [F_ILED3]               = REG_FIELD(AFE440X_LEDCNTRL, 12, 17),
  79         /* Offset DAC */
  80         [F_OFFDAC_AMB2]         = REG_FIELD(AFE4404_OFFDAC, 0, 4),
  81         [F_OFFDAC_LED1]         = REG_FIELD(AFE4404_OFFDAC, 5, 9),
  82         [F_OFFDAC_AMB1]         = REG_FIELD(AFE4404_OFFDAC, 10, 14),
  83         [F_OFFDAC_LED2]         = REG_FIELD(AFE4404_OFFDAC, 15, 19),
  84 };
  85
  86 /**
  87  * struct afe4404_data - AFE4404 device instance data
  88  * @dev: Device structure
  89  * @regmap: Register map of the device
  90  * @fields: Register fields of the device
  91  * @regulator: Pointer to the regulator for the IC
  92  * @trig: IIO trigger for this device
  93  * @irq: ADC_RDY line interrupt number
  94  * @buffer: Used to construct a scan to push to the iio buffer.
  95  */
  96 struct afe4404_data {
  97         struct device *dev;
  98         struct regmap *regmap;
  99         struct regmap_field *fields[F_MAX_FIELDS];
 100         struct regulator *regulator;
 101         struct iio_trigger *trig;
 102         int irq;
 103         s32 buffer[10] __aligned(8);
 104 };
 105
 106 enum afe4404_chan_id {
 107         LED2 = 1,
 108         ALED2,
 109         LED1,
 110         ALED1,
 111         LED2_ALED2,
 112         LED1_ALED1,
 113 };
 114
 115 static const unsigned int afe4404_channel_values[] = {
 116         [LED2] = AFE440X_LED2VAL,
 117         [ALED2] = AFE440X_ALED2VAL,
 118         [LED1] = AFE440X_LED1VAL,
 119         [ALED1] = AFE440X_ALED1VAL,
 120         [LED2_ALED2] = AFE440X_LED2_ALED2VAL,
 121         [LED1_ALED1] = AFE440X_LED1_ALED1VAL,
 122 };
 123
 124 static const unsigned int afe4404_channel_leds[] = {
 125         [LED2] = F_ILED2,
 126         [ALED2] = F_ILED3,
 127         [LED1] = F_ILED1,
 128 };
 129
 130 static const unsigned int afe4404_channel_offdacs[] = {
 131         [LED2] = F_OFFDAC_LED2,
 132         [ALED2] = F_OFFDAC_AMB2,
 133         [LED1] = F_OFFDAC_LED1,
 134         [ALED1] = F_OFFDAC_AMB1,
 135 };
 136
 137 static const struct iio_chan_spec afe4404_channels[] = {
 138         /* ADC values */
 139         AFE440X_INTENSITY_CHAN(LED2, BIT(IIO_CHAN_INFO_OFFSET)),
 140         AFE440X_INTENSITY_CHAN(ALED2, BIT(IIO_CHAN_INFO_OFFSET)),
 141         AFE440X_INTENSITY_CHAN(LED1, BIT(IIO_CHAN_INFO_OFFSET)),
 142         AFE440X_INTENSITY_CHAN(ALED1, BIT(IIO_CHAN_INFO_OFFSET)),
 143         AFE440X_INTENSITY_CHAN(LED2_ALED2, 0),
 144         AFE440X_INTENSITY_CHAN(LED1_ALED1, 0),
 145         /* LED current */
 146         AFE440X_CURRENT_CHAN(LED2),
 147         AFE440X_CURRENT_CHAN(ALED2),
 148         AFE440X_CURRENT_CHAN(LED1),
 149 };
 150
 151 static const struct afe440x_val_table afe4404_res_table[] = {
 152         { .integer = 500000, .fract = 0 },
 153         { .integer = 250000, .fract = 0 },
 154         { .integer = 100000, .fract = 0 },
 155         { .integer = 50000, .fract = 0 },
 156         { .integer = 25000, .fract = 0 },
 157         { .integer = 10000, .fract = 0 },
 158         { .integer = 1000000, .fract = 0 },
 159         { .integer = 2000000, .fract = 0 },
 160 };
 161 AFE440X_TABLE_ATTR(in_intensity_resistance_available, afe4404_res_table);
 162
 163 static const struct afe440x_val_table afe4404_cap_table[] = {
 164         { .integer = 0, .fract = 5000 },
 165         { .integer = 0, .fract = 2500 },
 166         { .integer = 0, .fract = 10000 },
 167         { .integer = 0, .fract = 7500 },
 168         { .integer = 0, .fract = 20000 },
 169         { .integer = 0, .fract = 17500 },
 170         { .integer = 0, .fract = 25000 },
 171         { .integer = 0, .fract = 22500 },
 172 };
 173 AFE440X_TABLE_ATTR(in_intensity_capacitance_available, afe4404_cap_table);
 174
 175 static ssize_t afe440x_show_register(struct device *dev,
 176                                      struct device_attribute *attr,
 177                                      char *buf)
 178 {
 179         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 180         struct afe4404_data *afe = iio_priv(indio_dev);
 181         struct afe440x_attr *afe440x_attr = to_afe440x_attr(attr);
 182         unsigned int reg_val;
 183         int vals[2];
 184         int ret;
 185
 186         ret = regmap_field_read(afe->fields[afe440x_attr->field], &reg_val);
 187         if (ret)
 188                 return ret;
 189
 190         if (reg_val >= afe440x_attr->table_size)
 191                 return -EINVAL;
 192
 193         vals[0] = afe440x_attr->val_table[reg_val].integer;
 194         vals[1] = afe440x_attr->val_table[reg_val].fract;
 195
 196         return iio_format_value(buf, IIO_VAL_INT_PLUS_MICRO, 2, vals);
 197 }
 198
 199 static ssize_t afe440x_store_register(struct device *dev,
 200                                       struct device_attribute *attr,
 201                                       const char *buf, size_t count)
 202 {
 203         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 204         struct afe4404_data *afe = iio_priv(indio_dev);
 205         struct afe440x_attr *afe440x_attr = to_afe440x_attr(attr);
 206         int val, integer, fract, ret;
 207
 208         ret = iio_str_to_fixpoint(buf, 100000, &integer, &fract);
 209         if (ret)
 210                 return ret;
 211
 212         for (val = 0; val < afe440x_attr->table_size; val++)
 213                 if (afe440x_attr->val_table[val].integer == integer &&
 214                     afe440x_attr->val_table[val].fract == fract)
 215                         break;
 216         if (val == afe440x_attr->table_size)
 217                 return -EINVAL;
 218
 219         ret = regmap_field_write(afe->fields[afe440x_attr->field], val);
 220         if (ret)
 221                 return ret;
 222
 223         return count;
 224 }
 225
 226 static AFE440X_ATTR(in_intensity1_resistance, F_TIA_GAIN_SEP, afe4404_res_table);
 227 static AFE440X_ATTR(in_intensity1_capacitance, F_TIA_CF_SEP, afe4404_cap_table);
 228
 229 static AFE440X_ATTR(in_intensity2_resistance, F_TIA_GAIN_SEP, afe4404_res_table);
 230 static AFE440X_ATTR(in_intensity2_capacitance, F_TIA_CF_SEP, afe4404_cap_table);
 231
 232 static AFE440X_ATTR(in_intensity3_resistance, F_TIA_GAIN, afe4404_res_table);
 233 static AFE440X_ATTR(in_intensity3_capacitance, TIA_CF, afe4404_cap_table);
 234
 235 static AFE440X_ATTR(in_intensity4_resistance, F_TIA_GAIN, afe4404_res_table);
 236 static AFE440X_ATTR(in_intensity4_capacitance, TIA_CF, afe4404_cap_table);
 237
 238 static struct attribute *afe440x_attributes[] = {
 239         &dev_attr_in_intensity_resistance_available.attr,
 240         &dev_attr_in_intensity_capacitance_available.attr,
 241         &afe440x_attr_in_intensity1_resistance.dev_attr.attr,
 242         &afe440x_attr_in_intensity1_capacitance.dev_attr.attr,
 243         &afe440x_attr_in_intensity2_resistance.dev_attr.attr,
 244         &afe440x_attr_in_intensity2_capacitance.dev_attr.attr,
 245         &afe440x_attr_in_intensity3_resistance.dev_attr.attr,
 246         &afe440x_attr_in_intensity3_capacitance.dev_attr.attr,
 247         &afe440x_attr_in_intensity4_resistance.dev_attr.attr,
 248         &afe440x_attr_in_intensity4_capacitance.dev_attr.attr,
 249         NULL
 250 };
 251
 252 static const struct attribute_group afe440x_attribute_group = {
 253         .attrs = afe440x_attributes
 254 };
 255
 256 static int afe4404_read_raw(struct iio_dev *indio_dev,
 257                             struct iio_chan_spec const *chan,
 258                             int *val, int *val2, long mask)
 259 {
 260         struct afe4404_data *afe = iio_priv(indio_dev);
 261         unsigned int value_reg, led_field, offdac_field;
 262         int ret;
 263
 264         switch (chan->type) {
 265         case IIO_INTENSITY:
 266                 switch (mask) {
 267                 case IIO_CHAN_INFO_RAW:
 268                         value_reg = afe4404_channel_values[chan->address];
 269                         ret = regmap_read(afe->regmap, value_reg, val);
 270                         if (ret)
 271                                 return ret;
 272                         return IIO_VAL_INT;
 273                 case IIO_CHAN_INFO_OFFSET:
 274                         offdac_field = afe4404_channel_offdacs[chan->address];
 275                         ret = regmap_field_read(afe->fields[offdac_field], val);
 276                         if (ret)
 277                                 return ret;
 278                         return IIO_VAL_INT;
 279                 }
 280                 break;
 281         case IIO_CURRENT:
 282                 switch (mask) {
 283                 case IIO_CHAN_INFO_RAW:
 284                         led_field = afe4404_channel_leds[chan->address];
 285                         ret = regmap_field_read(afe->fields[led_field], val);
 286                         if (ret)
 287                                 return ret;
 288                         return IIO_VAL_INT;
 289                 case IIO_CHAN_INFO_SCALE:
 290                         *val = 0;
 291                         *val2 = 800000;
 292                         return IIO_VAL_INT_PLUS_MICRO;
 293                 }
 294                 break;
 295         default:
 296                 break;
 297         }
 298
 299         return -EINVAL;
 300 }
 301
 302 static int afe4404_write_raw(struct iio_dev *indio_dev,
 303                              struct iio_chan_spec const *chan,
 304                              int val, int val2, long mask)
 305 {
 306         struct afe4404_data *afe = iio_priv(indio_dev);
 307         unsigned int led_field, offdac_field;
 308
 309         switch (chan->type) {
 310         case IIO_INTENSITY:
 311                 switch (mask) {
 312                 case IIO_CHAN_INFO_OFFSET:
 313                         offdac_field = afe4404_channel_offdacs[chan->address];
 314                         return regmap_field_write(afe->fields[offdac_field], val);
 315                 }
 316                 break;
 317         case IIO_CURRENT:
 318                 switch (mask) {
 319                 case IIO_CHAN_INFO_RAW:
 320                         led_field = afe4404_channel_leds[chan->address];
 321                         return regmap_field_write(afe->fields[led_field], val);
 322                 }
 323                 break;
 324         default:
 325                 break;
 326         }
 327
 328         return -EINVAL;
 329 }
 330
 331 static const struct iio_info afe4404_iio_info = {
 332         .attrs = &afe440x_attribute_group,
 333         .read_raw = afe4404_read_raw,
 334         .write_raw = afe4404_write_raw,
 335         .driver_module = THIS_MODULE,
 336 };
 337
 338 static irqreturn_t afe4404_trigger_handler(int irq, void *private)
 339 {
 340         struct iio_poll_func *pf = private;
 341         struct iio_dev *indio_dev = pf->indio_dev;
 342         struct afe4404_data *afe = iio_priv(indio_dev);
 343         int ret, bit, i = 0;
 344
 345         for_each_set_bit(bit, indio_dev->active_scan_mask,
 346                          indio_dev->masklength) {
 347                 ret = regmap_read(afe->regmap, afe4404_channel_values[bit],
 348                                   &afe->buffer[i++]);
 349                 if (ret)
 350                         goto err;
 351         }
 352
 353         iio_push_to_buffers_with_timestamp(indio_dev, afe->buffer,
 354                                            pf->timestamp);
 355 err:
 356         iio_trigger_notify_done(indio_dev->trig);
 357
 358         return IRQ_HANDLED;
 359 }
 360
 361 static const struct iio_trigger_ops afe4404_trigger_ops = {
 362         .owner = THIS_MODULE,
 363 };
 364
 365 /* Default timings from data-sheet */
 366 #define AFE4404_TIMING_PAIRS                    \
 367         { AFE440X_PRPCOUNT,     39999   },      \
 368         { AFE440X_LED2LEDSTC,   0       },      \
 369         { AFE440X_LED2LEDENDC,  398     },      \
 370         { AFE440X_LED2STC,      80      },      \
 371         { AFE440X_LED2ENDC,     398     },      \
 372         { AFE440X_ADCRSTSTCT0,  5600    },      \
 373         { AFE440X_ADCRSTENDCT0, 5606    },      \
 374         { AFE440X_LED2CONVST,   5607    },      \
 375         { AFE440X_LED2CONVEND,  6066    },      \
 376         { AFE4404_LED3LEDSTC,   400     },      \
 377         { AFE4404_LED3LEDENDC,  798     },      \
 378         { AFE440X_ALED2STC,     480     },      \
 379         { AFE440X_ALED2ENDC,    798     },      \
 380         { AFE440X_ADCRSTSTCT1,  6068    },      \
 381         { AFE440X_ADCRSTENDCT1, 6074    },      \
 382         { AFE440X_ALED2CONVST,  6075    },      \
 383         { AFE440X_ALED2CONVEND, 6534    },      \
 384         { AFE440X_LED1LEDSTC,   800     },      \
 385         { AFE440X_LED1LEDENDC,  1198    },      \
 386         { AFE440X_LED1STC,      880     },      \
 387         { AFE440X_LED1ENDC,     1198    },      \
 388         { AFE440X_ADCRSTSTCT2,  6536    },      \
 389         { AFE440X_ADCRSTENDCT2, 6542    },      \
 390         { AFE440X_LED1CONVST,   6543    },      \
 391         { AFE440X_LED1CONVEND,  7003    },      \
 392         { AFE440X_ALED1STC,     1280    },      \
 393         { AFE440X_ALED1ENDC,    1598    },      \
 394         { AFE440X_ADCRSTSTCT3,  7005    },      \
 395         { AFE440X_ADCRSTENDCT3, 7011    },      \
 396         { AFE440X_ALED1CONVST,  7012    },      \
 397         { AFE440X_ALED1CONVEND, 7471    },      \
 398         { AFE440X_PDNCYCLESTC,  7671    },      \
 399         { AFE440X_PDNCYCLEENDC, 39199   }
 400
 401 static const struct reg_sequence afe4404_reg_sequences[] = {
 402         AFE4404_TIMING_PAIRS,
 403         { AFE440X_CONTROL1, AFE440X_CONTROL1_TIMEREN },
 404         { AFE4404_TIA_GAIN_SEP, AFE440X_TIAGAIN_ENSEPGAIN },
 405         { AFE440X_CONTROL2, AFE440X_CONTROL2_OSC_ENABLE },
 406 };
 407
 408 static const struct regmap_range afe4404_yes_ranges[] = {
 409         regmap_reg_range(AFE440X_LED2VAL, AFE440X_LED1_ALED1VAL),
 410         regmap_reg_range(AFE4404_AVG_LED2_ALED2VAL, AFE4404_AVG_LED1_ALED1VAL),
 411 };
 412
 413 static const struct regmap_access_table afe4404_volatile_table = {
 414         .yes_ranges = afe4404_yes_ranges,
 415         .n_yes_ranges = ARRAY_SIZE(afe4404_yes_ranges),
 416 };
 417
 418 static const struct regmap_config afe4404_regmap_config = {
 419         .reg_bits = 8,
 420         .val_bits = 24,
 421
 422         .max_register = AFE4404_AVG_LED1_ALED1VAL,
 423         .cache_type = REGCACHE_RBTREE,
 424         .volatile_table = &afe4404_volatile_table,
 425 };
 426
 427 static const struct of_device_id afe4404_of_match[] = {
 428         { .compatible = "ti,afe4404", },
 429         { /* sentinel */ }
 430 };
 431 MODULE_DEVICE_TABLE(of, afe4404_of_match);
 432
 433 static int __maybe_unused afe4404_suspend(struct device *dev)
 434 {
 435         struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
 436         struct afe4404_data *afe = iio_priv(indio_dev);
 437         int ret;
 438
 439         ret = regmap_update_bits(afe->regmap, AFE440X_CONTROL2,
 440                                  AFE440X_CONTROL2_PDN_AFE,
 441                                  AFE440X_CONTROL2_PDN_AFE);
 442         if (ret)
 443                 return ret;
 444
 445         ret = regulator_disable(afe->regulator);
 446         if (ret) {
 447                 dev_err(dev, "Unable to disable regulator\n");
 448                 return ret;
 449         }
 450
 451         return 0;
 452 }
 453
 454 static int __maybe_unused afe4404_resume(struct device *dev)
 455 {
 456         struct iio_dev *indio_dev = i2c_get_clientdata(to_i2c_client(dev));
 457         struct afe4404_data *afe = iio_priv(indio_dev);
 458         int ret;
 459
 460         ret = regulator_enable(afe->regulator);
 461         if (ret) {
 462                 dev_err(dev, "Unable to enable regulator\n");
 463                 return ret;
 464         }
 465
 466         ret = regmap_update_bits(afe->regmap, AFE440X_CONTROL2,
 467                                  AFE440X_CONTROL2_PDN_AFE, 0);
 468         if (ret)
 469                 return ret;
 470
 471         return 0;
 472 }
 473
 474 static SIMPLE_DEV_PM_OPS(afe4404_pm_ops, afe4404_suspend, afe4404_resume);
 475
 476 static int afe4404_probe(struct i2c_client *client,
 477                          const struct i2c_device_id *id)
 478 {
 479         struct iio_dev *indio_dev;
 480         struct afe4404_data *afe;
 481         int i, ret;
 482
 483         indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*afe));
 484         if (!indio_dev)
 485                 return -ENOMEM;
 486
 487         afe = iio_priv(indio_dev);
 488         i2c_set_clientdata(client, indio_dev);
 489
 490         afe->dev = &client->dev;
 491         afe->irq = client->irq;
 492
 493         afe->regmap = devm_regmap_init_i2c(client, &afe4404_regmap_config);
 494         if (IS_ERR(afe->regmap)) {
 495                 dev_err(afe->dev, "Unable to allocate register map\n");
 496                 return PTR_ERR(afe->regmap);
 497         }
 498
 499         for (i = 0; i < F_MAX_FIELDS; i++) {
 500                 afe->fields[i] = devm_regmap_field_alloc(afe->dev, afe->regmap,
 501                                                          afe4404_reg_fields[i]);
 502                 if (IS_ERR(afe->fields[i])) {
 503                         dev_err(afe->dev, "Unable to allocate regmap fields\n");
 504                         return PTR_ERR(afe->fields[i]);
 505                 }
 506         }
 507
 508         afe->regulator = devm_regulator_get(afe->dev, "tx_sup");
 509         if (IS_ERR(afe->regulator)) {
 510                 dev_err(afe->dev, "Unable to get regulator\n");
 511                 return PTR_ERR(afe->regulator);
 512         }
 513         ret = regulator_enable(afe->regulator);
 514         if (ret) {
 515                 dev_err(afe->dev, "Unable to enable regulator\n");
 516                 return ret;
 517         }
 518
 519         ret = regmap_write(afe->regmap, AFE440X_CONTROL0,
 520                            AFE440X_CONTROL0_SW_RESET);
 521         if (ret) {
 522                 dev_err(afe->dev, "Unable to reset device\n");
 523                 goto disable_reg;
 524         }
 525
 526         ret = regmap_multi_reg_write(afe->regmap, afe4404_reg_sequences,
 527                                      ARRAY_SIZE(afe4404_reg_sequences));
 528         if (ret) {
 529                 dev_err(afe->dev, "Unable to set register defaults\n");
 530                 goto disable_reg;
 531         }
 532
 533         indio_dev->modes = INDIO_DIRECT_MODE;
 534         indio_dev->dev.parent = afe->dev;
 535         indio_dev->channels = afe4404_channels;
 536         indio_dev->num_channels = ARRAY_SIZE(afe4404_channels);
 537         indio_dev->name = AFE4404_DRIVER_NAME;
 538         indio_dev->info = &afe4404_iio_info;
 539
 540         if (afe->irq > 0) {
 541                 afe->trig = devm_iio_trigger_alloc(afe->dev,
 542                                                    "%s-dev%d",
 543                                                    indio_dev->name,
 544                                                    indio_dev->id);
 545                 if (!afe->trig) {
 546                         dev_err(afe->dev, "Unable to allocate IIO trigger\n");
 547                         ret = -ENOMEM;
 548                         goto disable_reg;
 549                 }
 550
 551                 iio_trigger_set_drvdata(afe->trig, indio_dev);
 552
 553                 afe->trig->ops = &afe4404_trigger_ops;
 554                 afe->trig->dev.parent = afe->dev;
 555
 556                 ret = iio_trigger_register(afe->trig);
 557                 if (ret) {
 558                         dev_err(afe->dev, "Unable to register IIO trigger\n");
 559                         goto disable_reg;
 560                 }
 561
 562                 ret = devm_request_threaded_irq(afe->dev, afe->irq,
 563                                                 iio_trigger_generic_data_rdy_poll,
 564                                                 NULL, IRQF_ONESHOT,
 565                                                 AFE4404_DRIVER_NAME,
 566                                                 afe->trig);
 567                 if (ret) {
 568                         dev_err(afe->dev, "Unable to request IRQ\n");
 569                         goto disable_reg;
 570                 }
 571         }
 572
 573         ret = iio_triggered_buffer_setup(indio_dev, &iio_pollfunc_store_time,
 574                                          afe4404_trigger_handler, NULL);
 575         if (ret) {
 576                 dev_err(afe->dev, "Unable to setup buffer\n");
 577                 goto unregister_trigger;
 578         }
 579
 580         ret = iio_device_register(indio_dev);
 581         if (ret) {
 582                 dev_err(afe->dev, "Unable to register IIO device\n");
 583                 goto unregister_triggered_buffer;
 584         }
 585
 586         return 0;
 587
 588 unregister_triggered_buffer:
 589         iio_triggered_buffer_cleanup(indio_dev);
 590 unregister_trigger:
 591         if (afe->irq > 0)
 592                 iio_trigger_unregister(afe->trig);
 593 disable_reg:
 594         regulator_disable(afe->regulator);
 595
 596         return ret;
 597 }
 598
 599 static int afe4404_remove(struct i2c_client *client)
 600 {
 601         struct iio_dev *indio_dev = i2c_get_clientdata(client);
 602         struct afe4404_data *afe = iio_priv(indio_dev);
 603         int ret;
 604
 605         iio_device_unregister(indio_dev);
 606
 607         iio_triggered_buffer_cleanup(indio_dev);
 608
 609         if (afe->irq > 0)
 610                 iio_trigger_unregister(afe->trig);
 611
 612         ret = regulator_disable(afe->regulator);
 613         if (ret) {
 614                 dev_err(afe->dev, "Unable to disable regulator\n");
 615                 return ret;
 616         }
 617
 618         return 0;
 619 }
 620
 621 static const struct i2c_device_id afe4404_ids[] = {
 622         { "afe4404", 0 },
 623         { /* sentinel */ }
 624 };
 625 MODULE_DEVICE_TABLE(i2c, afe4404_ids);
 626
 627 static struct i2c_driver afe4404_i2c_driver = {
 628         .driver = {
 629                 .name = AFE4404_DRIVER_NAME,
 630                 .of_match_table = afe4404_of_match,
 631                 .pm = &afe4404_pm_ops,
 632         },
 633         .probe = afe4404_probe,
 634         .remove = afe4404_remove,
 635         .id_table = afe4404_ids,
 636 };
 637 module_i2c_driver(afe4404_i2c_driver);
 638
 639 MODULE_AUTHOR("Andrew F. Davis <afd@ti.com>");
 640 MODULE_DESCRIPTION("TI AFE4404 Heart Rate Monitor and Pulse Oximeter AFE");
 641 MODULE_LICENSE("GPL v2");