sx_common.c 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * Copyright 2021 Google LLC.
  4. *
  5. * Common part of most Semtech SAR sensor.
  6. */
  7. #include <linux/bitops.h>
  8. #include <linux/byteorder/generic.h>
  9. #include <linux/delay.h>
  10. #include <linux/device.h>
  11. #include <linux/err.h>
  12. #include <linux/export.h>
  13. #include <linux/interrupt.h>
  14. #include <linux/irqreturn.h>
  15. #include <linux/i2c.h>
  16. #include <linux/kernel.h>
  17. #include <linux/module.h>
  18. #include <linux/regmap.h>
  19. #include <linux/regulator/consumer.h>
  20. #include <vdso/bits.h>
  21. #include <linux/iio/buffer.h>
  22. #include <linux/iio/events.h>
  23. #include <linux/iio/iio.h>
  24. #include <linux/iio/trigger.h>
  25. #include <linux/iio/triggered_buffer.h>
  26. #include <linux/iio/trigger_consumer.h>
  27. #include "sx_common.h"
  28. /* All Semtech SAR sensors have IRQ bit in the same order. */
  29. #define SX_COMMON_CONVDONE_IRQ BIT(0)
  30. #define SX_COMMON_FAR_IRQ BIT(2)
  31. #define SX_COMMON_CLOSE_IRQ BIT(3)
  32. const struct iio_event_spec sx_common_events[3] = {
  33. {
  34. .type = IIO_EV_TYPE_THRESH,
  35. .dir = IIO_EV_DIR_RISING,
  36. .mask_shared_by_all = BIT(IIO_EV_INFO_PERIOD),
  37. },
  38. {
  39. .type = IIO_EV_TYPE_THRESH,
  40. .dir = IIO_EV_DIR_FALLING,
  41. .mask_shared_by_all = BIT(IIO_EV_INFO_PERIOD),
  42. },
  43. {
  44. .type = IIO_EV_TYPE_THRESH,
  45. .dir = IIO_EV_DIR_EITHER,
  46. .mask_separate = BIT(IIO_EV_INFO_ENABLE) |
  47. BIT(IIO_EV_INFO_HYSTERESIS) |
  48. BIT(IIO_EV_INFO_VALUE),
  49. },
  50. };
  51. EXPORT_SYMBOL_NS_GPL(sx_common_events, SEMTECH_PROX);
  52. static irqreturn_t sx_common_irq_handler(int irq, void *private)
  53. {
  54. struct iio_dev *indio_dev = private;
  55. struct sx_common_data *data = iio_priv(indio_dev);
  56. if (data->trigger_enabled)
  57. iio_trigger_poll(data->trig);
  58. /*
  59. * Even if no event is enabled, we need to wake the thread to clear the
  60. * interrupt state by reading SX_COMMON_REG_IRQ_SRC.
  61. * It is not possible to do that here because regmap_read takes a mutex.
  62. */
  63. return IRQ_WAKE_THREAD;
  64. }
  65. static void sx_common_push_events(struct iio_dev *indio_dev)
  66. {
  67. int ret;
  68. unsigned int val, chan;
  69. struct sx_common_data *data = iio_priv(indio_dev);
  70. s64 timestamp = iio_get_time_ns(indio_dev);
  71. unsigned long prox_changed;
  72. /* Read proximity state on all channels */
  73. ret = regmap_read(data->regmap, data->chip_info->reg_stat, &val);
  74. if (ret) {
  75. dev_err(&data->client->dev, "i2c transfer error in irq\n");
  76. return;
  77. }
  78. val >>= data->chip_info->stat_offset;
  79. /*
  80. * Only iterate over channels with changes on proximity status that have
  81. * events enabled.
  82. */
  83. prox_changed = (data->chan_prox_stat ^ val) & data->chan_event;
  84. for_each_set_bit(chan, &prox_changed, data->chip_info->num_channels) {
  85. int dir;
  86. u64 ev;
  87. dir = (val & BIT(chan)) ? IIO_EV_DIR_FALLING : IIO_EV_DIR_RISING;
  88. ev = IIO_UNMOD_EVENT_CODE(IIO_PROXIMITY, chan,
  89. IIO_EV_TYPE_THRESH, dir);
  90. iio_push_event(indio_dev, ev, timestamp);
  91. }
  92. data->chan_prox_stat = val;
  93. }
  94. static int sx_common_enable_irq(struct sx_common_data *data, unsigned int irq)
  95. {
  96. if (!data->client->irq)
  97. return 0;
  98. return regmap_update_bits(data->regmap, data->chip_info->reg_irq_msk,
  99. irq << data->chip_info->irq_msk_offset,
  100. irq << data->chip_info->irq_msk_offset);
  101. }
  102. static int sx_common_disable_irq(struct sx_common_data *data, unsigned int irq)
  103. {
  104. if (!data->client->irq)
  105. return 0;
  106. return regmap_update_bits(data->regmap, data->chip_info->reg_irq_msk,
  107. irq << data->chip_info->irq_msk_offset, 0);
  108. }
  109. static int sx_common_update_chan_en(struct sx_common_data *data,
  110. unsigned long chan_read,
  111. unsigned long chan_event)
  112. {
  113. int ret;
  114. unsigned long channels = chan_read | chan_event;
  115. if ((data->chan_read | data->chan_event) != channels) {
  116. ret = regmap_update_bits(data->regmap,
  117. data->chip_info->reg_enable_chan,
  118. data->chip_info->mask_enable_chan,
  119. channels);
  120. if (ret)
  121. return ret;
  122. }
  123. data->chan_read = chan_read;
  124. data->chan_event = chan_event;
  125. return 0;
  126. }
  127. static int sx_common_get_read_channel(struct sx_common_data *data, int channel)
  128. {
  129. return sx_common_update_chan_en(data, data->chan_read | BIT(channel),
  130. data->chan_event);
  131. }
  132. static int sx_common_put_read_channel(struct sx_common_data *data, int channel)
  133. {
  134. return sx_common_update_chan_en(data, data->chan_read & ~BIT(channel),
  135. data->chan_event);
  136. }
  137. static int sx_common_get_event_channel(struct sx_common_data *data, int channel)
  138. {
  139. return sx_common_update_chan_en(data, data->chan_read,
  140. data->chan_event | BIT(channel));
  141. }
  142. static int sx_common_put_event_channel(struct sx_common_data *data, int channel)
  143. {
  144. return sx_common_update_chan_en(data, data->chan_read,
  145. data->chan_event & ~BIT(channel));
  146. }
  147. /**
  148. * sx_common_read_proximity() - Read raw proximity value.
  149. * @data: Internal data
  150. * @chan: Channel to read
  151. * @val: pointer to return read value.
  152. *
  153. * Request a conversion, wait for the sensor to be ready and
  154. * return the raw proximity value.
  155. */
  156. int sx_common_read_proximity(struct sx_common_data *data,
  157. const struct iio_chan_spec *chan, int *val)
  158. {
  159. int ret;
  160. __be16 rawval;
  161. mutex_lock(&data->mutex);
  162. ret = sx_common_get_read_channel(data, chan->channel);
  163. if (ret)
  164. goto out;
  165. ret = sx_common_enable_irq(data, SX_COMMON_CONVDONE_IRQ);
  166. if (ret)
  167. goto out_put_channel;
  168. mutex_unlock(&data->mutex);
  169. if (data->client->irq) {
  170. ret = wait_for_completion_interruptible(&data->completion);
  171. reinit_completion(&data->completion);
  172. } else {
  173. ret = data->chip_info->ops.wait_for_sample(data);
  174. }
  175. mutex_lock(&data->mutex);
  176. if (ret)
  177. goto out_disable_irq;
  178. ret = data->chip_info->ops.read_prox_data(data, chan, &rawval);
  179. if (ret)
  180. goto out_disable_irq;
  181. *val = sign_extend32(be16_to_cpu(rawval), chan->scan_type.realbits - 1);
  182. ret = sx_common_disable_irq(data, SX_COMMON_CONVDONE_IRQ);
  183. if (ret)
  184. goto out_put_channel;
  185. ret = sx_common_put_read_channel(data, chan->channel);
  186. if (ret)
  187. goto out;
  188. mutex_unlock(&data->mutex);
  189. return IIO_VAL_INT;
  190. out_disable_irq:
  191. sx_common_disable_irq(data, SX_COMMON_CONVDONE_IRQ);
  192. out_put_channel:
  193. sx_common_put_read_channel(data, chan->channel);
  194. out:
  195. mutex_unlock(&data->mutex);
  196. return ret;
  197. }
  198. EXPORT_SYMBOL_NS_GPL(sx_common_read_proximity, SEMTECH_PROX);
  199. /**
  200. * sx_common_read_event_config() - Configure event setting.
  201. * @indio_dev: iio device object
  202. * @chan: Channel to read
  203. * @type: Type of event (unused)
  204. * @dir: Direction of event (unused)
  205. *
  206. * return if the given channel is used for event gathering.
  207. */
  208. int sx_common_read_event_config(struct iio_dev *indio_dev,
  209. const struct iio_chan_spec *chan,
  210. enum iio_event_type type,
  211. enum iio_event_direction dir)
  212. {
  213. struct sx_common_data *data = iio_priv(indio_dev);
  214. return !!(data->chan_event & BIT(chan->channel));
  215. }
  216. EXPORT_SYMBOL_NS_GPL(sx_common_read_event_config, SEMTECH_PROX);
  217. /**
  218. * sx_common_write_event_config() - Configure event setting.
  219. * @indio_dev: iio device object
  220. * @chan: Channel to enable
  221. * @type: Type of event (unused)
  222. * @dir: Direction of event (unused)
  223. * @state: State of the event.
  224. *
  225. * Enable/Disable event on a given channel.
  226. */
  227. int sx_common_write_event_config(struct iio_dev *indio_dev,
  228. const struct iio_chan_spec *chan,
  229. enum iio_event_type type,
  230. enum iio_event_direction dir, int state)
  231. {
  232. struct sx_common_data *data = iio_priv(indio_dev);
  233. unsigned int eventirq = SX_COMMON_FAR_IRQ | SX_COMMON_CLOSE_IRQ;
  234. int ret;
  235. /* If the state hasn't changed, there's nothing to do. */
  236. if (!!(data->chan_event & BIT(chan->channel)) == state)
  237. return 0;
  238. mutex_lock(&data->mutex);
  239. if (state) {
  240. ret = sx_common_get_event_channel(data, chan->channel);
  241. if (ret)
  242. goto out_unlock;
  243. if (!(data->chan_event & ~BIT(chan->channel))) {
  244. ret = sx_common_enable_irq(data, eventirq);
  245. if (ret)
  246. sx_common_put_event_channel(data, chan->channel);
  247. }
  248. } else {
  249. ret = sx_common_put_event_channel(data, chan->channel);
  250. if (ret)
  251. goto out_unlock;
  252. if (!data->chan_event) {
  253. ret = sx_common_disable_irq(data, eventirq);
  254. if (ret)
  255. sx_common_get_event_channel(data, chan->channel);
  256. }
  257. }
  258. out_unlock:
  259. mutex_unlock(&data->mutex);
  260. return ret;
  261. }
  262. EXPORT_SYMBOL_NS_GPL(sx_common_write_event_config, SEMTECH_PROX);
  263. static int sx_common_set_trigger_state(struct iio_trigger *trig, bool state)
  264. {
  265. struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
  266. struct sx_common_data *data = iio_priv(indio_dev);
  267. int ret = 0;
  268. mutex_lock(&data->mutex);
  269. if (state)
  270. ret = sx_common_enable_irq(data, SX_COMMON_CONVDONE_IRQ);
  271. else if (!data->chan_read)
  272. ret = sx_common_disable_irq(data, SX_COMMON_CONVDONE_IRQ);
  273. if (ret)
  274. goto out;
  275. data->trigger_enabled = state;
  276. out:
  277. mutex_unlock(&data->mutex);
  278. return ret;
  279. }
  280. static const struct iio_trigger_ops sx_common_trigger_ops = {
  281. .set_trigger_state = sx_common_set_trigger_state,
  282. };
  283. static irqreturn_t sx_common_irq_thread_handler(int irq, void *private)
  284. {
  285. struct iio_dev *indio_dev = private;
  286. struct sx_common_data *data = iio_priv(indio_dev);
  287. int ret;
  288. unsigned int val;
  289. mutex_lock(&data->mutex);
  290. ret = regmap_read(data->regmap, SX_COMMON_REG_IRQ_SRC, &val);
  291. if (ret) {
  292. dev_err(&data->client->dev, "i2c transfer error in irq\n");
  293. goto out;
  294. }
  295. if (val & ((SX_COMMON_FAR_IRQ | SX_COMMON_CLOSE_IRQ) << data->chip_info->irq_msk_offset))
  296. sx_common_push_events(indio_dev);
  297. if (val & (SX_COMMON_CONVDONE_IRQ << data->chip_info->irq_msk_offset))
  298. complete(&data->completion);
  299. out:
  300. mutex_unlock(&data->mutex);
  301. return IRQ_HANDLED;
  302. }
  303. static irqreturn_t sx_common_trigger_handler(int irq, void *private)
  304. {
  305. struct iio_poll_func *pf = private;
  306. struct iio_dev *indio_dev = pf->indio_dev;
  307. struct sx_common_data *data = iio_priv(indio_dev);
  308. __be16 val;
  309. int bit, ret, i = 0;
  310. mutex_lock(&data->mutex);
  311. for_each_set_bit(bit, indio_dev->active_scan_mask,
  312. indio_dev->masklength) {
  313. ret = data->chip_info->ops.read_prox_data(data,
  314. &indio_dev->channels[bit],
  315. &val);
  316. if (ret)
  317. goto out;
  318. data->buffer.channels[i++] = val;
  319. }
  320. iio_push_to_buffers_with_timestamp(indio_dev, &data->buffer,
  321. pf->timestamp);
  322. out:
  323. mutex_unlock(&data->mutex);
  324. iio_trigger_notify_done(indio_dev->trig);
  325. return IRQ_HANDLED;
  326. }
  327. static int sx_common_buffer_preenable(struct iio_dev *indio_dev)
  328. {
  329. struct sx_common_data *data = iio_priv(indio_dev);
  330. unsigned long channels = 0;
  331. int bit, ret;
  332. mutex_lock(&data->mutex);
  333. for_each_set_bit(bit, indio_dev->active_scan_mask,
  334. indio_dev->masklength)
  335. __set_bit(indio_dev->channels[bit].channel, &channels);
  336. ret = sx_common_update_chan_en(data, channels, data->chan_event);
  337. mutex_unlock(&data->mutex);
  338. return ret;
  339. }
  340. static int sx_common_buffer_postdisable(struct iio_dev *indio_dev)
  341. {
  342. struct sx_common_data *data = iio_priv(indio_dev);
  343. int ret;
  344. mutex_lock(&data->mutex);
  345. ret = sx_common_update_chan_en(data, 0, data->chan_event);
  346. mutex_unlock(&data->mutex);
  347. return ret;
  348. }
  349. static const struct iio_buffer_setup_ops sx_common_buffer_setup_ops = {
  350. .preenable = sx_common_buffer_preenable,
  351. .postdisable = sx_common_buffer_postdisable,
  352. };
  353. static void sx_common_regulator_disable(void *_data)
  354. {
  355. struct sx_common_data *data = _data;
  356. regulator_bulk_disable(ARRAY_SIZE(data->supplies), data->supplies);
  357. }
  358. #define SX_COMMON_SOFT_RESET 0xde
  359. static int sx_common_init_device(struct device *dev, struct iio_dev *indio_dev)
  360. {
  361. struct sx_common_data *data = iio_priv(indio_dev);
  362. struct sx_common_reg_default tmp;
  363. const struct sx_common_reg_default *initval;
  364. int ret;
  365. unsigned int i, val;
  366. ret = regmap_write(data->regmap, data->chip_info->reg_reset,
  367. SX_COMMON_SOFT_RESET);
  368. if (ret)
  369. return ret;
  370. usleep_range(1000, 2000); /* power-up time is ~1ms. */
  371. /* Clear reset interrupt state by reading SX_COMMON_REG_IRQ_SRC. */
  372. ret = regmap_read(data->regmap, SX_COMMON_REG_IRQ_SRC, &val);
  373. if (ret)
  374. return ret;
  375. /* Program defaults from constant or BIOS. */
  376. for (i = 0; i < data->chip_info->num_default_regs; i++) {
  377. initval = data->chip_info->ops.get_default_reg(dev, i, &tmp);
  378. ret = regmap_write(data->regmap, initval->reg, initval->def);
  379. if (ret)
  380. return ret;
  381. }
  382. return data->chip_info->ops.init_compensation(indio_dev);
  383. }
  384. /**
  385. * sx_common_probe() - Common setup for Semtech SAR sensor
  386. * @client: I2C client object
  387. * @chip_info: Semtech sensor chip information.
  388. * @regmap_config: Sensor registers map configuration.
  389. */
  390. int sx_common_probe(struct i2c_client *client,
  391. const struct sx_common_chip_info *chip_info,
  392. const struct regmap_config *regmap_config)
  393. {
  394. struct device *dev = &client->dev;
  395. struct iio_dev *indio_dev;
  396. struct sx_common_data *data;
  397. int ret;
  398. indio_dev = devm_iio_device_alloc(dev, sizeof(*data));
  399. if (!indio_dev)
  400. return -ENOMEM;
  401. data = iio_priv(indio_dev);
  402. data->chip_info = chip_info;
  403. data->client = client;
  404. data->supplies[0].supply = "vdd";
  405. data->supplies[1].supply = "svdd";
  406. mutex_init(&data->mutex);
  407. init_completion(&data->completion);
  408. data->regmap = devm_regmap_init_i2c(client, regmap_config);
  409. if (IS_ERR(data->regmap))
  410. return dev_err_probe(dev, PTR_ERR(data->regmap),
  411. "Could init register map\n");
  412. ret = devm_regulator_bulk_get(dev, ARRAY_SIZE(data->supplies),
  413. data->supplies);
  414. if (ret)
  415. return dev_err_probe(dev, ret, "Unable to get regulators\n");
  416. ret = regulator_bulk_enable(ARRAY_SIZE(data->supplies), data->supplies);
  417. if (ret)
  418. return dev_err_probe(dev, ret, "Unable to enable regulators\n");
  419. /* Must wait for Tpor time after initial power up */
  420. usleep_range(1000, 1100);
  421. ret = devm_add_action_or_reset(dev, sx_common_regulator_disable, data);
  422. if (ret)
  423. return dev_err_probe(dev, ret,
  424. "Unable to register regulators deleter\n");
  425. ret = data->chip_info->ops.check_whoami(dev, indio_dev);
  426. if (ret)
  427. return dev_err_probe(dev, ret, "error reading WHOAMI\n");
  428. indio_dev->modes = INDIO_DIRECT_MODE;
  429. indio_dev->channels = data->chip_info->iio_channels;
  430. indio_dev->num_channels = data->chip_info->num_iio_channels;
  431. indio_dev->info = &data->chip_info->iio_info;
  432. i2c_set_clientdata(client, indio_dev);
  433. ret = sx_common_init_device(dev, indio_dev);
  434. if (ret)
  435. return dev_err_probe(dev, ret, "Unable to initialize sensor\n");
  436. if (client->irq) {
  437. ret = devm_request_threaded_irq(dev, client->irq,
  438. sx_common_irq_handler,
  439. sx_common_irq_thread_handler,
  440. IRQF_ONESHOT,
  441. "sx_event", indio_dev);
  442. if (ret)
  443. return dev_err_probe(dev, ret, "No IRQ\n");
  444. data->trig = devm_iio_trigger_alloc(dev, "%s-dev%d",
  445. indio_dev->name,
  446. iio_device_id(indio_dev));
  447. if (!data->trig)
  448. return -ENOMEM;
  449. data->trig->ops = &sx_common_trigger_ops;
  450. iio_trigger_set_drvdata(data->trig, indio_dev);
  451. ret = devm_iio_trigger_register(dev, data->trig);
  452. if (ret)
  453. return ret;
  454. }
  455. ret = devm_iio_triggered_buffer_setup(dev, indio_dev,
  456. iio_pollfunc_store_time,
  457. sx_common_trigger_handler,
  458. &sx_common_buffer_setup_ops);
  459. if (ret)
  460. return ret;
  461. return devm_iio_device_register(dev, indio_dev);
  462. }
  463. EXPORT_SYMBOL_NS_GPL(sx_common_probe, SEMTECH_PROX);
  464. MODULE_AUTHOR("Gwendal Grignou <[email protected]>");
  465. MODULE_DESCRIPTION("Common functions and structures for Semtech sensor");
  466. MODULE_LICENSE("GPL v2");