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