Pileus Git - ~andy/linux/blob - 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/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
 475 static irqreturn_t ab8500_irq(int irq, void *dev)
 476 {
 477         struct ab8500 *ab8500 = dev;
 478         int i;
 479
 480         dev_vdbg(ab8500->dev, "interrupt\n");
 481
 482         atomic_inc(&ab8500->transfer_ongoing);
 483
 484         for (i = 0; i < ab8500->mask_size; i++) {
 485                 int regoffset = ab8500->irq_reg_offset[i];
 486                 int status;
 487                 u8 value;
 488
 489                 /*
 490                  * Interrupt register 12 doesn't exist prior to AB8500 version
 491                  * 2.0
 492                  */
 493                 if (regoffset == 11 && is_ab8500_1p1_or_earlier(ab8500))
 494                         continue;
 495
 496                 status = get_register_interruptible(ab8500, AB8500_INTERRUPT,
 497                         AB8500_IT_LATCH1_REG + regoffset, &value);
 498                 if (status < 0 || value == 0)
 499                         continue;
 500
 501                 do {
 502                         int bit = __ffs(value);
 503                         int line = i * 8 + bit;
 504
 505                         handle_nested_irq(ab8500->irq_base + line);
 506                         value &= ~(1 << bit);
 507
 508                 } while (value);
 509         }
 510         atomic_dec(&ab8500->transfer_ongoing);
 511         return IRQ_HANDLED;
 512 }
 513
 514 /**
 515  * ab8500_irq_get_virq(): Map an interrupt on a chip to a virtual IRQ
 516  *
 517  * @ab8500: ab8500_irq controller to operate on.
 518  * @irq: index of the interrupt requested in the chip IRQs
 519  *
 520  * Useful for drivers to request their own IRQs.
 521  */
 522 int ab8500_irq_get_virq(struct ab8500 *ab8500, int irq)
 523 {
 524         if (!ab8500)
 525                 return -EINVAL;
 526
 527         return irq_create_mapping(ab8500->domain, irq);
 528 }
 529 EXPORT_SYMBOL_GPL(ab8500_irq_get_virq);
 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                 .num_resources = ARRAY_SIZE(ab8500_debug_resources),
 974                 .resources = ab8500_debug_resources,
 975         },
 976 #endif
 977         {
 978                 .name = "ab8500-sysctrl",
 979         },
 980         {
 981                 .name = "ab8500-regulator",
 982         },
 983         {
 984                 .name = "ab8500-gpadc",
 985                 .num_resources = ARRAY_SIZE(ab8500_gpadc_resources),
 986                 .resources = ab8500_gpadc_resources,
 987         },
 988         {
 989                 .name = "ab8500-rtc",
 990                 .num_resources = ARRAY_SIZE(ab8500_rtc_resources),
 991                 .resources = ab8500_rtc_resources,
 992         },
 993         {
 994                 .name = "ab8500-acc-det",
 995                 .num_resources = ARRAY_SIZE(ab8500_av_acc_detect_resources),
 996                 .resources = ab8500_av_acc_detect_resources,
 997         },
 998         {
 999                 .name = "ab8500-poweron-key",
1000                 .num_resources = ARRAY_SIZE(ab8500_poweronkey_db_resources),
1001                 .resources = ab8500_poweronkey_db_resources,
1002         },
1003         {
1004                 .name = "ab8500-pwm",
1005                 .id = 1,
1006         },
1007         {
1008                 .name = "ab8500-pwm",
1009                 .id = 2,
1010         },
1011         {
1012                 .name = "ab8500-pwm",
1013                 .id = 3,
1014         },
1015         { .name = "ab8500-leds", },
1016         {
1017                 .name = "ab8500-denc",
1018         },
1019         {
1020                 .name = "ab8500-temp",
1021                 .num_resources = ARRAY_SIZE(ab8500_temp_resources),
1022                 .resources = ab8500_temp_resources,
1023         },
1024 };
1025
1026 static struct mfd_cell __devinitdata ab8500_bm_devs[] = {
1027         {
1028                 .name = "ab8500-charger",
1029                 .num_resources = ARRAY_SIZE(ab8500_charger_resources),
1030                 .resources = ab8500_charger_resources,
1031         },
1032         {
1033                 .name = "ab8500-btemp",
1034                 .num_resources = ARRAY_SIZE(ab8500_btemp_resources),
1035                 .resources = ab8500_btemp_resources,
1036         },
1037         {
1038                 .name = "ab8500-fg",
1039                 .num_resources = ARRAY_SIZE(ab8500_fg_resources),
1040                 .resources = ab8500_fg_resources,
1041         },
1042         {
1043                 .name = "ab8500-chargalg",
1044                 .num_resources = ARRAY_SIZE(ab8500_chargalg_resources),
1045                 .resources = ab8500_chargalg_resources,
1046         },
1047 };
1048
1049 static struct mfd_cell __devinitdata ab8500_devs[] = {
1050         {
1051                 .name = "ab8500-gpio",
1052                 .num_resources = ARRAY_SIZE(ab8500_gpio_resources),
1053                 .resources = ab8500_gpio_resources,
1054         },
1055         {
1056                 .name = "ab8500-usb",
1057                 .num_resources = ARRAY_SIZE(ab8500_usb_resources),
1058                 .resources = ab8500_usb_resources,
1059         },
1060         {
1061                 .name = "ab8500-codec",
1062         },
1063 };
1064
1065 static struct mfd_cell __devinitdata ab9540_devs[] = {
1066         {
1067                 .name = "ab8500-gpio",
1068                 .num_resources = ARRAY_SIZE(ab9540_gpio_resources),
1069                 .resources = ab9540_gpio_resources,
1070         },
1071         {
1072                 .name = "ab9540-usb",
1073                 .num_resources = ARRAY_SIZE(ab8500_usb_resources),
1074                 .resources = ab8500_usb_resources,
1075         },
1076         {
1077                 .name = "ab9540-codec",
1078         },
1079 };
1080
1081 /* Device list common to ab9540 and ab8505 */
1082 static struct mfd_cell __devinitdata ab9540_ab8505_devs[] = {
1083         {
1084                 .name = "ab-iddet",
1085                 .num_resources = ARRAY_SIZE(ab8505_iddet_resources),
1086                 .resources = ab8505_iddet_resources,
1087         },
1088 };
1089
1090 static ssize_t show_chip_id(struct device *dev,
1091                                 struct device_attribute *attr, char *buf)
1092 {
1093         struct ab8500 *ab8500;
1094
1095         ab8500 = dev_get_drvdata(dev);
1096         return sprintf(buf, "%#x\n", ab8500 ? ab8500->chip_id : -EINVAL);
1097 }
1098
1099 /*
1100  * ab8500 has switched off due to (SWITCH_OFF_STATUS):
1101  * 0x01 Swoff bit programming
1102  * 0x02 Thermal protection activation
1103  * 0x04 Vbat lower then BattOk falling threshold
1104  * 0x08 Watchdog expired
1105  * 0x10 Non presence of 32kHz clock
1106  * 0x20 Battery level lower than power on reset threshold
1107  * 0x40 Power on key 1 pressed longer than 10 seconds
1108  * 0x80 DB8500 thermal shutdown
1109  */
1110 static ssize_t show_switch_off_status(struct device *dev,
1111                                 struct device_attribute *attr, char *buf)
1112 {
1113         int ret;
1114         u8 value;
1115         struct ab8500 *ab8500;
1116
1117         ab8500 = dev_get_drvdata(dev);
1118         ret = get_register_interruptible(ab8500, AB8500_RTC,
1119                 AB8500_SWITCH_OFF_STATUS, &value);
1120         if (ret < 0)
1121                 return ret;
1122         return sprintf(buf, "%#x\n", value);
1123 }
1124
1125 /*
1126  * ab8500 has turned on due to (TURN_ON_STATUS):
1127  * 0x01 PORnVbat
1128  * 0x02 PonKey1dbF
1129  * 0x04 PonKey2dbF
1130  * 0x08 RTCAlarm
1131  * 0x10 MainChDet
1132  * 0x20 VbusDet
1133  * 0x40 UsbIDDetect
1134  * 0x80 Reserved
1135  */
1136 static ssize_t show_turn_on_status(struct device *dev,
1137                                 struct device_attribute *attr, char *buf)
1138 {
1139         int ret;
1140         u8 value;
1141         struct ab8500 *ab8500;
1142
1143         ab8500 = dev_get_drvdata(dev);
1144         ret = get_register_interruptible(ab8500, AB8500_SYS_CTRL1_BLOCK,
1145                 AB8500_TURN_ON_STATUS, &value);
1146         if (ret < 0)
1147                 return ret;
1148         return sprintf(buf, "%#x\n", value);
1149 }
1150
1151 static ssize_t show_ab9540_dbbrstn(struct device *dev,
1152                                 struct device_attribute *attr, char *buf)
1153 {
1154         struct ab8500 *ab8500;
1155         int ret;
1156         u8 value;
1157
1158         ab8500 = dev_get_drvdata(dev);
1159
1160         ret = get_register_interruptible(ab8500, AB8500_REGU_CTRL2,
1161                 AB9540_MODEM_CTRL2_REG, &value);
1162         if (ret < 0)
1163                 return ret;
1164
1165         return sprintf(buf, "%d\n",
1166                         (value & AB9540_MODEM_CTRL2_SWDBBRSTN_BIT) ? 1 : 0);
1167 }
1168
1169 static ssize_t store_ab9540_dbbrstn(struct device *dev,
1170         struct device_attribute *attr, const char *buf, size_t count)
1171 {
1172         struct ab8500 *ab8500;
1173         int ret = count;
1174         int err;
1175         u8 bitvalues;
1176
1177         ab8500 = dev_get_drvdata(dev);
1178
1179         if (count > 0) {
1180                 switch (buf[0]) {
1181                 case '0':
1182                         bitvalues = 0;
1183                         break;
1184                 case '1':
1185                         bitvalues = AB9540_MODEM_CTRL2_SWDBBRSTN_BIT;
1186                         break;
1187                 default:
1188                         goto exit;
1189                 }
1190
1191                 err = mask_and_set_register_interruptible(ab8500,
1192                         AB8500_REGU_CTRL2, AB9540_MODEM_CTRL2_REG,
1193                         AB9540_MODEM_CTRL2_SWDBBRSTN_BIT, bitvalues);
1194                 if (err)
1195                         dev_info(ab8500->dev,
1196                                 "Failed to set DBBRSTN %c, err %#x\n",
1197                                 buf[0], err);
1198         }
1199
1200 exit:
1201         return ret;
1202 }
1203
1204 static DEVICE_ATTR(chip_id, S_IRUGO, show_chip_id, NULL);
1205 static DEVICE_ATTR(switch_off_status, S_IRUGO, show_switch_off_status, NULL);
1206 static DEVICE_ATTR(turn_on_status, S_IRUGO, show_turn_on_status, NULL);
1207 static DEVICE_ATTR(dbbrstn, S_IRUGO | S_IWUSR,
1208                         show_ab9540_dbbrstn, store_ab9540_dbbrstn);
1209
1210 static struct attribute *ab8500_sysfs_entries[] = {
1211         &dev_attr_chip_id.attr,
1212         &dev_attr_switch_off_status.attr,
1213         &dev_attr_turn_on_status.attr,
1214         NULL,
1215 };
1216
1217 static struct attribute *ab9540_sysfs_entries[] = {
1218         &dev_attr_chip_id.attr,
1219         &dev_attr_switch_off_status.attr,
1220         &dev_attr_turn_on_status.attr,
1221         &dev_attr_dbbrstn.attr,
1222         NULL,
1223 };
1224
1225 static struct attribute_group ab8500_attr_group = {
1226         .attrs  = ab8500_sysfs_entries,
1227 };
1228
1229 static struct attribute_group ab9540_attr_group = {
1230         .attrs  = ab9540_sysfs_entries,
1231 };
1232
1233 static int __devinit ab8500_probe(struct platform_device *pdev)
1234 {
1235         struct ab8500_platform_data *plat = dev_get_platdata(&pdev->dev);
1236         const struct platform_device_id *platid = platform_get_device_id(pdev);
1237         enum ab8500_version version = AB8500_VERSION_UNDEFINED;
1238         struct device_node *np = pdev->dev.of_node;
1239         struct ab8500 *ab8500;
1240         struct resource *resource;
1241         int ret;
1242         int i;
1243         u8 value;
1244
1245         ab8500 = kzalloc(sizeof *ab8500, GFP_KERNEL);
1246         if (!ab8500)
1247                 return -ENOMEM;
1248
1249         if (plat)
1250                 ab8500->irq_base = plat->irq_base;
1251
1252         ab8500->dev = &pdev->dev;
1253
1254         resource = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
1255         if (!resource) {
1256                 ret = -ENODEV;
1257                 goto out_free_ab8500;
1258         }
1259
1260         ab8500->irq = resource->start;
1261
1262         ab8500->read = ab8500_prcmu_read;
1263         ab8500->write = ab8500_prcmu_write;
1264         ab8500->write_masked = ab8500_prcmu_write_masked;
1265
1266         mutex_init(&ab8500->lock);
1267         mutex_init(&ab8500->irq_lock);
1268         atomic_set(&ab8500->transfer_ongoing, 0);
1269
1270         platform_set_drvdata(pdev, ab8500);
1271
1272         if (platid)
1273                 version = platid->driver_data;
1274
1275         if (version != AB8500_VERSION_UNDEFINED)
1276                 ab8500->version = version;
1277         else {
1278                 ret = get_register_interruptible(ab8500, AB8500_MISC,
1279                         AB8500_IC_NAME_REG, &value);
1280                 if (ret < 0)
1281                         goto out_free_ab8500;
1282
1283                 ab8500->version = value;
1284         }
1285
1286         ret = get_register_interruptible(ab8500, AB8500_MISC,
1287                 AB8500_REV_REG, &value);
1288         if (ret < 0)
1289                 goto out_free_ab8500;
1290
1291         ab8500->chip_id = value;
1292
1293         dev_info(ab8500->dev, "detected chip, %s rev. %1x.%1x\n",
1294                         ab8500_version_str[ab8500->version],
1295                         ab8500->chip_id >> 4,
1296                         ab8500->chip_id & 0x0F);
1297
1298         /* Configure AB8500 or AB9540 IRQ */
1299         if (is_ab9540(ab8500) || is_ab8505(ab8500)) {
1300                 ab8500->mask_size = AB9540_NUM_IRQ_REGS;
1301                 ab8500->irq_reg_offset = ab9540_irq_regoffset;
1302         } else {
1303                 ab8500->mask_size = AB8500_NUM_IRQ_REGS;
1304                 ab8500->irq_reg_offset = ab8500_irq_regoffset;
1305         }
1306         ab8500->mask = kzalloc(ab8500->mask_size, GFP_KERNEL);
1307         if (!ab8500->mask)
1308                 return -ENOMEM;
1309         ab8500->oldmask = kzalloc(ab8500->mask_size, GFP_KERNEL);
1310         if (!ab8500->oldmask) {
1311                 ret = -ENOMEM;
1312                 goto out_freemask;
1313         }
1314         /*
1315          * ab8500 has switched off due to (SWITCH_OFF_STATUS):
1316          * 0x01 Swoff bit programming
1317          * 0x02 Thermal protection activation
1318          * 0x04 Vbat lower then BattOk falling threshold
1319          * 0x08 Watchdog expired
1320          * 0x10 Non presence of 32kHz clock
1321          * 0x20 Battery level lower than power on reset threshold
1322          * 0x40 Power on key 1 pressed longer than 10 seconds
1323          * 0x80 DB8500 thermal shutdown
1324          */
1325
1326         ret = get_register_interruptible(ab8500, AB8500_RTC,
1327                 AB8500_SWITCH_OFF_STATUS, &value);
1328         if (ret < 0)
1329                 return ret;
1330         dev_info(ab8500->dev, "switch off status: %#x\n", value);
1331
1332         if (plat && plat->init)
1333                 plat->init(ab8500);
1334
1335         /* Clear and mask all interrupts */
1336         for (i = 0; i < ab8500->mask_size; i++) {
1337                 /*
1338                  * Interrupt register 12 doesn't exist prior to AB8500 version
1339                  * 2.0
1340                  */
1341                 if (ab8500->irq_reg_offset[i] == 11 &&
1342                                 is_ab8500_1p1_or_earlier(ab8500))
1343                         continue;
1344
1345                 get_register_interruptible(ab8500, AB8500_INTERRUPT,
1346                         AB8500_IT_LATCH1_REG + ab8500->irq_reg_offset[i],
1347                         &value);
1348                 set_register_interruptible(ab8500, AB8500_INTERRUPT,
1349                         AB8500_IT_MASK1_REG + ab8500->irq_reg_offset[i], 0xff);
1350         }
1351
1352         ret = abx500_register_ops(ab8500->dev, &ab8500_ops);
1353         if (ret)
1354                 goto out_freeoldmask;
1355
1356         for (i = 0; i < ab8500->mask_size; i++)
1357                 ab8500->mask[i] = ab8500->oldmask[i] = 0xff;
1358
1359         ret = ab8500_irq_init(ab8500, np);
1360         if (ret)
1361                 goto out_freeoldmask;
1362
1363         /*  Activate this feature only in ab9540 */
1364         /*  till tests are done on ab8500 1p2 or later*/
1365         if (is_ab9540(ab8500)) {
1366                 ret = request_threaded_irq(ab8500->irq, NULL,
1367                                         ab8500_hierarchical_irq,
1368                                         IRQF_ONESHOT | IRQF_NO_SUSPEND,
1369                                         "ab8500", ab8500);
1370         }
1371         else {
1372                 ret = request_threaded_irq(ab8500->irq, NULL,
1373                                         ab8500_irq,
1374                                         IRQF_ONESHOT | IRQF_NO_SUSPEND,
1375                                         "ab8500", ab8500);
1376                 if (ret)
1377                         goto out_freeoldmask;
1378         }
1379
1380         if (!np) {
1381                 ret = mfd_add_devices(ab8500->dev, 0, abx500_common_devs,
1382                                 ARRAY_SIZE(abx500_common_devs), NULL,
1383                                 ab8500->irq_base);
1384
1385                 if (ret)
1386                         goto out_freeirq;
1387
1388                 if (is_ab9540(ab8500))
1389                         ret = mfd_add_devices(ab8500->dev, 0, ab9540_devs,
1390                                         ARRAY_SIZE(ab9540_devs), NULL,
1391                                         ab8500->irq_base);
1392                 else
1393                         ret = mfd_add_devices(ab8500->dev, 0, ab8500_devs,
1394                                         ARRAY_SIZE(ab8500_devs), NULL,
1395                                         ab8500->irq_base);
1396                 if (ret)
1397                         goto out_freeirq;
1398
1399                 if (is_ab9540(ab8500) || is_ab8505(ab8500))
1400                         ret = mfd_add_devices(ab8500->dev, 0, ab9540_ab8505_devs,
1401                                         ARRAY_SIZE(ab9540_ab8505_devs), NULL,
1402                                         ab8500->irq_base);
1403                 if (ret)
1404                         goto out_freeirq;
1405         }
1406
1407         if (!no_bm) {
1408                 /* Add battery management devices */
1409                 ret = mfd_add_devices(ab8500->dev, 0, ab8500_bm_devs,
1410                                       ARRAY_SIZE(ab8500_bm_devs), NULL,
1411                                       ab8500->irq_base);
1412                 if (ret)
1413                         dev_err(ab8500->dev, "error adding bm devices\n");
1414         }
1415
1416         if (is_ab9540(ab8500))
1417                 ret = sysfs_create_group(&ab8500->dev->kobj,
1418                                         &ab9540_attr_group);
1419         else
1420                 ret = sysfs_create_group(&ab8500->dev->kobj,
1421                                         &ab8500_attr_group);
1422         if (ret)
1423                 dev_err(ab8500->dev, "error creating sysfs entries\n");
1424
1425         return ret;
1426
1427 out_freeirq:
1428         free_irq(ab8500->irq, ab8500);
1429 out_freeoldmask:
1430         kfree(ab8500->oldmask);
1431 out_freemask:
1432         kfree(ab8500->mask);
1433 out_free_ab8500:
1434         kfree(ab8500);
1435
1436         return ret;
1437 }
1438
1439 static int __devexit ab8500_remove(struct platform_device *pdev)
1440 {
1441         struct ab8500 *ab8500 = platform_get_drvdata(pdev);
1442
1443         if (is_ab9540(ab8500))
1444                 sysfs_remove_group(&ab8500->dev->kobj, &ab9540_attr_group);
1445         else
1446                 sysfs_remove_group(&ab8500->dev->kobj, &ab8500_attr_group);
1447
1448         mfd_remove_devices(ab8500->dev);
1449         free_irq(ab8500->irq, ab8500);
1450
1451         kfree(ab8500->oldmask);
1452         kfree(ab8500->mask);
1453         kfree(ab8500);
1454
1455         return 0;
1456 }
1457
1458 static const struct platform_device_id ab8500_id[] = {
1459         { "ab8500-core", AB8500_VERSION_AB8500 },
1460         { "ab8505-i2c", AB8500_VERSION_AB8505 },
1461         { "ab9540-i2c", AB8500_VERSION_AB9540 },
1462         { "ab8540-i2c", AB8500_VERSION_AB8540 },
1463         { }
1464 };
1465
1466 static struct platform_driver ab8500_core_driver = {
1467         .driver = {
1468                 .name = "ab8500-core",
1469                 .owner = THIS_MODULE,
1470         },
1471         .probe  = ab8500_probe,
1472         .remove = __devexit_p(ab8500_remove),
1473         .id_table = ab8500_id,
1474 };
1475
1476 static int __init ab8500_core_init(void)
1477 {
1478         return platform_driver_register(&ab8500_core_driver);
1479 }
1480
1481 static void __exit ab8500_core_exit(void)
1482 {
1483         platform_driver_unregister(&ab8500_core_driver);
1484 }
1485 core_initcall(ab8500_core_init);
1486 module_exit(ab8500_core_exit);
1487
1488 MODULE_AUTHOR("Mattias Wallin, Srinidhi Kasagar, Rabin Vincent");
1489 MODULE_DESCRIPTION("AB8500 MFD core");
1490 MODULE_LICENSE("GPL v2");