]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - drivers/mfd/ab8500-core.c
projects / mirror_ubuntu-artful-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'docs-next' of git://git.lwn.net/linux-2.6
[mirror_ubuntu-artful-kernel.git] / drivers / mfd / ab8500-core.c
1 /*
2 * Copyright (C) ST-Ericsson SA 2010
3 *
4 * License Terms: GNU General Public License v2
5 * Author: Srinidhi Kasagar <srinidhi.kasagar@stericsson.com>
6 * Author: Rabin Vincent <rabin.vincent@stericsson.com>
7 * Author: Mattias Wallin <mattias.wallin@stericsson.com>
8 */
9
10 #include <linux/kernel.h>
11 #include <linux/slab.h>
12 #include <linux/init.h>
13 #include <linux/irq.h>
14 #include <linux/delay.h>
15 #include <linux/interrupt.h>
16 #include <linux/module.h>
17 #include <linux/platform_device.h>
18 #include <linux/mfd/core.h>
19 #include <linux/mfd/abx500.h>
20 #include <linux/mfd/ab8500.h>
21 #include <linux/regulator/ab8500.h>
22
23 /*
24 * Interrupt register offsets
25 * Bank : 0x0E
26 */
27 #define AB8500_IT_SOURCE1_REG 0x00
28 #define AB8500_IT_SOURCE2_REG 0x01
29 #define AB8500_IT_SOURCE3_REG 0x02
30 #define AB8500_IT_SOURCE4_REG 0x03
31 #define AB8500_IT_SOURCE5_REG 0x04
32 #define AB8500_IT_SOURCE6_REG 0x05
33 #define AB8500_IT_SOURCE7_REG 0x06
34 #define AB8500_IT_SOURCE8_REG 0x07
35 #define AB8500_IT_SOURCE19_REG 0x12
36 #define AB8500_IT_SOURCE20_REG 0x13
37 #define AB8500_IT_SOURCE21_REG 0x14
38 #define AB8500_IT_SOURCE22_REG 0x15
39 #define AB8500_IT_SOURCE23_REG 0x16
40 #define AB8500_IT_SOURCE24_REG 0x17
41
42 /*
43 * latch registers
44 */
45 #define AB8500_IT_LATCH1_REG 0x20
46 #define AB8500_IT_LATCH2_REG 0x21
47 #define AB8500_IT_LATCH3_REG 0x22
48 #define AB8500_IT_LATCH4_REG 0x23
49 #define AB8500_IT_LATCH5_REG 0x24
50 #define AB8500_IT_LATCH6_REG 0x25
51 #define AB8500_IT_LATCH7_REG 0x26
52 #define AB8500_IT_LATCH8_REG 0x27
53 #define AB8500_IT_LATCH9_REG 0x28
54 #define AB8500_IT_LATCH10_REG 0x29
55 #define AB8500_IT_LATCH12_REG 0x2B
56 #define AB8500_IT_LATCH19_REG 0x32
57 #define AB8500_IT_LATCH20_REG 0x33
58 #define AB8500_IT_LATCH21_REG 0x34
59 #define AB8500_IT_LATCH22_REG 0x35
60 #define AB8500_IT_LATCH23_REG 0x36
61 #define AB8500_IT_LATCH24_REG 0x37
62
63 /*
64 * mask registers
65 */
66
67 #define AB8500_IT_MASK1_REG 0x40
68 #define AB8500_IT_MASK2_REG 0x41
69 #define AB8500_IT_MASK3_REG 0x42
70 #define AB8500_IT_MASK4_REG 0x43
71 #define AB8500_IT_MASK5_REG 0x44
72 #define AB8500_IT_MASK6_REG 0x45
73 #define AB8500_IT_MASK7_REG 0x46
74 #define AB8500_IT_MASK8_REG 0x47
75 #define AB8500_IT_MASK9_REG 0x48
76 #define AB8500_IT_MASK10_REG 0x49
77 #define AB8500_IT_MASK11_REG 0x4A
78 #define AB8500_IT_MASK12_REG 0x4B
79 #define AB8500_IT_MASK13_REG 0x4C
80 #define AB8500_IT_MASK14_REG 0x4D
81 #define AB8500_IT_MASK15_REG 0x4E
82 #define AB8500_IT_MASK16_REG 0x4F
83 #define AB8500_IT_MASK17_REG 0x50
84 #define AB8500_IT_MASK18_REG 0x51
85 #define AB8500_IT_MASK19_REG 0x52
86 #define AB8500_IT_MASK20_REG 0x53
87 #define AB8500_IT_MASK21_REG 0x54
88 #define AB8500_IT_MASK22_REG 0x55
89 #define AB8500_IT_MASK23_REG 0x56
90 #define AB8500_IT_MASK24_REG 0x57
91
92 #define AB8500_REV_REG 0x80
93 #define AB8500_SWITCH_OFF_STATUS 0x00
94
95 /*
96 * Map interrupt numbers to the LATCH and MASK register offsets, Interrupt
97 * numbers are indexed into this array with (num / 8).
98 *
99 * This is one off from the register names, i.e. AB8500_IT_MASK1_REG is at
100 * offset 0.
101 */
102 static const int ab8500_irq_regoffset[AB8500_NUM_IRQ_REGS] = {
103 0, 1, 2, 3, 4, 6, 7, 8, 9, 11, 18, 19, 20, 21,
104 };
105
106 static int ab8500_get_chip_id(struct device *dev)
107 {
108 struct ab8500 *ab8500;
109
110 if (!dev)
111 return -EINVAL;
112 ab8500 = dev_get_drvdata(dev->parent);
113 return ab8500 ? (int)ab8500->chip_id : -EINVAL;
114 }
115
116 static int set_register_interruptible(struct ab8500 *ab8500, u8 bank,
117 u8 reg, u8 data)
118 {
119 int ret;
120 /*
121 * Put the u8 bank and u8 register together into a an u16.
122 * The bank on higher 8 bits and register in lower 8 bits.
123 * */
124 u16 addr = ((u16)bank) << 8 | reg;
125
126 dev_vdbg(ab8500->dev, "wr: addr %#x <= %#x\n", addr, data);
127
128 ret = mutex_lock_interruptible(&ab8500->lock);
129 if (ret)
130 return ret;
131
132 ret = ab8500->write(ab8500, addr, data);
133 if (ret < 0)
134 dev_err(ab8500->dev, "failed to write reg %#x: %d\n",
135 addr, ret);
136 mutex_unlock(&ab8500->lock);
137
138 return ret;
139 }
140
141 static int ab8500_set_register(struct device *dev, u8 bank,
142 u8 reg, u8 value)
143 {
144 struct ab8500 *ab8500 = dev_get_drvdata(dev->parent);
145
146 return set_register_interruptible(ab8500, bank, reg, value);
147 }
148
149 static int get_register_interruptible(struct ab8500 *ab8500, u8 bank,
150 u8 reg, u8 *value)
151 {
152 int ret;
153 /* put the u8 bank and u8 reg together into a an u16.
154 * bank on higher 8 bits and reg in lower */
155 u16 addr = ((u16)bank) << 8 | reg;
156
157 ret = mutex_lock_interruptible(&ab8500->lock);
158 if (ret)
159 return ret;
160
161 ret = ab8500->read(ab8500, addr);
162 if (ret < 0)
163 dev_err(ab8500->dev, "failed to read reg %#x: %d\n",
164 addr, ret);
165 else
166 *value = ret;
167
168 mutex_unlock(&ab8500->lock);
169 dev_vdbg(ab8500->dev, "rd: addr %#x => data %#x\n", addr, ret);
170
171 return ret;
172 }
173
174 static int ab8500_get_register(struct device *dev, u8 bank,
175 u8 reg, u8 *value)
176 {
177 struct ab8500 *ab8500 = dev_get_drvdata(dev->parent);
178
179 return get_register_interruptible(ab8500, bank, reg, value);
180 }
181
182 static int mask_and_set_register_interruptible(struct ab8500 *ab8500, u8 bank,
183 u8 reg, u8 bitmask, u8 bitvalues)
184 {
185 int ret;
186 u8 data;
187 /* put the u8 bank and u8 reg together into a an u16.
188 * bank on higher 8 bits and reg in lower */
189 u16 addr = ((u16)bank) << 8 | reg;
190
191 ret = mutex_lock_interruptible(&ab8500->lock);
192 if (ret)
193 return ret;
194
195 ret = ab8500->read(ab8500, addr);
196 if (ret < 0) {
197 dev_err(ab8500->dev, "failed to read reg %#x: %d\n",
198 addr, ret);
199 goto out;
200 }
201
202 data = (u8)ret;
203 data = (~bitmask & data) | (bitmask & bitvalues);
204
205 ret = ab8500->write(ab8500, addr, data);
206 if (ret < 0)
207 dev_err(ab8500->dev, "failed to write reg %#x: %d\n",
208 addr, ret);
209
210 dev_vdbg(ab8500->dev, "mask: addr %#x => data %#x\n", addr, data);
211 out:
212 mutex_unlock(&ab8500->lock);
213 return ret;
214 }
215
216 static int ab8500_mask_and_set_register(struct device *dev,
217 u8 bank, u8 reg, u8 bitmask, u8 bitvalues)
218 {
219 struct ab8500 *ab8500 = dev_get_drvdata(dev->parent);
220
221 return mask_and_set_register_interruptible(ab8500, bank, reg,
222 bitmask, bitvalues);
223
224 }
225
226 static struct abx500_ops ab8500_ops = {
227 .get_chip_id = ab8500_get_chip_id,
228 .get_register = ab8500_get_register,
229 .set_register = ab8500_set_register,
230 .get_register_page = NULL,
231 .set_register_page = NULL,
232 .mask_and_set_register = ab8500_mask_and_set_register,
233 .event_registers_startup_state_get = NULL,
234 .startup_irq_enabled = NULL,
235 };
236
237 static void ab8500_irq_lock(struct irq_data *data)
238 {
239 struct ab8500 *ab8500 = irq_data_get_irq_chip_data(data);
240
241 mutex_lock(&ab8500->irq_lock);
242 }
243
244 static void ab8500_irq_sync_unlock(struct irq_data *data)
245 {
246 struct ab8500 *ab8500 = irq_data_get_irq_chip_data(data);
247 int i;
248
249 for (i = 0; i < AB8500_NUM_IRQ_REGS; i++) {
250 u8 old = ab8500->oldmask[i];
251 u8 new = ab8500->mask[i];
252 int reg;
253
254 if (new == old)
255 continue;
256
257 /* Interrupt register 12 does'nt exist prior to version 0x20 */
258 if (ab8500_irq_regoffset[i] == 11 && ab8500->chip_id < 0x20)
259 continue;
260
261 ab8500->oldmask[i] = new;
262
263 reg = AB8500_IT_MASK1_REG + ab8500_irq_regoffset[i];
264 set_register_interruptible(ab8500, AB8500_INTERRUPT, reg, new);
265 }
266
267 mutex_unlock(&ab8500->irq_lock);
268 }
269
270 static void ab8500_irq_mask(struct irq_data *data)
271 {
272 struct ab8500 *ab8500 = irq_data_get_irq_chip_data(data);
273 int offset = data->irq - ab8500->irq_base;
274 int index = offset / 8;
275 int mask = 1 << (offset % 8);
276
277 ab8500->mask[index] |= mask;
278 }
279
280 static void ab8500_irq_unmask(struct irq_data *data)
281 {
282 struct ab8500 *ab8500 = irq_data_get_irq_chip_data(data);
283 int offset = data->irq - ab8500->irq_base;
284 int index = offset / 8;
285 int mask = 1 << (offset % 8);
286
287 ab8500->mask[index] &= ~mask;
288 }
289
290 static struct irq_chip ab8500_irq_chip = {
291 .name = "ab8500",
292 .irq_bus_lock = ab8500_irq_lock,
293 .irq_bus_sync_unlock = ab8500_irq_sync_unlock,
294 .irq_mask = ab8500_irq_mask,
295 .irq_unmask = ab8500_irq_unmask,
296 };
297
298 static irqreturn_t ab8500_irq(int irq, void *dev)
299 {
300 struct ab8500 *ab8500 = dev;
301 int i;
302
303 dev_vdbg(ab8500->dev, "interrupt\n");
304
305 for (i = 0; i < AB8500_NUM_IRQ_REGS; i++) {
306 int regoffset = ab8500_irq_regoffset[i];
307 int status;
308 u8 value;
309
310 /* Interrupt register 12 does'nt exist prior to version 0x20 */
311 if (regoffset == 11 && ab8500->chip_id < 0x20)
312 continue;
313
314 status = get_register_interruptible(ab8500, AB8500_INTERRUPT,
315 AB8500_IT_LATCH1_REG + regoffset, &value);
316 if (status < 0 || value == 0)
317 continue;
318
319 do {
320 int bit = __ffs(value);
321 int line = i * 8 + bit;
322
323 handle_nested_irq(ab8500->irq_base + line);
324 value &= ~(1 << bit);
325 } while (value);
326 }
327
328 return IRQ_HANDLED;
329 }
330
331 static int ab8500_irq_init(struct ab8500 *ab8500)
332 {
333 int base = ab8500->irq_base;
334 int irq;
335
336 for (irq = base; irq < base + AB8500_NR_IRQS; irq++) {
337 set_irq_chip_data(irq, ab8500);
338 set_irq_chip_and_handler(irq, &ab8500_irq_chip,
339 handle_simple_irq);
340 set_irq_nested_thread(irq, 1);
341 #ifdef CONFIG_ARM
342 set_irq_flags(irq, IRQF_VALID);
343 #else
344 set_irq_noprobe(irq);
345 #endif
346 }
347
348 return 0;
349 }
350
351 static void ab8500_irq_remove(struct ab8500 *ab8500)
352 {
353 int base = ab8500->irq_base;
354 int irq;
355
356 for (irq = base; irq < base + AB8500_NR_IRQS; irq++) {
357 #ifdef CONFIG_ARM
358 set_irq_flags(irq, 0);
359 #endif
360 set_irq_chip_and_handler(irq, NULL, NULL);
361 set_irq_chip_data(irq, NULL);
362 }
363 }
364
365 static struct resource ab8500_gpadc_resources[] = {
366 {
367 .name = "HW_CONV_END",
368 .start = AB8500_INT_GP_HW_ADC_CONV_END,
369 .end = AB8500_INT_GP_HW_ADC_CONV_END,
370 .flags = IORESOURCE_IRQ,
371 },
372 {
373 .name = "SW_CONV_END",
374 .start = AB8500_INT_GP_SW_ADC_CONV_END,
375 .end = AB8500_INT_GP_SW_ADC_CONV_END,
376 .flags = IORESOURCE_IRQ,
377 },
378 };
379
380 static struct resource ab8500_rtc_resources[] = {
381 {
382 .name = "60S",
383 .start = AB8500_INT_RTC_60S,
384 .end = AB8500_INT_RTC_60S,
385 .flags = IORESOURCE_IRQ,
386 },
387 {
388 .name = "ALARM",
389 .start = AB8500_INT_RTC_ALARM,
390 .end = AB8500_INT_RTC_ALARM,
391 .flags = IORESOURCE_IRQ,
392 },
393 };
394
395 static struct resource ab8500_poweronkey_db_resources[] = {
396 {
397 .name = "ONKEY_DBF",
398 .start = AB8500_INT_PON_KEY1DB_F,
399 .end = AB8500_INT_PON_KEY1DB_F,
400 .flags = IORESOURCE_IRQ,
401 },
402 {
403 .name = "ONKEY_DBR",
404 .start = AB8500_INT_PON_KEY1DB_R,
405 .end = AB8500_INT_PON_KEY1DB_R,
406 .flags = IORESOURCE_IRQ,
407 },
408 };
409
410 static struct resource ab8500_bm_resources[] = {
411 {
412 .name = "MAIN_EXT_CH_NOT_OK",
413 .start = AB8500_INT_MAIN_EXT_CH_NOT_OK,
414 .end = AB8500_INT_MAIN_EXT_CH_NOT_OK,
415 .flags = IORESOURCE_IRQ,
416 },
417 {
418 .name = "BATT_OVV",
419 .start = AB8500_INT_BATT_OVV,
420 .end = AB8500_INT_BATT_OVV,
421 .flags = IORESOURCE_IRQ,
422 },
423 {
424 .name = "MAIN_CH_UNPLUG_DET",
425 .start = AB8500_INT_MAIN_CH_UNPLUG_DET,
426 .end = AB8500_INT_MAIN_CH_UNPLUG_DET,
427 .flags = IORESOURCE_IRQ,
428 },
429 {
430 .name = "MAIN_CHARGE_PLUG_DET",
431 .start = AB8500_INT_MAIN_CH_PLUG_DET,
432 .end = AB8500_INT_MAIN_CH_PLUG_DET,
433 .flags = IORESOURCE_IRQ,
434 },
435 {
436 .name = "VBUS_DET_F",
437 .start = AB8500_INT_VBUS_DET_F,
438 .end = AB8500_INT_VBUS_DET_F,
439 .flags = IORESOURCE_IRQ,
440 },
441 {
442 .name = "VBUS_DET_R",
443 .start = AB8500_INT_VBUS_DET_R,
444 .end = AB8500_INT_VBUS_DET_R,
445 .flags = IORESOURCE_IRQ,
446 },
447 {
448 .name = "BAT_CTRL_INDB",
449 .start = AB8500_INT_BAT_CTRL_INDB,
450 .end = AB8500_INT_BAT_CTRL_INDB,
451 .flags = IORESOURCE_IRQ,
452 },
453 {
454 .name = "CH_WD_EXP",
455 .start = AB8500_INT_CH_WD_EXP,
456 .end = AB8500_INT_CH_WD_EXP,
457 .flags = IORESOURCE_IRQ,
458 },
459 {
460 .name = "VBUS_OVV",
461 .start = AB8500_INT_VBUS_OVV,
462 .end = AB8500_INT_VBUS_OVV,
463 .flags = IORESOURCE_IRQ,
464 },
465 {
466 .name = "NCONV_ACCU",
467 .start = AB8500_INT_CCN_CONV_ACC,
468 .end = AB8500_INT_CCN_CONV_ACC,
469 .flags = IORESOURCE_IRQ,
470 },
471 {
472 .name = "LOW_BAT_F",
473 .start = AB8500_INT_LOW_BAT_F,
474 .end = AB8500_INT_LOW_BAT_F,
475 .flags = IORESOURCE_IRQ,
476 },
477 {
478 .name = "LOW_BAT_R",
479 .start = AB8500_INT_LOW_BAT_R,
480 .end = AB8500_INT_LOW_BAT_R,
481 .flags = IORESOURCE_IRQ,
482 },
483 {
484 .name = "BTEMP_LOW",
485 .start = AB8500_INT_BTEMP_LOW,
486 .end = AB8500_INT_BTEMP_LOW,
487 .flags = IORESOURCE_IRQ,
488 },
489 {
490 .name = "BTEMP_HIGH",
491 .start = AB8500_INT_BTEMP_HIGH,
492 .end = AB8500_INT_BTEMP_HIGH,
493 .flags = IORESOURCE_IRQ,
494 },
495 {
496 .name = "USB_CHARGER_NOT_OKR",
497 .start = AB8500_INT_USB_CHARGER_NOT_OK,
498 .end = AB8500_INT_USB_CHARGER_NOT_OK,
499 .flags = IORESOURCE_IRQ,
500 },
501 {
502 .name = "USB_CHARGE_DET_DONE",
503 .start = AB8500_INT_USB_CHG_DET_DONE,
504 .end = AB8500_INT_USB_CHG_DET_DONE,
505 .flags = IORESOURCE_IRQ,
506 },
507 {
508 .name = "USB_CH_TH_PROT_R",
509 .start = AB8500_INT_USB_CH_TH_PROT_R,
510 .end = AB8500_INT_USB_CH_TH_PROT_R,
511 .flags = IORESOURCE_IRQ,
512 },
513 {
514 .name = "MAIN_CH_TH_PROT_R",
515 .start = AB8500_INT_MAIN_CH_TH_PROT_R,
516 .end = AB8500_INT_MAIN_CH_TH_PROT_R,
517 .flags = IORESOURCE_IRQ,
518 },
519 {
520 .name = "USB_CHARGER_NOT_OKF",
521 .start = AB8500_INT_USB_CHARGER_NOT_OKF,
522 .end = AB8500_INT_USB_CHARGER_NOT_OKF,
523 .flags = IORESOURCE_IRQ,
524 },
525 };
526
527 static struct resource ab8500_debug_resources[] = {
528 {
529 .name = "IRQ_FIRST",
530 .start = AB8500_INT_MAIN_EXT_CH_NOT_OK,
531 .end = AB8500_INT_MAIN_EXT_CH_NOT_OK,
532 .flags = IORESOURCE_IRQ,
533 },
534 {
535 .name = "IRQ_LAST",
536 .start = AB8500_INT_USB_CHARGER_NOT_OKF,
537 .end = AB8500_INT_USB_CHARGER_NOT_OKF,
538 .flags = IORESOURCE_IRQ,
539 },
540 };
541
542 static struct resource ab8500_usb_resources[] = {
543 {
544 .name = "ID_WAKEUP_R",
545 .start = AB8500_INT_ID_WAKEUP_R,
546 .end = AB8500_INT_ID_WAKEUP_R,
547 .flags = IORESOURCE_IRQ,
548 },
549 {
550 .name = "ID_WAKEUP_F",
551 .start = AB8500_INT_ID_WAKEUP_F,
552 .end = AB8500_INT_ID_WAKEUP_F,
553 .flags = IORESOURCE_IRQ,
554 },
555 {
556 .name = "VBUS_DET_F",
557 .start = AB8500_INT_VBUS_DET_F,
558 .end = AB8500_INT_VBUS_DET_F,
559 .flags = IORESOURCE_IRQ,
560 },
561 {
562 .name = "VBUS_DET_R",
563 .start = AB8500_INT_VBUS_DET_R,
564 .end = AB8500_INT_VBUS_DET_R,
565 .flags = IORESOURCE_IRQ,
566 },
567 {
568 .name = "USB_LINK_STATUS",
569 .start = AB8500_INT_USB_LINK_STATUS,
570 .end = AB8500_INT_USB_LINK_STATUS,
571 .flags = IORESOURCE_IRQ,
572 },
573 };
574
575 static struct resource ab8500_temp_resources[] = {
576 {
577 .name = "AB8500_TEMP_WARM",
578 .start = AB8500_INT_TEMP_WARM,
579 .end = AB8500_INT_TEMP_WARM,
580 .flags = IORESOURCE_IRQ,
581 },
582 };
583
584 static struct mfd_cell ab8500_devs[] = {
585 #ifdef CONFIG_DEBUG_FS
586 {
587 .name = "ab8500-debug",
588 .num_resources = ARRAY_SIZE(ab8500_debug_resources),
589 .resources = ab8500_debug_resources,
590 },
591 #endif
592 {
593 .name = "ab8500-sysctrl",
594 },
595 {
596 .name = "ab8500-regulator",
597 },
598 {
599 .name = "ab8500-gpadc",
600 .num_resources = ARRAY_SIZE(ab8500_gpadc_resources),
601 .resources = ab8500_gpadc_resources,
602 },
603 {
604 .name = "ab8500-rtc",
605 .num_resources = ARRAY_SIZE(ab8500_rtc_resources),
606 .resources = ab8500_rtc_resources,
607 },
608 {
609 .name = "ab8500-bm",
610 .num_resources = ARRAY_SIZE(ab8500_bm_resources),
611 .resources = ab8500_bm_resources,
612 },
613 { .name = "ab8500-codec", },
614 {
615 .name = "ab8500-usb",
616 .num_resources = ARRAY_SIZE(ab8500_usb_resources),
617 .resources = ab8500_usb_resources,
618 },
619 {
620 .name = "ab8500-poweron-key",
621 .num_resources = ARRAY_SIZE(ab8500_poweronkey_db_resources),
622 .resources = ab8500_poweronkey_db_resources,
623 },
624 {
625 .name = "ab8500-pwm",
626 .id = 1,
627 },
628 {
629 .name = "ab8500-pwm",
630 .id = 2,
631 },
632 {
633 .name = "ab8500-pwm",
634 .id = 3,
635 },
636 { .name = "ab8500-leds", },
637 {
638 .name = "ab8500-denc",
639 },
640 {
641 .name = "ab8500-temp",
642 .num_resources = ARRAY_SIZE(ab8500_temp_resources),
643 .resources = ab8500_temp_resources,
644 },
645 };
646
647 static ssize_t show_chip_id(struct device *dev,
648 struct device_attribute *attr, char *buf)
649 {
650 struct ab8500 *ab8500;
651
652 ab8500 = dev_get_drvdata(dev);
653 return sprintf(buf, "%#x\n", ab8500 ? ab8500->chip_id : -EINVAL);
654 }
655
656 /*
657 * ab8500 has switched off due to (SWITCH_OFF_STATUS):
658 * 0x01 Swoff bit programming
659 * 0x02 Thermal protection activation
660 * 0x04 Vbat lower then BattOk falling threshold
661 * 0x08 Watchdog expired
662 * 0x10 Non presence of 32kHz clock
663 * 0x20 Battery level lower than power on reset threshold
664 * 0x40 Power on key 1 pressed longer than 10 seconds
665 * 0x80 DB8500 thermal shutdown
666 */
667 static ssize_t show_switch_off_status(struct device *dev,
668 struct device_attribute *attr, char *buf)
669 {
670 int ret;
671 u8 value;
672 struct ab8500 *ab8500;
673
674 ab8500 = dev_get_drvdata(dev);
675 ret = get_register_interruptible(ab8500, AB8500_RTC,
676 AB8500_SWITCH_OFF_STATUS, &value);
677 if (ret < 0)
678 return ret;
679 return sprintf(buf, "%#x\n", value);
680 }
681
682 static DEVICE_ATTR(chip_id, S_IRUGO, show_chip_id, NULL);
683 static DEVICE_ATTR(switch_off_status, S_IRUGO, show_switch_off_status, NULL);
684
685 static struct attribute *ab8500_sysfs_entries[] = {
686 &dev_attr_chip_id.attr,
687 &dev_attr_switch_off_status.attr,
688 NULL,
689 };
690
691 static struct attribute_group ab8500_attr_group = {
692 .attrs = ab8500_sysfs_entries,
693 };
694
695 int __devinit ab8500_init(struct ab8500 *ab8500)
696 {
697 struct ab8500_platform_data *plat = dev_get_platdata(ab8500->dev);
698 int ret;
699 int i;
700 u8 value;
701
702 if (plat)
703 ab8500->irq_base = plat->irq_base;
704
705 mutex_init(&ab8500->lock);
706 mutex_init(&ab8500->irq_lock);
707
708 ret = get_register_interruptible(ab8500, AB8500_MISC,
709 AB8500_REV_REG, &value);
710 if (ret < 0)
711 return ret;
712
713 /*
714 * 0x0 - Early Drop
715 * 0x10 - Cut 1.0
716 * 0x11 - Cut 1.1
717 * 0x20 - Cut 2.0
718 * 0x30 - Cut 3.0
719 */
720 if (value == 0x0 || value == 0x10 || value == 0x11 || value == 0x20 ||
721 value == 0x30) {
722 dev_info(ab8500->dev, "detected chip, revision: %#x\n", value);
723 } else {
724 dev_err(ab8500->dev, "unknown chip, revision: %#x\n", value);
725 return -EINVAL;
726 }
727 ab8500->chip_id = value;
728
729 /*
730 * ab8500 has switched off due to (SWITCH_OFF_STATUS):
731 * 0x01 Swoff bit programming
732 * 0x02 Thermal protection activation
733 * 0x04 Vbat lower then BattOk falling threshold
734 * 0x08 Watchdog expired
735 * 0x10 Non presence of 32kHz clock
736 * 0x20 Battery level lower than power on reset threshold
737 * 0x40 Power on key 1 pressed longer than 10 seconds
738 * 0x80 DB8500 thermal shutdown
739 */
740
741 ret = get_register_interruptible(ab8500, AB8500_RTC,
742 AB8500_SWITCH_OFF_STATUS, &value);
743 if (ret < 0)
744 return ret;
745 dev_info(ab8500->dev, "switch off status: %#x", value);
746
747 if (plat && plat->init)
748 plat->init(ab8500);
749
750 /* Clear and mask all interrupts */
751 for (i = 0; i < AB8500_NUM_IRQ_REGS; i++) {
752 /* Interrupt register 12 does'nt exist prior to version 0x20 */
753 if (ab8500_irq_regoffset[i] == 11 && ab8500->chip_id < 0x20)
754 continue;
755
756 get_register_interruptible(ab8500, AB8500_INTERRUPT,
757 AB8500_IT_LATCH1_REG + ab8500_irq_regoffset[i],
758 &value);
759 set_register_interruptible(ab8500, AB8500_INTERRUPT,
760 AB8500_IT_MASK1_REG + ab8500_irq_regoffset[i], 0xff);
761 }
762
763 ret = abx500_register_ops(ab8500->dev, &ab8500_ops);
764 if (ret)
765 return ret;
766
767 for (i = 0; i < AB8500_NUM_IRQ_REGS; i++)
768 ab8500->mask[i] = ab8500->oldmask[i] = 0xff;
769
770 if (ab8500->irq_base) {
771 ret = ab8500_irq_init(ab8500);
772 if (ret)
773 return ret;
774
775 ret = request_threaded_irq(ab8500->irq, NULL, ab8500_irq,
776 IRQF_ONESHOT | IRQF_NO_SUSPEND,
777 "ab8500", ab8500);
778 if (ret)
779 goto out_removeirq;
780 }
781
782 ret = mfd_add_devices(ab8500->dev, 0, ab8500_devs,
783 ARRAY_SIZE(ab8500_devs), NULL,
784 ab8500->irq_base);
785 if (ret)
786 goto out_freeirq;
787
788 ret = sysfs_create_group(&ab8500->dev->kobj, &ab8500_attr_group);
789 if (ret)
790 dev_err(ab8500->dev, "error creating sysfs entries\n");
791
792 return ret;
793
794 out_freeirq:
795 if (ab8500->irq_base) {
796 free_irq(ab8500->irq, ab8500);
797 out_removeirq:
798 ab8500_irq_remove(ab8500);
799 }
800 return ret;
801 }
802
803 int __devexit ab8500_exit(struct ab8500 *ab8500)
804 {
805 sysfs_remove_group(&ab8500->dev->kobj, &ab8500_attr_group);
806 mfd_remove_devices(ab8500->dev);
807 if (ab8500->irq_base) {
808 free_irq(ab8500->irq, ab8500);
809 ab8500_irq_remove(ab8500);
810 }
811
812 return 0;
813 }
814
815 MODULE_AUTHOR("Mattias Wallin, Srinidhi Kasagar, Rabin Vincent");
816 MODULE_DESCRIPTION("AB8500 MFD core");
817 MODULE_LICENSE("GPL v2");
Ubuntu Artful kernel mirror