Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
ab8500-core.c
Go to the documentation of this file.
1 /*
2  * Copyright (C) ST-Ericsson SA 2010
3  *
4  * License Terms: GNU General Public License v2
5  * Author: Srinidhi Kasagar <[email protected]>
6  * Author: Rabin Vincent <[email protected]>
7  * Author: Mattias Wallin <[email protected]>
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/irqdomain.h>
15 #include <linux/delay.h>
16 #include <linux/interrupt.h>
17 #include <linux/module.h>
18 #include <linux/platform_device.h>
19 #include <linux/mfd/core.h>
20 #include <linux/mfd/abx500.h>
21 #include <linux/mfd/abx500/ab8500.h>
22 #include <linux/mfd/dbx500-prcmu.h>
23 #include <linux/regulator/ab8500.h>
24 #include <linux/of.h>
25 #include <linux/of_device.h>
26 
27 /*
28  * Interrupt register offsets
29  * Bank : 0x0E
30  */
31 #define AB8500_IT_SOURCE1_REG 0x00
32 #define AB8500_IT_SOURCE2_REG 0x01
33 #define AB8500_IT_SOURCE3_REG 0x02
34 #define AB8500_IT_SOURCE4_REG 0x03
35 #define AB8500_IT_SOURCE5_REG 0x04
36 #define AB8500_IT_SOURCE6_REG 0x05
37 #define AB8500_IT_SOURCE7_REG 0x06
38 #define AB8500_IT_SOURCE8_REG 0x07
39 #define AB9540_IT_SOURCE13_REG 0x0C
40 #define AB8500_IT_SOURCE19_REG 0x12
41 #define AB8500_IT_SOURCE20_REG 0x13
42 #define AB8500_IT_SOURCE21_REG 0x14
43 #define AB8500_IT_SOURCE22_REG 0x15
44 #define AB8500_IT_SOURCE23_REG 0x16
45 #define AB8500_IT_SOURCE24_REG 0x17
46 
47 /*
48  * latch registers
49  */
50 #define AB8500_IT_LATCH1_REG 0x20
51 #define AB8500_IT_LATCH2_REG 0x21
52 #define AB8500_IT_LATCH3_REG 0x22
53 #define AB8500_IT_LATCH4_REG 0x23
54 #define AB8500_IT_LATCH5_REG 0x24
55 #define AB8500_IT_LATCH6_REG 0x25
56 #define AB8500_IT_LATCH7_REG 0x26
57 #define AB8500_IT_LATCH8_REG 0x27
58 #define AB8500_IT_LATCH9_REG 0x28
59 #define AB8500_IT_LATCH10_REG 0x29
60 #define AB8500_IT_LATCH12_REG 0x2B
61 #define AB9540_IT_LATCH13_REG 0x2C
62 #define AB8500_IT_LATCH19_REG 0x32
63 #define AB8500_IT_LATCH20_REG 0x33
64 #define AB8500_IT_LATCH21_REG 0x34
65 #define AB8500_IT_LATCH22_REG 0x35
66 #define AB8500_IT_LATCH23_REG 0x36
67 #define AB8500_IT_LATCH24_REG 0x37
68 
69 /*
70  * mask registers
71  */
72 
73 #define AB8500_IT_MASK1_REG 0x40
74 #define AB8500_IT_MASK2_REG 0x41
75 #define AB8500_IT_MASK3_REG 0x42
76 #define AB8500_IT_MASK4_REG 0x43
77 #define AB8500_IT_MASK5_REG 0x44
78 #define AB8500_IT_MASK6_REG 0x45
79 #define AB8500_IT_MASK7_REG 0x46
80 #define AB8500_IT_MASK8_REG 0x47
81 #define AB8500_IT_MASK9_REG 0x48
82 #define AB8500_IT_MASK10_REG 0x49
83 #define AB8500_IT_MASK11_REG 0x4A
84 #define AB8500_IT_MASK12_REG 0x4B
85 #define AB8500_IT_MASK13_REG 0x4C
86 #define AB8500_IT_MASK14_REG 0x4D
87 #define AB8500_IT_MASK15_REG 0x4E
88 #define AB8500_IT_MASK16_REG 0x4F
89 #define AB8500_IT_MASK17_REG 0x50
90 #define AB8500_IT_MASK18_REG 0x51
91 #define AB8500_IT_MASK19_REG 0x52
92 #define AB8500_IT_MASK20_REG 0x53
93 #define AB8500_IT_MASK21_REG 0x54
94 #define AB8500_IT_MASK22_REG 0x55
95 #define AB8500_IT_MASK23_REG 0x56
96 #define AB8500_IT_MASK24_REG 0x57
97 
98 /*
99  * latch hierarchy registers
100  */
101 #define AB8500_IT_LATCHHIER1_REG 0x60
102 #define AB8500_IT_LATCHHIER2_REG 0x61
103 #define AB8500_IT_LATCHHIER3_REG 0x62
104 
105 #define AB8500_IT_LATCHHIER_NUM 3
106 
107 #define AB8500_REV_REG 0x80
108 #define AB8500_IC_NAME_REG 0x82
109 #define AB8500_SWITCH_OFF_STATUS 0x00
110 
111 #define AB8500_TURN_ON_STATUS 0x00
112 
113 static bool no_bm; /* No battery management */
114 module_param(no_bm, bool, S_IRUGO);
115 
116 #define AB9540_MODEM_CTRL2_REG 0x23
117 #define AB9540_MODEM_CTRL2_SWDBBRSTN_BIT BIT(2)
118 
119 /*
120  * Map interrupt numbers to the LATCH and MASK register offsets, Interrupt
121  * numbers are indexed into this array with (num / 8). The interupts are
122  * defined in linux/mfd/ab8500.h
123  *
124  * This is one off from the register names, i.e. AB8500_IT_MASK1_REG is at
125  * offset 0.
126  */
127 /* AB8500 support */
128 static const int ab8500_irq_regoffset[AB8500_NUM_IRQ_REGS] = {
129  0, 1, 2, 3, 4, 6, 7, 8, 9, 11, 18, 19, 20, 21,
130 };
131 
132 /* AB9540 support */
133 static const int ab9540_irq_regoffset[AB9540_NUM_IRQ_REGS] = {
134  0, 1, 2, 3, 4, 6, 7, 8, 9, 11, 18, 19, 20, 21, 12, 13, 24,
135 };
136 
137 static const char ab8500_version_str[][7] = {
138  [AB8500_VERSION_AB8500] = "AB8500",
139  [AB8500_VERSION_AB8505] = "AB8505",
140  [AB8500_VERSION_AB9540] = "AB9540",
141  [AB8500_VERSION_AB8540] = "AB8540",
142 };
143 
144 static int ab8500_prcmu_write(struct ab8500 *ab8500, u16 addr, u8 data)
145 {
146  int ret;
147 
148  ret = prcmu_abb_write((u8)(addr >> 8), (u8)(addr & 0xFF), &data, 1);
149  if (ret < 0)
150  dev_err(ab8500->dev, "prcmu i2c error %d\n", ret);
151  return ret;
152 }
153 
154 static int ab8500_prcmu_write_masked(struct ab8500 *ab8500, u16 addr, u8 mask,
155  u8 data)
156 {
157  int ret;
158 
159  ret = prcmu_abb_write_masked((u8)(addr >> 8), (u8)(addr & 0xFF), &data,
160  &mask, 1);
161  if (ret < 0)
162  dev_err(ab8500->dev, "prcmu i2c error %d\n", ret);
163  return ret;
164 }
165 
166 static int ab8500_prcmu_read(struct ab8500 *ab8500, u16 addr)
167 {
168  int ret;
169  u8 data;
170 
171  ret = prcmu_abb_read((u8)(addr >> 8), (u8)(addr & 0xFF), &data, 1);
172  if (ret < 0) {
173  dev_err(ab8500->dev, "prcmu i2c error %d\n", ret);
174  return ret;
175  }
176  return (int)data;
177 }
178 
179 static int ab8500_get_chip_id(struct device *dev)
180 {
181  struct ab8500 *ab8500;
182 
183  if (!dev)
184  return -EINVAL;
185  ab8500 = dev_get_drvdata(dev->parent);
186  return ab8500 ? (int)ab8500->chip_id : -EINVAL;
187 }
188 
189 static int set_register_interruptible(struct ab8500 *ab8500, u8 bank,
190  u8 reg, u8 data)
191 {
192  int ret;
193  /*
194  * Put the u8 bank and u8 register together into a an u16.
195  * The bank on higher 8 bits and register in lower 8 bits.
196  * */
197  u16 addr = ((u16)bank) << 8 | reg;
198 
199  dev_vdbg(ab8500->dev, "wr: addr %#x <= %#x\n", addr, data);
200 
201  mutex_lock(&ab8500->lock);
202 
203  ret = ab8500->write(ab8500, addr, data);
204  if (ret < 0)
205  dev_err(ab8500->dev, "failed to write reg %#x: %d\n",
206  addr, ret);
207  mutex_unlock(&ab8500->lock);
208 
209  return ret;
210 }
211 
212 static int ab8500_set_register(struct device *dev, u8 bank,
213  u8 reg, u8 value)
214 {
215  int ret;
216  struct ab8500 *ab8500 = dev_get_drvdata(dev->parent);
217 
218  atomic_inc(&ab8500->transfer_ongoing);
219  ret = set_register_interruptible(ab8500, bank, reg, value);
220  atomic_dec(&ab8500->transfer_ongoing);
221  return ret;
222 }
223 
224 static int get_register_interruptible(struct ab8500 *ab8500, u8 bank,
225  u8 reg, u8 *value)
226 {
227  int ret;
228  /* put the u8 bank and u8 reg together into a an u16.
229  * bank on higher 8 bits and reg in lower */
230  u16 addr = ((u16)bank) << 8 | reg;
231 
232  mutex_lock(&ab8500->lock);
233 
234  ret = ab8500->read(ab8500, addr);
235  if (ret < 0)
236  dev_err(ab8500->dev, "failed to read reg %#x: %d\n",
237  addr, ret);
238  else
239  *value = ret;
240 
241  mutex_unlock(&ab8500->lock);
242  dev_vdbg(ab8500->dev, "rd: addr %#x => data %#x\n", addr, ret);
243 
244  return ret;
245 }
246 
247 static int ab8500_get_register(struct device *dev, u8 bank,
248  u8 reg, u8 *value)
249 {
250  int ret;
251  struct ab8500 *ab8500 = dev_get_drvdata(dev->parent);
252 
253  atomic_inc(&ab8500->transfer_ongoing);
254  ret = get_register_interruptible(ab8500, bank, reg, value);
255  atomic_dec(&ab8500->transfer_ongoing);
256  return ret;
257 }
258 
259 static int mask_and_set_register_interruptible(struct ab8500 *ab8500, u8 bank,
260  u8 reg, u8 bitmask, u8 bitvalues)
261 {
262  int ret;
263  /* put the u8 bank and u8 reg together into a an u16.
264  * bank on higher 8 bits and reg in lower */
265  u16 addr = ((u16)bank) << 8 | reg;
266 
267  mutex_lock(&ab8500->lock);
268 
269  if (ab8500->write_masked == NULL) {
270  u8 data;
271 
272  ret = ab8500->read(ab8500, addr);
273  if (ret < 0) {
274  dev_err(ab8500->dev, "failed to read reg %#x: %d\n",
275  addr, ret);
276  goto out;
277  }
278 
279  data = (u8)ret;
280  data = (~bitmask & data) | (bitmask & bitvalues);
281 
282  ret = ab8500->write(ab8500, addr, data);
283  if (ret < 0)
284  dev_err(ab8500->dev, "failed to write reg %#x: %d\n",
285  addr, ret);
286 
287  dev_vdbg(ab8500->dev, "mask: addr %#x => data %#x\n", addr,
288  data);
289  goto out;
290  }
291  ret = ab8500->write_masked(ab8500, addr, bitmask, bitvalues);
292  if (ret < 0)
293  dev_err(ab8500->dev, "failed to modify reg %#x: %d\n", addr,
294  ret);
295 out:
296  mutex_unlock(&ab8500->lock);
297  return ret;
298 }
299 
300 static int ab8500_mask_and_set_register(struct device *dev,
301  u8 bank, u8 reg, u8 bitmask, u8 bitvalues)
302 {
303  int ret;
304  struct ab8500 *ab8500 = dev_get_drvdata(dev->parent);
305 
306  atomic_inc(&ab8500->transfer_ongoing);
307  ret= mask_and_set_register_interruptible(ab8500, bank, reg,
308  bitmask, bitvalues);
309  atomic_dec(&ab8500->transfer_ongoing);
310  return ret;
311 }
312 
313 static struct abx500_ops ab8500_ops = {
314  .get_chip_id = ab8500_get_chip_id,
315  .get_register = ab8500_get_register,
316  .set_register = ab8500_set_register,
317  .get_register_page = NULL,
318  .set_register_page = NULL,
319  .mask_and_set_register = ab8500_mask_and_set_register,
320  .event_registers_startup_state_get = NULL,
321  .startup_irq_enabled = NULL,
322 };
323 
324 static void ab8500_irq_lock(struct irq_data *data)
325 {
326  struct ab8500 *ab8500 = irq_data_get_irq_chip_data(data);
327 
328  mutex_lock(&ab8500->irq_lock);
329  atomic_inc(&ab8500->transfer_ongoing);
330 }
331 
332 static void ab8500_irq_sync_unlock(struct irq_data *data)
333 {
334  struct ab8500 *ab8500 = irq_data_get_irq_chip_data(data);
335  int i;
336 
337  for (i = 0; i < ab8500->mask_size; i++) {
338  u8 old = ab8500->oldmask[i];
339  u8 new = ab8500->mask[i];
340  int reg;
341 
342  if (new == old)
343  continue;
344 
345  /*
346  * Interrupt register 12 doesn't exist prior to AB8500 version
347  * 2.0
348  */
349  if (ab8500->irq_reg_offset[i] == 11 &&
350  is_ab8500_1p1_or_earlier(ab8500))
351  continue;
352 
353  ab8500->oldmask[i] = new;
354 
355  reg = AB8500_IT_MASK1_REG + ab8500->irq_reg_offset[i];
356  set_register_interruptible(ab8500, AB8500_INTERRUPT, reg, new);
357  }
358  atomic_dec(&ab8500->transfer_ongoing);
359  mutex_unlock(&ab8500->irq_lock);
360 }
361 
362 static void ab8500_irq_mask(struct irq_data *data)
363 {
364  struct ab8500 *ab8500 = irq_data_get_irq_chip_data(data);
365  int offset = data->hwirq;
366  int index = offset / 8;
367  int mask = 1 << (offset % 8);
368 
369  ab8500->mask[index] |= mask;
370 }
371 
372 static void ab8500_irq_unmask(struct irq_data *data)
373 {
374  struct ab8500 *ab8500 = irq_data_get_irq_chip_data(data);
375  int offset = data->hwirq;
376  int index = offset / 8;
377  int mask = 1 << (offset % 8);
378 
379  ab8500->mask[index] &= ~mask;
380 }
381 
382 static struct irq_chip ab8500_irq_chip = {
383  .name = "ab8500",
384  .irq_bus_lock = ab8500_irq_lock,
385  .irq_bus_sync_unlock = ab8500_irq_sync_unlock,
386  .irq_mask = ab8500_irq_mask,
387  .irq_disable = ab8500_irq_mask,
388  .irq_unmask = ab8500_irq_unmask,
389 };
390 
391 static int ab8500_handle_hierarchical_line(struct ab8500 *ab8500,
392  int latch_offset, u8 latch_val)
393 {
394  int int_bit = __ffs(latch_val);
395  int line, i;
396 
397  do {
398  int_bit = __ffs(latch_val);
399 
400  for (i = 0; i < ab8500->mask_size; i++)
401  if (ab8500->irq_reg_offset[i] == latch_offset)
402  break;
403 
404  if (i >= ab8500->mask_size) {
405  dev_err(ab8500->dev, "Register offset 0x%2x not declared\n",
406  latch_offset);
407  return -ENXIO;
408  }
409 
410  line = (i << 3) + int_bit;
411  latch_val &= ~(1 << int_bit);
412 
413  handle_nested_irq(ab8500->irq_base + line);
414  } while (latch_val);
415 
416  return 0;
417 }
418 
419 static int ab8500_handle_hierarchical_latch(struct ab8500 *ab8500,
420  int hier_offset, u8 hier_val)
421 {
422  int latch_bit, status;
423  u8 latch_offset, latch_val;
424 
425  do {
426  latch_bit = __ffs(hier_val);
427  latch_offset = (hier_offset << 3) + latch_bit;
428 
429  /* Fix inconsistent ITFromLatch25 bit mapping... */
430  if (unlikely(latch_offset == 17))
431  latch_offset = 24;
432 
433  status = get_register_interruptible(ab8500,
434  AB8500_INTERRUPT,
435  AB8500_IT_LATCH1_REG + latch_offset,
436  &latch_val);
437  if (status < 0 || latch_val == 0)
438  goto discard;
439 
440  status = ab8500_handle_hierarchical_line(ab8500,
441  latch_offset, latch_val);
442  if (status < 0)
443  return status;
444 discard:
445  hier_val &= ~(1 << latch_bit);
446  } while (hier_val);
447 
448  return 0;
449 }
450 
451 static irqreturn_t ab8500_hierarchical_irq(int irq, void *dev)
452 {
453  struct ab8500 *ab8500 = dev;
454  u8 i;
455 
456  dev_vdbg(ab8500->dev, "interrupt\n");
457 
458  /* Hierarchical interrupt version */
459  for (i = 0; i < AB8500_IT_LATCHHIER_NUM; i++) {
460  int status;
461  u8 hier_val;
462 
463  status = get_register_interruptible(ab8500, AB8500_INTERRUPT,
464  AB8500_IT_LATCHHIER1_REG + i, &hier_val);
465  if (status < 0 || hier_val == 0)
466  continue;
467 
468  status = ab8500_handle_hierarchical_latch(ab8500, i, hier_val);
469  if (status < 0)
470  break;
471  }
472  return IRQ_HANDLED;
473 }
474 
483 static int ab8500_irq_get_virq(struct ab8500 *ab8500, int irq)
484 {
485  if (!ab8500)
486  return -EINVAL;
487 
488  return irq_create_mapping(ab8500->domain, irq);
489 }
490 
491 static irqreturn_t ab8500_irq(int irq, void *dev)
492 {
493  struct ab8500 *ab8500 = dev;
494  int i;
495 
496  dev_vdbg(ab8500->dev, "interrupt\n");
497 
498  atomic_inc(&ab8500->transfer_ongoing);
499 
500  for (i = 0; i < ab8500->mask_size; i++) {
501  int regoffset = ab8500->irq_reg_offset[i];
502  int status;
503  u8 value;
504 
505  /*
506  * Interrupt register 12 doesn't exist prior to AB8500 version
507  * 2.0
508  */
509  if (regoffset == 11 && is_ab8500_1p1_or_earlier(ab8500))
510  continue;
511 
512  status = get_register_interruptible(ab8500, AB8500_INTERRUPT,
513  AB8500_IT_LATCH1_REG + regoffset, &value);
514  if (status < 0 || value == 0)
515  continue;
516 
517  do {
518  int bit = __ffs(value);
519  int line = i * 8 + bit;
520  int virq = ab8500_irq_get_virq(ab8500, line);
521 
522  handle_nested_irq(virq);
523  value &= ~(1 << bit);
524 
525  } while (value);
526  }
527  atomic_dec(&ab8500->transfer_ongoing);
528  return IRQ_HANDLED;
529 }
530 
531 static int ab8500_irq_map(struct irq_domain *d, unsigned int virq,
532  irq_hw_number_t hwirq)
533 {
534  struct ab8500 *ab8500 = d->host_data;
535 
536  if (!ab8500)
537  return -EINVAL;
538 
539  irq_set_chip_data(virq, ab8500);
540  irq_set_chip_and_handler(virq, &ab8500_irq_chip,
541  handle_simple_irq);
542  irq_set_nested_thread(virq, 1);
543 #ifdef CONFIG_ARM
544  set_irq_flags(virq, IRQF_VALID);
545 #else
546  irq_set_noprobe(virq);
547 #endif
548 
549  return 0;
550 }
551 
552 static struct irq_domain_ops ab8500_irq_ops = {
553  .map = ab8500_irq_map,
554  .xlate = irq_domain_xlate_twocell,
555 };
556 
557 static int ab8500_irq_init(struct ab8500 *ab8500, struct device_node *np)
558 {
559  int num_irqs;
560 
561  if (is_ab9540(ab8500))
562  num_irqs = AB9540_NR_IRQS;
563  else if (is_ab8505(ab8500))
564  num_irqs = AB8505_NR_IRQS;
565  else
566  num_irqs = AB8500_NR_IRQS;
567 
568  if (ab8500->irq_base) {
569  ab8500->domain = irq_domain_add_legacy(
570  NULL, num_irqs, ab8500->irq_base,
571  0, &ab8500_irq_ops, ab8500);
572  }
573  else {
574  ab8500->domain = irq_domain_add_linear(
575  np, num_irqs, &ab8500_irq_ops, ab8500);
576  }
577 
578  if (!ab8500->domain) {
579  dev_err(ab8500->dev, "Failed to create irqdomain\n");
580  return -ENOSYS;
581  }
582 
583  return 0;
584 }
585 
586 int ab8500_suspend(struct ab8500 *ab8500)
587 {
588  if (atomic_read(&ab8500->transfer_ongoing))
589  return -EINVAL;
590  else
591  return 0;
592 }
593 
594 /* AB8500 GPIO Resources */
595 static struct resource __devinitdata ab8500_gpio_resources[] = {
596  {
597  .name = "GPIO_INT6",
598  .start = AB8500_INT_GPIO6R,
599  .end = AB8500_INT_GPIO41F,
600  .flags = IORESOURCE_IRQ,
601  }
602 };
603 
604 /* AB9540 GPIO Resources */
605 static struct resource __devinitdata ab9540_gpio_resources[] = {
606  {
607  .name = "GPIO_INT6",
608  .start = AB8500_INT_GPIO6R,
609  .end = AB8500_INT_GPIO41F,
610  .flags = IORESOURCE_IRQ,
611  },
612  {
613  .name = "GPIO_INT14",
614  .start = AB9540_INT_GPIO50R,
615  .end = AB9540_INT_GPIO54R,
616  .flags = IORESOURCE_IRQ,
617  },
618  {
619  .name = "GPIO_INT15",
620  .start = AB9540_INT_GPIO50F,
621  .end = AB9540_INT_GPIO54F,
622  .flags = IORESOURCE_IRQ,
623  }
624 };
625 
626 static struct resource __devinitdata ab8500_gpadc_resources[] = {
627  {
628  .name = "HW_CONV_END",
629  .start = AB8500_INT_GP_HW_ADC_CONV_END,
630  .end = AB8500_INT_GP_HW_ADC_CONV_END,
631  .flags = IORESOURCE_IRQ,
632  },
633  {
634  .name = "SW_CONV_END",
635  .start = AB8500_INT_GP_SW_ADC_CONV_END,
636  .end = AB8500_INT_GP_SW_ADC_CONV_END,
637  .flags = IORESOURCE_IRQ,
638  },
639 };
640 
641 static struct resource __devinitdata ab8500_rtc_resources[] = {
642  {
643  .name = "60S",
644  .start = AB8500_INT_RTC_60S,
645  .end = AB8500_INT_RTC_60S,
646  .flags = IORESOURCE_IRQ,
647  },
648  {
649  .name = "ALARM",
650  .start = AB8500_INT_RTC_ALARM,
651  .end = AB8500_INT_RTC_ALARM,
652  .flags = IORESOURCE_IRQ,
653  },
654 };
655 
656 static struct resource __devinitdata ab8500_poweronkey_db_resources[] = {
657  {
658  .name = "ONKEY_DBF",
659  .start = AB8500_INT_PON_KEY1DB_F,
660  .end = AB8500_INT_PON_KEY1DB_F,
661  .flags = IORESOURCE_IRQ,
662  },
663  {
664  .name = "ONKEY_DBR",
665  .start = AB8500_INT_PON_KEY1DB_R,
666  .end = AB8500_INT_PON_KEY1DB_R,
667  .flags = IORESOURCE_IRQ,
668  },
669 };
670 
671 static struct resource __devinitdata ab8500_av_acc_detect_resources[] = {
672  {
673  .name = "ACC_DETECT_1DB_F",
674  .start = AB8500_INT_ACC_DETECT_1DB_F,
675  .end = AB8500_INT_ACC_DETECT_1DB_F,
676  .flags = IORESOURCE_IRQ,
677  },
678  {
679  .name = "ACC_DETECT_1DB_R",
680  .start = AB8500_INT_ACC_DETECT_1DB_R,
681  .end = AB8500_INT_ACC_DETECT_1DB_R,
682  .flags = IORESOURCE_IRQ,
683  },
684  {
685  .name = "ACC_DETECT_21DB_F",
686  .start = AB8500_INT_ACC_DETECT_21DB_F,
687  .end = AB8500_INT_ACC_DETECT_21DB_F,
688  .flags = IORESOURCE_IRQ,
689  },
690  {
691  .name = "ACC_DETECT_21DB_R",
692  .start = AB8500_INT_ACC_DETECT_21DB_R,
693  .end = AB8500_INT_ACC_DETECT_21DB_R,
694  .flags = IORESOURCE_IRQ,
695  },
696  {
697  .name = "ACC_DETECT_22DB_F",
698  .start = AB8500_INT_ACC_DETECT_22DB_F,
699  .end = AB8500_INT_ACC_DETECT_22DB_F,
700  .flags = IORESOURCE_IRQ,
701  },
702  {
703  .name = "ACC_DETECT_22DB_R",
704  .start = AB8500_INT_ACC_DETECT_22DB_R,
705  .end = AB8500_INT_ACC_DETECT_22DB_R,
706  .flags = IORESOURCE_IRQ,
707  },
708 };
709 
710 static struct resource __devinitdata ab8500_charger_resources[] = {
711  {
712  .name = "MAIN_CH_UNPLUG_DET",
713  .start = AB8500_INT_MAIN_CH_UNPLUG_DET,
714  .end = AB8500_INT_MAIN_CH_UNPLUG_DET,
715  .flags = IORESOURCE_IRQ,
716  },
717  {
718  .name = "MAIN_CHARGE_PLUG_DET",
719  .start = AB8500_INT_MAIN_CH_PLUG_DET,
720  .end = AB8500_INT_MAIN_CH_PLUG_DET,
721  .flags = IORESOURCE_IRQ,
722  },
723  {
724  .name = "VBUS_DET_R",
725  .start = AB8500_INT_VBUS_DET_R,
726  .end = AB8500_INT_VBUS_DET_R,
727  .flags = IORESOURCE_IRQ,
728  },
729  {
730  .name = "VBUS_DET_F",
731  .start = AB8500_INT_VBUS_DET_F,
732  .end = AB8500_INT_VBUS_DET_F,
733  .flags = IORESOURCE_IRQ,
734  },
735  {
736  .name = "USB_LINK_STATUS",
737  .start = AB8500_INT_USB_LINK_STATUS,
738  .end = AB8500_INT_USB_LINK_STATUS,
739  .flags = IORESOURCE_IRQ,
740  },
741  {
742  .name = "VBUS_OVV",
743  .start = AB8500_INT_VBUS_OVV,
744  .end = AB8500_INT_VBUS_OVV,
745  .flags = IORESOURCE_IRQ,
746  },
747  {
748  .name = "USB_CH_TH_PROT_R",
749  .start = AB8500_INT_USB_CH_TH_PROT_R,
750  .end = AB8500_INT_USB_CH_TH_PROT_R,
751  .flags = IORESOURCE_IRQ,
752  },
753  {
754  .name = "USB_CH_TH_PROT_F",
755  .start = AB8500_INT_USB_CH_TH_PROT_F,
756  .end = AB8500_INT_USB_CH_TH_PROT_F,
757  .flags = IORESOURCE_IRQ,
758  },
759  {
760  .name = "MAIN_EXT_CH_NOT_OK",
761  .start = AB8500_INT_MAIN_EXT_CH_NOT_OK,
762  .end = AB8500_INT_MAIN_EXT_CH_NOT_OK,
763  .flags = IORESOURCE_IRQ,
764  },
765  {
766  .name = "MAIN_CH_TH_PROT_R",
767  .start = AB8500_INT_MAIN_CH_TH_PROT_R,
768  .end = AB8500_INT_MAIN_CH_TH_PROT_R,
769  .flags = IORESOURCE_IRQ,
770  },
771  {
772  .name = "MAIN_CH_TH_PROT_F",
773  .start = AB8500_INT_MAIN_CH_TH_PROT_F,
774  .end = AB8500_INT_MAIN_CH_TH_PROT_F,
775  .flags = IORESOURCE_IRQ,
776  },
777  {
778  .name = "USB_CHARGER_NOT_OKR",
779  .start = AB8500_INT_USB_CHARGER_NOT_OKR,
780  .end = AB8500_INT_USB_CHARGER_NOT_OKR,
781  .flags = IORESOURCE_IRQ,
782  },
783  {
784  .name = "CH_WD_EXP",
785  .start = AB8500_INT_CH_WD_EXP,
786  .end = AB8500_INT_CH_WD_EXP,
787  .flags = IORESOURCE_IRQ,
788  },
789 };
790 
791 static struct resource __devinitdata ab8500_btemp_resources[] = {
792  {
793  .name = "BAT_CTRL_INDB",
794  .start = AB8500_INT_BAT_CTRL_INDB,
795  .end = AB8500_INT_BAT_CTRL_INDB,
796  .flags = IORESOURCE_IRQ,
797  },
798  {
799  .name = "BTEMP_LOW",
800  .start = AB8500_INT_BTEMP_LOW,
801  .end = AB8500_INT_BTEMP_LOW,
802  .flags = IORESOURCE_IRQ,
803  },
804  {
805  .name = "BTEMP_HIGH",
806  .start = AB8500_INT_BTEMP_HIGH,
807  .end = AB8500_INT_BTEMP_HIGH,
808  .flags = IORESOURCE_IRQ,
809  },
810  {
811  .name = "BTEMP_LOW_MEDIUM",
812  .start = AB8500_INT_BTEMP_LOW_MEDIUM,
813  .end = AB8500_INT_BTEMP_LOW_MEDIUM,
814  .flags = IORESOURCE_IRQ,
815  },
816  {
817  .name = "BTEMP_MEDIUM_HIGH",
818  .start = AB8500_INT_BTEMP_MEDIUM_HIGH,
819  .end = AB8500_INT_BTEMP_MEDIUM_HIGH,
820  .flags = IORESOURCE_IRQ,
821  },
822 };
823 
824 static struct resource __devinitdata ab8500_fg_resources[] = {
825  {
826  .name = "NCONV_ACCU",
827  .start = AB8500_INT_CCN_CONV_ACC,
828  .end = AB8500_INT_CCN_CONV_ACC,
829  .flags = IORESOURCE_IRQ,
830  },
831  {
832  .name = "BATT_OVV",
833  .start = AB8500_INT_BATT_OVV,
834  .end = AB8500_INT_BATT_OVV,
835  .flags = IORESOURCE_IRQ,
836  },
837  {
838  .name = "LOW_BAT_F",
839  .start = AB8500_INT_LOW_BAT_F,
840  .end = AB8500_INT_LOW_BAT_F,
841  .flags = IORESOURCE_IRQ,
842  },
843  {
844  .name = "LOW_BAT_R",
845  .start = AB8500_INT_LOW_BAT_R,
846  .end = AB8500_INT_LOW_BAT_R,
847  .flags = IORESOURCE_IRQ,
848  },
849  {
850  .name = "CC_INT_CALIB",
851  .start = AB8500_INT_CC_INT_CALIB,
852  .end = AB8500_INT_CC_INT_CALIB,
853  .flags = IORESOURCE_IRQ,
854  },
855  {
856  .name = "CCEOC",
857  .start = AB8500_INT_CCEOC,
858  .end = AB8500_INT_CCEOC,
859  .flags = IORESOURCE_IRQ,
860  },
861 };
862 
863 static struct resource __devinitdata ab8500_chargalg_resources[] = {};
864 
865 #ifdef CONFIG_DEBUG_FS
866 static struct resource __devinitdata ab8500_debug_resources[] = {
867  {
868  .name = "IRQ_FIRST",
869  .start = AB8500_INT_MAIN_EXT_CH_NOT_OK,
870  .end = AB8500_INT_MAIN_EXT_CH_NOT_OK,
871  .flags = IORESOURCE_IRQ,
872  },
873  {
874  .name = "IRQ_LAST",
875  .start = AB8500_INT_XTAL32K_KO,
876  .end = AB8500_INT_XTAL32K_KO,
877  .flags = IORESOURCE_IRQ,
878  },
879 };
880 #endif
881 
882 static struct resource __devinitdata ab8500_usb_resources[] = {
883  {
884  .name = "ID_WAKEUP_R",
885  .start = AB8500_INT_ID_WAKEUP_R,
886  .end = AB8500_INT_ID_WAKEUP_R,
887  .flags = IORESOURCE_IRQ,
888  },
889  {
890  .name = "ID_WAKEUP_F",
891  .start = AB8500_INT_ID_WAKEUP_F,
892  .end = AB8500_INT_ID_WAKEUP_F,
893  .flags = IORESOURCE_IRQ,
894  },
895  {
896  .name = "VBUS_DET_F",
897  .start = AB8500_INT_VBUS_DET_F,
898  .end = AB8500_INT_VBUS_DET_F,
899  .flags = IORESOURCE_IRQ,
900  },
901  {
902  .name = "VBUS_DET_R",
903  .start = AB8500_INT_VBUS_DET_R,
904  .end = AB8500_INT_VBUS_DET_R,
905  .flags = IORESOURCE_IRQ,
906  },
907  {
908  .name = "USB_LINK_STATUS",
909  .start = AB8500_INT_USB_LINK_STATUS,
910  .end = AB8500_INT_USB_LINK_STATUS,
911  .flags = IORESOURCE_IRQ,
912  },
913  {
914  .name = "USB_ADP_PROBE_PLUG",
915  .start = AB8500_INT_ADP_PROBE_PLUG,
916  .end = AB8500_INT_ADP_PROBE_PLUG,
917  .flags = IORESOURCE_IRQ,
918  },
919  {
920  .name = "USB_ADP_PROBE_UNPLUG",
921  .start = AB8500_INT_ADP_PROBE_UNPLUG,
922  .end = AB8500_INT_ADP_PROBE_UNPLUG,
923  .flags = IORESOURCE_IRQ,
924  },
925 };
926 
927 static struct resource __devinitdata ab8505_iddet_resources[] = {
928  {
929  .name = "KeyDeglitch",
930  .start = AB8505_INT_KEYDEGLITCH,
931  .end = AB8505_INT_KEYDEGLITCH,
932  .flags = IORESOURCE_IRQ,
933  },
934  {
935  .name = "KP",
936  .start = AB8505_INT_KP,
937  .end = AB8505_INT_KP,
938  .flags = IORESOURCE_IRQ,
939  },
940  {
941  .name = "IKP",
942  .start = AB8505_INT_IKP,
943  .end = AB8505_INT_IKP,
944  .flags = IORESOURCE_IRQ,
945  },
946  {
947  .name = "IKR",
948  .start = AB8505_INT_IKR,
949  .end = AB8505_INT_IKR,
950  .flags = IORESOURCE_IRQ,
951  },
952  {
953  .name = "KeyStuck",
954  .start = AB8505_INT_KEYSTUCK,
955  .end = AB8505_INT_KEYSTUCK,
956  .flags = IORESOURCE_IRQ,
957  },
958 };
959 
960 static struct resource __devinitdata ab8500_temp_resources[] = {
961  {
962  .name = "AB8500_TEMP_WARM",
963  .start = AB8500_INT_TEMP_WARM,
964  .end = AB8500_INT_TEMP_WARM,
965  .flags = IORESOURCE_IRQ,
966  },
967 };
968 
969 static struct mfd_cell __devinitdata abx500_common_devs[] = {
970 #ifdef CONFIG_DEBUG_FS
971  {
972  .name = "ab8500-debug",
973  .of_compatible = "stericsson,ab8500-debug",
974  .num_resources = ARRAY_SIZE(ab8500_debug_resources),
975  .resources = ab8500_debug_resources,
976  },
977 #endif
978  {
979  .name = "ab8500-sysctrl",
980  .of_compatible = "stericsson,ab8500-sysctrl",
981  },
982  {
983  .name = "ab8500-regulator",
984  .of_compatible = "stericsson,ab8500-regulator",
985  },
986  {
987  .name = "ab8500-gpadc",
988  .of_compatible = "stericsson,ab8500-gpadc",
989  .num_resources = ARRAY_SIZE(ab8500_gpadc_resources),
990  .resources = ab8500_gpadc_resources,
991  },
992  {
993  .name = "ab8500-rtc",
994  .of_compatible = "stericsson,ab8500-rtc",
995  .num_resources = ARRAY_SIZE(ab8500_rtc_resources),
996  .resources = ab8500_rtc_resources,
997  },
998  {
999  .name = "ab8500-acc-det",
1000  .of_compatible = "stericsson,ab8500-acc-det",
1001  .num_resources = ARRAY_SIZE(ab8500_av_acc_detect_resources),
1002  .resources = ab8500_av_acc_detect_resources,
1003  },
1004  {
1005  .name = "ab8500-poweron-key",
1006  .of_compatible = "stericsson,ab8500-poweron-key",
1007  .num_resources = ARRAY_SIZE(ab8500_poweronkey_db_resources),
1008  .resources = ab8500_poweronkey_db_resources,
1009  },
1010  {
1011  .name = "ab8500-pwm",
1012  .of_compatible = "stericsson,ab8500-pwm",
1013  .id = 1,
1014  },
1015  {
1016  .name = "ab8500-pwm",
1017  .of_compatible = "stericsson,ab8500-pwm",
1018  .id = 2,
1019  },
1020  {
1021  .name = "ab8500-pwm",
1022  .of_compatible = "stericsson,ab8500-pwm",
1023  .id = 3,
1024  },
1025  {
1026  .name = "ab8500-leds",
1027  .of_compatible = "stericsson,ab8500-leds",
1028  },
1029  {
1030  .name = "ab8500-denc",
1031  .of_compatible = "stericsson,ab8500-denc",
1032  },
1033  {
1034  .name = "ab8500-temp",
1035  .of_compatible = "stericsson,ab8500-temp",
1036  .num_resources = ARRAY_SIZE(ab8500_temp_resources),
1037  .resources = ab8500_temp_resources,
1038  },
1039 };
1040 
1041 static struct mfd_cell __devinitdata ab8500_bm_devs[] = {
1042  {
1043  .name = "ab8500-charger",
1044  .num_resources = ARRAY_SIZE(ab8500_charger_resources),
1045  .resources = ab8500_charger_resources,
1046  },
1047  {
1048  .name = "ab8500-btemp",
1049  .num_resources = ARRAY_SIZE(ab8500_btemp_resources),
1050  .resources = ab8500_btemp_resources,
1051  },
1052  {
1053  .name = "ab8500-fg",
1054  .num_resources = ARRAY_SIZE(ab8500_fg_resources),
1055  .resources = ab8500_fg_resources,
1056  },
1057  {
1058  .name = "ab8500-chargalg",
1059  .num_resources = ARRAY_SIZE(ab8500_chargalg_resources),
1060  .resources = ab8500_chargalg_resources,
1061  },
1062 };
1063 
1064 static struct mfd_cell __devinitdata ab8500_devs[] = {
1065  {
1066  .name = "ab8500-gpio",
1067  .of_compatible = "stericsson,ab8500-gpio",
1068  .num_resources = ARRAY_SIZE(ab8500_gpio_resources),
1069  .resources = ab8500_gpio_resources,
1070  },
1071  {
1072  .name = "ab8500-usb",
1073  .of_compatible = "stericsson,ab8500-usb",
1074  .num_resources = ARRAY_SIZE(ab8500_usb_resources),
1075  .resources = ab8500_usb_resources,
1076  },
1077  {
1078  .name = "ab8500-codec",
1079  .of_compatible = "stericsson,ab8500-codec",
1080  },
1081 };
1082 
1083 static struct mfd_cell __devinitdata ab9540_devs[] = {
1084  {
1085  .name = "ab8500-gpio",
1086  .num_resources = ARRAY_SIZE(ab9540_gpio_resources),
1087  .resources = ab9540_gpio_resources,
1088  },
1089  {
1090  .name = "ab9540-usb",
1091  .num_resources = ARRAY_SIZE(ab8500_usb_resources),
1092  .resources = ab8500_usb_resources,
1093  },
1094  {
1095  .name = "ab9540-codec",
1096  },
1097 };
1098 
1099 /* Device list common to ab9540 and ab8505 */
1100 static struct mfd_cell __devinitdata ab9540_ab8505_devs[] = {
1101  {
1102  .name = "ab-iddet",
1103  .num_resources = ARRAY_SIZE(ab8505_iddet_resources),
1104  .resources = ab8505_iddet_resources,
1105  },
1106 };
1107 
1108 static ssize_t show_chip_id(struct device *dev,
1109  struct device_attribute *attr, char *buf)
1110 {
1111  struct ab8500 *ab8500;
1112 
1113  ab8500 = dev_get_drvdata(dev);
1114  return sprintf(buf, "%#x\n", ab8500 ? ab8500->chip_id : -EINVAL);
1115 }
1116 
1117 /*
1118  * ab8500 has switched off due to (SWITCH_OFF_STATUS):
1119  * 0x01 Swoff bit programming
1120  * 0x02 Thermal protection activation
1121  * 0x04 Vbat lower then BattOk falling threshold
1122  * 0x08 Watchdog expired
1123  * 0x10 Non presence of 32kHz clock
1124  * 0x20 Battery level lower than power on reset threshold
1125  * 0x40 Power on key 1 pressed longer than 10 seconds
1126  * 0x80 DB8500 thermal shutdown
1127  */
1128 static ssize_t show_switch_off_status(struct device *dev,
1129  struct device_attribute *attr, char *buf)
1130 {
1131  int ret;
1132  u8 value;
1133  struct ab8500 *ab8500;
1134 
1135  ab8500 = dev_get_drvdata(dev);
1136  ret = get_register_interruptible(ab8500, AB8500_RTC,
1137  AB8500_SWITCH_OFF_STATUS, &value);
1138  if (ret < 0)
1139  return ret;
1140  return sprintf(buf, "%#x\n", value);
1141 }
1142 
1143 /*
1144  * ab8500 has turned on due to (TURN_ON_STATUS):
1145  * 0x01 PORnVbat
1146  * 0x02 PonKey1dbF
1147  * 0x04 PonKey2dbF
1148  * 0x08 RTCAlarm
1149  * 0x10 MainChDet
1150  * 0x20 VbusDet
1151  * 0x40 UsbIDDetect
1152  * 0x80 Reserved
1153  */
1154 static ssize_t show_turn_on_status(struct device *dev,
1155  struct device_attribute *attr, char *buf)
1156 {
1157  int ret;
1158  u8 value;
1159  struct ab8500 *ab8500;
1160 
1161  ab8500 = dev_get_drvdata(dev);
1162  ret = get_register_interruptible(ab8500, AB8500_SYS_CTRL1_BLOCK,
1163  AB8500_TURN_ON_STATUS, &value);
1164  if (ret < 0)
1165  return ret;
1166  return sprintf(buf, "%#x\n", value);
1167 }
1168 
1169 static ssize_t show_ab9540_dbbrstn(struct device *dev,
1170  struct device_attribute *attr, char *buf)
1171 {
1172  struct ab8500 *ab8500;
1173  int ret;
1174  u8 value;
1175 
1176  ab8500 = dev_get_drvdata(dev);
1177 
1178  ret = get_register_interruptible(ab8500, AB8500_REGU_CTRL2,
1179  AB9540_MODEM_CTRL2_REG, &value);
1180  if (ret < 0)
1181  return ret;
1182 
1183  return sprintf(buf, "%d\n",
1184  (value & AB9540_MODEM_CTRL2_SWDBBRSTN_BIT) ? 1 : 0);
1185 }
1186 
1187 static ssize_t store_ab9540_dbbrstn(struct device *dev,
1188  struct device_attribute *attr, const char *buf, size_t count)
1189 {
1190  struct ab8500 *ab8500;
1191  int ret = count;
1192  int err;
1193  u8 bitvalues;
1194 
1195  ab8500 = dev_get_drvdata(dev);
1196 
1197  if (count > 0) {
1198  switch (buf[0]) {
1199  case '0':
1200  bitvalues = 0;
1201  break;
1202  case '1':
1203  bitvalues = AB9540_MODEM_CTRL2_SWDBBRSTN_BIT;
1204  break;
1205  default:
1206  goto exit;
1207  }
1208 
1209  err = mask_and_set_register_interruptible(ab8500,
1210  AB8500_REGU_CTRL2, AB9540_MODEM_CTRL2_REG,
1211  AB9540_MODEM_CTRL2_SWDBBRSTN_BIT, bitvalues);
1212  if (err)
1213  dev_info(ab8500->dev,
1214  "Failed to set DBBRSTN %c, err %#x\n",
1215  buf[0], err);
1216  }
1217 
1218 exit:
1219  return ret;
1220 }
1221 
1222 static DEVICE_ATTR(chip_id, S_IRUGO, show_chip_id, NULL);
1223 static DEVICE_ATTR(switch_off_status, S_IRUGO, show_switch_off_status, NULL);
1224 static DEVICE_ATTR(turn_on_status, S_IRUGO, show_turn_on_status, NULL);
1225 static DEVICE_ATTR(dbbrstn, S_IRUGO | S_IWUSR,
1226  show_ab9540_dbbrstn, store_ab9540_dbbrstn);
1227 
1228 static struct attribute *ab8500_sysfs_entries[] = {
1229  &dev_attr_chip_id.attr,
1230  &dev_attr_switch_off_status.attr,
1231  &dev_attr_turn_on_status.attr,
1232  NULL,
1233 };
1234 
1235 static struct attribute *ab9540_sysfs_entries[] = {
1236  &dev_attr_chip_id.attr,
1237  &dev_attr_switch_off_status.attr,
1238  &dev_attr_turn_on_status.attr,
1239  &dev_attr_dbbrstn.attr,
1240  NULL,
1241 };
1242 
1243 static struct attribute_group ab8500_attr_group = {
1244  .attrs = ab8500_sysfs_entries,
1245 };
1246 
1247 static struct attribute_group ab9540_attr_group = {
1248  .attrs = ab9540_sysfs_entries,
1249 };
1250 
1251 static int __devinit ab8500_probe(struct platform_device *pdev)
1252 {
1253  static char *switch_off_status[] = {
1254  "Swoff bit programming",
1255  "Thermal protection activation",
1256  "Vbat lower then BattOk falling threshold",
1257  "Watchdog expired",
1258  "Non presence of 32kHz clock",
1259  "Battery level lower than power on reset threshold",
1260  "Power on key 1 pressed longer than 10 seconds",
1261  "DB8500 thermal shutdown"};
1262  struct ab8500_platform_data *plat = dev_get_platdata(&pdev->dev);
1263  const struct platform_device_id *platid = platform_get_device_id(pdev);
1264  enum ab8500_version version = AB8500_VERSION_UNDEFINED;
1265  struct device_node *np = pdev->dev.of_node;
1266  struct ab8500 *ab8500;
1267  struct resource *resource;
1268  int ret;
1269  int i;
1270  u8 value;
1271 
1272  ab8500 = kzalloc(sizeof *ab8500, GFP_KERNEL);
1273  if (!ab8500)
1274  return -ENOMEM;
1275 
1276  if (plat)
1277  ab8500->irq_base = plat->irq_base;
1278 
1279  ab8500->dev = &pdev->dev;
1280 
1281  resource = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
1282  if (!resource) {
1283  ret = -ENODEV;
1284  goto out_free_ab8500;
1285  }
1286 
1287  ab8500->irq = resource->start;
1288 
1289  ab8500->read = ab8500_prcmu_read;
1290  ab8500->write = ab8500_prcmu_write;
1291  ab8500->write_masked = ab8500_prcmu_write_masked;
1292 
1293  mutex_init(&ab8500->lock);
1294  mutex_init(&ab8500->irq_lock);
1295  atomic_set(&ab8500->transfer_ongoing, 0);
1296 
1297  platform_set_drvdata(pdev, ab8500);
1298 
1299  if (platid)
1300  version = platid->driver_data;
1301 
1302  if (version != AB8500_VERSION_UNDEFINED)
1303  ab8500->version = version;
1304  else {
1305  ret = get_register_interruptible(ab8500, AB8500_MISC,
1306  AB8500_IC_NAME_REG, &value);
1307  if (ret < 0)
1308  goto out_free_ab8500;
1309 
1310  ab8500->version = value;
1311  }
1312 
1313  ret = get_register_interruptible(ab8500, AB8500_MISC,
1314  AB8500_REV_REG, &value);
1315  if (ret < 0)
1316  goto out_free_ab8500;
1317 
1318  ab8500->chip_id = value;
1319 
1320  dev_info(ab8500->dev, "detected chip, %s rev. %1x.%1x\n",
1321  ab8500_version_str[ab8500->version],
1322  ab8500->chip_id >> 4,
1323  ab8500->chip_id & 0x0F);
1324 
1325  /* Configure AB8500 or AB9540 IRQ */
1326  if (is_ab9540(ab8500) || is_ab8505(ab8500)) {
1327  ab8500->mask_size = AB9540_NUM_IRQ_REGS;
1328  ab8500->irq_reg_offset = ab9540_irq_regoffset;
1329  } else {
1330  ab8500->mask_size = AB8500_NUM_IRQ_REGS;
1331  ab8500->irq_reg_offset = ab8500_irq_regoffset;
1332  }
1333  ab8500->mask = kzalloc(ab8500->mask_size, GFP_KERNEL);
1334  if (!ab8500->mask)
1335  return -ENOMEM;
1336  ab8500->oldmask = kzalloc(ab8500->mask_size, GFP_KERNEL);
1337  if (!ab8500->oldmask) {
1338  ret = -ENOMEM;
1339  goto out_freemask;
1340  }
1341  /*
1342  * ab8500 has switched off due to (SWITCH_OFF_STATUS):
1343  * 0x01 Swoff bit programming
1344  * 0x02 Thermal protection activation
1345  * 0x04 Vbat lower then BattOk falling threshold
1346  * 0x08 Watchdog expired
1347  * 0x10 Non presence of 32kHz clock
1348  * 0x20 Battery level lower than power on reset threshold
1349  * 0x40 Power on key 1 pressed longer than 10 seconds
1350  * 0x80 DB8500 thermal shutdown
1351  */
1352 
1353  ret = get_register_interruptible(ab8500, AB8500_RTC,
1354  AB8500_SWITCH_OFF_STATUS, &value);
1355  if (ret < 0)
1356  return ret;
1357  dev_info(ab8500->dev, "switch off cause(s) (%#x): ", value);
1358 
1359  if (value) {
1360  for (i = 0; i < ARRAY_SIZE(switch_off_status); i++) {
1361  if (value & 1)
1362  printk(KERN_CONT " \"%s\"",
1363  switch_off_status[i]);
1364  value = value >> 1;
1365 
1366  }
1367  printk(KERN_CONT "\n");
1368  } else {
1369  printk(KERN_CONT " None\n");
1370  }
1371 
1372  if (plat && plat->init)
1373  plat->init(ab8500);
1374 
1375  /* Clear and mask all interrupts */
1376  for (i = 0; i < ab8500->mask_size; i++) {
1377  /*
1378  * Interrupt register 12 doesn't exist prior to AB8500 version
1379  * 2.0
1380  */
1381  if (ab8500->irq_reg_offset[i] == 11 &&
1382  is_ab8500_1p1_or_earlier(ab8500))
1383  continue;
1384 
1385  get_register_interruptible(ab8500, AB8500_INTERRUPT,
1386  AB8500_IT_LATCH1_REG + ab8500->irq_reg_offset[i],
1387  &value);
1388  set_register_interruptible(ab8500, AB8500_INTERRUPT,
1389  AB8500_IT_MASK1_REG + ab8500->irq_reg_offset[i], 0xff);
1390  }
1391 
1392  ret = abx500_register_ops(ab8500->dev, &ab8500_ops);
1393  if (ret)
1394  goto out_freeoldmask;
1395 
1396  for (i = 0; i < ab8500->mask_size; i++)
1397  ab8500->mask[i] = ab8500->oldmask[i] = 0xff;
1398 
1399  ret = ab8500_irq_init(ab8500, np);
1400  if (ret)
1401  goto out_freeoldmask;
1402 
1403  /* Activate this feature only in ab9540 */
1404  /* till tests are done on ab8500 1p2 or later*/
1405  if (is_ab9540(ab8500)) {
1406  ret = request_threaded_irq(ab8500->irq, NULL,
1407  ab8500_hierarchical_irq,
1408  IRQF_ONESHOT | IRQF_NO_SUSPEND,
1409  "ab8500", ab8500);
1410  }
1411  else {
1412  ret = request_threaded_irq(ab8500->irq, NULL,
1413  ab8500_irq,
1414  IRQF_ONESHOT | IRQF_NO_SUSPEND,
1415  "ab8500", ab8500);
1416  if (ret)
1417  goto out_freeoldmask;
1418  }
1419 
1420  ret = mfd_add_devices(ab8500->dev, 0, abx500_common_devs,
1421  ARRAY_SIZE(abx500_common_devs), NULL,
1422  ab8500->irq_base, ab8500->domain);
1423  if (ret)
1424  goto out_freeirq;
1425 
1426  if (is_ab9540(ab8500))
1427  ret = mfd_add_devices(ab8500->dev, 0, ab9540_devs,
1428  ARRAY_SIZE(ab9540_devs), NULL,
1429  ab8500->irq_base, ab8500->domain);
1430  else
1431  ret = mfd_add_devices(ab8500->dev, 0, ab8500_devs,
1432  ARRAY_SIZE(ab8500_devs), NULL,
1433  ab8500->irq_base, ab8500->domain);
1434  if (ret)
1435  goto out_freeirq;
1436 
1437  if (is_ab9540(ab8500) || is_ab8505(ab8500))
1438  ret = mfd_add_devices(ab8500->dev, 0, ab9540_ab8505_devs,
1439  ARRAY_SIZE(ab9540_ab8505_devs), NULL,
1440  ab8500->irq_base, ab8500->domain);
1441  if (ret)
1442  goto out_freeirq;
1443 
1444  if (!no_bm) {
1445  /* Add battery management devices */
1446  ret = mfd_add_devices(ab8500->dev, 0, ab8500_bm_devs,
1447  ARRAY_SIZE(ab8500_bm_devs), NULL,
1448  ab8500->irq_base, ab8500->domain);
1449  if (ret)
1450  dev_err(ab8500->dev, "error adding bm devices\n");
1451  }
1452 
1453  if (is_ab9540(ab8500))
1454  ret = sysfs_create_group(&ab8500->dev->kobj,
1455  &ab9540_attr_group);
1456  else
1457  ret = sysfs_create_group(&ab8500->dev->kobj,
1458  &ab8500_attr_group);
1459  if (ret)
1460  dev_err(ab8500->dev, "error creating sysfs entries\n");
1461 
1462  return ret;
1463 
1464 out_freeirq:
1465  free_irq(ab8500->irq, ab8500);
1466 out_freeoldmask:
1467  kfree(ab8500->oldmask);
1468 out_freemask:
1469  kfree(ab8500->mask);
1470 out_free_ab8500:
1471  kfree(ab8500);
1472 
1473  return ret;
1474 }
1475 
1476 static int __devexit ab8500_remove(struct platform_device *pdev)
1477 {
1478  struct ab8500 *ab8500 = platform_get_drvdata(pdev);
1479 
1480  if (is_ab9540(ab8500))
1481  sysfs_remove_group(&ab8500->dev->kobj, &ab9540_attr_group);
1482  else
1483  sysfs_remove_group(&ab8500->dev->kobj, &ab8500_attr_group);
1484 
1485  mfd_remove_devices(ab8500->dev);
1486  free_irq(ab8500->irq, ab8500);
1487 
1488  kfree(ab8500->oldmask);
1489  kfree(ab8500->mask);
1490  kfree(ab8500);
1491 
1492  return 0;
1493 }
1494 
1495 static const struct platform_device_id ab8500_id[] = {
1496  { "ab8500-core", AB8500_VERSION_AB8500 },
1497  { "ab8505-i2c", AB8500_VERSION_AB8505 },
1498  { "ab9540-i2c", AB8500_VERSION_AB9540 },
1499  { "ab8540-i2c", AB8500_VERSION_AB8540 },
1500  { }
1501 };
1502 
1503 static struct platform_driver ab8500_core_driver = {
1504  .driver = {
1505  .name = "ab8500-core",
1506  .owner = THIS_MODULE,
1507  },
1508  .probe = ab8500_probe,
1509  .remove = __devexit_p(ab8500_remove),
1510  .id_table = ab8500_id,
1511 };
1512 
1513 static int __init ab8500_core_init(void)
1514 {
1515  return platform_driver_register(&ab8500_core_driver);
1516 }
1517 
1518 static void __exit ab8500_core_exit(void)
1519 {
1520  platform_driver_unregister(&ab8500_core_driver);
1521 }
1522 core_initcall(ab8500_core_init);
1523 module_exit(ab8500_core_exit);
1524 
1525 MODULE_AUTHOR("Mattias Wallin, Srinidhi Kasagar, Rabin Vincent");
1526 MODULE_DESCRIPTION("AB8500 MFD core");
1527 MODULE_LICENSE("GPL v2");
Generated on Thu Jan 10 2013 13:53:41 for Linux Kernel by   doxygen 1.8.2