mfd: Convert wm8994 to use generic regmap irq_chip

Factor out the irq_chip implementation, substantially reducing the code size for the driver. Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com> Acked-by: Samuel Ortiz <sameo@linux.intel.com>

mfd: Convert wm8994 to use generic regmap irq_chip
Factor out the irq_chip implementation, substantially reducing the code size for the driver. Signed-off-by: Mark Brown <broonie@opensource.wolfsonmicro.com> Acked-by: Samuel Ortiz <sameo@linux.intel.com>
Mark Brown
1 parent e292b578c9
Showing 3 changed files with 35 additions and 165 deletions Side-by-side Diff
drivers/mfd/Kconfig
drivers/mfd/wm8994-irq.c
include/linux/mfd/wm8994/core.h
@@ -477,6 +477,7 @@
 	bool "Support Wolfson Microelectronics WM8994"
 	select MFD_CORE
 	select REGMAP_I2C
+	select REGMAP_IRQ
 	depends on I2C=y && GENERIC_HARDIRQS
 	help
 	  The WM8994 is a highly integrated hi-fi CODEC designed for
@@ -18,239 +18,128 @@
 #include <linux/irq.h>
 #include <linux/mfd/core.h>
 #include <linux/interrupt.h>
+#include <linux/regmap.h>
  
 #include <linux/mfd/wm8994/core.h>
 #include <linux/mfd/wm8994/registers.h>
  
 #include <linux/delay.h>
  
