0001
0002
0003
0004
0005
0006
0007
0008
0009 #include <linux/module.h>
0010 #include <linux/init.h>
0011 #include <linux/interrupt.h>
0012 #include <linux/delay.h>
0013 #include <linux/mutex.h>
0014 #include <linux/err.h>
0015 #include <linux/irq.h>
0016 #include <linux/irq_work.h>
0017 #include <linux/i2c.h>
0018 #include <linux/mod_devicetable.h>
0019 #include <linux/regmap.h>
0020 #include <linux/iio/iio.h>
0021 #include <linux/iio/buffer.h>
0022 #include <linux/iio/trigger.h>
0023 #include <linux/iio/trigger_consumer.h>
0024 #include <linux/iio/triggered_buffer.h>
0025 #include <linux/pm_runtime.h>
0026
0027 #define ATLAS_REGMAP_NAME "atlas_regmap"
0028 #define ATLAS_DRV_NAME "atlas"
0029
0030 #define ATLAS_REG_DEV_TYPE 0x00
0031 #define ATLAS_REG_DEV_VERSION 0x01
0032
0033 #define ATLAS_REG_INT_CONTROL 0x04
0034 #define ATLAS_REG_INT_CONTROL_EN BIT(3)
0035
0036 #define ATLAS_REG_PWR_CONTROL 0x06
0037
0038 #define ATLAS_REG_PH_CALIB_STATUS 0x0d
0039 #define ATLAS_REG_PH_CALIB_STATUS_MASK 0x07
0040 #define ATLAS_REG_PH_CALIB_STATUS_LOW BIT(0)
0041 #define ATLAS_REG_PH_CALIB_STATUS_MID BIT(1)
0042 #define ATLAS_REG_PH_CALIB_STATUS_HIGH BIT(2)
0043
0044 #define ATLAS_REG_EC_CALIB_STATUS 0x0f
0045 #define ATLAS_REG_EC_CALIB_STATUS_MASK 0x0f
0046 #define ATLAS_REG_EC_CALIB_STATUS_DRY BIT(0)
0047 #define ATLAS_REG_EC_CALIB_STATUS_SINGLE BIT(1)
0048 #define ATLAS_REG_EC_CALIB_STATUS_LOW BIT(2)
0049 #define ATLAS_REG_EC_CALIB_STATUS_HIGH BIT(3)
0050
0051 #define ATLAS_REG_DO_CALIB_STATUS 0x09
0052 #define ATLAS_REG_DO_CALIB_STATUS_MASK 0x03
0053 #define ATLAS_REG_DO_CALIB_STATUS_PRESSURE BIT(0)
0054 #define ATLAS_REG_DO_CALIB_STATUS_DO BIT(1)
0055
0056 #define ATLAS_REG_RTD_DATA 0x0e
0057
0058 #define ATLAS_REG_PH_TEMP_DATA 0x0e
0059 #define ATLAS_REG_PH_DATA 0x16
0060
0061 #define ATLAS_REG_EC_PROBE 0x08
0062 #define ATLAS_REG_EC_TEMP_DATA 0x10
0063 #define ATLAS_REG_EC_DATA 0x18
0064 #define ATLAS_REG_TDS_DATA 0x1c
0065 #define ATLAS_REG_PSS_DATA 0x20
0066
0067 #define ATLAS_REG_ORP_CALIB_STATUS 0x0d
0068 #define ATLAS_REG_ORP_DATA 0x0e
0069
0070 #define ATLAS_REG_DO_TEMP_DATA 0x12
0071 #define ATLAS_REG_DO_DATA 0x22
0072
0073 #define ATLAS_PH_INT_TIME_IN_MS 450
0074 #define ATLAS_EC_INT_TIME_IN_MS 650
0075 #define ATLAS_ORP_INT_TIME_IN_MS 450
0076 #define ATLAS_DO_INT_TIME_IN_MS 450
0077 #define ATLAS_RTD_INT_TIME_IN_MS 450
0078
0079 enum {
0080 ATLAS_PH_SM,
0081 ATLAS_EC_SM,
0082 ATLAS_ORP_SM,
0083 ATLAS_DO_SM,
0084 ATLAS_RTD_SM,
0085 };
0086
0087 struct atlas_data {
0088 struct i2c_client *client;
0089 struct iio_trigger *trig;
0090 struct atlas_device *chip;
0091 struct regmap *regmap;
0092 struct irq_work work;
0093 unsigned int interrupt_enabled;
0094
0095 __be32 buffer[6] __aligned(8);
0096 };
0097
0098 static const struct regmap_config atlas_regmap_config = {
0099 .name = ATLAS_REGMAP_NAME,
0100 .reg_bits = 8,
0101 .val_bits = 8,
0102 };
0103
0104 static int atlas_buffer_num_channels(const struct iio_chan_spec *spec)
0105 {
0106 int idx = 0;
0107
0108 for (; spec->type != IIO_TIMESTAMP; spec++)
0109 idx++;
0110
0111 return idx;
0112 };
0113
0114 static const struct iio_chan_spec atlas_ph_channels[] = {
0115 {
0116 .type = IIO_PH,
0117 .address = ATLAS_REG_PH_DATA,
0118 .info_mask_separate =
0119 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
0120 .scan_index = 0,
0121 .scan_type = {
0122 .sign = 'u',
0123 .realbits = 32,
0124 .storagebits = 32,
0125 .endianness = IIO_BE,
0126 },
0127 },
0128 IIO_CHAN_SOFT_TIMESTAMP(1),
0129 {
0130 .type = IIO_TEMP,
0131 .address = ATLAS_REG_PH_TEMP_DATA,
0132 .info_mask_separate =
0133 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
0134 .output = 1,
0135 .scan_index = -1
0136 },
0137 };
0138
0139 #define ATLAS_CONCENTRATION_CHANNEL(_idx, _addr) \
0140 {\
0141 .type = IIO_CONCENTRATION, \
0142 .indexed = 1, \
0143 .channel = _idx, \
0144 .address = _addr, \
0145 .info_mask_separate = \
0146 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE), \
0147 .scan_index = _idx + 1, \
0148 .scan_type = { \
0149 .sign = 'u', \
0150 .realbits = 32, \
0151 .storagebits = 32, \
0152 .endianness = IIO_BE, \
0153 }, \
0154 }
0155
0156 static const struct iio_chan_spec atlas_ec_channels[] = {
0157 {
0158 .type = IIO_ELECTRICALCONDUCTIVITY,
0159 .address = ATLAS_REG_EC_DATA,
0160 .info_mask_separate =
0161 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
0162 .scan_index = 0,
0163 .scan_type = {
0164 .sign = 'u',
0165 .realbits = 32,
0166 .storagebits = 32,
0167 .endianness = IIO_BE,
0168 },
0169 },
0170 ATLAS_CONCENTRATION_CHANNEL(0, ATLAS_REG_TDS_DATA),
0171 ATLAS_CONCENTRATION_CHANNEL(1, ATLAS_REG_PSS_DATA),
0172 IIO_CHAN_SOFT_TIMESTAMP(3),
0173 {
0174 .type = IIO_TEMP,
0175 .address = ATLAS_REG_EC_TEMP_DATA,
0176 .info_mask_separate =
0177 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
0178 .output = 1,
0179 .scan_index = -1
0180 },
0181 };
0182
0183 static const struct iio_chan_spec atlas_orp_channels[] = {
0184 {
0185 .type = IIO_VOLTAGE,
0186 .address = ATLAS_REG_ORP_DATA,
0187 .info_mask_separate =
0188 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
0189 .scan_index = 0,
0190 .scan_type = {
0191 .sign = 's',
0192 .realbits = 32,
0193 .storagebits = 32,
0194 .endianness = IIO_BE,
0195 },
0196 },
0197 IIO_CHAN_SOFT_TIMESTAMP(1),
0198 };
0199
0200 static const struct iio_chan_spec atlas_do_channels[] = {
0201 {
0202 .type = IIO_CONCENTRATION,
0203 .address = ATLAS_REG_DO_DATA,
0204 .info_mask_separate =
0205 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
0206 .scan_index = 0,
0207 .scan_type = {
0208 .sign = 'u',
0209 .realbits = 32,
0210 .storagebits = 32,
0211 .endianness = IIO_BE,
0212 },
0213 },
0214 IIO_CHAN_SOFT_TIMESTAMP(1),
0215 {
0216 .type = IIO_TEMP,
0217 .address = ATLAS_REG_DO_TEMP_DATA,
0218 .info_mask_separate =
0219 BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
0220 .output = 1,
0221 .scan_index = -1
0222 },
0223 };
0224
0225 static const struct iio_chan_spec atlas_rtd_channels[] = {
0226 {
0227 .type = IIO_TEMP,
0228 .address = ATLAS_REG_RTD_DATA,
0229 .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
0230 .scan_index = 0,
0231 .scan_type = {
0232 .sign = 's',
0233 .realbits = 32,
0234 .storagebits = 32,
0235 .endianness = IIO_BE,
0236 },
0237 },
0238 IIO_CHAN_SOFT_TIMESTAMP(1),
0239 };
0240
0241 static int atlas_check_ph_calibration(struct atlas_data *data)
0242 {
0243 struct device *dev = &data->client->dev;
0244 int ret;
0245 unsigned int val;
0246
0247 ret = regmap_read(data->regmap, ATLAS_REG_PH_CALIB_STATUS, &val);
0248 if (ret)
0249 return ret;
0250
0251 if (!(val & ATLAS_REG_PH_CALIB_STATUS_MASK)) {
0252 dev_warn(dev, "device has not been calibrated\n");
0253 return 0;
0254 }
0255
0256 if (!(val & ATLAS_REG_PH_CALIB_STATUS_LOW))
0257 dev_warn(dev, "device missing low point calibration\n");
0258
0259 if (!(val & ATLAS_REG_PH_CALIB_STATUS_MID))
0260 dev_warn(dev, "device missing mid point calibration\n");
0261
0262 if (!(val & ATLAS_REG_PH_CALIB_STATUS_HIGH))
0263 dev_warn(dev, "device missing high point calibration\n");
0264
0265 return 0;
0266 }
0267
0268 static int atlas_check_ec_calibration(struct atlas_data *data)
0269 {
0270 struct device *dev = &data->client->dev;
0271 int ret;
0272 unsigned int val;
0273 __be16 rval;
0274
0275 ret = regmap_bulk_read(data->regmap, ATLAS_REG_EC_PROBE, &rval, 2);
0276 if (ret)
0277 return ret;
0278
0279 val = be16_to_cpu(rval);
0280 dev_info(dev, "probe set to K = %d.%.2d", val / 100, val % 100);
0281
0282 ret = regmap_read(data->regmap, ATLAS_REG_EC_CALIB_STATUS, &val);
0283 if (ret)
0284 return ret;
0285
0286 if (!(val & ATLAS_REG_EC_CALIB_STATUS_MASK)) {
0287 dev_warn(dev, "device has not been calibrated\n");
0288 return 0;
0289 }
0290
0291 if (!(val & ATLAS_REG_EC_CALIB_STATUS_DRY))
0292 dev_warn(dev, "device missing dry point calibration\n");
0293
0294 if (val & ATLAS_REG_EC_CALIB_STATUS_SINGLE) {
0295 dev_warn(dev, "device using single point calibration\n");
0296 } else {
0297 if (!(val & ATLAS_REG_EC_CALIB_STATUS_LOW))
0298 dev_warn(dev, "device missing low point calibration\n");
0299
0300 if (!(val & ATLAS_REG_EC_CALIB_STATUS_HIGH))
0301 dev_warn(dev, "device missing high point calibration\n");
0302 }
0303
0304 return 0;
0305 }
0306
0307 static int atlas_check_orp_calibration(struct atlas_data *data)
0308 {
0309 struct device *dev = &data->client->dev;
0310 int ret;
0311 unsigned int val;
0312
0313 ret = regmap_read(data->regmap, ATLAS_REG_ORP_CALIB_STATUS, &val);
0314 if (ret)
0315 return ret;
0316
0317 if (!val)
0318 dev_warn(dev, "device has not been calibrated\n");
0319
0320 return 0;
0321 }
0322
0323 static int atlas_check_do_calibration(struct atlas_data *data)
0324 {
0325 struct device *dev = &data->client->dev;
0326 int ret;
0327 unsigned int val;
0328
0329 ret = regmap_read(data->regmap, ATLAS_REG_DO_CALIB_STATUS, &val);
0330 if (ret)
0331 return ret;
0332
0333 if (!(val & ATLAS_REG_DO_CALIB_STATUS_MASK)) {
0334 dev_warn(dev, "device has not been calibrated\n");
0335 return 0;
0336 }
0337
0338 if (!(val & ATLAS_REG_DO_CALIB_STATUS_PRESSURE))
0339 dev_warn(dev, "device missing atmospheric pressure calibration\n");
0340
0341 if (!(val & ATLAS_REG_DO_CALIB_STATUS_DO))
0342 dev_warn(dev, "device missing dissolved oxygen calibration\n");
0343
0344 return 0;
0345 }
0346
0347 struct atlas_device {
0348 const struct iio_chan_spec *channels;
0349 int num_channels;
0350 int data_reg;
0351
0352 int (*calibration)(struct atlas_data *data);
0353 int delay;
0354 };
0355
0356 static struct atlas_device atlas_devices[] = {
0357 [ATLAS_PH_SM] = {
0358 .channels = atlas_ph_channels,
0359 .num_channels = 3,
0360 .data_reg = ATLAS_REG_PH_DATA,
0361 .calibration = &atlas_check_ph_calibration,
0362 .delay = ATLAS_PH_INT_TIME_IN_MS,
0363 },
0364 [ATLAS_EC_SM] = {
0365 .channels = atlas_ec_channels,
0366 .num_channels = 5,
0367 .data_reg = ATLAS_REG_EC_DATA,
0368 .calibration = &atlas_check_ec_calibration,
0369 .delay = ATLAS_EC_INT_TIME_IN_MS,
0370 },
0371 [ATLAS_ORP_SM] = {
0372 .channels = atlas_orp_channels,
0373 .num_channels = 2,
0374 .data_reg = ATLAS_REG_ORP_DATA,
0375 .calibration = &atlas_check_orp_calibration,
0376 .delay = ATLAS_ORP_INT_TIME_IN_MS,
0377 },
0378 [ATLAS_DO_SM] = {
0379 .channels = atlas_do_channels,
0380 .num_channels = 3,
0381 .data_reg = ATLAS_REG_DO_DATA,
0382 .calibration = &atlas_check_do_calibration,
0383 .delay = ATLAS_DO_INT_TIME_IN_MS,
0384 },
0385 [ATLAS_RTD_SM] = {
0386 .channels = atlas_rtd_channels,
0387 .num_channels = 2,
0388 .data_reg = ATLAS_REG_RTD_DATA,
0389 .delay = ATLAS_RTD_INT_TIME_IN_MS,
0390 },
0391 };
0392
0393 static int atlas_set_powermode(struct atlas_data *data, int on)
0394 {
0395 return regmap_write(data->regmap, ATLAS_REG_PWR_CONTROL, on);
0396 }
0397
0398 static int atlas_set_interrupt(struct atlas_data *data, bool state)
0399 {
0400 if (!data->interrupt_enabled)
0401 return 0;
0402
0403 return regmap_update_bits(data->regmap, ATLAS_REG_INT_CONTROL,
0404 ATLAS_REG_INT_CONTROL_EN,
0405 state ? ATLAS_REG_INT_CONTROL_EN : 0);
0406 }
0407
0408 static int atlas_buffer_postenable(struct iio_dev *indio_dev)
0409 {
0410 struct atlas_data *data = iio_priv(indio_dev);
0411 int ret;
0412
0413 ret = pm_runtime_resume_and_get(&data->client->dev);
0414 if (ret)
0415 return ret;
0416
0417 return atlas_set_interrupt(data, true);
0418 }
0419
0420 static int atlas_buffer_predisable(struct iio_dev *indio_dev)
0421 {
0422 struct atlas_data *data = iio_priv(indio_dev);
0423 int ret;
0424
0425 ret = atlas_set_interrupt(data, false);
0426 if (ret)
0427 return ret;
0428
0429 pm_runtime_mark_last_busy(&data->client->dev);
0430 ret = pm_runtime_put_autosuspend(&data->client->dev);
0431 if (ret)
0432 return ret;
0433
0434 return 0;
0435 }
0436
0437 static const struct iio_buffer_setup_ops atlas_buffer_setup_ops = {
0438 .postenable = atlas_buffer_postenable,
0439 .predisable = atlas_buffer_predisable,
0440 };
0441
0442 static void atlas_work_handler(struct irq_work *work)
0443 {
0444 struct atlas_data *data = container_of(work, struct atlas_data, work);
0445
0446 iio_trigger_poll(data->trig);
0447 }
0448
0449 static irqreturn_t atlas_trigger_handler(int irq, void *private)
0450 {
0451 struct iio_poll_func *pf = private;
0452 struct iio_dev *indio_dev = pf->indio_dev;
0453 struct atlas_data *data = iio_priv(indio_dev);
0454 int channels = atlas_buffer_num_channels(data->chip->channels);
0455 int ret;
0456
0457 ret = regmap_bulk_read(data->regmap, data->chip->data_reg,
0458 &data->buffer, sizeof(__be32) * channels);
0459
0460 if (!ret)
0461 iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,
0462 iio_get_time_ns(indio_dev));
0463
0464 iio_trigger_notify_done(indio_dev->trig);
0465
0466 return IRQ_HANDLED;
0467 }
0468
0469 static irqreturn_t atlas_interrupt_handler(int irq, void *private)
0470 {
0471 struct iio_dev *indio_dev = private;
0472 struct atlas_data *data = iio_priv(indio_dev);
0473
0474 irq_work_queue(&data->work);
0475
0476 return IRQ_HANDLED;
0477 }
0478
0479 static int atlas_read_measurement(struct atlas_data *data, int reg, __be32 *val)
0480 {
0481 struct device *dev = &data->client->dev;
0482 int suspended = pm_runtime_suspended(dev);
0483 int ret;
0484
0485 ret = pm_runtime_resume_and_get(dev);
0486 if (ret)
0487 return ret;
0488
0489 if (suspended)
0490 msleep(data->chip->delay);
0491
0492 ret = regmap_bulk_read(data->regmap, reg, val, sizeof(*val));
0493
0494 pm_runtime_mark_last_busy(dev);
0495 pm_runtime_put_autosuspend(dev);
0496
0497 return ret;
0498 }
0499
0500 static int atlas_read_raw(struct iio_dev *indio_dev,
0501 struct iio_chan_spec const *chan,
0502 int *val, int *val2, long mask)
0503 {
0504 struct atlas_data *data = iio_priv(indio_dev);
0505
0506 switch (mask) {
0507 case IIO_CHAN_INFO_PROCESSED:
0508 case IIO_CHAN_INFO_RAW: {
0509 int ret;
0510 __be32 reg;
0511
0512 switch (chan->type) {
0513 case IIO_TEMP:
0514 ret = regmap_bulk_read(data->regmap, chan->address,
0515 ®, sizeof(reg));
0516 break;
0517 case IIO_PH:
0518 case IIO_CONCENTRATION:
0519 case IIO_ELECTRICALCONDUCTIVITY:
0520 case IIO_VOLTAGE:
0521 ret = iio_device_claim_direct_mode(indio_dev);
0522 if (ret)
0523 return ret;
0524
0525 ret = atlas_read_measurement(data, chan->address, ®);
0526
0527 iio_device_release_direct_mode(indio_dev);
0528 break;
0529 default:
0530 ret = -EINVAL;
0531 }
0532
0533 if (!ret) {
0534 *val = be32_to_cpu(reg);
0535 ret = IIO_VAL_INT;
0536 }
0537 return ret;
0538 }
0539 case IIO_CHAN_INFO_SCALE:
0540 switch (chan->type) {
0541 case IIO_TEMP:
0542 *val = 10;
0543 return IIO_VAL_INT;
0544 case IIO_PH:
0545 *val = 1;
0546 *val2 = 1000;
0547 break;
0548 case IIO_ELECTRICALCONDUCTIVITY:
0549 *val = 1;
0550 *val2 = 100000;
0551 break;
0552 case IIO_CONCENTRATION:
0553 *val = 0;
0554 *val2 = 1000;
0555 return IIO_VAL_INT_PLUS_NANO;
0556 case IIO_VOLTAGE:
0557 *val = 1;
0558 *val2 = 10;
0559 break;
0560 default:
0561 return -EINVAL;
0562 }
0563 return IIO_VAL_FRACTIONAL;
0564 }
0565
0566 return -EINVAL;
0567 }
0568
0569 static int atlas_write_raw(struct iio_dev *indio_dev,
0570 struct iio_chan_spec const *chan,
0571 int val, int val2, long mask)
0572 {
0573 struct atlas_data *data = iio_priv(indio_dev);
0574 __be32 reg = cpu_to_be32(val / 10);
0575
0576 if (val2 != 0 || val < 0 || val > 20000)
0577 return -EINVAL;
0578
0579 if (mask != IIO_CHAN_INFO_RAW || chan->type != IIO_TEMP)
0580 return -EINVAL;
0581
0582 return regmap_bulk_write(data->regmap, chan->address,
0583 ®, sizeof(reg));
0584 }
0585
0586 static const struct iio_info atlas_info = {
0587 .read_raw = atlas_read_raw,
0588 .write_raw = atlas_write_raw,
0589 };
0590
0591 static const struct i2c_device_id atlas_id[] = {
0592 { "atlas-ph-sm", ATLAS_PH_SM },
0593 { "atlas-ec-sm", ATLAS_EC_SM },
0594 { "atlas-orp-sm", ATLAS_ORP_SM },
0595 { "atlas-do-sm", ATLAS_DO_SM },
0596 { "atlas-rtd-sm", ATLAS_RTD_SM },
0597 {}
0598 };
0599 MODULE_DEVICE_TABLE(i2c, atlas_id);
0600
0601 static const struct of_device_id atlas_dt_ids[] = {
0602 { .compatible = "atlas,ph-sm", .data = (void *)ATLAS_PH_SM, },
0603 { .compatible = "atlas,ec-sm", .data = (void *)ATLAS_EC_SM, },
0604 { .compatible = "atlas,orp-sm", .data = (void *)ATLAS_ORP_SM, },
0605 { .compatible = "atlas,do-sm", .data = (void *)ATLAS_DO_SM, },
0606 { .compatible = "atlas,rtd-sm", .data = (void *)ATLAS_RTD_SM, },
0607 { }
0608 };
0609 MODULE_DEVICE_TABLE(of, atlas_dt_ids);
0610
0611 static int atlas_probe(struct i2c_client *client,
0612 const struct i2c_device_id *id)
0613 {
0614 struct atlas_data *data;
0615 struct atlas_device *chip;
0616 struct iio_trigger *trig;
0617 struct iio_dev *indio_dev;
0618 int ret;
0619
0620 indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
0621 if (!indio_dev)
0622 return -ENOMEM;
0623
0624 if (!dev_fwnode(&client->dev))
0625 chip = &atlas_devices[id->driver_data];
0626 else
0627 chip = &atlas_devices[(unsigned long)device_get_match_data(&client->dev)];
0628
0629 indio_dev->info = &atlas_info;
0630 indio_dev->name = ATLAS_DRV_NAME;
0631 indio_dev->channels = chip->channels;
0632 indio_dev->num_channels = chip->num_channels;
0633 indio_dev->modes = INDIO_BUFFER_SOFTWARE | INDIO_DIRECT_MODE;
0634
0635 trig = devm_iio_trigger_alloc(&client->dev, "%s-dev%d",
0636 indio_dev->name, iio_device_id(indio_dev));
0637
0638 if (!trig)
0639 return -ENOMEM;
0640
0641 data = iio_priv(indio_dev);
0642 data->client = client;
0643 data->trig = trig;
0644 data->chip = chip;
0645 iio_trigger_set_drvdata(trig, indio_dev);
0646
0647 i2c_set_clientdata(client, indio_dev);
0648
0649 data->regmap = devm_regmap_init_i2c(client, &atlas_regmap_config);
0650 if (IS_ERR(data->regmap)) {
0651 dev_err(&client->dev, "regmap initialization failed\n");
0652 return PTR_ERR(data->regmap);
0653 }
0654
0655 ret = pm_runtime_set_active(&client->dev);
0656 if (ret)
0657 return ret;
0658
0659 ret = chip->calibration(data);
0660 if (ret)
0661 return ret;
0662
0663 ret = iio_trigger_register(trig);
0664 if (ret) {
0665 dev_err(&client->dev, "failed to register trigger\n");
0666 return ret;
0667 }
0668
0669 ret = iio_triggered_buffer_setup(indio_dev, &iio_pollfunc_store_time,
0670 &atlas_trigger_handler, &atlas_buffer_setup_ops);
0671 if (ret) {
0672 dev_err(&client->dev, "cannot setup iio trigger\n");
0673 goto unregister_trigger;
0674 }
0675
0676 init_irq_work(&data->work, atlas_work_handler);
0677
0678 if (client->irq > 0) {
0679
0680 ret = devm_request_threaded_irq(&client->dev, client->irq,
0681 NULL, atlas_interrupt_handler,
0682 IRQF_TRIGGER_RISING |
0683 IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
0684 "atlas_irq",
0685 indio_dev);
0686
0687 if (ret)
0688 dev_warn(&client->dev,
0689 "request irq (%d) failed\n", client->irq);
0690 else
0691 data->interrupt_enabled = 1;
0692 }
0693
0694 ret = atlas_set_powermode(data, 1);
0695 if (ret) {
0696 dev_err(&client->dev, "cannot power device on");
0697 goto unregister_buffer;
0698 }
0699
0700 pm_runtime_enable(&client->dev);
0701 pm_runtime_set_autosuspend_delay(&client->dev, 2500);
0702 pm_runtime_use_autosuspend(&client->dev);
0703
0704 ret = iio_device_register(indio_dev);
0705 if (ret) {
0706 dev_err(&client->dev, "unable to register device\n");
0707 goto unregister_pm;
0708 }
0709
0710 return 0;
0711
0712 unregister_pm:
0713 pm_runtime_disable(&client->dev);
0714 atlas_set_powermode(data, 0);
0715
0716 unregister_buffer:
0717 iio_triggered_buffer_cleanup(indio_dev);
0718
0719 unregister_trigger:
0720 iio_trigger_unregister(data->trig);
0721
0722 return ret;
0723 }
0724
0725 static int atlas_remove(struct i2c_client *client)
0726 {
0727 struct iio_dev *indio_dev = i2c_get_clientdata(client);
0728 struct atlas_data *data = iio_priv(indio_dev);
0729 int ret;
0730
0731 iio_device_unregister(indio_dev);
0732 iio_triggered_buffer_cleanup(indio_dev);
0733 iio_trigger_unregister(data->trig);
0734
0735 pm_runtime_disable(&client->dev);
0736 pm_runtime_set_suspended(&client->dev);
0737
0738 ret = atlas_set_powermode(data, 0);
0739 if (ret)
0740 dev_err(&client->dev, "Failed to power down device (%pe)\n",
0741 ERR_PTR(ret));
0742
0743 return 0;
0744 }
0745
0746 static int atlas_runtime_suspend(struct device *dev)
0747 {
0748 struct atlas_data *data =
0749 iio_priv(i2c_get_clientdata(to_i2c_client(dev)));
0750
0751 return atlas_set_powermode(data, 0);
0752 }
0753
0754 static int atlas_runtime_resume(struct device *dev)
0755 {
0756 struct atlas_data *data =
0757 iio_priv(i2c_get_clientdata(to_i2c_client(dev)));
0758
0759 return atlas_set_powermode(data, 1);
0760 }
0761
0762 static const struct dev_pm_ops atlas_pm_ops = {
0763 RUNTIME_PM_OPS(atlas_runtime_suspend, atlas_runtime_resume, NULL)
0764 };
0765
0766 static struct i2c_driver atlas_driver = {
0767 .driver = {
0768 .name = ATLAS_DRV_NAME,
0769 .of_match_table = atlas_dt_ids,
0770 .pm = pm_ptr(&atlas_pm_ops),
0771 },
0772 .probe = atlas_probe,
0773 .remove = atlas_remove,
0774 .id_table = atlas_id,
0775 };
0776 module_i2c_driver(atlas_driver);
0777
0778 MODULE_AUTHOR("Matt Ranostay <matt.ranostay@konsulko.com>");
0779 MODULE_DESCRIPTION("Atlas Scientific SM sensors");
0780 MODULE_LICENSE("GPL");
