?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
bridge: netfilter: fix update_pmtu crash with GRE
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / mfd / wm8350-core.c
blob0d47fb9e4b3bcec5248e510504d8c6b5f2b059ec
1 /*
2 * wm8350-core.c -- Device access for Wolfson WM8350
3 *
4 * Copyright 2007, 2008 Wolfson Microelectronics PLC.
5 *
6 * Author: Liam Girdwood, Mark Brown
7 *
8 * This program is free software; you can redistribute it and/or modify it
9 * under the terms of the GNU General Public License as published by the
10 * Free Software Foundation; either version 2 of the License, or (at your
11 * option) any later version.
12 *
13 */
14
15 #include <linux/kernel.h>
16 #include <linux/module.h>
17 #include <linux/init.h>
18 #include <linux/bug.h>
19 #include <linux/device.h>
20 #include <linux/delay.h>
21 #include <linux/interrupt.h>
22 #include <linux/workqueue.h>
23
24 #include <linux/mfd/wm8350/core.h>
25 #include <linux/mfd/wm8350/audio.h>
26 #include <linux/mfd/wm8350/comparator.h>
27 #include <linux/mfd/wm8350/gpio.h>
28 #include <linux/mfd/wm8350/pmic.h>
29 #include <linux/mfd/wm8350/rtc.h>
30 #include <linux/mfd/wm8350/supply.h>
31 #include <linux/mfd/wm8350/wdt.h>
32
33 #define WM8350_UNLOCK_KEY 0x0013
34 #define WM8350_LOCK_KEY 0x0000
35
36 #define WM8350_CLOCK_CONTROL_1 0x28
37 #define WM8350_AIF_TEST 0x74
38
39 /* debug */
40 #define WM8350_BUS_DEBUG 0
41 #if WM8350_BUS_DEBUG
42 #define dump(regs, src) do { \
43 int i_; \
44 u16 *src_ = src; \
45 printk(KERN_DEBUG); \
46 for (i_ = 0; i_ < regs; i_++) \
47 printk(" 0x%4.4x", *src_++); \
48 printk("\n"); \
49 } while (0);
50 #else
51 #define dump(bytes, src)
52 #endif
53
54 #define WM8350_LOCK_DEBUG 0
55 #if WM8350_LOCK_DEBUG
56 #define ldbg(format, arg...) printk(format, ## arg)
57 #else
58 #define ldbg(format, arg...)
59 #endif
60
61 /*
62 * WM8350 Device IO
63 */
64 static DEFINE_MUTEX(io_mutex);
65 static DEFINE_MUTEX(reg_lock_mutex);
66 static DEFINE_MUTEX(auxadc_mutex);
67
68 /* Perform a physical read from the device.
69 */
70 static int wm8350_phys_read(struct wm8350 *wm8350, u8 reg, int num_regs,
71 u16 *dest)
72 {
73 int i, ret;
74 int bytes = num_regs * 2;
75
76 dev_dbg(wm8350->dev, "volatile read\n");
77 ret = wm8350->read_dev(wm8350, reg, bytes, (char *)dest);
78
79 for (i = reg; i < reg + num_regs; i++) {
80 /* Cache is CPU endian */
81 dest[i - reg] = be16_to_cpu(dest[i - reg]);
82
83 /* Satisfy non-volatile bits from cache */
84 dest[i - reg] &= wm8350_reg_io_map[i].vol;
85 dest[i - reg] |= wm8350->reg_cache[i];
86
87 /* Mask out non-readable bits */
88 dest[i - reg] &= wm8350_reg_io_map[i].readable;
89 }
90
91 dump(num_regs, dest);
92
93 return ret;
94 }
95
96 static int wm8350_read(struct wm8350 *wm8350, u8 reg, int num_regs, u16 *dest)
97 {
98 int i;
99 int end = reg + num_regs;
100 int ret = 0;
101 int bytes = num_regs * 2;
102
103 if (wm8350->read_dev == NULL)
104 return -ENODEV;
105
106 if ((reg + num_regs - 1) > WM8350_MAX_REGISTER) {
107 dev_err(wm8350->dev, "invalid reg %x\n",
108 reg + num_regs - 1);
109 return -EINVAL;
110 }
111
112 dev_dbg(wm8350->dev,
113 "%s R%d(0x%2.2x) %d regs\n", __func__, reg, reg, num_regs);
114
115 #if WM8350_BUS_DEBUG
116 /* we can _safely_ read any register, but warn if read not supported */
117 for (i = reg; i < end; i++) {
118 if (!wm8350_reg_io_map[i].readable)
119 dev_warn(wm8350->dev,
120 "reg R%d is not readable\n", i);
121 }
122 #endif
123
124 /* if any volatile registers are required, then read back all */
125 for (i = reg; i < end; i++)
126 if (wm8350_reg_io_map[i].vol)
127 return wm8350_phys_read(wm8350, reg, num_regs, dest);
128
129 /* no volatiles, then cache is good */
130 dev_dbg(wm8350->dev, "cache read\n");
131 memcpy(dest, &wm8350->reg_cache[reg], bytes);
132 dump(num_regs, dest);
133 return ret;
134 }
135
136 static inline int is_reg_locked(struct wm8350 *wm8350, u8 reg)
137 {
138 if (reg == WM8350_SECURITY ||
139 wm8350->reg_cache[WM8350_SECURITY] == WM8350_UNLOCK_KEY)
140 return 0;
141
142 if ((reg == WM8350_GPIO_CONFIGURATION_I_O) ||
143 (reg >= WM8350_GPIO_FUNCTION_SELECT_1 &&
144 reg <= WM8350_GPIO_FUNCTION_SELECT_4) ||
145 (reg >= WM8350_BATTERY_CHARGER_CONTROL_1 &&
146 reg <= WM8350_BATTERY_CHARGER_CONTROL_3))
147 return 1;
148 return 0;
149 }
150
151 static int wm8350_write(struct wm8350 *wm8350, u8 reg, int num_regs, u16 *src)
152 {
153 int i;
154 int end = reg + num_regs;
155 int bytes = num_regs * 2;
156
157 if (wm8350->write_dev == NULL)
158 return -ENODEV;
159
160 if ((reg + num_regs - 1) > WM8350_MAX_REGISTER) {
161 dev_err(wm8350->dev, "invalid reg %x\n",
162 reg + num_regs - 1);
163 return -EINVAL;
164 }
165
166 /* it's generally not a good idea to write to RO or locked registers */
167 for (i = reg; i < end; i++) {
168 if (!wm8350_reg_io_map[i].writable) {
169 dev_err(wm8350->dev,
170 "attempted write to read only reg R%d\n", i);
171 return -EINVAL;
172 }
173
174 if (is_reg_locked(wm8350, i)) {
175 dev_err(wm8350->dev,
176 "attempted write to locked reg R%d\n", i);
177 return -EINVAL;
178 }
179
180 src[i - reg] &= wm8350_reg_io_map[i].writable;
181
182 wm8350->reg_cache[i] =
183 (wm8350->reg_cache[i] & ~wm8350_reg_io_map[i].writable)
184 | src[i - reg];
185
186 /* Don't store volatile bits */
187 wm8350->reg_cache[i] &= ~wm8350_reg_io_map[i].vol;
188
189 src[i - reg] = cpu_to_be16(src[i - reg]);
190 }
191
192 /* Actually write it out */
193 return wm8350->write_dev(wm8350, reg, bytes, (char *)src);
194 }
195
196 /*
197 * Safe read, modify, write methods
198 */
199 int wm8350_clear_bits(struct wm8350 *wm8350, u16 reg, u16 mask)
200 {
201 u16 data;
202 int err;
203
204 mutex_lock(&io_mutex);
205 err = wm8350_read(wm8350, reg, 1, &data);
206 if (err) {
207 dev_err(wm8350->dev, "read from reg R%d failed\n", reg);
208 goto out;
209 }
210
211 data &= ~mask;
212 err = wm8350_write(wm8350, reg, 1, &data);
213 if (err)
214 dev_err(wm8350->dev, "write to reg R%d failed\n", reg);
215 out:
216 mutex_unlock(&io_mutex);
217 return err;
218 }
219 EXPORT_SYMBOL_GPL(wm8350_clear_bits);
220
221 int wm8350_set_bits(struct wm8350 *wm8350, u16 reg, u16 mask)
222 {
223 u16 data;
224 int err;
225
226 mutex_lock(&io_mutex);
227 err = wm8350_read(wm8350, reg, 1, &data);
228 if (err) {
229 dev_err(wm8350->dev, "read from reg R%d failed\n", reg);
230 goto out;
231 }
232
233 data |= mask;
234 err = wm8350_write(wm8350, reg, 1, &data);
235 if (err)
236 dev_err(wm8350->dev, "write to reg R%d failed\n", reg);
237 out:
238 mutex_unlock(&io_mutex);
239 return err;
240 }
241 EXPORT_SYMBOL_GPL(wm8350_set_bits);
242
243 u16 wm8350_reg_read(struct wm8350 *wm8350, int reg)
244 {
245 u16 data;
246 int err;
247
248 mutex_lock(&io_mutex);
249 err = wm8350_read(wm8350, reg, 1, &data);
250 if (err)
251 dev_err(wm8350->dev, "read from reg R%d failed\n", reg);
252
253 mutex_unlock(&io_mutex);
254 return data;
255 }
256 EXPORT_SYMBOL_GPL(wm8350_reg_read);
257
258 int wm8350_reg_write(struct wm8350 *wm8350, int reg, u16 val)
259 {
260 int ret;
261 u16 data = val;
262
263 mutex_lock(&io_mutex);
264 ret = wm8350_write(wm8350, reg, 1, &data);
265 if (ret)
266 dev_err(wm8350->dev, "write to reg R%d failed\n", reg);
267 mutex_unlock(&io_mutex);
268 return ret;
269 }
270 EXPORT_SYMBOL_GPL(wm8350_reg_write);
271
272 int wm8350_block_read(struct wm8350 *wm8350, int start_reg, int regs,
273 u16 *dest)
274 {
275 int err = 0;
276
277 mutex_lock(&io_mutex);
278 err = wm8350_read(wm8350, start_reg, regs, dest);
279 if (err)
280 dev_err(wm8350->dev, "block read starting from R%d failed\n",
281 start_reg);
282 mutex_unlock(&io_mutex);
283 return err;
284 }
285 EXPORT_SYMBOL_GPL(wm8350_block_read);
286
287 int wm8350_block_write(struct wm8350 *wm8350, int start_reg, int regs,
288 u16 *src)
289 {
290 int ret = 0;
291
292 mutex_lock(&io_mutex);
293 ret = wm8350_write(wm8350, start_reg, regs, src);
294 if (ret)
295 dev_err(wm8350->dev, "block write starting at R%d failed\n",
296 start_reg);
297 mutex_unlock(&io_mutex);
298 return ret;
299 }
300 EXPORT_SYMBOL_GPL(wm8350_block_write);
301
302 int wm8350_reg_lock(struct wm8350 *wm8350)
303 {
304 u16 key = WM8350_LOCK_KEY;
305 int ret;
306
307 ldbg(__func__);
308 mutex_lock(&io_mutex);
309 ret = wm8350_write(wm8350, WM8350_SECURITY, 1, &key);
310 if (ret)
311 dev_err(wm8350->dev, "lock failed\n");
312 mutex_unlock(&io_mutex);
313 return ret;
314 }
315 EXPORT_SYMBOL_GPL(wm8350_reg_lock);
316
317 int wm8350_reg_unlock(struct wm8350 *wm8350)
318 {
319 u16 key = WM8350_UNLOCK_KEY;
320 int ret;
321
322 ldbg(__func__);
323 mutex_lock(&io_mutex);
324 ret = wm8350_write(wm8350, WM8350_SECURITY, 1, &key);
325 if (ret)
326 dev_err(wm8350->dev, "unlock failed\n");
327 mutex_unlock(&io_mutex);
328 return ret;
329 }
330 EXPORT_SYMBOL_GPL(wm8350_reg_unlock);
331
332 static void wm8350_irq_call_handler(struct wm8350 *wm8350, int irq)
333 {
334 mutex_lock(&wm8350->irq_mutex);
335
336 if (wm8350->irq[irq].handler)
337 wm8350->irq[irq].handler(wm8350, irq, wm8350->irq[irq].data);
338 else {
339 dev_err(wm8350->dev, "irq %d nobody cared. now masked.\n",
340 irq);
341 wm8350_mask_irq(wm8350, irq);
342 }
343
344 mutex_unlock(&wm8350->irq_mutex);
345 }
346
347 /*
348 * wm8350_irq_worker actually handles the interrupts. Since all
349 * interrupts are clear on read the IRQ line will be reasserted and
350 * the physical IRQ will be handled again if another interrupt is
351 * asserted while we run - in the normal course of events this is a
352 * rare occurrence so we save I2C/SPI reads.
353 */
354 static void wm8350_irq_worker(struct work_struct *work)
355 {
356 struct wm8350 *wm8350 = container_of(work, struct wm8350, irq_work);
357 u16 level_one, status1, status2, comp;
358
359 /* TODO: Use block reads to improve performance? */
360 level_one = wm8350_reg_read(wm8350, WM8350_SYSTEM_INTERRUPTS)
361 & ~wm8350_reg_read(wm8350, WM8350_SYSTEM_INTERRUPTS_MASK);
362 status1 = wm8350_reg_read(wm8350, WM8350_INT_STATUS_1)
363 & ~wm8350_reg_read(wm8350, WM8350_INT_STATUS_1_MASK);
364 status2 = wm8350_reg_read(wm8350, WM8350_INT_STATUS_2)
365 & ~wm8350_reg_read(wm8350, WM8350_INT_STATUS_2_MASK);
366 comp = wm8350_reg_read(wm8350, WM8350_COMPARATOR_INT_STATUS)
367 & ~wm8350_reg_read(wm8350, WM8350_COMPARATOR_INT_STATUS_MASK);
368
369 /* over current */
370 if (level_one & WM8350_OC_INT) {
371 u16 oc;
372
373 oc = wm8350_reg_read(wm8350, WM8350_OVER_CURRENT_INT_STATUS);
374 oc &= ~wm8350_reg_read(wm8350,
375 WM8350_OVER_CURRENT_INT_STATUS_MASK);
376
377 if (oc & WM8350_OC_LS_EINT) /* limit switch */
378 wm8350_irq_call_handler(wm8350, WM8350_IRQ_OC_LS);
379 }
380
381 /* under voltage */
382 if (level_one & WM8350_UV_INT) {
383 u16 uv;
384
385 uv = wm8350_reg_read(wm8350, WM8350_UNDER_VOLTAGE_INT_STATUS);
386 uv &= ~wm8350_reg_read(wm8350,
387 WM8350_UNDER_VOLTAGE_INT_STATUS_MASK);
388
389 if (uv & WM8350_UV_DC1_EINT)
390 wm8350_irq_call_handler(wm8350, WM8350_IRQ_UV_DC1);
391 if (uv & WM8350_UV_DC2_EINT)
392 wm8350_irq_call_handler(wm8350, WM8350_IRQ_UV_DC2);
393 if (uv & WM8350_UV_DC3_EINT)
394 wm8350_irq_call_handler(wm8350, WM8350_IRQ_UV_DC3);
395 if (uv & WM8350_UV_DC4_EINT)
396 wm8350_irq_call_handler(wm8350, WM8350_IRQ_UV_DC4);
397 if (uv & WM8350_UV_DC5_EINT)
398 wm8350_irq_call_handler(wm8350, WM8350_IRQ_UV_DC5);
399 if (uv & WM8350_UV_DC6_EINT)
400 wm8350_irq_call_handler(wm8350, WM8350_IRQ_UV_DC6);
401 if (uv & WM8350_UV_LDO1_EINT)
402 wm8350_irq_call_handler(wm8350, WM8350_IRQ_UV_LDO1);
403 if (uv & WM8350_UV_LDO2_EINT)
404 wm8350_irq_call_handler(wm8350, WM8350_IRQ_UV_LDO2);
405 if (uv & WM8350_UV_LDO3_EINT)
406 wm8350_irq_call_handler(wm8350, WM8350_IRQ_UV_LDO3);
407 if (uv & WM8350_UV_LDO4_EINT)
408 wm8350_irq_call_handler(wm8350, WM8350_IRQ_UV_LDO4);
409 }
410
411 /* charger, RTC */
412 if (status1) {
413 if (status1 & WM8350_CHG_BAT_HOT_EINT)
414 wm8350_irq_call_handler(wm8350,
415 WM8350_IRQ_CHG_BAT_HOT);
416 if (status1 & WM8350_CHG_BAT_COLD_EINT)
417 wm8350_irq_call_handler(wm8350,
418 WM8350_IRQ_CHG_BAT_COLD);
419 if (status1 & WM8350_CHG_BAT_FAIL_EINT)
420 wm8350_irq_call_handler(wm8350,
421 WM8350_IRQ_CHG_BAT_FAIL);
422 if (status1 & WM8350_CHG_TO_EINT)
423 wm8350_irq_call_handler(wm8350, WM8350_IRQ_CHG_TO);
424 if (status1 & WM8350_CHG_END_EINT)
425 wm8350_irq_call_handler(wm8350, WM8350_IRQ_CHG_END);
426 if (status1 & WM8350_CHG_START_EINT)
427 wm8350_irq_call_handler(wm8350, WM8350_IRQ_CHG_START);
428 if (status1 & WM8350_CHG_FAST_RDY_EINT)
429 wm8350_irq_call_handler(wm8350,
430 WM8350_IRQ_CHG_FAST_RDY);
431 if (status1 & WM8350_CHG_VBATT_LT_3P9_EINT)
432 wm8350_irq_call_handler(wm8350,
433 WM8350_IRQ_CHG_VBATT_LT_3P9);
434 if (status1 & WM8350_CHG_VBATT_LT_3P1_EINT)
435 wm8350_irq_call_handler(wm8350,
436 WM8350_IRQ_CHG_VBATT_LT_3P1);
437 if (status1 & WM8350_CHG_VBATT_LT_2P85_EINT)
438 wm8350_irq_call_handler(wm8350,
439 WM8350_IRQ_CHG_VBATT_LT_2P85);
440 if (status1 & WM8350_RTC_ALM_EINT)
441 wm8350_irq_call_handler(wm8350, WM8350_IRQ_RTC_ALM);
442 if (status1 & WM8350_RTC_SEC_EINT)
443 wm8350_irq_call_handler(wm8350, WM8350_IRQ_RTC_SEC);
444 if (status1 & WM8350_RTC_PER_EINT)
445 wm8350_irq_call_handler(wm8350, WM8350_IRQ_RTC_PER);
446 }
447
448 /* current sink, system, aux adc */
449 if (status2) {
450 if (status2 & WM8350_CS1_EINT)
451 wm8350_irq_call_handler(wm8350, WM8350_IRQ_CS1);
452 if (status2 & WM8350_CS2_EINT)
453 wm8350_irq_call_handler(wm8350, WM8350_IRQ_CS2);
454
455 if (status2 & WM8350_SYS_HYST_COMP_FAIL_EINT)
456 wm8350_irq_call_handler(wm8350,
457 WM8350_IRQ_SYS_HYST_COMP_FAIL);
458 if (status2 & WM8350_SYS_CHIP_GT115_EINT)
459 wm8350_irq_call_handler(wm8350,
460 WM8350_IRQ_SYS_CHIP_GT115);
461 if (status2 & WM8350_SYS_CHIP_GT140_EINT)
462 wm8350_irq_call_handler(wm8350,
463 WM8350_IRQ_SYS_CHIP_GT140);
464 if (status2 & WM8350_SYS_WDOG_TO_EINT)
465 wm8350_irq_call_handler(wm8350,
466 WM8350_IRQ_SYS_WDOG_TO);
467
468 if (status2 & WM8350_AUXADC_DATARDY_EINT)
469 wm8350_irq_call_handler(wm8350,
470 WM8350_IRQ_AUXADC_DATARDY);
471 if (status2 & WM8350_AUXADC_DCOMP4_EINT)
472 wm8350_irq_call_handler(wm8350,
473 WM8350_IRQ_AUXADC_DCOMP4);
474 if (status2 & WM8350_AUXADC_DCOMP3_EINT)
475 wm8350_irq_call_handler(wm8350,
476 WM8350_IRQ_AUXADC_DCOMP3);
477 if (status2 & WM8350_AUXADC_DCOMP2_EINT)
478 wm8350_irq_call_handler(wm8350,
479 WM8350_IRQ_AUXADC_DCOMP2);
480 if (status2 & WM8350_AUXADC_DCOMP1_EINT)
481 wm8350_irq_call_handler(wm8350,
482 WM8350_IRQ_AUXADC_DCOMP1);
483
484 if (status2 & WM8350_USB_LIMIT_EINT)
485 wm8350_irq_call_handler(wm8350, WM8350_IRQ_USB_LIMIT);
486 }
487
488 /* wake, codec, ext */
489 if (comp) {
490 if (comp & WM8350_WKUP_OFF_STATE_EINT)
491 wm8350_irq_call_handler(wm8350,
492 WM8350_IRQ_WKUP_OFF_STATE);
493 if (comp & WM8350_WKUP_HIB_STATE_EINT)
494 wm8350_irq_call_handler(wm8350,
495 WM8350_IRQ_WKUP_HIB_STATE);
496 if (comp & WM8350_WKUP_CONV_FAULT_EINT)
497 wm8350_irq_call_handler(wm8350,
498 WM8350_IRQ_WKUP_CONV_FAULT);
499 if (comp & WM8350_WKUP_WDOG_RST_EINT)
500 wm8350_irq_call_handler(wm8350,
501 WM8350_IRQ_WKUP_WDOG_RST);
502 if (comp & WM8350_WKUP_GP_PWR_ON_EINT)
503 wm8350_irq_call_handler(wm8350,
504 WM8350_IRQ_WKUP_GP_PWR_ON);
505 if (comp & WM8350_WKUP_ONKEY_EINT)
506 wm8350_irq_call_handler(wm8350, WM8350_IRQ_WKUP_ONKEY);
507 if (comp & WM8350_WKUP_GP_WAKEUP_EINT)
508 wm8350_irq_call_handler(wm8350,
509 WM8350_IRQ_WKUP_GP_WAKEUP);
510
511 if (comp & WM8350_CODEC_JCK_DET_L_EINT)
512 wm8350_irq_call_handler(wm8350,
513 WM8350_IRQ_CODEC_JCK_DET_L);
514 if (comp & WM8350_CODEC_JCK_DET_R_EINT)
515 wm8350_irq_call_handler(wm8350,
516 WM8350_IRQ_CODEC_JCK_DET_R);
517 if (comp & WM8350_CODEC_MICSCD_EINT)
518 wm8350_irq_call_handler(wm8350,
519 WM8350_IRQ_CODEC_MICSCD);
520 if (comp & WM8350_CODEC_MICD_EINT)
521 wm8350_irq_call_handler(wm8350, WM8350_IRQ_CODEC_MICD);
522
523 if (comp & WM8350_EXT_USB_FB_EINT)
524 wm8350_irq_call_handler(wm8350, WM8350_IRQ_EXT_USB_FB);
525 if (comp & WM8350_EXT_WALL_FB_EINT)
526 wm8350_irq_call_handler(wm8350,
527 WM8350_IRQ_EXT_WALL_FB);
528 if (comp & WM8350_EXT_BAT_FB_EINT)
529 wm8350_irq_call_handler(wm8350, WM8350_IRQ_EXT_BAT_FB);
530 }
531
532 if (level_one & WM8350_GP_INT) {
533 int i;
534 u16 gpio;
535
536 gpio = wm8350_reg_read(wm8350, WM8350_GPIO_INT_STATUS);
537 gpio &= ~wm8350_reg_read(wm8350,
538 WM8350_GPIO_INT_STATUS_MASK);
539
540 for (i = 0; i < 12; i++) {
541 if (gpio & (1 << i))
542 wm8350_irq_call_handler(wm8350,
543 WM8350_IRQ_GPIO(i));
544 }
545 }
546
547 enable_irq(wm8350->chip_irq);
548 }
549
550 static irqreturn_t wm8350_irq(int irq, void *data)
551 {
552 struct wm8350 *wm8350 = data;
553
554 disable_irq_nosync(irq);
555 schedule_work(&wm8350->irq_work);
556
557 return IRQ_HANDLED;
558 }
559
560 int wm8350_register_irq(struct wm8350 *wm8350, int irq,
561 void (*handler) (struct wm8350 *, int, void *),
562 void *data)
563 {
564 if (irq < 0 || irq > WM8350_NUM_IRQ || !handler)
565 return -EINVAL;
566
567 if (wm8350->irq[irq].handler)
568 return -EBUSY;
569
570 mutex_lock(&wm8350->irq_mutex);
571 wm8350->irq[irq].handler = handler;
572 wm8350->irq[irq].data = data;
573 mutex_unlock(&wm8350->irq_mutex);
574
575 return 0;
576 }
577 EXPORT_SYMBOL_GPL(wm8350_register_irq);
578
579 int wm8350_free_irq(struct wm8350 *wm8350, int irq)
580 {
581 if (irq < 0 || irq > WM8350_NUM_IRQ)
582 return -EINVAL;
583
584 mutex_lock(&wm8350->irq_mutex);
585 wm8350->irq[irq].handler = NULL;
586 mutex_unlock(&wm8350->irq_mutex);
587 return 0;
588 }
589 EXPORT_SYMBOL_GPL(wm8350_free_irq);
590
591 int wm8350_mask_irq(struct wm8350 *wm8350, int irq)
592 {
593 switch (irq) {
594 case WM8350_IRQ_CHG_BAT_HOT:
595 return wm8350_set_bits(wm8350, WM8350_INT_STATUS_1_MASK,
596 WM8350_IM_CHG_BAT_HOT_EINT);
597 case WM8350_IRQ_CHG_BAT_COLD:
598 return wm8350_set_bits(wm8350, WM8350_INT_STATUS_1_MASK,
599 WM8350_IM_CHG_BAT_COLD_EINT);
600 case WM8350_IRQ_CHG_BAT_FAIL:
601 return wm8350_set_bits(wm8350, WM8350_INT_STATUS_1_MASK,
602 WM8350_IM_CHG_BAT_FAIL_EINT);
603 case WM8350_IRQ_CHG_TO:
604 return wm8350_set_bits(wm8350, WM8350_INT_STATUS_1_MASK,
605 WM8350_IM_CHG_TO_EINT);
606 case WM8350_IRQ_CHG_END:
607 return wm8350_set_bits(wm8350, WM8350_INT_STATUS_1_MASK,
608 WM8350_IM_CHG_END_EINT);
609 case WM8350_IRQ_CHG_START:
610 return wm8350_set_bits(wm8350, WM8350_INT_STATUS_1_MASK,
611 WM8350_IM_CHG_START_EINT);
612 case WM8350_IRQ_CHG_FAST_RDY:
613 return wm8350_set_bits(wm8350, WM8350_INT_STATUS_1_MASK,
614 WM8350_IM_CHG_FAST_RDY_EINT);
615 case WM8350_IRQ_RTC_PER:
616 return wm8350_set_bits(wm8350, WM8350_INT_STATUS_1_MASK,
617 WM8350_IM_RTC_PER_EINT);
618 case WM8350_IRQ_RTC_SEC:
619 return wm8350_set_bits(wm8350, WM8350_INT_STATUS_1_MASK,
620 WM8350_IM_RTC_SEC_EINT);
621 case WM8350_IRQ_RTC_ALM:
622 return wm8350_set_bits(wm8350, WM8350_INT_STATUS_1_MASK,
623 WM8350_IM_RTC_ALM_EINT);
624 case WM8350_IRQ_CHG_VBATT_LT_3P9:
625 return wm8350_set_bits(wm8350, WM8350_INT_STATUS_1_MASK,
626 WM8350_IM_CHG_VBATT_LT_3P9_EINT);
627 case WM8350_IRQ_CHG_VBATT_LT_3P1:
628 return wm8350_set_bits(wm8350, WM8350_INT_STATUS_1_MASK,
629 WM8350_IM_CHG_VBATT_LT_3P1_EINT);
630 case WM8350_IRQ_CHG_VBATT_LT_2P85:
631 return wm8350_set_bits(wm8350, WM8350_INT_STATUS_1_MASK,
632 WM8350_IM_CHG_VBATT_LT_2P85_EINT);
633 case WM8350_IRQ_CS1:
634 return wm8350_set_bits(wm8350, WM8350_INT_STATUS_2_MASK,
635 WM8350_IM_CS1_EINT);
636 case WM8350_IRQ_CS2:
637 return wm8350_set_bits(wm8350, WM8350_INT_STATUS_2_MASK,
638 WM8350_IM_CS2_EINT);
639 case WM8350_IRQ_USB_LIMIT:
640 return wm8350_set_bits(wm8350, WM8350_INT_STATUS_2_MASK,
641 WM8350_IM_USB_LIMIT_EINT);
642 case WM8350_IRQ_AUXADC_DATARDY:
643 return wm8350_set_bits(wm8350, WM8350_INT_STATUS_2_MASK,
644 WM8350_IM_AUXADC_DATARDY_EINT);
645 case WM8350_IRQ_AUXADC_DCOMP4:
646 return wm8350_set_bits(wm8350, WM8350_INT_STATUS_2_MASK,
647 WM8350_IM_AUXADC_DCOMP4_EINT);
648 case WM8350_IRQ_AUXADC_DCOMP3:
649 return wm8350_set_bits(wm8350, WM8350_INT_STATUS_2_MASK,
650 WM8350_IM_AUXADC_DCOMP3_EINT);
651 case WM8350_IRQ_AUXADC_DCOMP2:
652 return wm8350_set_bits(wm8350, WM8350_INT_STATUS_2_MASK,
653 WM8350_IM_AUXADC_DCOMP2_EINT);
654 case WM8350_IRQ_AUXADC_DCOMP1:
655 return wm8350_set_bits(wm8350, WM8350_INT_STATUS_2_MASK,
656 WM8350_IM_AUXADC_DCOMP1_EINT);
657 case WM8350_IRQ_SYS_HYST_COMP_FAIL:
658 return wm8350_set_bits(wm8350, WM8350_INT_STATUS_2_MASK,
659 WM8350_IM_SYS_HYST_COMP_FAIL_EINT);
660 case WM8350_IRQ_SYS_CHIP_GT115:
661 return wm8350_set_bits(wm8350, WM8350_INT_STATUS_2_MASK,
662 WM8350_IM_SYS_CHIP_GT115_EINT);
663 case WM8350_IRQ_SYS_CHIP_GT140:
664 return wm8350_set_bits(wm8350, WM8350_INT_STATUS_2_MASK,
665 WM8350_IM_SYS_CHIP_GT140_EINT);
666 case WM8350_IRQ_SYS_WDOG_TO:
667 return wm8350_set_bits(wm8350, WM8350_INT_STATUS_2_MASK,
668 WM8350_IM_SYS_WDOG_TO_EINT);
669 case WM8350_IRQ_UV_LDO4:
670 return wm8350_set_bits(wm8350,
671 WM8350_UNDER_VOLTAGE_INT_STATUS_MASK,
672 WM8350_IM_UV_LDO4_EINT);
673 case WM8350_IRQ_UV_LDO3:
674 return wm8350_set_bits(wm8350,
675 WM8350_UNDER_VOLTAGE_INT_STATUS_MASK,
676 WM8350_IM_UV_LDO3_EINT);
677 case WM8350_IRQ_UV_LDO2:
678 return wm8350_set_bits(wm8350,
679 WM8350_UNDER_VOLTAGE_INT_STATUS_MASK,
680 WM8350_IM_UV_LDO2_EINT);
681 case WM8350_IRQ_UV_LDO1:
682 return wm8350_set_bits(wm8350,
683 WM8350_UNDER_VOLTAGE_INT_STATUS_MASK,
684 WM8350_IM_UV_LDO1_EINT);
685 case WM8350_IRQ_UV_DC6:
686 return wm8350_set_bits(wm8350,
687 WM8350_UNDER_VOLTAGE_INT_STATUS_MASK,
688 WM8350_IM_UV_DC6_EINT);
689 case WM8350_IRQ_UV_DC5:
690 return wm8350_set_bits(wm8350,
691 WM8350_UNDER_VOLTAGE_INT_STATUS_MASK,
692 WM8350_IM_UV_DC5_EINT);
693 case WM8350_IRQ_UV_DC4:
694 return wm8350_set_bits(wm8350,
695 WM8350_UNDER_VOLTAGE_INT_STATUS_MASK,
696 WM8350_IM_UV_DC4_EINT);
697 case WM8350_IRQ_UV_DC3:
698 return wm8350_set_bits(wm8350,
699 WM8350_UNDER_VOLTAGE_INT_STATUS_MASK,
700 WM8350_IM_UV_DC3_EINT);
701 case WM8350_IRQ_UV_DC2:
702 return wm8350_set_bits(wm8350,
703 WM8350_UNDER_VOLTAGE_INT_STATUS_MASK,
704 WM8350_IM_UV_DC2_EINT);
705 case WM8350_IRQ_UV_DC1:
706 return wm8350_set_bits(wm8350,
707 WM8350_UNDER_VOLTAGE_INT_STATUS_MASK,
708 WM8350_IM_UV_DC1_EINT);
709 case WM8350_IRQ_OC_LS:
710 return wm8350_set_bits(wm8350,
711 WM8350_OVER_CURRENT_INT_STATUS_MASK,
712 WM8350_IM_OC_LS_EINT);
713 case WM8350_IRQ_EXT_USB_FB:
714 return wm8350_set_bits(wm8350,
715 WM8350_COMPARATOR_INT_STATUS_MASK,
716 WM8350_IM_EXT_USB_FB_EINT);
717 case WM8350_IRQ_EXT_WALL_FB:
718 return wm8350_set_bits(wm8350,
719 WM8350_COMPARATOR_INT_STATUS_MASK,
720 WM8350_IM_EXT_WALL_FB_EINT);
721 case WM8350_IRQ_EXT_BAT_FB:
722 return wm8350_set_bits(wm8350,
723 WM8350_COMPARATOR_INT_STATUS_MASK,
724 WM8350_IM_EXT_BAT_FB_EINT);
725 case WM8350_IRQ_CODEC_JCK_DET_L:
726 return wm8350_set_bits(wm8350,
727 WM8350_COMPARATOR_INT_STATUS_MASK,
728 WM8350_IM_CODEC_JCK_DET_L_EINT);
729 case WM8350_IRQ_CODEC_JCK_DET_R:
730 return wm8350_set_bits(wm8350,
731 WM8350_COMPARATOR_INT_STATUS_MASK,
732 WM8350_IM_CODEC_JCK_DET_R_EINT);
733 case WM8350_IRQ_CODEC_MICSCD:
734 return wm8350_set_bits(wm8350,
735 WM8350_COMPARATOR_INT_STATUS_MASK,
736 WM8350_IM_CODEC_MICSCD_EINT);
737 case WM8350_IRQ_CODEC_MICD:
738 return wm8350_set_bits(wm8350,
739 WM8350_COMPARATOR_INT_STATUS_MASK,
740 WM8350_IM_CODEC_MICD_EINT);
741 case WM8350_IRQ_WKUP_OFF_STATE:
742 return wm8350_set_bits(wm8350,
743 WM8350_COMPARATOR_INT_STATUS_MASK,
744 WM8350_IM_WKUP_OFF_STATE_EINT);
745 case WM8350_IRQ_WKUP_HIB_STATE:
746 return wm8350_set_bits(wm8350,
747 WM8350_COMPARATOR_INT_STATUS_MASK,
748 WM8350_IM_WKUP_HIB_STATE_EINT);
749 case WM8350_IRQ_WKUP_CONV_FAULT:
750 return wm8350_set_bits(wm8350,
751 WM8350_COMPARATOR_INT_STATUS_MASK,
752 WM8350_IM_WKUP_CONV_FAULT_EINT);
753 case WM8350_IRQ_WKUP_WDOG_RST:
754 return wm8350_set_bits(wm8350,
755 WM8350_COMPARATOR_INT_STATUS_MASK,
756 WM8350_IM_WKUP_OFF_STATE_EINT);
757 case WM8350_IRQ_WKUP_GP_PWR_ON:
758 return wm8350_set_bits(wm8350,
759 WM8350_COMPARATOR_INT_STATUS_MASK,
760 WM8350_IM_WKUP_GP_PWR_ON_EINT);
761 case WM8350_IRQ_WKUP_ONKEY:
762 return wm8350_set_bits(wm8350,
763 WM8350_COMPARATOR_INT_STATUS_MASK,
764 WM8350_IM_WKUP_ONKEY_EINT);
765 case WM8350_IRQ_WKUP_GP_WAKEUP:
766 return wm8350_set_bits(wm8350,
767 WM8350_COMPARATOR_INT_STATUS_MASK,
768 WM8350_IM_WKUP_GP_WAKEUP_EINT);
769 case WM8350_IRQ_GPIO(0):
770 return wm8350_set_bits(wm8350,
771 WM8350_GPIO_INT_STATUS_MASK,
772 WM8350_IM_GP0_EINT);
773 case WM8350_IRQ_GPIO(1):
774 return wm8350_set_bits(wm8350,
775 WM8350_GPIO_INT_STATUS_MASK,
776 WM8350_IM_GP1_EINT);
777 case WM8350_IRQ_GPIO(2):
778 return wm8350_set_bits(wm8350,
779 WM8350_GPIO_INT_STATUS_MASK,
780 WM8350_IM_GP2_EINT);
781 case WM8350_IRQ_GPIO(3):
782 return wm8350_set_bits(wm8350,
783 WM8350_GPIO_INT_STATUS_MASK,
784 WM8350_IM_GP3_EINT);
785 case WM8350_IRQ_GPIO(4):
786 return wm8350_set_bits(wm8350,
787 WM8350_GPIO_INT_STATUS_MASK,
788 WM8350_IM_GP4_EINT);
789 case WM8350_IRQ_GPIO(5):
790 return wm8350_set_bits(wm8350,
791 WM8350_GPIO_INT_STATUS_MASK,
792 WM8350_IM_GP5_EINT);
793 case WM8350_IRQ_GPIO(6):
794 return wm8350_set_bits(wm8350,
795 WM8350_GPIO_INT_STATUS_MASK,
796 WM8350_IM_GP6_EINT);
797 case WM8350_IRQ_GPIO(7):
798 return wm8350_set_bits(wm8350,
799 WM8350_GPIO_INT_STATUS_MASK,
800 WM8350_IM_GP7_EINT);
801 case WM8350_IRQ_GPIO(8):
802 return wm8350_set_bits(wm8350,
803 WM8350_GPIO_INT_STATUS_MASK,
804 WM8350_IM_GP8_EINT);
805 case WM8350_IRQ_GPIO(9):
806 return wm8350_set_bits(wm8350,
807 WM8350_GPIO_INT_STATUS_MASK,
808 WM8350_IM_GP9_EINT);
809 case WM8350_IRQ_GPIO(10):
810 return wm8350_set_bits(wm8350,
811 WM8350_GPIO_INT_STATUS_MASK,
812 WM8350_IM_GP10_EINT);
813 case WM8350_IRQ_GPIO(11):
814 return wm8350_set_bits(wm8350,
815 WM8350_GPIO_INT_STATUS_MASK,
816 WM8350_IM_GP11_EINT);
817 case WM8350_IRQ_GPIO(12):
818 return wm8350_set_bits(wm8350,
819 WM8350_GPIO_INT_STATUS_MASK,
820 WM8350_IM_GP12_EINT);
821 default:
822 dev_warn(wm8350->dev, "Attempting to mask unknown IRQ %d\n",
823 irq);
824 return -EINVAL;
825 }
826 return 0;
827 }
828 EXPORT_SYMBOL_GPL(wm8350_mask_irq);
829
830 int wm8350_unmask_irq(struct wm8350 *wm8350, int irq)
831 {
832 switch (irq) {
833 case WM8350_IRQ_CHG_BAT_HOT:
834 return wm8350_clear_bits(wm8350, WM8350_INT_STATUS_1_MASK,
835 WM8350_IM_CHG_BAT_HOT_EINT);
836 case WM8350_IRQ_CHG_BAT_COLD:
837 return wm8350_clear_bits(wm8350, WM8350_INT_STATUS_1_MASK,
838 WM8350_IM_CHG_BAT_COLD_EINT);
839 case WM8350_IRQ_CHG_BAT_FAIL:
840 return wm8350_clear_bits(wm8350, WM8350_INT_STATUS_1_MASK,
841 WM8350_IM_CHG_BAT_FAIL_EINT);
842 case WM8350_IRQ_CHG_TO:
843 return wm8350_clear_bits(wm8350, WM8350_INT_STATUS_1_MASK,
844 WM8350_IM_CHG_TO_EINT);
845 case WM8350_IRQ_CHG_END:
846 return wm8350_clear_bits(wm8350, WM8350_INT_STATUS_1_MASK,
847 WM8350_IM_CHG_END_EINT);
848 case WM8350_IRQ_CHG_START:
849 return wm8350_clear_bits(wm8350, WM8350_INT_STATUS_1_MASK,
850 WM8350_IM_CHG_START_EINT);
851 case WM8350_IRQ_CHG_FAST_RDY:
852 return wm8350_clear_bits(wm8350, WM8350_INT_STATUS_1_MASK,
853 WM8350_IM_CHG_FAST_RDY_EINT);
854 case WM8350_IRQ_RTC_PER:
855 return wm8350_clear_bits(wm8350, WM8350_INT_STATUS_1_MASK,
856 WM8350_IM_RTC_PER_EINT);
857 case WM8350_IRQ_RTC_SEC:
858 return wm8350_clear_bits(wm8350, WM8350_INT_STATUS_1_MASK,
859 WM8350_IM_RTC_SEC_EINT);
860 case WM8350_IRQ_RTC_ALM:
861 return wm8350_clear_bits(wm8350, WM8350_INT_STATUS_1_MASK,
862 WM8350_IM_RTC_ALM_EINT);
863 case WM8350_IRQ_CHG_VBATT_LT_3P9:
864 return wm8350_clear_bits(wm8350, WM8350_INT_STATUS_1_MASK,
865 WM8350_IM_CHG_VBATT_LT_3P9_EINT);
866 case WM8350_IRQ_CHG_VBATT_LT_3P1:
867 return wm8350_clear_bits(wm8350, WM8350_INT_STATUS_1_MASK,
868 WM8350_IM_CHG_VBATT_LT_3P1_EINT);
869 case WM8350_IRQ_CHG_VBATT_LT_2P85:
870 return wm8350_clear_bits(wm8350, WM8350_INT_STATUS_1_MASK,
871 WM8350_IM_CHG_VBATT_LT_2P85_EINT);
872 case WM8350_IRQ_CS1:
873 return wm8350_clear_bits(wm8350, WM8350_INT_STATUS_2_MASK,
874 WM8350_IM_CS1_EINT);
875 case WM8350_IRQ_CS2:
876 return wm8350_clear_bits(wm8350, WM8350_INT_STATUS_2_MASK,
877 WM8350_IM_CS2_EINT);
878 case WM8350_IRQ_USB_LIMIT:
879 return wm8350_clear_bits(wm8350, WM8350_INT_STATUS_2_MASK,
880 WM8350_IM_USB_LIMIT_EINT);
881 case WM8350_IRQ_AUXADC_DATARDY:
882 return wm8350_clear_bits(wm8350, WM8350_INT_STATUS_2_MASK,
883 WM8350_IM_AUXADC_DATARDY_EINT);
884 case WM8350_IRQ_AUXADC_DCOMP4:
885 return wm8350_clear_bits(wm8350, WM8350_INT_STATUS_2_MASK,
886 WM8350_IM_AUXADC_DCOMP4_EINT);
887 case WM8350_IRQ_AUXADC_DCOMP3:
888 return wm8350_clear_bits(wm8350, WM8350_INT_STATUS_2_MASK,
889 WM8350_IM_AUXADC_DCOMP3_EINT);
890 case WM8350_IRQ_AUXADC_DCOMP2:
891 return wm8350_clear_bits(wm8350, WM8350_INT_STATUS_2_MASK,
892 WM8350_IM_AUXADC_DCOMP2_EINT);
893 case WM8350_IRQ_AUXADC_DCOMP1:
894 return wm8350_clear_bits(wm8350, WM8350_INT_STATUS_2_MASK,
895 WM8350_IM_AUXADC_DCOMP1_EINT);
896 case WM8350_IRQ_SYS_HYST_COMP_FAIL:
897 return wm8350_clear_bits(wm8350, WM8350_INT_STATUS_2_MASK,
898 WM8350_IM_SYS_HYST_COMP_FAIL_EINT);
899 case WM8350_IRQ_SYS_CHIP_GT115:
900 return wm8350_clear_bits(wm8350, WM8350_INT_STATUS_2_MASK,
901 WM8350_IM_SYS_CHIP_GT115_EINT);
902 case WM8350_IRQ_SYS_CHIP_GT140:
903 return wm8350_clear_bits(wm8350, WM8350_INT_STATUS_2_MASK,
904 WM8350_IM_SYS_CHIP_GT140_EINT);
905 case WM8350_IRQ_SYS_WDOG_TO:
906 return wm8350_clear_bits(wm8350, WM8350_INT_STATUS_2_MASK,
907 WM8350_IM_SYS_WDOG_TO_EINT);
908 case WM8350_IRQ_UV_LDO4:
909 return wm8350_clear_bits(wm8350,
910 WM8350_UNDER_VOLTAGE_INT_STATUS_MASK,
911 WM8350_IM_UV_LDO4_EINT);
912 case WM8350_IRQ_UV_LDO3:
913 return wm8350_clear_bits(wm8350,
914 WM8350_UNDER_VOLTAGE_INT_STATUS_MASK,
915 WM8350_IM_UV_LDO3_EINT);
916 case WM8350_IRQ_UV_LDO2:
917 return wm8350_clear_bits(wm8350,
918 WM8350_UNDER_VOLTAGE_INT_STATUS_MASK,
919 WM8350_IM_UV_LDO2_EINT);
920 case WM8350_IRQ_UV_LDO1:
921 return wm8350_clear_bits(wm8350,
922 WM8350_UNDER_VOLTAGE_INT_STATUS_MASK,
923 WM8350_IM_UV_LDO1_EINT);
924 case WM8350_IRQ_UV_DC6:
925 return wm8350_clear_bits(wm8350,
926 WM8350_UNDER_VOLTAGE_INT_STATUS_MASK,
927 WM8350_IM_UV_DC6_EINT);
928 case WM8350_IRQ_UV_DC5:
929 return wm8350_clear_bits(wm8350,
930 WM8350_UNDER_VOLTAGE_INT_STATUS_MASK,
931 WM8350_IM_UV_DC5_EINT);
932 case WM8350_IRQ_UV_DC4:
933 return wm8350_clear_bits(wm8350,
934 WM8350_UNDER_VOLTAGE_INT_STATUS_MASK,
935 WM8350_IM_UV_DC4_EINT);
936 case WM8350_IRQ_UV_DC3:
937 return wm8350_clear_bits(wm8350,
938 WM8350_UNDER_VOLTAGE_INT_STATUS_MASK,
939 WM8350_IM_UV_DC3_EINT);
940 case WM8350_IRQ_UV_DC2:
941 return wm8350_clear_bits(wm8350,
942 WM8350_UNDER_VOLTAGE_INT_STATUS_MASK,
943 WM8350_IM_UV_DC2_EINT);
944 case WM8350_IRQ_UV_DC1:
945 return wm8350_clear_bits(wm8350,
946 WM8350_UNDER_VOLTAGE_INT_STATUS_MASK,
947 WM8350_IM_UV_DC1_EINT);
948 case WM8350_IRQ_OC_LS:
949 return wm8350_clear_bits(wm8350,
950 WM8350_OVER_CURRENT_INT_STATUS_MASK,
951 WM8350_IM_OC_LS_EINT);
952 case WM8350_IRQ_EXT_USB_FB:
953 return wm8350_clear_bits(wm8350,
954 WM8350_COMPARATOR_INT_STATUS_MASK,
955 WM8350_IM_EXT_USB_FB_EINT);
956 case WM8350_IRQ_EXT_WALL_FB:
957 return wm8350_clear_bits(wm8350,
958 WM8350_COMPARATOR_INT_STATUS_MASK,
959 WM8350_IM_EXT_WALL_FB_EINT);
960 case WM8350_IRQ_EXT_BAT_FB:
961 return wm8350_clear_bits(wm8350,
962 WM8350_COMPARATOR_INT_STATUS_MASK,
963 WM8350_IM_EXT_BAT_FB_EINT);
964 case WM8350_IRQ_CODEC_JCK_DET_L:
965 return wm8350_clear_bits(wm8350,
966 WM8350_COMPARATOR_INT_STATUS_MASK,
967 WM8350_IM_CODEC_JCK_DET_L_EINT);
968 case WM8350_IRQ_CODEC_JCK_DET_R:
969 return wm8350_clear_bits(wm8350,
970 WM8350_COMPARATOR_INT_STATUS_MASK,
971 WM8350_IM_CODEC_JCK_DET_R_EINT);
972 case WM8350_IRQ_CODEC_MICSCD:
973 return wm8350_clear_bits(wm8350,
974 WM8350_COMPARATOR_INT_STATUS_MASK,
975 WM8350_IM_CODEC_MICSCD_EINT);
976 case WM8350_IRQ_CODEC_MICD:
977 return wm8350_clear_bits(wm8350,
978 WM8350_COMPARATOR_INT_STATUS_MASK,
979 WM8350_IM_CODEC_MICD_EINT);
980 case WM8350_IRQ_WKUP_OFF_STATE:
981 return wm8350_clear_bits(wm8350,
982 WM8350_COMPARATOR_INT_STATUS_MASK,
983 WM8350_IM_WKUP_OFF_STATE_EINT);
984 case WM8350_IRQ_WKUP_HIB_STATE:
985 return wm8350_clear_bits(wm8350,
986 WM8350_COMPARATOR_INT_STATUS_MASK,
987 WM8350_IM_WKUP_HIB_STATE_EINT);
988 case WM8350_IRQ_WKUP_CONV_FAULT:
989 return wm8350_clear_bits(wm8350,
990 WM8350_COMPARATOR_INT_STATUS_MASK,
991 WM8350_IM_WKUP_CONV_FAULT_EINT);
992 case WM8350_IRQ_WKUP_WDOG_RST:
993 return wm8350_clear_bits(wm8350,
994 WM8350_COMPARATOR_INT_STATUS_MASK,
995 WM8350_IM_WKUP_OFF_STATE_EINT);
996 case WM8350_IRQ_WKUP_GP_PWR_ON:
997 return wm8350_clear_bits(wm8350,
998 WM8350_COMPARATOR_INT_STATUS_MASK,
999 WM8350_IM_WKUP_GP_PWR_ON_EINT);
1000 case WM8350_IRQ_WKUP_ONKEY:
1001 return wm8350_clear_bits(wm8350,
1002 WM8350_COMPARATOR_INT_STATUS_MASK,
1003 WM8350_IM_WKUP_ONKEY_EINT);
1004 case WM8350_IRQ_WKUP_GP_WAKEUP:
1005 return wm8350_clear_bits(wm8350,
1006 WM8350_COMPARATOR_INT_STATUS_MASK,
1007 WM8350_IM_WKUP_GP_WAKEUP_EINT);
1008 case WM8350_IRQ_GPIO(0):
1009 return wm8350_clear_bits(wm8350,
1010 WM8350_GPIO_INT_STATUS_MASK,
1011 WM8350_IM_GP0_EINT);
1012 case WM8350_IRQ_GPIO(1):
1013 return wm8350_clear_bits(wm8350,
1014 WM8350_GPIO_INT_STATUS_MASK,
1015 WM8350_IM_GP1_EINT);
1016 case WM8350_IRQ_GPIO(2):
1017 return wm8350_clear_bits(wm8350,
1018 WM8350_GPIO_INT_STATUS_MASK,
1019 WM8350_IM_GP2_EINT);
1020 case WM8350_IRQ_GPIO(3):
1021 return wm8350_clear_bits(wm8350,
1022 WM8350_GPIO_INT_STATUS_MASK,
1023 WM8350_IM_GP3_EINT);
1024 case WM8350_IRQ_GPIO(4):
1025 return wm8350_clear_bits(wm8350,
1026 WM8350_GPIO_INT_STATUS_MASK,
1027 WM8350_IM_GP4_EINT);
1028 case WM8350_IRQ_GPIO(5):
1029 return wm8350_clear_bits(wm8350,
1030 WM8350_GPIO_INT_STATUS_MASK,
1031 WM8350_IM_GP5_EINT);
1032 case WM8350_IRQ_GPIO(6):
1033 return wm8350_clear_bits(wm8350,
1034 WM8350_GPIO_INT_STATUS_MASK,
1035 WM8350_IM_GP6_EINT);
1036 case WM8350_IRQ_GPIO(7):
1037 return wm8350_clear_bits(wm8350,
1038 WM8350_GPIO_INT_STATUS_MASK,
1039 WM8350_IM_GP7_EINT);
1040 case WM8350_IRQ_GPIO(8):
1041 return wm8350_clear_bits(wm8350,
1042 WM8350_GPIO_INT_STATUS_MASK,
1043 WM8350_IM_GP8_EINT);
1044 case WM8350_IRQ_GPIO(9):
1045 return wm8350_clear_bits(wm8350,
1046 WM8350_GPIO_INT_STATUS_MASK,
1047 WM8350_IM_GP9_EINT);
1048 case WM8350_IRQ_GPIO(10):
1049 return wm8350_clear_bits(wm8350,
1050 WM8350_GPIO_INT_STATUS_MASK,
1051 WM8350_IM_GP10_EINT);
1052 case WM8350_IRQ_GPIO(11):
1053 return wm8350_clear_bits(wm8350,
1054 WM8350_GPIO_INT_STATUS_MASK,
1055 WM8350_IM_GP11_EINT);
1056 case WM8350_IRQ_GPIO(12):
1057 return wm8350_clear_bits(wm8350,
1058 WM8350_GPIO_INT_STATUS_MASK,
1059 WM8350_IM_GP12_EINT);
1060 default:
1061 dev_warn(wm8350->dev, "Attempting to unmask unknown IRQ %d\n",
1062 irq);
1063 return -EINVAL;
1064 }
1065 return 0;
1066 }
1067 EXPORT_SYMBOL_GPL(wm8350_unmask_irq);
1068
1069 /*
1070 * Cache is always host endian.
1071 */
1072 static int wm8350_create_cache(struct wm8350 *wm8350, int mode)
1073 {
1074 int i, ret = 0;
1075 u16 value;
1076 const u16 *reg_map;
1077
1078 switch (mode) {
1079 #ifdef CONFIG_MFD_WM8350_CONFIG_MODE_0
1080 case 0:
1081 reg_map = wm8350_mode0_defaults;
1082 break;
1083 #endif
1084 #ifdef CONFIG_MFD_WM8350_CONFIG_MODE_1
1085 case 1:
1086 reg_map = wm8350_mode1_defaults;
1087 break;
1088 #endif
1089 #ifdef CONFIG_MFD_WM8350_CONFIG_MODE_2
1090 case 2:
1091 reg_map = wm8350_mode2_defaults;
1092 break;
1093 #endif
1094 #ifdef CONFIG_MFD_WM8350_CONFIG_MODE_3
1095 case 3:
1096 reg_map = wm8350_mode3_defaults;
1097 break;
1098 #endif
1099 default:
1100 dev_err(wm8350->dev, "Configuration mode %d not supported\n",
1101 mode);
1102 return -EINVAL;
1103 }
1104
1105 wm8350->reg_cache =
1106 kzalloc(sizeof(u16) * (WM8350_MAX_REGISTER + 1), GFP_KERNEL);
1107 if (wm8350->reg_cache == NULL)
1108 return -ENOMEM;
1109
1110 /* Read the initial cache state back from the device - this is
1111 * a PMIC so the device many not be in a virgin state and we
1112 * can't rely on the silicon values.
1113 */
1114 for (i = 0; i < WM8350_MAX_REGISTER; i++) {
1115 /* audio register range */
1116 if (wm8350_reg_io_map[i].readable &&
1117 (i < WM8350_CLOCK_CONTROL_1 || i > WM8350_AIF_TEST)) {
1118 ret = wm8350->read_dev(wm8350, i, 2, (char *)&value);
1119 if (ret < 0) {
1120 dev_err(wm8350->dev,
1121 "failed to read initial cache value\n");
1122 goto out;
1123 }
1124 value = be16_to_cpu(value);
1125 value &= wm8350_reg_io_map[i].readable;
1126 value &= ~wm8350_reg_io_map[i].vol;
1127 wm8350->reg_cache[i] = value;
1128 } else
1129 wm8350->reg_cache[i] = reg_map[i];
1130 }
1131
1132 out:
1133 return ret;
1134 }
1135
1136 /*
1137 * Register a client device. This is non-fatal since there is no need to
1138 * fail the entire device init due to a single platform device failing.
1139 */
1140 static void wm8350_client_dev_register(struct wm8350 *wm8350,
1141 const char *name,
1142 struct platform_device **pdev)
1143 {
1144 int ret;
1145
1146 *pdev = platform_device_alloc(name, -1);
1147 if (pdev == NULL) {
1148 dev_err(wm8350->dev, "Failed to allocate %s\n", name);
1149 return;
1150 }
1151
1152 (*pdev)->dev.parent = wm8350->dev;
1153 platform_set_drvdata(*pdev, wm8350);
1154 ret = platform_device_add(*pdev);
1155 if (ret != 0) {
1156 dev_err(wm8350->dev, "Failed to register %s: %d\n", name, ret);
1157 platform_device_put(*pdev);
1158 *pdev = NULL;
1159 }
1160 }
1161
1162 int wm8350_device_init(struct wm8350 *wm8350, int irq,
1163 struct wm8350_platform_data *pdata)
1164 {
1165 int ret = -EINVAL;
1166 u16 id1, id2, mask, mode;
1167
1168 /* get WM8350 revision and config mode */
1169 wm8350->read_dev(wm8350, WM8350_RESET_ID, sizeof(id1), &id1);
1170 wm8350->read_dev(wm8350, WM8350_ID, sizeof(id2), &id2);
1171
1172 id1 = be16_to_cpu(id1);
1173 id2 = be16_to_cpu(id2);
1174
1175 if (id1 == 0x6143) {
1176 switch ((id2 & WM8350_CHIP_REV_MASK) >> 12) {
1177 case WM8350_REV_E:
1178 dev_info(wm8350->dev, "Found Rev E device\n");
1179 wm8350->rev = WM8350_REV_E;
1180 break;
1181 case WM8350_REV_F:
1182 dev_info(wm8350->dev, "Found Rev F device\n");
1183 wm8350->rev = WM8350_REV_F;
1184 break;
1185 case WM8350_REV_G:
1186 dev_info(wm8350->dev, "Found Rev G device\n");
1187 wm8350->rev = WM8350_REV_G;
1188 break;
1189 default:
1190 /* For safety we refuse to run on unknown hardware */
1191 dev_info(wm8350->dev, "Found unknown rev\n");
1192 ret = -ENODEV;
1193 goto err;
1194 }
1195 } else {
1196 dev_info(wm8350->dev, "Device with ID %x is not a WM8350\n",
1197 id1);
1198 ret = -ENODEV;
1199 goto err;
1200 }
1201
1202 mode = id2 & WM8350_CONF_STS_MASK >> 10;
1203 mask = id2 & WM8350_CUST_ID_MASK;
1204 dev_info(wm8350->dev, "Config mode %d, ROM mask %d\n", mode, mask);
1205
1206 ret = wm8350_create_cache(wm8350, mode);
1207 if (ret < 0) {
1208 printk(KERN_ERR "wm8350: failed to create register cache\n");
1209 return ret;
1210 }
1211
1212 if (pdata->init) {
1213 ret = pdata->init(wm8350);
1214 if (ret != 0) {
1215 dev_err(wm8350->dev, "Platform init() failed: %d\n",
1216 ret);
1217 goto err;
1218 }
1219 }
1220
1221 mutex_init(&wm8350->irq_mutex);
1222 INIT_WORK(&wm8350->irq_work, wm8350_irq_worker);
1223 if (irq) {
1224 ret = request_irq(irq, wm8350_irq, 0,
1225 "wm8350", wm8350);
1226 if (ret != 0) {
1227 dev_err(wm8350->dev, "Failed to request IRQ: %d\n",
1228 ret);
1229 goto err;
1230 }
1231 } else {
1232 dev_err(wm8350->dev, "No IRQ configured\n");
1233 goto err;
1234 }
1235 wm8350->chip_irq = irq;
1236
1237 wm8350_reg_write(wm8350, WM8350_SYSTEM_INTERRUPTS_MASK, 0x0);
1238
1239 wm8350_client_dev_register(wm8350, "wm8350-codec",
1240 &(wm8350->codec.pdev));
1241 wm8350_client_dev_register(wm8350, "wm8350-gpio",
1242 &(wm8350->gpio.pdev));
1243 wm8350_client_dev_register(wm8350, "wm8350-power",
1244 &(wm8350->power.pdev));
1245 wm8350_client_dev_register(wm8350, "wm8350-rtc", &(wm8350->rtc.pdev));
1246 wm8350_client_dev_register(wm8350, "wm8350-wdt", &(wm8350->wdt.pdev));
1247
1248 return 0;
1249
1250 err:
1251 kfree(wm8350->reg_cache);
1252 return ret;
1253 }
1254 EXPORT_SYMBOL_GPL(wm8350_device_init);
1255
1256 void wm8350_device_exit(struct wm8350 *wm8350)
1257 {
1258 int i;
1259
1260 for (i = 0; i < ARRAY_SIZE(wm8350->pmic.pdev); i++)
1261 platform_device_unregister(wm8350->pmic.pdev[i]);
1262
1263 platform_device_unregister(wm8350->wdt.pdev);
1264 platform_device_unregister(wm8350->rtc.pdev);
1265 platform_device_unregister(wm8350->power.pdev);
1266 platform_device_unregister(wm8350->gpio.pdev);
1267 platform_device_unregister(wm8350->codec.pdev);
1268
1269 free_irq(wm8350->chip_irq, wm8350);
1270 flush_work(&wm8350->irq_work);
1271 kfree(wm8350->reg_cache);
1272 }
1273 EXPORT_SYMBOL_GPL(wm8350_device_exit);
1274
1275 MODULE_DESCRIPTION("WM8350 AudioPlus PMIC core driver");
1276 MODULE_LICENSE("GPL");
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree