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