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