-struct wm8994_irq_data {
-	int reg;
-	int mask;
-};
-
-static struct wm8994_irq_data wm8994_irqs[] = {
+static struct regmap_irq wm8994_irqs[] = {
 	[WM8994_IRQ_TEMP_SHUT] = {
-		.reg = 2,
+		.reg_offset = 1,
 		.mask = WM8994_TEMP_SHUT_EINT,
 	},
 	[WM8994_IRQ_MIC1_DET] = {
-		.reg = 2,
+		.reg_offset = 1,
 		.mask = WM8994_MIC1_DET_EINT,
 	},
 	[WM8994_IRQ_MIC1_SHRT] = {
-		.reg = 2,
+		.reg_offset = 1,
 		.mask = WM8994_MIC1_SHRT_EINT,
 	},
 	[WM8994_IRQ_MIC2_DET] = {
-		.reg = 2,
+		.reg_offset = 1,
 		.mask = WM8994_MIC2_DET_EINT,
 	},
 	[WM8994_IRQ_MIC2_SHRT] = {
-		.reg = 2,
+		.reg_offset = 1,
 		.mask = WM8994_MIC2_SHRT_EINT,
 	},
 	[WM8994_IRQ_FLL1_LOCK] = {
-		.reg = 2,
+		.reg_offset = 1,
 		.mask = WM8994_FLL1_LOCK_EINT,
 	},
 	[WM8994_IRQ_FLL2_LOCK] = {
-		.reg = 2,
+		.reg_offset = 1,
 		.mask = WM8994_FLL2_LOCK_EINT,
 	},
 	[WM8994_IRQ_SRC1_LOCK] = {
-		.reg = 2,
+		.reg_offset = 1,
 		.mask = WM8994_SRC1_LOCK_EINT,
 	},
 	[WM8994_IRQ_SRC2_LOCK] = {
-		.reg = 2,
+		.reg_offset = 1,
 		.mask = WM8994_SRC2_LOCK_EINT,
 	},
 	[WM8994_IRQ_AIF1DRC1_SIG_DET] = {
-		.reg = 2,
+		.reg_offset = 1,
 		.mask = WM8994_AIF1DRC1_SIG_DET,
 	},
 	[WM8994_IRQ_AIF1DRC2_SIG_DET] = {
-		.reg = 2,
+		.reg_offset = 1,
 		.mask = WM8994_AIF1DRC2_SIG_DET_EINT,
 	},
 	[WM8994_IRQ_AIF2DRC_SIG_DET] = {
-		.reg = 2,
+		.reg_offset = 1,
 		.mask = WM8994_AIF2DRC_SIG_DET_EINT,
 	},
 	[WM8994_IRQ_FIFOS_ERR] = {
-		.reg = 2,
+		.reg_offset = 1,
 		.mask = WM8994_FIFOS_ERR_EINT,
 	},
 	[WM8994_IRQ_WSEQ_DONE] = {
-		.reg = 2,
+		.reg_offset = 1,
 		.mask = WM8994_WSEQ_DONE_EINT,
 	},
 	[WM8994_IRQ_DCS_DONE] = {
-		.reg = 2,
+		.reg_offset = 1,
 		.mask = WM8994_DCS_DONE_EINT,
 	},
 	[WM8994_IRQ_TEMP_WARN] = {
-		.reg = 2,
+		.reg_offset = 1,
 		.mask = WM8994_TEMP_WARN_EINT,
 	},
 	[WM8994_IRQ_GPIO(1)] = {
-		.reg = 1,
 		.mask = WM8994_GP1_EINT,
 	},
 	[WM8994_IRQ_GPIO(2)] = {
-		.reg = 1,
 		.mask = WM8994_GP2_EINT,
 	},
 	[WM8994_IRQ_GPIO(3)] = {
-		.reg = 1,
 		.mask = WM8994_GP3_EINT,
 	},
 	[WM8994_IRQ_GPIO(4)] = {
-		.reg = 1,
 		.mask = WM8994_GP4_EINT,
 	},
 	[WM8994_IRQ_GPIO(5)] = {
-		.reg = 1,
 		.mask = WM8994_GP5_EINT,
 	},
 	[WM8994_IRQ_GPIO(6)] = {
-		.reg = 1,
 		.mask = WM8994_GP6_EINT,
 	},
 	[WM8994_IRQ_GPIO(7)] = {
-		.reg = 1,
 		.mask = WM8994_GP7_EINT,
 	},
 	[WM8994_IRQ_GPIO(8)] = {
-		.reg = 1,
 		.mask = WM8994_GP8_EINT,
 	},
 	[WM8994_IRQ_GPIO(9)] = {
-		.reg = 1,
 		.mask = WM8994_GP8_EINT,
 	},
 	[WM8994_IRQ_GPIO(10)] = {
-		.reg = 1,
 		.mask = WM8994_GP10_EINT,
 	},
 	[WM8994_IRQ_GPIO(11)] = {
-		.reg = 1,
 		.mask = WM8994_GP11_EINT,
 	},
 };
  
-static inline struct wm8994_irq_data *irq_to_wm8994_irq(struct wm8994 *wm8994,
-							int irq)
-{
-	return &wm8994_irqs[irq - wm8994->irq_base];
-}
+static struct regmap_irq_chip wm8994_irq_chip = {
+	.name = "wm8994",
+	.irqs = wm8994_irqs,
+	.num_irqs = ARRAY_SIZE(wm8994_irqs),
  
-static void wm8994_irq_lock(struct irq_data *data)
-{
-	struct wm8994 *wm8994 = irq_data_get_irq_chip_data(data);
-
-	mutex_lock(&wm8994->irq_lock);
-}
-
-static void wm8994_irq_sync_unlock(struct irq_data *data)
-{
-	struct wm8994 *wm8994 = irq_data_get_irq_chip_data(data);
-	int i;
-
-	for (i = 0; i < ARRAY_SIZE(wm8994->irq_masks_cur); i++) {
-		/* If there's been a change in the mask write it back
-		 * to the hardware. */
-		if (wm8994->irq_masks_cur[i] != wm8994->irq_masks_cache[i]) {
-			wm8994->irq_masks_cache[i] = wm8994->irq_masks_cur[i];
-			wm8994_reg_write(wm8994,
-					 WM8994_INTERRUPT_STATUS_1_MASK + i,
-					 wm8994->irq_masks_cur[i]);
-		}
-	}
-
-	mutex_unlock(&wm8994->irq_lock);
-}
-
-static void wm8994_irq_enable(struct irq_data *data)
-{
-	struct wm8994 *wm8994 = irq_data_get_irq_chip_data(data);
-	struct wm8994_irq_data *irq_data = irq_to_wm8994_irq(wm8994,
-							     data->irq);
-
-	wm8994->irq_masks_cur[irq_data->reg - 1] &= ~irq_data->mask;
-}
-
-static void wm8994_irq_disable(struct irq_data *data)
-{
-	struct wm8994 *wm8994 = irq_data_get_irq_chip_data(data);
-	struct wm8994_irq_data *irq_data = irq_to_wm8994_irq(wm8994,
-							     data->irq);
-
-	wm8994->irq_masks_cur[irq_data->reg - 1] |= irq_data->mask;
-}
-
-static struct irq_chip wm8994_irq_chip = {
-	.name			= "wm8994",
-	.irq_bus_lock		= wm8994_irq_lock,
-	.irq_bus_sync_unlock	= wm8994_irq_sync_unlock,
-	.irq_disable		= wm8994_irq_disable,
-	.irq_enable		= wm8994_irq_enable,
+	.num_regs = 2,
+	.status_base = WM8994_INTERRUPT_STATUS_1,
+	.mask_base = WM8994_INTERRUPT_STATUS_1_MASK,
+	.ack_base = WM8994_INTERRUPT_STATUS_1,
 };
  
-/* The processing of the primary interrupt occurs in a thread so that
- * we can interact with the device over I2C or SPI. */
-static irqreturn_t wm8994_irq_thread(int irq, void *data)
+int wm8994_irq_init(struct wm8994 *wm8994)
 {
-	struct wm8994 *wm8994 = data;
-	unsigned int i;
-	u16 status[WM8994_NUM_IRQ_REGS];
 	int ret;
  
-	ret = wm8994_bulk_read(wm8994, WM8994_INTERRUPT_STATUS_1,
-			       WM8994_NUM_IRQ_REGS, status);
-	if (ret < 0) {
-		dev_err(wm8994->dev, "Failed to read interrupt status: %d\n",
-			ret);
-		return IRQ_NONE;
-	}
-
-	/* Bit swap and apply masking */
-	for (i = 0; i < WM8994_NUM_IRQ_REGS; i++) {
-		status[i] = be16_to_cpu(status[i]);
-		status[i] &= ~wm8994->irq_masks_cur[i];
-	}
-
-	/* Ack any unmasked IRQs */
-	for (i = 0; i < ARRAY_SIZE(status); i++) {
-		if (status[i])
-			wm8994_reg_write(wm8994, WM8994_INTERRUPT_STATUS_1 + i,
-					 status[i]);
-	}
-
-	/* Report */
-	for (i = 0; i < ARRAY_SIZE(wm8994_irqs); i++) {
-		if (status[wm8994_irqs[i].reg - 1] & wm8994_irqs[i].mask)
-			handle_nested_irq(wm8994->irq_base + i);
-	}
-
-	return IRQ_HANDLED;
-}
-
-int wm8994_irq_init(struct wm8994 *wm8994)
-{
-	int i, cur_irq, ret;
-
-	mutex_init(&wm8994->irq_lock);
-
-	/* Mask the individual interrupt sources */
-	for (i = 0; i < ARRAY_SIZE(wm8994->irq_masks_cur); i++) {
-		wm8994->irq_masks_cur[i] = 0xffff;
-		wm8994->irq_masks_cache[i] = 0xffff;
-		wm8994_reg_write(wm8994, WM8994_INTERRUPT_STATUS_1_MASK + i,
-				 0xffff);
-	}
-
 	if (!wm8994->irq) {
 		dev_warn(wm8994->dev,
 			 "No interrupt specified, no interrupts\n");
  
@@ -264,30 +153,12 @@
 		return 0;
 	}
  
-	/* Register them with genirq */
-	for (cur_irq = wm8994->irq_base;
-	     cur_irq < ARRAY_SIZE(wm8994_irqs) + wm8994->irq_base;
-	     cur_irq++) {
-		irq_set_chip_data(cur_irq, wm8994);
-		irq_set_chip_and_handler(cur_irq, &wm8994_irq_chip,
-					 handle_edge_irq);
-		irq_set_nested_thread(cur_irq, 1);
-
-		/* ARM needs us to explicitly flag the IRQ as valid
-		 * and will set them noprobe when we do so. */
-#ifdef CONFIG_ARM
-		set_irq_flags(cur_irq, IRQF_VALID);
-#else
-		irq_set_noprobe(cur_irq);
-#endif
-	}
-
-	ret = request_threaded_irq(wm8994->irq, NULL, wm8994_irq_thread,
-				   IRQF_TRIGGER_HIGH | IRQF_ONESHOT,
-				   "wm8994", wm8994);
+	ret = regmap_add_irq_chip(wm8994->regmap, wm8994->irq,
+				  IRQF_TRIGGER_HIGH | IRQF_ONESHOT,
+				  wm8994->irq_base, &wm8994_irq_chip,
+				  &wm8994->irq_data);
 	if (ret != 0) {
-		dev_err(wm8994->dev, "Failed to request IRQ %d: %d\n",
-			wm8994->irq, ret);
+		dev_err(wm8994->dev, "Failed to register IRQ chip: %d\n", ret);
 		return ret;
 	}
  
@@ -299,7 +170,6 @@
  
 void wm8994_irq_exit(struct wm8994 *wm8994)
 {
-	if (wm8994->irq)
-		free_irq(wm8994->irq, wm8994);
+	regmap_del_irq_chip(wm8994->irq, wm8994->irq_data);
 }
@@ -67,8 +67,7 @@
 	int irq_base;
  
 	int irq;
-	u16 irq_masks_cur[WM8994_NUM_IRQ_REGS];
-	u16 irq_masks_cache[WM8994_NUM_IRQ_REGS];
+	struct regmap_irq_chip_data *irq_data;
  
 	/* Used over suspend/resume */
 	bool suspended;
...	...	@@ -477,6 +477,7 @@
477	477	bool "Support Wolfson Microelectronics WM8994"
478	478	select MFD_CORE
479	479	select REGMAP_I2C
	480	+ select REGMAP_IRQ
480	481	depends on I2C=y && GENERIC_HARDIRQS
481	482	help
482	483	The WM8994 is a highly integrated hi-fi CODEC designed for
...	...	@@ -18,239 +18,128 @@
18	18	#include <linux/irq.h>
19	19	#include <linux/mfd/core.h>
20	20	#include <linux/interrupt.h>
	21	+#include <linux/regmap.h>
21	22
22	23	#include <linux/mfd/wm8994/core.h>
23	24	#include <linux/mfd/wm8994/registers.h>
24	25
25	26	#include <linux/delay.h>
26	27
27		-struct wm8994_irq_data {
28		- int reg;
29		- int mask;
30		-};
31		-
32		-static struct wm8994_irq_data wm8994_irqs[] = {
	28	+static struct regmap_irq wm8994_irqs[] = {
33	29	[WM8994_IRQ_TEMP_SHUT] = {
34		- .reg = 2,
	30	+ .reg_offset = 1,
35	31	.mask = WM8994_TEMP_SHUT_EINT,
36	32	},
37	33	[WM8994_IRQ_MIC1_DET] = {
38		- .reg = 2,
	34	+ .reg_offset = 1,
39	35	.mask = WM8994_MIC1_DET_EINT,
40	36	},
41	37	[WM8994_IRQ_MIC1_SHRT] = {
42		- .reg = 2,
	38	+ .reg_offset = 1,
43	39	.mask = WM8994_MIC1_SHRT_EINT,
44	40	},
45	41	[WM8994_IRQ_MIC2_DET] = {
46		- .reg = 2,
	42	+ .reg_offset = 1,
47	43	.mask = WM8994_MIC2_DET_EINT,
48	44	},
49	45	[WM8994_IRQ_MIC2_SHRT] = {
50		- .reg = 2,
	46	+ .reg_offset = 1,
51	47	.mask = WM8994_MIC2_SHRT_EINT,
52	48	},
53	49	[WM8994_IRQ_FLL1_LOCK] = {
54		- .reg = 2,
	50	+ .reg_offset = 1,
55	51	.mask = WM8994_FLL1_LOCK_EINT,
56	52	},
57	53	[WM8994_IRQ_FLL2_LOCK] = {
58		- .reg = 2,
	54	+ .reg_offset = 1,
59	55	.mask = WM8994_FLL2_LOCK_EINT,
60	56	},
61	57	[WM8994_IRQ_SRC1_LOCK] = {
62		- .reg = 2,
	58	+ .reg_offset = 1,
63	59	.mask = WM8994_SRC1_LOCK_EINT,
64	60	},
65	61	[WM8994_IRQ_SRC2_LOCK] = {
66		- .reg = 2,
	62	+ .reg_offset = 1,
67	63	.mask = WM8994_SRC2_LOCK_EINT,
68	64	},
69	65	[WM8994_IRQ_AIF1DRC1_SIG_DET] = {
70		- .reg = 2,
	66	+ .reg_offset = 1,
71	67	.mask = WM8994_AIF1DRC1_SIG_DET,
72	68	},
73	69	[WM8994_IRQ_AIF1DRC2_SIG_DET] = {
74		- .reg = 2,
	70	+ .reg_offset = 1,
75	71	.mask = WM8994_AIF1DRC2_SIG_DET_EINT,
76	72	},
77	73	[WM8994_IRQ_AIF2DRC_SIG_DET] = {
78		- .reg = 2,
	74	+ .reg_offset = 1,
79	75	.mask = WM8994_AIF2DRC_SIG_DET_EINT,
80	76	},
81	77	[WM8994_IRQ_FIFOS_ERR] = {
82		- .reg = 2,
	78	+ .reg_offset = 1,
83	79	.mask = WM8994_FIFOS_ERR_EINT,
84	80	},
85	81	[WM8994_IRQ_WSEQ_DONE] = {
86		- .reg = 2,
	82	+ .reg_offset = 1,
87	83	.mask = WM8994_WSEQ_DONE_EINT,
88	84	},
89	85	[WM8994_IRQ_DCS_DONE] = {
90		- .reg = 2,
	86	+ .reg_offset = 1,
91	87	.mask = WM8994_DCS_DONE_EINT,
92	88	},
93	89	[WM8994_IRQ_TEMP_WARN] = {
94		- .reg = 2,
	90	+ .reg_offset = 1,
95	91	.mask = WM8994_TEMP_WARN_EINT,
96	92	},
97	93	[WM8994_IRQ_GPIO(1)] = {
98		- .reg = 1,
99	94	.mask = WM8994_GP1_EINT,
100	95	},
101	96	[WM8994_IRQ_GPIO(2)] = {
102		- .reg = 1,
103	97	.mask = WM8994_GP2_EINT,
104	98	},
105	99	[WM8994_IRQ_GPIO(3)] = {
106		- .reg = 1,
107	100	.mask = WM8994_GP3_EINT,
108	101	},
109	102	[WM8994_IRQ_GPIO(4)] = {
110		- .reg = 1,
111	103	.mask = WM8994_GP4_EINT,
112	104	},
113	105	[WM8994_IRQ_GPIO(5)] = {
114		- .reg = 1,
115	106	.mask = WM8994_GP5_EINT,
116	107	},
117	108	[WM8994_IRQ_GPIO(6)] = {
118		- .reg = 1,
119	109	.mask = WM8994_GP6_EINT,
120	110	},
121	111	[WM8994_IRQ_GPIO(7)] = {
122		- .reg = 1,
123	112	.mask = WM8994_GP7_EINT,
124	113	},
125	114	[WM8994_IRQ_GPIO(8)] = {
126		- .reg = 1,
127	115	.mask = WM8994_GP8_EINT,
128	116	},
129	117	[WM8994_IRQ_GPIO(9)] = {
130		- .reg = 1,
131	118	.mask = WM8994_GP8_EINT,
132	119	},
133	120	[WM8994_IRQ_GPIO(10)] = {
134		- .reg = 1,
135	121	.mask = WM8994_GP10_EINT,
136	122	},
137	123	[WM8994_IRQ_GPIO(11)] = {
138		- .reg = 1,
139	124	.mask = WM8994_GP11_EINT,
140	125	},
141	126	};
142	127
143		-static inline struct wm8994_irq_data irq_to_wm8994_irq(struct wm8994 wm8994,
144		- int irq)
145		-{
146		- return &wm8994_irqs[irq - wm8994->irq_base];
147		-}
	128	+static struct regmap_irq_chip wm8994_irq_chip = {
	129	+ .name = "wm8994",
	130	+ .irqs = wm8994_irqs,
	131	+ .num_irqs = ARRAY_SIZE(wm8994_irqs),
148	132
149		-static void wm8994_irq_lock(struct irq_data *data)
150		-{
151		- struct wm8994 *wm8994 = irq_data_get_irq_chip_data(data);
152		-
153		- mutex_lock(&wm8994->irq_lock);
154		-}
155		-
156		-static void wm8994_irq_sync_unlock(struct irq_data *data)
157		-{
158		- struct wm8994 *wm8994 = irq_data_get_irq_chip_data(data);
159		- int i;
160		-
161		- for (i = 0; i < ARRAY_SIZE(wm8994->irq_masks_cur); i++) {
162		- /* If there's been a change in the mask write it back
163		- * to the hardware. */
164		- if (wm8994->irq_masks_cur[i] != wm8994->irq_masks_cache[i]) {
165		- wm8994->irq_masks_cache[i] = wm8994->irq_masks_cur[i];
166		- wm8994_reg_write(wm8994,
167		- WM8994_INTERRUPT_STATUS_1_MASK + i,
168		- wm8994->irq_masks_cur[i]);
169		- }
170		- }
171		-
172		- mutex_unlock(&wm8994->irq_lock);
173		-}
174		-
175		-static void wm8994_irq_enable(struct irq_data *data)
176		-{
177		- struct wm8994 *wm8994 = irq_data_get_irq_chip_data(data);
178		- struct wm8994_irq_data *irq_data = irq_to_wm8994_irq(wm8994,
179		- data->irq);
180		-
181		- wm8994->irq_masks_cur[irq_data->reg - 1] &= ~irq_data->mask;
182		-}
183		-
184		-static void wm8994_irq_disable(struct irq_data *data)
185		-{
186		- struct wm8994 *wm8994 = irq_data_get_irq_chip_data(data);
187		- struct wm8994_irq_data *irq_data = irq_to_wm8994_irq(wm8994,
188		- data->irq);
189		-
190		- wm8994->irq_masks_cur[irq_data->reg - 1] \|= irq_data->mask;
191		-}
192		-
193		-static struct irq_chip wm8994_irq_chip = {
194		- .name = "wm8994",
195		- .irq_bus_lock = wm8994_irq_lock,
196		- .irq_bus_sync_unlock = wm8994_irq_sync_unlock,
197		- .irq_disable = wm8994_irq_disable,
198		- .irq_enable = wm8994_irq_enable,
	133	+ .num_regs = 2,
	134	+ .status_base = WM8994_INTERRUPT_STATUS_1,
	135	+ .mask_base = WM8994_INTERRUPT_STATUS_1_MASK,
	136	+ .ack_base = WM8994_INTERRUPT_STATUS_1,
199	137	};
200	138
201		-/* The processing of the primary interrupt occurs in a thread so that
202		- * we can interact with the device over I2C or SPI. */
203		-static irqreturn_t wm8994_irq_thread(int irq, void *data)
	139	+int wm8994_irq_init(struct wm8994 *wm8994)
204	140	{
205		- struct wm8994 *wm8994 = data;
206		- unsigned int i;
207		- u16 status[WM8994_NUM_IRQ_REGS];
208	141	int ret;
209	142
210		- ret = wm8994_bulk_read(wm8994, WM8994_INTERRUPT_STATUS_1,
211		- WM8994_NUM_IRQ_REGS, status);
212		- if (ret < 0) {
213		- dev_err(wm8994->dev, "Failed to read interrupt status: %d\n",
214		- ret);
215		- return IRQ_NONE;
216		- }
217		-
218		- /* Bit swap and apply masking */
219		- for (i = 0; i < WM8994_NUM_IRQ_REGS; i++) {
220		- status[i] = be16_to_cpu(status[i]);
221		- status[i] &= ~wm8994->irq_masks_cur[i];
222		- }
223		-
224		- /* Ack any unmasked IRQs */
225		- for (i = 0; i < ARRAY_SIZE(status); i++) {
226		- if (status[i])
227		- wm8994_reg_write(wm8994, WM8994_INTERRUPT_STATUS_1 + i,
228		- status[i]);
229		- }
230		-
231		- /* Report */
232		- for (i = 0; i < ARRAY_SIZE(wm8994_irqs); i++) {
233		- if (status[wm8994_irqs[i].reg - 1] & wm8994_irqs[i].mask)
234		- handle_nested_irq(wm8994->irq_base + i);
235		- }
236		-
237		- return IRQ_HANDLED;
238		-}
239		-
240		-int wm8994_irq_init(struct wm8994 *wm8994)
241		-{
242		- int i, cur_irq, ret;
243		-
244		- mutex_init(&wm8994->irq_lock);
245		-
246		- /* Mask the individual interrupt sources */
247		- for (i = 0; i < ARRAY_SIZE(wm8994->irq_masks_cur); i++) {
248		- wm8994->irq_masks_cur[i] = 0xffff;
249		- wm8994->irq_masks_cache[i] = 0xffff;
250		- wm8994_reg_write(wm8994, WM8994_INTERRUPT_STATUS_1_MASK + i,
251		- 0xffff);
252		- }
253		-
254	143	if (!wm8994->irq) {
255	144	dev_warn(wm8994->dev,
256	145	"No interrupt specified, no interrupts\n");
257	146
...	...	@@ -264,30 +153,12 @@
264	153	return 0;
265	154	}
266	155
267		- /* Register them with genirq */
268		- for (cur_irq = wm8994->irq_base;
269		- cur_irq < ARRAY_SIZE(wm8994_irqs) + wm8994->irq_base;
270		- cur_irq++) {
271		- irq_set_chip_data(cur_irq, wm8994);
272		- irq_set_chip_and_handler(cur_irq, &wm8994_irq_chip,
273		- handle_edge_irq);
274		- irq_set_nested_thread(cur_irq, 1);
275		-
276		- /* ARM needs us to explicitly flag the IRQ as valid
277		- * and will set them noprobe when we do so. */
278		-#ifdef CONFIG_ARM
279		- set_irq_flags(cur_irq, IRQF_VALID);
280		-#else
281		- irq_set_noprobe(cur_irq);
282		-#endif
283		- }
284		-
285		- ret = request_threaded_irq(wm8994->irq, NULL, wm8994_irq_thread,
286		- IRQF_TRIGGER_HIGH \| IRQF_ONESHOT,
287		- "wm8994", wm8994);
	156	+ ret = regmap_add_irq_chip(wm8994->regmap, wm8994->irq,
	157	+ IRQF_TRIGGER_HIGH \| IRQF_ONESHOT,
	158	+ wm8994->irq_base, &wm8994_irq_chip,
	159	+ &wm8994->irq_data);
288	160	if (ret != 0) {
289		- dev_err(wm8994->dev, "Failed to request IRQ %d: %d\n",
290		- wm8994->irq, ret);
	161	+ dev_err(wm8994->dev, "Failed to register IRQ chip: %d\n", ret);
291	162	return ret;
292	163	}
293	164
...	...	@@ -299,7 +170,6 @@
299	170
300	171	void wm8994_irq_exit(struct wm8994 *wm8994)
301	172	{
302		- if (wm8994->irq)
303		- free_irq(wm8994->irq, wm8994);
	173	+ regmap_del_irq_chip(wm8994->irq, wm8994->irq_data);
304	174	}
...	...	@@ -67,8 +67,7 @@
67	67	int irq_base;
68	68
69	69	int irq;
70		- u16 irq_masks_cur[WM8994_NUM_IRQ_REGS];
71		- u16 irq_masks_cache[WM8994_NUM_IRQ_REGS];
	70	+ struct regmap_irq_chip_data *irq_data;
72	71
73	72	/* Used over suspend/resume */
74	73	bool suspended;