arizona-irq.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Arizona interrupt support
  4. *
  5. * Copyright 2012 Wolfson Microelectronics plc
  6. *
  7. * Author: Mark Brown <broonie@opensource.wolfsonmicro.com>
  8. */
  9. #include <linux/delay.h>
  10. #include <linux/gpio.h>
  11. #include <linux/interrupt.h>
  12. #include <linux/irq.h>
  13. #include <linux/irqdomain.h>
  14. #include <linux/module.h>
  15. #include <linux/pm_runtime.h>
  16. #include <linux/regmap.h>
  17. #include <linux/regulator/consumer.h>
  18. #include <linux/slab.h>
  19. #include <linux/mfd/arizona/core.h>
  20. #include <linux/mfd/arizona/registers.h>
  21. #include "arizona.h"
  22. #define ARIZONA_AOD_IRQ_INDEX 0
  23. #define ARIZONA_MAIN_IRQ_INDEX 1
  24. static int arizona_map_irq(struct arizona *arizona, int irq)
  25. {
  26. int ret;
  27. if (arizona->aod_irq_chip) {
  28. ret = regmap_irq_get_virq(arizona->aod_irq_chip, irq);
  29. if (ret >= 0)
  30. return ret;
  31. }
  32. return regmap_irq_get_virq(arizona->irq_chip, irq);
  33. }
  34. int arizona_request_irq(struct arizona *arizona, int irq, char *name,
  35. irq_handler_t handler, void *data)
  36. {
  37. irq = arizona_map_irq(arizona, irq);
  38. if (irq < 0)
  39. return irq;
  40. return request_threaded_irq(irq, NULL, handler, IRQF_ONESHOT,
  41. name, data);
  42. }
  43. EXPORT_SYMBOL_GPL(arizona_request_irq);
  44. void arizona_free_irq(struct arizona *arizona, int irq, void *data)
  45. {
  46. irq = arizona_map_irq(arizona, irq);
  47. if (irq < 0)
  48. return;
  49. free_irq(irq, data);
  50. }
  51. EXPORT_SYMBOL_GPL(arizona_free_irq);
  52. int arizona_set_irq_wake(struct arizona *arizona, int irq, int on)
  53. {
  54. irq = arizona_map_irq(arizona, irq);
  55. if (irq < 0)
  56. return irq;
  57. return irq_set_irq_wake(irq, on);
  58. }
  59. EXPORT_SYMBOL_GPL(arizona_set_irq_wake);
  60. static irqreturn_t arizona_boot_done(int irq, void *data)
  61. {
  62. struct arizona *arizona = data;
  63. dev_dbg(arizona->dev, "Boot done\n");
  64. return IRQ_HANDLED;
  65. }
  66. static irqreturn_t arizona_ctrlif_err(int irq, void *data)
  67. {
  68. struct arizona *arizona = data;
  69. /*
  70. * For pretty much all potential sources a register cache sync
  71. * won't help, we've just got a software bug somewhere.
  72. */
  73. dev_err(arizona->dev, "Control interface error\n");
  74. return IRQ_HANDLED;
  75. }
  76. static irqreturn_t arizona_irq_thread(int irq, void *data)
  77. {
  78. struct arizona *arizona = data;
  79. bool poll;
  80. unsigned int val;
  81. int ret;
  82. ret = pm_runtime_resume_and_get(arizona->dev);
  83. if (ret < 0) {
  84. dev_err(arizona->dev, "Failed to resume device: %d\n", ret);
  85. return IRQ_NONE;
  86. }
  87. do {
  88. poll = false;
  89. if (arizona->aod_irq_chip) {
  90. /*
  91. * Check the AOD status register to determine whether
  92. * the nested IRQ handler should be called.
  93. */
  94. ret = regmap_read(arizona->regmap,
  95. ARIZONA_AOD_IRQ1, &val);
  96. if (ret)
  97. dev_warn(arizona->dev,
  98. "Failed to read AOD IRQ1 %d\n", ret);
  99. else if (val)
  100. handle_nested_irq(
  101. irq_find_mapping(arizona->virq, 0));
  102. }
  103. /*
  104. * Check if one of the main interrupts is asserted and only
  105. * check that domain if it is.
  106. */
  107. ret = regmap_read(arizona->regmap, ARIZONA_IRQ_PIN_STATUS,
  108. &val);
  109. if (ret == 0 && val & ARIZONA_IRQ1_STS) {
  110. handle_nested_irq(irq_find_mapping(arizona->virq, 1));
  111. } else if (ret != 0) {
  112. dev_err(arizona->dev,
  113. "Failed to read main IRQ status: %d\n", ret);
  114. }
  115. /*
  116. * Poll the IRQ pin status to see if we're really done
  117. * if the interrupt controller can't do it for us.
  118. */
  119. if (!arizona->pdata.irq_gpio) {
  120. break;
  121. } else if (arizona->pdata.irq_flags & IRQF_TRIGGER_RISING &&
  122. gpio_get_value_cansleep(arizona->pdata.irq_gpio)) {
  123. poll = true;
  124. } else if (arizona->pdata.irq_flags & IRQF_TRIGGER_FALLING &&
  125. !gpio_get_value_cansleep(arizona->pdata.irq_gpio)) {
  126. poll = true;
  127. }
  128. } while (poll);
  129. pm_runtime_mark_last_busy(arizona->dev);
  130. pm_runtime_put_autosuspend(arizona->dev);
  131. return IRQ_HANDLED;
  132. }
  133. static void arizona_irq_enable(struct irq_data *data)
  134. {
  135. }
  136. static void arizona_irq_disable(struct irq_data *data)
  137. {
  138. }
  139. static int arizona_irq_set_wake(struct irq_data *data, unsigned int on)
  140. {
  141. struct arizona *arizona = irq_data_get_irq_chip_data(data);
  142. return irq_set_irq_wake(arizona->irq, on);
  143. }
  144. static struct irq_chip arizona_irq_chip = {
  145. .name = "arizona",
  146. .irq_disable = arizona_irq_disable,
  147. .irq_enable = arizona_irq_enable,
  148. .irq_set_wake = arizona_irq_set_wake,
  149. };
  150. static struct lock_class_key arizona_irq_lock_class;
  151. static struct lock_class_key arizona_irq_request_class;
  152. static int arizona_irq_map(struct irq_domain *h, unsigned int virq,
  153. irq_hw_number_t hw)
  154. {
  155. struct arizona *data = h->host_data;
  156. irq_set_chip_data(virq, data);
  157. irq_set_lockdep_class(virq, &arizona_irq_lock_class,
  158. &arizona_irq_request_class);
  159. irq_set_chip_and_handler(virq, &arizona_irq_chip, handle_simple_irq);
  160. irq_set_nested_thread(virq, 1);
  161. irq_set_noprobe(virq);
  162. return 0;
  163. }
  164. static const struct irq_domain_ops arizona_domain_ops = {
  165. .map = arizona_irq_map,
  166. .xlate = irq_domain_xlate_twocell,
  167. };
  168. int arizona_irq_init(struct arizona *arizona)
  169. {
  170. int flags = IRQF_ONESHOT;
  171. int ret;
  172. const struct regmap_irq_chip *aod, *irq;
  173. struct irq_data *irq_data;
  174. unsigned int virq;
  175. arizona->ctrlif_error = true;
  176. switch (arizona->type) {
  177. #ifdef CONFIG_MFD_WM5102
  178. case WM5102:
  179. aod = &wm5102_aod;
  180. irq = &wm5102_irq;
  181. arizona->ctrlif_error = false;
  182. break;
  183. #endif
  184. #ifdef CONFIG_MFD_WM5110
  185. case WM5110:
  186. case WM8280:
  187. aod = &wm5110_aod;
  188. switch (arizona->rev) {
  189. case 0 ... 2:
  190. irq = &wm5110_irq;
  191. break;
  192. default:
  193. irq = &wm5110_revd_irq;
  194. break;
  195. }
  196. arizona->ctrlif_error = false;
  197. break;
  198. #endif
  199. #ifdef CONFIG_MFD_CS47L24
  200. case WM1831:
  201. case CS47L24:
  202. aod = NULL;
  203. irq = &cs47l24_irq;
  204. arizona->ctrlif_error = false;
  205. break;
  206. #endif
  207. #ifdef CONFIG_MFD_WM8997
  208. case WM8997:
  209. aod = &wm8997_aod;
  210. irq = &wm8997_irq;
  211. arizona->ctrlif_error = false;
  212. break;
  213. #endif
  214. #ifdef CONFIG_MFD_WM8998
  215. case WM8998:
  216. case WM1814:
  217. aod = &wm8998_aod;
  218. irq = &wm8998_irq;
  219. arizona->ctrlif_error = false;
  220. break;
  221. #endif
  222. default:
  223. BUG_ON("Unknown Arizona class device" == NULL);
  224. return -EINVAL;
  225. }
  226. /* Disable all wake sources by default */
  227. regmap_write(arizona->regmap, ARIZONA_WAKE_CONTROL, 0);
  228. /* Read the flags from the interrupt controller if not specified */
  229. if (!arizona->pdata.irq_flags) {
  230. irq_data = irq_get_irq_data(arizona->irq);
  231. if (!irq_data) {
  232. dev_err(arizona->dev, "Invalid IRQ: %d\n",
  233. arizona->irq);
  234. return -EINVAL;
  235. }
  236. arizona->pdata.irq_flags = irqd_get_trigger_type(irq_data);
  237. switch (arizona->pdata.irq_flags) {
  238. case IRQF_TRIGGER_LOW:
  239. case IRQF_TRIGGER_HIGH:
  240. case IRQF_TRIGGER_RISING:
  241. case IRQF_TRIGGER_FALLING:
  242. break;
  243. case IRQ_TYPE_NONE:
  244. default:
  245. /* Device default */
  246. arizona->pdata.irq_flags = IRQF_TRIGGER_LOW;
  247. break;
  248. }
  249. }
  250. if (arizona->pdata.irq_flags & (IRQF_TRIGGER_HIGH |
  251. IRQF_TRIGGER_RISING)) {
  252. ret = regmap_update_bits(arizona->regmap, ARIZONA_IRQ_CTRL_1,
  253. ARIZONA_IRQ_POL, 0);
  254. if (ret != 0) {
  255. dev_err(arizona->dev, "Couldn't set IRQ polarity: %d\n",
  256. ret);
  257. goto err;
  258. }
  259. }
  260. flags |= arizona->pdata.irq_flags;
  261. /* Allocate a virtual IRQ domain to distribute to the regmap domains */
  262. arizona->virq = irq_domain_add_linear(NULL, 2, &arizona_domain_ops,
  263. arizona);
  264. if (!arizona->virq) {
  265. dev_err(arizona->dev, "Failed to add core IRQ domain\n");
  266. ret = -EINVAL;
  267. goto err;
  268. }
  269. if (aod) {
  270. virq = irq_create_mapping(arizona->virq, ARIZONA_AOD_IRQ_INDEX);
  271. if (!virq) {
  272. dev_err(arizona->dev, "Failed to map AOD IRQs\n");
  273. ret = -EINVAL;
  274. goto err_domain;
  275. }
  276. ret = regmap_add_irq_chip(arizona->regmap, virq, IRQF_ONESHOT,
  277. 0, aod, &arizona->aod_irq_chip);
  278. if (ret != 0) {
  279. dev_err(arizona->dev,
  280. "Failed to add AOD IRQs: %d\n", ret);
  281. goto err_map_aod;
  282. }
  283. }
  284. virq = irq_create_mapping(arizona->virq, ARIZONA_MAIN_IRQ_INDEX);
  285. if (!virq) {
  286. dev_err(arizona->dev, "Failed to map main IRQs\n");
  287. ret = -EINVAL;
  288. goto err_aod;
  289. }
  290. ret = regmap_add_irq_chip(arizona->regmap, virq, IRQF_ONESHOT,
  291. 0, irq, &arizona->irq_chip);
  292. if (ret != 0) {
  293. dev_err(arizona->dev, "Failed to add main IRQs: %d\n", ret);
  294. goto err_map_main_irq;
  295. }
  296. /* Used to emulate edge trigger and to work around broken pinmux */
  297. if (arizona->pdata.irq_gpio) {
  298. if (gpio_to_irq(arizona->pdata.irq_gpio) != arizona->irq) {
  299. dev_warn(arizona->dev, "IRQ %d is not GPIO %d (%d)\n",
  300. arizona->irq, arizona->pdata.irq_gpio,
  301. gpio_to_irq(arizona->pdata.irq_gpio));
  302. arizona->irq = gpio_to_irq(arizona->pdata.irq_gpio);
  303. }
  304. ret = devm_gpio_request_one(arizona->dev,
  305. arizona->pdata.irq_gpio,
  306. GPIOF_IN, "arizona IRQ");
  307. if (ret != 0) {
  308. dev_err(arizona->dev,
  309. "Failed to request IRQ GPIO %d:: %d\n",
  310. arizona->pdata.irq_gpio, ret);
  311. arizona->pdata.irq_gpio = 0;
  312. }
  313. }
  314. ret = request_threaded_irq(arizona->irq, NULL, arizona_irq_thread,
  315. flags, "arizona", arizona);
  316. if (ret != 0) {
  317. dev_err(arizona->dev, "Failed to request primary IRQ %d: %d\n",
  318. arizona->irq, ret);
  319. goto err_main_irq;
  320. }
  321. /* Make sure the boot done IRQ is unmasked for resumes */
  322. ret = arizona_request_irq(arizona, ARIZONA_IRQ_BOOT_DONE, "Boot done",
  323. arizona_boot_done, arizona);
  324. if (ret != 0) {
  325. dev_err(arizona->dev, "Failed to request boot done %d: %d\n",
  326. arizona->irq, ret);
  327. goto err_boot_done;
  328. }
  329. /* Handle control interface errors in the core */
  330. if (arizona->ctrlif_error) {
  331. ret = arizona_request_irq(arizona, ARIZONA_IRQ_CTRLIF_ERR,
  332. "Control interface error",
  333. arizona_ctrlif_err, arizona);
  334. if (ret != 0) {
  335. dev_err(arizona->dev,
  336. "Failed to request CTRLIF_ERR %d: %d\n",
  337. arizona->irq, ret);
  338. goto err_ctrlif;
  339. }
  340. }
  341. return 0;
  342. err_ctrlif:
  343. arizona_free_irq(arizona, ARIZONA_IRQ_BOOT_DONE, arizona);
  344. err_boot_done:
  345. free_irq(arizona->irq, arizona);
  346. err_main_irq:
  347. regmap_del_irq_chip(irq_find_mapping(arizona->virq,
  348. ARIZONA_MAIN_IRQ_INDEX),
  349. arizona->irq_chip);
  350. err_map_main_irq:
  351. irq_dispose_mapping(irq_find_mapping(arizona->virq,
  352. ARIZONA_MAIN_IRQ_INDEX));
  353. err_aod:
  354. regmap_del_irq_chip(irq_find_mapping(arizona->virq,
  355. ARIZONA_AOD_IRQ_INDEX),
  356. arizona->aod_irq_chip);
  357. err_map_aod:
  358. irq_dispose_mapping(irq_find_mapping(arizona->virq,
  359. ARIZONA_AOD_IRQ_INDEX));
  360. err_domain:
  361. irq_domain_remove(arizona->virq);
  362. err:
  363. return ret;
  364. }
  365. int arizona_irq_exit(struct arizona *arizona)
  366. {
  367. unsigned int virq;
  368. if (arizona->ctrlif_error)
  369. arizona_free_irq(arizona, ARIZONA_IRQ_CTRLIF_ERR, arizona);
  370. arizona_free_irq(arizona, ARIZONA_IRQ_BOOT_DONE, arizona);
  371. virq = irq_find_mapping(arizona->virq, ARIZONA_MAIN_IRQ_INDEX);
  372. regmap_del_irq_chip(virq, arizona->irq_chip);
  373. irq_dispose_mapping(virq);
  374. virq = irq_find_mapping(arizona->virq, ARIZONA_AOD_IRQ_INDEX);
  375. regmap_del_irq_chip(virq, arizona->aod_irq_chip);
  376. irq_dispose_mapping(virq);
  377. irq_domain_remove(arizona->virq);
  378. free_irq(arizona->irq, arizona);
  379. return 0;
  380. }