atlas-sensor.c 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * atlas-sensor.c - Support for Atlas Scientific OEM SM sensors
  4. *
  5. * Copyright (C) 2015-2019 Konsulko Group
  6. * Author: Matt Ranostay <matt.ranostay@konsulko.com>
  7. */
  8. #include <linux/module.h>
  9. #include <linux/init.h>
  10. #include <linux/interrupt.h>
  11. #include <linux/delay.h>
  12. #include <linux/mutex.h>
  13. #include <linux/err.h>
  14. #include <linux/irq.h>
  15. #include <linux/irq_work.h>
  16. #include <linux/i2c.h>
  17. #include <linux/mod_devicetable.h>
  18. #include <linux/regmap.h>
  19. #include <linux/iio/iio.h>
  20. #include <linux/iio/buffer.h>
  21. #include <linux/iio/trigger.h>
  22. #include <linux/iio/trigger_consumer.h>
  23. #include <linux/iio/triggered_buffer.h>
  24. #include <linux/pm_runtime.h>
  25. #define ATLAS_REGMAP_NAME "atlas_regmap"
  26. #define ATLAS_DRV_NAME "atlas"
  27. #define ATLAS_REG_DEV_TYPE 0x00
  28. #define ATLAS_REG_DEV_VERSION 0x01
  29. #define ATLAS_REG_INT_CONTROL 0x04
  30. #define ATLAS_REG_INT_CONTROL_EN BIT(3)
  31. #define ATLAS_REG_PWR_CONTROL 0x06
  32. #define ATLAS_REG_PH_CALIB_STATUS 0x0d
  33. #define ATLAS_REG_PH_CALIB_STATUS_MASK 0x07
  34. #define ATLAS_REG_PH_CALIB_STATUS_LOW BIT(0)
  35. #define ATLAS_REG_PH_CALIB_STATUS_MID BIT(1)
  36. #define ATLAS_REG_PH_CALIB_STATUS_HIGH BIT(2)
  37. #define ATLAS_REG_EC_CALIB_STATUS 0x0f
  38. #define ATLAS_REG_EC_CALIB_STATUS_MASK 0x0f
  39. #define ATLAS_REG_EC_CALIB_STATUS_DRY BIT(0)
  40. #define ATLAS_REG_EC_CALIB_STATUS_SINGLE BIT(1)
  41. #define ATLAS_REG_EC_CALIB_STATUS_LOW BIT(2)
  42. #define ATLAS_REG_EC_CALIB_STATUS_HIGH BIT(3)
  43. #define ATLAS_REG_DO_CALIB_STATUS 0x09
  44. #define ATLAS_REG_DO_CALIB_STATUS_MASK 0x03
  45. #define ATLAS_REG_DO_CALIB_STATUS_PRESSURE BIT(0)
  46. #define ATLAS_REG_DO_CALIB_STATUS_DO BIT(1)
  47. #define ATLAS_REG_RTD_DATA 0x0e
  48. #define ATLAS_REG_PH_TEMP_DATA 0x0e
  49. #define ATLAS_REG_PH_DATA 0x16
  50. #define ATLAS_REG_EC_PROBE 0x08
  51. #define ATLAS_REG_EC_TEMP_DATA 0x10
  52. #define ATLAS_REG_EC_DATA 0x18
  53. #define ATLAS_REG_TDS_DATA 0x1c
  54. #define ATLAS_REG_PSS_DATA 0x20
  55. #define ATLAS_REG_ORP_CALIB_STATUS 0x0d
  56. #define ATLAS_REG_ORP_DATA 0x0e
  57. #define ATLAS_REG_DO_TEMP_DATA 0x12
  58. #define ATLAS_REG_DO_DATA 0x22
  59. #define ATLAS_PH_INT_TIME_IN_MS 450
  60. #define ATLAS_EC_INT_TIME_IN_MS 650
  61. #define ATLAS_ORP_INT_TIME_IN_MS 450
  62. #define ATLAS_DO_INT_TIME_IN_MS 450
  63. #define ATLAS_RTD_INT_TIME_IN_MS 450
  64. enum {
  65. ATLAS_PH_SM,
  66. ATLAS_EC_SM,
  67. ATLAS_ORP_SM,
  68. ATLAS_DO_SM,
  69. ATLAS_RTD_SM,
  70. };
  71. struct atlas_data {
  72. struct i2c_client *client;
  73. struct iio_trigger *trig;
  74. struct atlas_device *chip;
  75. struct regmap *regmap;
  76. struct irq_work work;
  77. unsigned int interrupt_enabled;
  78. /* 96-bit data + 32-bit pad + 64-bit timestamp */
  79. __be32 buffer[6] __aligned(8);
  80. };
  81. static const struct regmap_config atlas_regmap_config = {
  82. .name = ATLAS_REGMAP_NAME,
  83. .reg_bits = 8,
  84. .val_bits = 8,
  85. };
  86. static int atlas_buffer_num_channels(const struct iio_chan_spec *spec)
  87. {
  88. int idx = 0;
  89. for (; spec->type != IIO_TIMESTAMP; spec++)
  90. idx++;
  91. return idx;
  92. };
  93. static const struct iio_chan_spec atlas_ph_channels[] = {
  94. {
  95. .type = IIO_PH,
  96. .address = ATLAS_REG_PH_DATA,
  97. .info_mask_separate =
  98. BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
  99. .scan_index = 0,
  100. .scan_type = {
  101. .sign = 'u',
  102. .realbits = 32,
  103. .storagebits = 32,
  104. .endianness = IIO_BE,
  105. },
  106. },
  107. IIO_CHAN_SOFT_TIMESTAMP(1),
  108. {
  109. .type = IIO_TEMP,
  110. .address = ATLAS_REG_PH_TEMP_DATA,
  111. .info_mask_separate =
  112. BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
  113. .output = 1,
  114. .scan_index = -1
  115. },
  116. };
  117. #define ATLAS_CONCENTRATION_CHANNEL(_idx, _addr) \
  118. {\
  119. .type = IIO_CONCENTRATION, \
  120. .indexed = 1, \
  121. .channel = _idx, \
  122. .address = _addr, \
  123. .info_mask_separate = \
  124. BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE), \
  125. .scan_index = _idx + 1, \
  126. .scan_type = { \
  127. .sign = 'u', \
  128. .realbits = 32, \
  129. .storagebits = 32, \
  130. .endianness = IIO_BE, \
  131. }, \
  132. }
  133. static const struct iio_chan_spec atlas_ec_channels[] = {
  134. {
  135. .type = IIO_ELECTRICALCONDUCTIVITY,
  136. .address = ATLAS_REG_EC_DATA,
  137. .info_mask_separate =
  138. BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
  139. .scan_index = 0,
  140. .scan_type = {
  141. .sign = 'u',
  142. .realbits = 32,
  143. .storagebits = 32,
  144. .endianness = IIO_BE,
  145. },
  146. },
  147. ATLAS_CONCENTRATION_CHANNEL(0, ATLAS_REG_TDS_DATA),
  148. ATLAS_CONCENTRATION_CHANNEL(1, ATLAS_REG_PSS_DATA),
  149. IIO_CHAN_SOFT_TIMESTAMP(3),
  150. {
  151. .type = IIO_TEMP,
  152. .address = ATLAS_REG_EC_TEMP_DATA,
  153. .info_mask_separate =
  154. BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
  155. .output = 1,
  156. .scan_index = -1
  157. },
  158. };
  159. static const struct iio_chan_spec atlas_orp_channels[] = {
  160. {
  161. .type = IIO_VOLTAGE,
  162. .address = ATLAS_REG_ORP_DATA,
  163. .info_mask_separate =
  164. BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
  165. .scan_index = 0,
  166. .scan_type = {
  167. .sign = 's',
  168. .realbits = 32,
  169. .storagebits = 32,
  170. .endianness = IIO_BE,
  171. },
  172. },
  173. IIO_CHAN_SOFT_TIMESTAMP(1),
  174. };
  175. static const struct iio_chan_spec atlas_do_channels[] = {
  176. {
  177. .type = IIO_CONCENTRATION,
  178. .address = ATLAS_REG_DO_DATA,
  179. .info_mask_separate =
  180. BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
  181. .scan_index = 0,
  182. .scan_type = {
  183. .sign = 'u',
  184. .realbits = 32,
  185. .storagebits = 32,
  186. .endianness = IIO_BE,
  187. },
  188. },
  189. IIO_CHAN_SOFT_TIMESTAMP(1),
  190. {
  191. .type = IIO_TEMP,
  192. .address = ATLAS_REG_DO_TEMP_DATA,
  193. .info_mask_separate =
  194. BIT(IIO_CHAN_INFO_RAW) | BIT(IIO_CHAN_INFO_SCALE),
  195. .output = 1,
  196. .scan_index = -1
  197. },
  198. };
  199. static const struct iio_chan_spec atlas_rtd_channels[] = {
  200. {
  201. .type = IIO_TEMP,
  202. .address = ATLAS_REG_RTD_DATA,
  203. .info_mask_separate = BIT(IIO_CHAN_INFO_PROCESSED),
  204. .scan_index = 0,
  205. .scan_type = {
  206. .sign = 's',
  207. .realbits = 32,
  208. .storagebits = 32,
  209. .endianness = IIO_BE,
  210. },
  211. },
  212. IIO_CHAN_SOFT_TIMESTAMP(1),
  213. };
  214. static int atlas_check_ph_calibration(struct atlas_data *data)
  215. {
  216. struct device *dev = &data->client->dev;
  217. int ret;
  218. unsigned int val;
  219. ret = regmap_read(data->regmap, ATLAS_REG_PH_CALIB_STATUS, &val);
  220. if (ret)
  221. return ret;
  222. if (!(val & ATLAS_REG_PH_CALIB_STATUS_MASK)) {
  223. dev_warn(dev, "device has not been calibrated\n");
  224. return 0;
  225. }
  226. if (!(val & ATLAS_REG_PH_CALIB_STATUS_LOW))
  227. dev_warn(dev, "device missing low point calibration\n");
  228. if (!(val & ATLAS_REG_PH_CALIB_STATUS_MID))
  229. dev_warn(dev, "device missing mid point calibration\n");
  230. if (!(val & ATLAS_REG_PH_CALIB_STATUS_HIGH))
  231. dev_warn(dev, "device missing high point calibration\n");
  232. return 0;
  233. }
  234. static int atlas_check_ec_calibration(struct atlas_data *data)
  235. {
  236. struct device *dev = &data->client->dev;
  237. int ret;
  238. unsigned int val;
  239. __be16 rval;
  240. ret = regmap_bulk_read(data->regmap, ATLAS_REG_EC_PROBE, &rval, 2);
  241. if (ret)
  242. return ret;
  243. val = be16_to_cpu(rval);
  244. dev_info(dev, "probe set to K = %d.%.2d", val / 100, val % 100);
  245. ret = regmap_read(data->regmap, ATLAS_REG_EC_CALIB_STATUS, &val);
  246. if (ret)
  247. return ret;
  248. if (!(val & ATLAS_REG_EC_CALIB_STATUS_MASK)) {
  249. dev_warn(dev, "device has not been calibrated\n");
  250. return 0;
  251. }
  252. if (!(val & ATLAS_REG_EC_CALIB_STATUS_DRY))
  253. dev_warn(dev, "device missing dry point calibration\n");
  254. if (val & ATLAS_REG_EC_CALIB_STATUS_SINGLE) {
  255. dev_warn(dev, "device using single point calibration\n");
  256. } else {
  257. if (!(val & ATLAS_REG_EC_CALIB_STATUS_LOW))
  258. dev_warn(dev, "device missing low point calibration\n");
  259. if (!(val & ATLAS_REG_EC_CALIB_STATUS_HIGH))
  260. dev_warn(dev, "device missing high point calibration\n");
  261. }
  262. return 0;
  263. }
  264. static int atlas_check_orp_calibration(struct atlas_data *data)
  265. {
  266. struct device *dev = &data->client->dev;
  267. int ret;
  268. unsigned int val;
  269. ret = regmap_read(data->regmap, ATLAS_REG_ORP_CALIB_STATUS, &val);
  270. if (ret)
  271. return ret;
  272. if (!val)
  273. dev_warn(dev, "device has not been calibrated\n");
  274. return 0;
  275. }
  276. static int atlas_check_do_calibration(struct atlas_data *data)
  277. {
  278. struct device *dev = &data->client->dev;
  279. int ret;
  280. unsigned int val;
  281. ret = regmap_read(data->regmap, ATLAS_REG_DO_CALIB_STATUS, &val);
  282. if (ret)
  283. return ret;
  284. if (!(val & ATLAS_REG_DO_CALIB_STATUS_MASK)) {
  285. dev_warn(dev, "device has not been calibrated\n");
  286. return 0;
  287. }
  288. if (!(val & ATLAS_REG_DO_CALIB_STATUS_PRESSURE))
  289. dev_warn(dev, "device missing atmospheric pressure calibration\n");
  290. if (!(val & ATLAS_REG_DO_CALIB_STATUS_DO))
  291. dev_warn(dev, "device missing dissolved oxygen calibration\n");
  292. return 0;
  293. }
  294. struct atlas_device {
  295. const struct iio_chan_spec *channels;
  296. int num_channels;
  297. int data_reg;
  298. int (*calibration)(struct atlas_data *data);
  299. int delay;
  300. };
  301. static struct atlas_device atlas_devices[] = {
  302. [ATLAS_PH_SM] = {
  303. .channels = atlas_ph_channels,
  304. .num_channels = 3,
  305. .data_reg = ATLAS_REG_PH_DATA,
  306. .calibration = &atlas_check_ph_calibration,
  307. .delay = ATLAS_PH_INT_TIME_IN_MS,
  308. },
  309. [ATLAS_EC_SM] = {
  310. .channels = atlas_ec_channels,
  311. .num_channels = 5,
  312. .data_reg = ATLAS_REG_EC_DATA,
  313. .calibration = &atlas_check_ec_calibration,
  314. .delay = ATLAS_EC_INT_TIME_IN_MS,
  315. },
  316. [ATLAS_ORP_SM] = {
  317. .channels = atlas_orp_channels,
  318. .num_channels = 2,
  319. .data_reg = ATLAS_REG_ORP_DATA,
  320. .calibration = &atlas_check_orp_calibration,
  321. .delay = ATLAS_ORP_INT_TIME_IN_MS,
  322. },
  323. [ATLAS_DO_SM] = {
  324. .channels = atlas_do_channels,
  325. .num_channels = 3,
  326. .data_reg = ATLAS_REG_DO_DATA,
  327. .calibration = &atlas_check_do_calibration,
  328. .delay = ATLAS_DO_INT_TIME_IN_MS,
  329. },
  330. [ATLAS_RTD_SM] = {
  331. .channels = atlas_rtd_channels,
  332. .num_channels = 2,
  333. .data_reg = ATLAS_REG_RTD_DATA,
  334. .delay = ATLAS_RTD_INT_TIME_IN_MS,
  335. },
  336. };
  337. static int atlas_set_powermode(struct atlas_data *data, int on)
  338. {
  339. return regmap_write(data->regmap, ATLAS_REG_PWR_CONTROL, on);
  340. }
  341. static int atlas_set_interrupt(struct atlas_data *data, bool state)
  342. {
  343. if (!data->interrupt_enabled)
  344. return 0;
  345. return regmap_update_bits(data->regmap, ATLAS_REG_INT_CONTROL,
  346. ATLAS_REG_INT_CONTROL_EN,
  347. state ? ATLAS_REG_INT_CONTROL_EN : 0);
  348. }
  349. static int atlas_buffer_postenable(struct iio_dev *indio_dev)
  350. {
  351. struct atlas_data *data = iio_priv(indio_dev);
  352. int ret;
  353. ret = pm_runtime_get_sync(&data->client->dev);
  354. if (ret < 0) {
  355. pm_runtime_put_noidle(&data->client->dev);
  356. return ret;
  357. }
  358. return atlas_set_interrupt(data, true);
  359. }
  360. static int atlas_buffer_predisable(struct iio_dev *indio_dev)
  361. {
  362. struct atlas_data *data = iio_priv(indio_dev);
  363. int ret;
  364. ret = atlas_set_interrupt(data, false);
  365. if (ret)
  366. return ret;
  367. pm_runtime_mark_last_busy(&data->client->dev);
  368. ret = pm_runtime_put_autosuspend(&data->client->dev);
  369. if (ret)
  370. return ret;
  371. return 0;
  372. }
  373. static const struct iio_trigger_ops atlas_interrupt_trigger_ops = {
  374. };
  375. static const struct iio_buffer_setup_ops atlas_buffer_setup_ops = {
  376. .postenable = atlas_buffer_postenable,
  377. .predisable = atlas_buffer_predisable,
  378. };
  379. static void atlas_work_handler(struct irq_work *work)
  380. {
  381. struct atlas_data *data = container_of(work, struct atlas_data, work);
  382. iio_trigger_poll(data->trig);
  383. }
  384. static irqreturn_t atlas_trigger_handler(int irq, void *private)
  385. {
  386. struct iio_poll_func *pf = private;
  387. struct iio_dev *indio_dev = pf->indio_dev;
  388. struct atlas_data *data = iio_priv(indio_dev);
  389. int channels = atlas_buffer_num_channels(data->chip->channels);
  390. int ret;
  391. ret = regmap_bulk_read(data->regmap, data->chip->data_reg,
  392. &data->buffer, sizeof(__be32) * channels);
  393. if (!ret)
  394. iio_push_to_buffers_with_timestamp(indio_dev, data->buffer,
  395. iio_get_time_ns(indio_dev));
  396. iio_trigger_notify_done(indio_dev->trig);
  397. return IRQ_HANDLED;
  398. }
  399. static irqreturn_t atlas_interrupt_handler(int irq, void *private)
  400. {
  401. struct iio_dev *indio_dev = private;
  402. struct atlas_data *data = iio_priv(indio_dev);
  403. irq_work_queue(&data->work);
  404. return IRQ_HANDLED;
  405. }
  406. static int atlas_read_measurement(struct atlas_data *data, int reg, __be32 *val)
  407. {
  408. struct device *dev = &data->client->dev;
  409. int suspended = pm_runtime_suspended(dev);
  410. int ret;
  411. ret = pm_runtime_get_sync(dev);
  412. if (ret < 0) {
  413. pm_runtime_put_noidle(dev);
  414. return ret;
  415. }
  416. if (suspended)
  417. msleep(data->chip->delay);
  418. ret = regmap_bulk_read(data->regmap, reg, val, sizeof(*val));
  419. pm_runtime_mark_last_busy(dev);
  420. pm_runtime_put_autosuspend(dev);
  421. return ret;
  422. }
  423. static int atlas_read_raw(struct iio_dev *indio_dev,
  424. struct iio_chan_spec const *chan,
  425. int *val, int *val2, long mask)
  426. {
  427. struct atlas_data *data = iio_priv(indio_dev);
  428. switch (mask) {
  429. case IIO_CHAN_INFO_PROCESSED:
  430. case IIO_CHAN_INFO_RAW: {
  431. int ret;
  432. __be32 reg;
  433. switch (chan->type) {
  434. case IIO_TEMP:
  435. ret = regmap_bulk_read(data->regmap, chan->address,
  436. &reg, sizeof(reg));
  437. break;
  438. case IIO_PH:
  439. case IIO_CONCENTRATION:
  440. case IIO_ELECTRICALCONDUCTIVITY:
  441. case IIO_VOLTAGE:
  442. ret = iio_device_claim_direct_mode(indio_dev);
  443. if (ret)
  444. return ret;
  445. ret = atlas_read_measurement(data, chan->address, &reg);
  446. iio_device_release_direct_mode(indio_dev);
  447. break;
  448. default:
  449. ret = -EINVAL;
  450. }
  451. if (!ret) {
  452. *val = be32_to_cpu(reg);
  453. ret = IIO_VAL_INT;
  454. }
  455. return ret;
  456. }
  457. case IIO_CHAN_INFO_SCALE:
  458. switch (chan->type) {
  459. case IIO_TEMP:
  460. *val = 10;
  461. return IIO_VAL_INT;
  462. case IIO_PH:
  463. *val = 1; /* 0.001 */
  464. *val2 = 1000;
  465. break;
  466. case IIO_ELECTRICALCONDUCTIVITY:
  467. *val = 1; /* 0.00001 */
  468. *val2 = 100000;
  469. break;
  470. case IIO_CONCENTRATION:
  471. *val = 0; /* 0.000000001 */
  472. *val2 = 1000;
  473. return IIO_VAL_INT_PLUS_NANO;
  474. case IIO_VOLTAGE:
  475. *val = 1; /* 0.1 */
  476. *val2 = 10;
  477. break;
  478. default:
  479. return -EINVAL;
  480. }
  481. return IIO_VAL_FRACTIONAL;
  482. }
  483. return -EINVAL;
  484. }
  485. static int atlas_write_raw(struct iio_dev *indio_dev,
  486. struct iio_chan_spec const *chan,
  487. int val, int val2, long mask)
  488. {
  489. struct atlas_data *data = iio_priv(indio_dev);
  490. __be32 reg = cpu_to_be32(val / 10);
  491. if (val2 != 0 || val < 0 || val > 20000)
  492. return -EINVAL;
  493. if (mask != IIO_CHAN_INFO_RAW || chan->type != IIO_TEMP)
  494. return -EINVAL;
  495. return regmap_bulk_write(data->regmap, chan->address,
  496. &reg, sizeof(reg));
  497. }
  498. static const struct iio_info atlas_info = {
  499. .read_raw = atlas_read_raw,
  500. .write_raw = atlas_write_raw,
  501. };
  502. static const struct i2c_device_id atlas_id[] = {
  503. { "atlas-ph-sm", ATLAS_PH_SM},
  504. { "atlas-ec-sm", ATLAS_EC_SM},
  505. { "atlas-orp-sm", ATLAS_ORP_SM},
  506. { "atlas-do-sm", ATLAS_DO_SM},
  507. { "atlas-rtd-sm", ATLAS_RTD_SM},
  508. {}
  509. };
  510. MODULE_DEVICE_TABLE(i2c, atlas_id);
  511. static const struct of_device_id atlas_dt_ids[] = {
  512. { .compatible = "atlas,ph-sm", .data = (void *)ATLAS_PH_SM, },
  513. { .compatible = "atlas,ec-sm", .data = (void *)ATLAS_EC_SM, },
  514. { .compatible = "atlas,orp-sm", .data = (void *)ATLAS_ORP_SM, },
  515. { .compatible = "atlas,do-sm", .data = (void *)ATLAS_DO_SM, },
  516. { .compatible = "atlas,rtd-sm", .data = (void *)ATLAS_RTD_SM, },
  517. { }
  518. };
  519. MODULE_DEVICE_TABLE(of, atlas_dt_ids);
  520. static int atlas_probe(struct i2c_client *client,
  521. const struct i2c_device_id *id)
  522. {
  523. struct atlas_data *data;
  524. struct atlas_device *chip;
  525. struct iio_trigger *trig;
  526. struct iio_dev *indio_dev;
  527. int ret;
  528. indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*data));
  529. if (!indio_dev)
  530. return -ENOMEM;
  531. if (!dev_fwnode(&client->dev))
  532. chip = &atlas_devices[id->driver_data];
  533. else
  534. chip = &atlas_devices[(unsigned long)device_get_match_data(&client->dev)];
  535. indio_dev->info = &atlas_info;
  536. indio_dev->name = ATLAS_DRV_NAME;
  537. indio_dev->channels = chip->channels;
  538. indio_dev->num_channels = chip->num_channels;
  539. indio_dev->modes = INDIO_BUFFER_SOFTWARE | INDIO_DIRECT_MODE;
  540. trig = devm_iio_trigger_alloc(&client->dev, "%s-dev%d",
  541. indio_dev->name, indio_dev->id);
  542. if (!trig)
  543. return -ENOMEM;
  544. data = iio_priv(indio_dev);
  545. data->client = client;
  546. data->trig = trig;
  547. data->chip = chip;
  548. trig->dev.parent = indio_dev->dev.parent;
  549. trig->ops = &atlas_interrupt_trigger_ops;
  550. iio_trigger_set_drvdata(trig, indio_dev);
  551. i2c_set_clientdata(client, indio_dev);
  552. data->regmap = devm_regmap_init_i2c(client, &atlas_regmap_config);
  553. if (IS_ERR(data->regmap)) {
  554. dev_err(&client->dev, "regmap initialization failed\n");
  555. return PTR_ERR(data->regmap);
  556. }
  557. ret = pm_runtime_set_active(&client->dev);
  558. if (ret)
  559. return ret;
  560. ret = chip->calibration(data);
  561. if (ret)
  562. return ret;
  563. ret = iio_trigger_register(trig);
  564. if (ret) {
  565. dev_err(&client->dev, "failed to register trigger\n");
  566. return ret;
  567. }
  568. ret = iio_triggered_buffer_setup(indio_dev, &iio_pollfunc_store_time,
  569. &atlas_trigger_handler, &atlas_buffer_setup_ops);
  570. if (ret) {
  571. dev_err(&client->dev, "cannot setup iio trigger\n");
  572. goto unregister_trigger;
  573. }
  574. init_irq_work(&data->work, atlas_work_handler);
  575. if (client->irq > 0) {
  576. /* interrupt pin toggles on new conversion */
  577. ret = devm_request_threaded_irq(&client->dev, client->irq,
  578. NULL, atlas_interrupt_handler,
  579. IRQF_TRIGGER_RISING |
  580. IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
  581. "atlas_irq",
  582. indio_dev);
  583. if (ret)
  584. dev_warn(&client->dev,
  585. "request irq (%d) failed\n", client->irq);
  586. else
  587. data->interrupt_enabled = 1;
  588. }
  589. ret = atlas_set_powermode(data, 1);
  590. if (ret) {
  591. dev_err(&client->dev, "cannot power device on");
  592. goto unregister_buffer;
  593. }
  594. pm_runtime_enable(&client->dev);
  595. pm_runtime_set_autosuspend_delay(&client->dev, 2500);
  596. pm_runtime_use_autosuspend(&client->dev);
  597. ret = iio_device_register(indio_dev);
  598. if (ret) {
  599. dev_err(&client->dev, "unable to register device\n");
  600. goto unregister_pm;
  601. }
  602. return 0;
  603. unregister_pm:
  604. pm_runtime_disable(&client->dev);
  605. atlas_set_powermode(data, 0);
  606. unregister_buffer:
  607. iio_triggered_buffer_cleanup(indio_dev);
  608. unregister_trigger:
  609. iio_trigger_unregister(data->trig);
  610. return ret;
  611. }
  612. static int atlas_remove(struct i2c_client *client)
  613. {
  614. struct iio_dev *indio_dev = i2c_get_clientdata(client);
  615. struct atlas_data *data = iio_priv(indio_dev);
  616. iio_device_unregister(indio_dev);
  617. iio_triggered_buffer_cleanup(indio_dev);
  618. iio_trigger_unregister(data->trig);
  619. pm_runtime_disable(&client->dev);
  620. pm_runtime_set_suspended(&client->dev);
  621. pm_runtime_put_noidle(&client->dev);
  622. return atlas_set_powermode(data, 0);
  623. }
  624. #ifdef CONFIG_PM
  625. static int atlas_runtime_suspend(struct device *dev)
  626. {
  627. struct atlas_data *data =
  628. iio_priv(i2c_get_clientdata(to_i2c_client(dev)));
  629. return atlas_set_powermode(data, 0);
  630. }
  631. static int atlas_runtime_resume(struct device *dev)
  632. {
  633. struct atlas_data *data =
  634. iio_priv(i2c_get_clientdata(to_i2c_client(dev)));
  635. return atlas_set_powermode(data, 1);
  636. }
  637. #endif
  638. static const struct dev_pm_ops atlas_pm_ops = {
  639. SET_RUNTIME_PM_OPS(atlas_runtime_suspend,
  640. atlas_runtime_resume, NULL)
  641. };
  642. static struct i2c_driver atlas_driver = {
  643. .driver = {
  644. .name = ATLAS_DRV_NAME,
  645. .of_match_table = atlas_dt_ids,
  646. .pm = &atlas_pm_ops,
  647. },
  648. .probe = atlas_probe,
  649. .remove = atlas_remove,
  650. .id_table = atlas_id,
  651. };
  652. module_i2c_driver(atlas_driver);
  653. MODULE_AUTHOR("Matt Ranostay <matt.ranostay@konsulko.com>");
  654. MODULE_DESCRIPTION("Atlas Scientific SM sensors");
  655. MODULE_LICENSE("GPL");