as3935.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * as3935.c - Support for AS3935 Franklin lightning sensor
  4. *
  5. * Copyright (C) 2014, 2017-2018
  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/workqueue.h>
  13. #include <linux/mutex.h>
  14. #include <linux/err.h>
  15. #include <linux/irq.h>
  16. #include <linux/gpio.h>
  17. #include <linux/spi/spi.h>
  18. #include <linux/iio/iio.h>
  19. #include <linux/iio/sysfs.h>
  20. #include <linux/iio/trigger.h>
  21. #include <linux/iio/trigger_consumer.h>
  22. #include <linux/iio/buffer.h>
  23. #include <linux/iio/triggered_buffer.h>
  24. #include <linux/of_gpio.h>
  25. #define AS3935_AFE_GAIN 0x00
  26. #define AS3935_AFE_MASK 0x3F
  27. #define AS3935_AFE_GAIN_MAX 0x1F
  28. #define AS3935_AFE_PWR_BIT BIT(0)
  29. #define AS3935_NFLWDTH 0x01
  30. #define AS3935_NFLWDTH_MASK 0x7f
  31. #define AS3935_INT 0x03
  32. #define AS3935_INT_MASK 0x0f
  33. #define AS3935_DISTURB_INT BIT(2)
  34. #define AS3935_EVENT_INT BIT(3)
  35. #define AS3935_NOISE_INT BIT(0)
  36. #define AS3935_DATA 0x07
  37. #define AS3935_DATA_MASK 0x3F
  38. #define AS3935_TUNE_CAP 0x08
  39. #define AS3935_DEFAULTS 0x3C
  40. #define AS3935_CALIBRATE 0x3D
  41. #define AS3935_READ_DATA BIT(14)
  42. #define AS3935_ADDRESS(x) ((x) << 8)
  43. #define MAX_PF_CAP 120
  44. #define TUNE_CAP_DIV 8
  45. struct as3935_state {
  46. struct spi_device *spi;
  47. struct iio_trigger *trig;
  48. struct mutex lock;
  49. struct delayed_work work;
  50. unsigned long noise_tripped;
  51. u32 tune_cap;
  52. u32 nflwdth_reg;
  53. u8 buffer[16]; /* 8-bit data + 56-bit padding + 64-bit timestamp */
  54. u8 buf[2] ____cacheline_aligned;
  55. };
  56. static const struct iio_chan_spec as3935_channels[] = {
  57. {
  58. .type = IIO_PROXIMITY,
  59. .info_mask_separate =
  60. BIT(IIO_CHAN_INFO_RAW) |
  61. BIT(IIO_CHAN_INFO_PROCESSED) |
  62. BIT(IIO_CHAN_INFO_SCALE),
  63. .scan_index = 0,
  64. .scan_type = {
  65. .sign = 'u',
  66. .realbits = 6,
  67. .storagebits = 8,
  68. },
  69. },
  70. IIO_CHAN_SOFT_TIMESTAMP(1),
  71. };
  72. static int as3935_read(struct as3935_state *st, unsigned int reg, int *val)
  73. {
  74. u8 cmd;
  75. int ret;
  76. cmd = (AS3935_READ_DATA | AS3935_ADDRESS(reg)) >> 8;
  77. ret = spi_w8r8(st->spi, cmd);
  78. if (ret < 0)
  79. return ret;
  80. *val = ret;
  81. return 0;
  82. }
  83. static int as3935_write(struct as3935_state *st,
  84. unsigned int reg,
  85. unsigned int val)
  86. {
  87. u8 *buf = st->buf;
  88. buf[0] = AS3935_ADDRESS(reg) >> 8;
  89. buf[1] = val;
  90. return spi_write(st->spi, buf, 2);
  91. }
  92. static ssize_t as3935_sensor_sensitivity_show(struct device *dev,
  93. struct device_attribute *attr,
  94. char *buf)
  95. {
  96. struct as3935_state *st = iio_priv(dev_to_iio_dev(dev));
  97. int val, ret;
  98. ret = as3935_read(st, AS3935_AFE_GAIN, &val);
  99. if (ret)
  100. return ret;
  101. val = (val & AS3935_AFE_MASK) >> 1;
  102. return sprintf(buf, "%d\n", val);
  103. }
  104. static ssize_t as3935_sensor_sensitivity_store(struct device *dev,
  105. struct device_attribute *attr,
  106. const char *buf, size_t len)
  107. {
  108. struct as3935_state *st = iio_priv(dev_to_iio_dev(dev));
  109. unsigned long val;
  110. int ret;
  111. ret = kstrtoul((const char *) buf, 10, &val);
  112. if (ret)
  113. return -EINVAL;
  114. if (val > AS3935_AFE_GAIN_MAX)
  115. return -EINVAL;
  116. as3935_write(st, AS3935_AFE_GAIN, val << 1);
  117. return len;
  118. }
  119. static ssize_t as3935_noise_level_tripped_show(struct device *dev,
  120. struct device_attribute *attr,
  121. char *buf)
  122. {
  123. struct as3935_state *st = iio_priv(dev_to_iio_dev(dev));
  124. int ret;
  125. mutex_lock(&st->lock);
  126. ret = sprintf(buf, "%d\n", !time_after(jiffies, st->noise_tripped + HZ));
  127. mutex_unlock(&st->lock);
  128. return ret;
  129. }
  130. static IIO_DEVICE_ATTR(sensor_sensitivity, S_IRUGO | S_IWUSR,
  131. as3935_sensor_sensitivity_show, as3935_sensor_sensitivity_store, 0);
  132. static IIO_DEVICE_ATTR(noise_level_tripped, S_IRUGO,
  133. as3935_noise_level_tripped_show, NULL, 0);
  134. static struct attribute *as3935_attributes[] = {
  135. &iio_dev_attr_sensor_sensitivity.dev_attr.attr,
  136. &iio_dev_attr_noise_level_tripped.dev_attr.attr,
  137. NULL,
  138. };
  139. static const struct attribute_group as3935_attribute_group = {
  140. .attrs = as3935_attributes,
  141. };
  142. static int as3935_read_raw(struct iio_dev *indio_dev,
  143. struct iio_chan_spec const *chan,
  144. int *val,
  145. int *val2,
  146. long m)
  147. {
  148. struct as3935_state *st = iio_priv(indio_dev);
  149. int ret;
  150. switch (m) {
  151. case IIO_CHAN_INFO_PROCESSED:
  152. case IIO_CHAN_INFO_RAW:
  153. *val2 = 0;
  154. ret = as3935_read(st, AS3935_DATA, val);
  155. if (ret)
  156. return ret;
  157. /* storm out of range */
  158. if (*val == AS3935_DATA_MASK)
  159. return -EINVAL;
  160. if (m == IIO_CHAN_INFO_RAW)
  161. return IIO_VAL_INT;
  162. if (m == IIO_CHAN_INFO_PROCESSED)
  163. *val *= 1000;
  164. break;
  165. case IIO_CHAN_INFO_SCALE:
  166. *val = 1000;
  167. break;
  168. default:
  169. return -EINVAL;
  170. }
  171. return IIO_VAL_INT;
  172. }
  173. static const struct iio_info as3935_info = {
  174. .attrs = &as3935_attribute_group,
  175. .read_raw = &as3935_read_raw,
  176. };
  177. static irqreturn_t as3935_trigger_handler(int irq, void *private)
  178. {
  179. struct iio_poll_func *pf = private;
  180. struct iio_dev *indio_dev = pf->indio_dev;
  181. struct as3935_state *st = iio_priv(indio_dev);
  182. int val, ret;
  183. ret = as3935_read(st, AS3935_DATA, &val);
  184. if (ret)
  185. goto err_read;
  186. st->buffer[0] = val & AS3935_DATA_MASK;
  187. iio_push_to_buffers_with_timestamp(indio_dev, &st->buffer,
  188. iio_get_time_ns(indio_dev));
  189. err_read:
  190. iio_trigger_notify_done(indio_dev->trig);
  191. return IRQ_HANDLED;
  192. }
  193. static const struct iio_trigger_ops iio_interrupt_trigger_ops = {
  194. };
  195. static void as3935_event_work(struct work_struct *work)
  196. {
  197. struct as3935_state *st;
  198. int val;
  199. int ret;
  200. st = container_of(work, struct as3935_state, work.work);
  201. ret = as3935_read(st, AS3935_INT, &val);
  202. if (ret) {
  203. dev_warn(&st->spi->dev, "read error\n");
  204. return;
  205. }
  206. val &= AS3935_INT_MASK;
  207. switch (val) {
  208. case AS3935_EVENT_INT:
  209. iio_trigger_poll_chained(st->trig);
  210. break;
  211. case AS3935_DISTURB_INT:
  212. case AS3935_NOISE_INT:
  213. mutex_lock(&st->lock);
  214. st->noise_tripped = jiffies;
  215. mutex_unlock(&st->lock);
  216. dev_warn(&st->spi->dev, "noise level is too high\n");
  217. break;
  218. }
  219. }
  220. static irqreturn_t as3935_interrupt_handler(int irq, void *private)
  221. {
  222. struct iio_dev *indio_dev = private;
  223. struct as3935_state *st = iio_priv(indio_dev);
  224. /*
  225. * Delay work for >2 milliseconds after an interrupt to allow
  226. * estimated distance to recalculated.
  227. */
  228. schedule_delayed_work(&st->work, msecs_to_jiffies(3));
  229. return IRQ_HANDLED;
  230. }
  231. static void calibrate_as3935(struct as3935_state *st)
  232. {
  233. as3935_write(st, AS3935_DEFAULTS, 0x96);
  234. as3935_write(st, AS3935_CALIBRATE, 0x96);
  235. as3935_write(st, AS3935_TUNE_CAP,
  236. BIT(5) | (st->tune_cap / TUNE_CAP_DIV));
  237. mdelay(2);
  238. as3935_write(st, AS3935_TUNE_CAP, (st->tune_cap / TUNE_CAP_DIV));
  239. as3935_write(st, AS3935_NFLWDTH, st->nflwdth_reg);
  240. }
  241. #ifdef CONFIG_PM_SLEEP
  242. static int as3935_suspend(struct device *dev)
  243. {
  244. struct iio_dev *indio_dev = dev_get_drvdata(dev);
  245. struct as3935_state *st = iio_priv(indio_dev);
  246. int val, ret;
  247. mutex_lock(&st->lock);
  248. ret = as3935_read(st, AS3935_AFE_GAIN, &val);
  249. if (ret)
  250. goto err_suspend;
  251. val |= AS3935_AFE_PWR_BIT;
  252. ret = as3935_write(st, AS3935_AFE_GAIN, val);
  253. err_suspend:
  254. mutex_unlock(&st->lock);
  255. return ret;
  256. }
  257. static int as3935_resume(struct device *dev)
  258. {
  259. struct iio_dev *indio_dev = dev_get_drvdata(dev);
  260. struct as3935_state *st = iio_priv(indio_dev);
  261. int val, ret;
  262. mutex_lock(&st->lock);
  263. ret = as3935_read(st, AS3935_AFE_GAIN, &val);
  264. if (ret)
  265. goto err_resume;
  266. val &= ~AS3935_AFE_PWR_BIT;
  267. ret = as3935_write(st, AS3935_AFE_GAIN, val);
  268. calibrate_as3935(st);
  269. err_resume:
  270. mutex_unlock(&st->lock);
  271. return ret;
  272. }
  273. static SIMPLE_DEV_PM_OPS(as3935_pm_ops, as3935_suspend, as3935_resume);
  274. #define AS3935_PM_OPS (&as3935_pm_ops)
  275. #else
  276. #define AS3935_PM_OPS NULL
  277. #endif
  278. static int as3935_probe(struct spi_device *spi)
  279. {
  280. struct iio_dev *indio_dev;
  281. struct iio_trigger *trig;
  282. struct as3935_state *st;
  283. struct device_node *np = spi->dev.of_node;
  284. int ret;
  285. /* Be sure lightning event interrupt is specified */
  286. if (!spi->irq) {
  287. dev_err(&spi->dev, "unable to get event interrupt\n");
  288. return -EINVAL;
  289. }
  290. indio_dev = devm_iio_device_alloc(&spi->dev, sizeof(*st));
  291. if (!indio_dev)
  292. return -ENOMEM;
  293. st = iio_priv(indio_dev);
  294. st->spi = spi;
  295. spi_set_drvdata(spi, indio_dev);
  296. mutex_init(&st->lock);
  297. INIT_DELAYED_WORK(&st->work, as3935_event_work);
  298. ret = of_property_read_u32(np,
  299. "ams,tuning-capacitor-pf", &st->tune_cap);
  300. if (ret) {
  301. st->tune_cap = 0;
  302. dev_warn(&spi->dev,
  303. "no tuning-capacitor-pf set, defaulting to %d",
  304. st->tune_cap);
  305. }
  306. if (st->tune_cap > MAX_PF_CAP) {
  307. dev_err(&spi->dev,
  308. "wrong tuning-capacitor-pf setting of %d\n",
  309. st->tune_cap);
  310. return -EINVAL;
  311. }
  312. ret = of_property_read_u32(np,
  313. "ams,nflwdth", &st->nflwdth_reg);
  314. if (!ret && st->nflwdth_reg > AS3935_NFLWDTH_MASK) {
  315. dev_err(&spi->dev,
  316. "invalid nflwdth setting of %d\n",
  317. st->nflwdth_reg);
  318. return -EINVAL;
  319. }
  320. indio_dev->dev.parent = &spi->dev;
  321. indio_dev->name = spi_get_device_id(spi)->name;
  322. indio_dev->channels = as3935_channels;
  323. indio_dev->num_channels = ARRAY_SIZE(as3935_channels);
  324. indio_dev->modes = INDIO_DIRECT_MODE;
  325. indio_dev->info = &as3935_info;
  326. trig = devm_iio_trigger_alloc(&spi->dev, "%s-dev%d",
  327. indio_dev->name, indio_dev->id);
  328. if (!trig)
  329. return -ENOMEM;
  330. st->trig = trig;
  331. st->noise_tripped = jiffies - HZ;
  332. trig->dev.parent = indio_dev->dev.parent;
  333. iio_trigger_set_drvdata(trig, indio_dev);
  334. trig->ops = &iio_interrupt_trigger_ops;
  335. ret = iio_trigger_register(trig);
  336. if (ret) {
  337. dev_err(&spi->dev, "failed to register trigger\n");
  338. return ret;
  339. }
  340. ret = iio_triggered_buffer_setup(indio_dev, iio_pollfunc_store_time,
  341. &as3935_trigger_handler, NULL);
  342. if (ret) {
  343. dev_err(&spi->dev, "cannot setup iio trigger\n");
  344. goto unregister_trigger;
  345. }
  346. calibrate_as3935(st);
  347. ret = devm_request_irq(&spi->dev, spi->irq,
  348. &as3935_interrupt_handler,
  349. IRQF_TRIGGER_RISING,
  350. dev_name(&spi->dev),
  351. indio_dev);
  352. if (ret) {
  353. dev_err(&spi->dev, "unable to request irq\n");
  354. goto unregister_buffer;
  355. }
  356. ret = iio_device_register(indio_dev);
  357. if (ret < 0) {
  358. dev_err(&spi->dev, "unable to register device\n");
  359. goto unregister_buffer;
  360. }
  361. return 0;
  362. unregister_buffer:
  363. iio_triggered_buffer_cleanup(indio_dev);
  364. unregister_trigger:
  365. iio_trigger_unregister(st->trig);
  366. return ret;
  367. }
  368. static int as3935_remove(struct spi_device *spi)
  369. {
  370. struct iio_dev *indio_dev = spi_get_drvdata(spi);
  371. struct as3935_state *st = iio_priv(indio_dev);
  372. iio_device_unregister(indio_dev);
  373. iio_triggered_buffer_cleanup(indio_dev);
  374. iio_trigger_unregister(st->trig);
  375. return 0;
  376. }
  377. static const struct of_device_id as3935_of_match[] = {
  378. { .compatible = "ams,as3935", },
  379. { /* sentinel */ },
  380. };
  381. MODULE_DEVICE_TABLE(of, as3935_of_match);
  382. static const struct spi_device_id as3935_id[] = {
  383. {"as3935", 0},
  384. {},
  385. };
  386. MODULE_DEVICE_TABLE(spi, as3935_id);
  387. static struct spi_driver as3935_driver = {
  388. .driver = {
  389. .name = "as3935",
  390. .of_match_table = of_match_ptr(as3935_of_match),
  391. .pm = AS3935_PM_OPS,
  392. },
  393. .probe = as3935_probe,
  394. .remove = as3935_remove,
  395. .id_table = as3935_id,
  396. };
  397. module_spi_driver(as3935_driver);
  398. MODULE_AUTHOR("Matt Ranostay <matt.ranostay@konsulko.com>");
  399. MODULE_DESCRIPTION("AS3935 lightning sensor");
  400. MODULE_LICENSE("GPL");