as3935.c 11 KB

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