drivers/mfd/88pm860x-core.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Base driver for Marvell 88PM8607
   4  *
   5  * Copyright (C) 2009 Marvell International Ltd.
   6  *
   7  * Author: Haojian Zhuang <haojian.zhuang@marvell.com>
   8  */
   9
  10 #include <linux/kernel.h>
  11 #include <linux/module.h>
  12 #include <linux/err.h>
  13 #include <linux/i2c.h>
  14 #include <linux/irq.h>
  15 #include <linux/interrupt.h>
  16 #include <linux/irqdomain.h>
  17 #include <linux/of.h>
  18 #include <linux/of_platform.h>
  19 #include <linux/platform_device.h>
  20 #include <linux/regmap.h>
  21 #include <linux/slab.h>
  22 #include <linux/mfd/core.h>
  23 #include <linux/mfd/88pm860x.h>
  24 #include <linux/regulator/machine.h>
  25 #include <linux/power/charger-manager.h>
  26
  27 #define INT_STATUS_NUM                  3
  28
  29 static const struct resource bk0_resources[] = {
  30         {2, 2, "duty cycle", IORESOURCE_REG, },
  31         {3, 3, "always on",  IORESOURCE_REG, },
  32         {3, 3, "current",    IORESOURCE_REG, },
  33 };
  34 static const struct resource bk1_resources[] = {
  35         {4, 4, "duty cycle", IORESOURCE_REG, },
  36         {5, 5, "always on",  IORESOURCE_REG, },
  37         {5, 5, "current",    IORESOURCE_REG, },
  38 };
  39 static const struct resource bk2_resources[] = {
  40         {6, 6, "duty cycle", IORESOURCE_REG, },
  41         {7, 7, "always on",  IORESOURCE_REG, },
  42         {5, 5, "current",    IORESOURCE_REG, },
  43 };
  44
  45 static const struct resource led0_resources[] = {
  46         /* RGB1 Red LED */
  47         {0xd, 0xd, "control", IORESOURCE_REG, },
  48         {0xc, 0xc, "blink",   IORESOURCE_REG, },
  49 };
  50 static const struct resource led1_resources[] = {
  51         /* RGB1 Green LED */
  52         {0xe, 0xe, "control", IORESOURCE_REG, },
  53         {0xc, 0xc, "blink",   IORESOURCE_REG, },
  54 };
  55 static const struct resource led2_resources[] = {
  56         /* RGB1 Blue LED */
  57         {0xf, 0xf, "control", IORESOURCE_REG, },
  58         {0xc, 0xc, "blink",   IORESOURCE_REG, },
  59 };
  60 static const struct resource led3_resources[] = {
  61         /* RGB2 Red LED */
  62         {0x9, 0x9, "control", IORESOURCE_REG, },
  63         {0x8, 0x8, "blink",   IORESOURCE_REG, },
  64 };
  65 static const struct resource led4_resources[] = {
  66         /* RGB2 Green LED */
  67         {0xa, 0xa, "control", IORESOURCE_REG, },
  68         {0x8, 0x8, "blink",   IORESOURCE_REG, },
  69 };
  70 static const struct resource led5_resources[] = {
  71         /* RGB2 Blue LED */
  72         {0xb, 0xb, "control", IORESOURCE_REG, },
  73         {0x8, 0x8, "blink",   IORESOURCE_REG, },
  74 };
  75
  76 static const struct resource buck1_resources[] = {
  77         {0x24, 0x24, "buck set", IORESOURCE_REG, },
  78 };
  79 static const struct resource buck2_resources[] = {
  80         {0x25, 0x25, "buck set", IORESOURCE_REG, },
  81 };
  82 static const struct resource buck3_resources[] = {
  83         {0x26, 0x26, "buck set", IORESOURCE_REG, },
  84 };
  85 static const struct resource ldo1_resources[] = {
  86         {0x10, 0x10, "ldo set", IORESOURCE_REG, },
  87 };
  88 static const struct resource ldo2_resources[] = {
  89         {0x11, 0x11, "ldo set", IORESOURCE_REG, },
  90 };
  91 static const struct resource ldo3_resources[] = {
  92         {0x12, 0x12, "ldo set", IORESOURCE_REG, },
  93 };
  94 static const struct resource ldo4_resources[] = {
  95         {0x13, 0x13, "ldo set", IORESOURCE_REG, },
  96 };
  97 static const struct resource ldo5_resources[] = {
  98         {0x14, 0x14, "ldo set", IORESOURCE_REG, },
  99 };
 100 static const struct resource ldo6_resources[] = {
 101         {0x15, 0x15, "ldo set", IORESOURCE_REG, },
 102 };
 103 static const struct resource ldo7_resources[] = {
 104         {0x16, 0x16, "ldo set", IORESOURCE_REG, },
 105 };
 106 static const struct resource ldo8_resources[] = {
 107         {0x17, 0x17, "ldo set", IORESOURCE_REG, },
 108 };
 109 static const struct resource ldo9_resources[] = {
 110         {0x18, 0x18, "ldo set", IORESOURCE_REG, },
 111 };
 112 static const struct resource ldo10_resources[] = {
 113         {0x19, 0x19, "ldo set", IORESOURCE_REG, },
 114 };
 115 static const struct resource ldo12_resources[] = {
 116         {0x1a, 0x1a, "ldo set", IORESOURCE_REG, },
 117 };
 118 static const struct resource ldo_vibrator_resources[] = {
 119         {0x28, 0x28, "ldo set", IORESOURCE_REG, },
 120 };
 121 static const struct resource ldo14_resources[] = {
 122         {0x1b, 0x1b, "ldo set", IORESOURCE_REG, },
 123 };
 124
 125 static struct resource touch_resources[] = {
 126         {PM8607_IRQ_PEN, PM8607_IRQ_PEN, "touch", IORESOURCE_IRQ,},
 127 };
 128
 129 static struct resource onkey_resources[] = {
 130         {PM8607_IRQ_ONKEY, PM8607_IRQ_ONKEY, "onkey", IORESOURCE_IRQ,},
 131 };
 132
 133 static struct resource codec_resources[] = {
 134         /* Headset microphone insertion or removal */
 135         {PM8607_IRQ_MICIN,   PM8607_IRQ_MICIN,   "micin",   IORESOURCE_IRQ,},
 136         /* Hook-switch press or release */
 137         {PM8607_IRQ_HOOK,    PM8607_IRQ_HOOK,    "hook",    IORESOURCE_IRQ,},
 138         /* Headset insertion or removal */
 139         {PM8607_IRQ_HEADSET, PM8607_IRQ_HEADSET, "headset", IORESOURCE_IRQ,},
 140         /* Audio short */
 141         {PM8607_IRQ_AUDIO_SHORT, PM8607_IRQ_AUDIO_SHORT, "audio-short",
 142          IORESOURCE_IRQ,},
 143 };
 144
 145 static struct resource battery_resources[] = {
 146         {PM8607_IRQ_CC,  PM8607_IRQ_CC,  "columb counter", IORESOURCE_IRQ,},
 147         {PM8607_IRQ_BAT, PM8607_IRQ_BAT, "battery",        IORESOURCE_IRQ,},
 148 };
 149
 150 static struct resource charger_resources[] = {
 151         {PM8607_IRQ_CHG,  PM8607_IRQ_CHG,  "charger detect",  IORESOURCE_IRQ,},
 152         {PM8607_IRQ_CHG_DONE,  PM8607_IRQ_CHG_DONE,  "charging done",
 153          IORESOURCE_IRQ,},
 154         {PM8607_IRQ_CHG_FAIL,  PM8607_IRQ_CHG_FAIL,  "charging timeout",
 155          IORESOURCE_IRQ,},
 156         {PM8607_IRQ_CHG_FAULT, PM8607_IRQ_CHG_FAULT, "charging fault",
 157          IORESOURCE_IRQ,},
 158         {PM8607_IRQ_GPADC1,    PM8607_IRQ_GPADC1,    "battery temperature",
 159          IORESOURCE_IRQ,},
 160         {PM8607_IRQ_VBAT, PM8607_IRQ_VBAT, "battery voltage", IORESOURCE_IRQ,},
 161         {PM8607_IRQ_VCHG, PM8607_IRQ_VCHG, "vchg voltage",    IORESOURCE_IRQ,},
 162 };
 163
 164 static struct resource rtc_resources[] = {
 165         {PM8607_IRQ_RTC, PM8607_IRQ_RTC, "rtc", IORESOURCE_IRQ,},
 166 };
 167
 168 static struct mfd_cell bk_devs[] = {
 169         {
 170                 .name = "88pm860x-backlight",
 171                 .id = 0,
 172                 .num_resources = ARRAY_SIZE(bk0_resources),
 173                 .resources = bk0_resources,
 174         }, {
 175                 .name = "88pm860x-backlight",
 176                 .id = 1,
 177                 .num_resources = ARRAY_SIZE(bk1_resources),
 178                 .resources = bk1_resources,
 179         }, {
 180                 .name = "88pm860x-backlight",
 181                 .id = 2,
 182                 .num_resources = ARRAY_SIZE(bk2_resources),
 183                 .resources = bk2_resources,
 184         },
 185 };
 186
 187 static struct mfd_cell led_devs[] = {
 188         {
 189                 .name = "88pm860x-led",
 190                 .id = 0,
 191                 .num_resources = ARRAY_SIZE(led0_resources),
 192                 .resources = led0_resources,
 193         }, {
 194                 .name = "88pm860x-led",
 195                 .id = 1,
 196                 .num_resources = ARRAY_SIZE(led1_resources),
 197                 .resources = led1_resources,
 198         }, {
 199                 .name = "88pm860x-led",
 200                 .id = 2,
 201                 .num_resources = ARRAY_SIZE(led2_resources),
 202                 .resources = led2_resources,
 203         }, {
 204                 .name = "88pm860x-led",
 205                 .id = 3,
 206                 .num_resources = ARRAY_SIZE(led3_resources),
 207                 .resources = led3_resources,
 208         }, {
 209                 .name = "88pm860x-led",
 210                 .id = 4,
 211                 .num_resources = ARRAY_SIZE(led4_resources),
 212                 .resources = led4_resources,
 213         }, {
 214                 .name = "88pm860x-led",
 215                 .id = 5,
 216                 .num_resources = ARRAY_SIZE(led5_resources),
 217                 .resources = led5_resources,
 218         },
 219 };
 220
 221 static struct mfd_cell reg_devs[] = {
 222         {
 223                 .name = "88pm860x-regulator",
 224                 .id = 0,
 225                 .num_resources = ARRAY_SIZE(buck1_resources),
 226                 .resources = buck1_resources,
 227         }, {
 228                 .name = "88pm860x-regulator",
 229                 .id = 1,
 230                 .num_resources = ARRAY_SIZE(buck2_resources),
 231                 .resources = buck2_resources,
 232         }, {
 233                 .name = "88pm860x-regulator",
 234                 .id = 2,
 235                 .num_resources = ARRAY_SIZE(buck3_resources),
 236                 .resources = buck3_resources,
 237         }, {
 238                 .name = "88pm860x-regulator",
 239                 .id = 3,
 240                 .num_resources = ARRAY_SIZE(ldo1_resources),
 241                 .resources = ldo1_resources,
 242         }, {
 243                 .name = "88pm860x-regulator",
 244                 .id = 4,
 245                 .num_resources = ARRAY_SIZE(ldo2_resources),
 246                 .resources = ldo2_resources,
 247         }, {
 248                 .name = "88pm860x-regulator",
 249                 .id = 5,
 250                 .num_resources = ARRAY_SIZE(ldo3_resources),
 251                 .resources = ldo3_resources,
 252         }, {
 253                 .name = "88pm860x-regulator",
 254                 .id = 6,
 255                 .num_resources = ARRAY_SIZE(ldo4_resources),
 256                 .resources = ldo4_resources,
 257         }, {
 258                 .name = "88pm860x-regulator",
 259                 .id = 7,
 260                 .num_resources = ARRAY_SIZE(ldo5_resources),
 261                 .resources = ldo5_resources,
 262         }, {
 263                 .name = "88pm860x-regulator",
 264                 .id = 8,
 265                 .num_resources = ARRAY_SIZE(ldo6_resources),
 266                 .resources = ldo6_resources,
 267         }, {
 268                 .name = "88pm860x-regulator",
 269                 .id = 9,
 270                 .num_resources = ARRAY_SIZE(ldo7_resources),
 271                 .resources = ldo7_resources,
 272         }, {
 273                 .name = "88pm860x-regulator",
 274                 .id = 10,
 275                 .num_resources = ARRAY_SIZE(ldo8_resources),
 276                 .resources = ldo8_resources,
 277         }, {
 278                 .name = "88pm860x-regulator",
 279                 .id = 11,
 280                 .num_resources = ARRAY_SIZE(ldo9_resources),
 281                 .resources = ldo9_resources,
 282         }, {
 283                 .name = "88pm860x-regulator",
 284                 .id = 12,
 285                 .num_resources = ARRAY_SIZE(ldo10_resources),
 286                 .resources = ldo10_resources,
 287         }, {
 288                 .name = "88pm860x-regulator",
 289                 .id = 13,
 290                 .num_resources = ARRAY_SIZE(ldo12_resources),
 291                 .resources = ldo12_resources,
 292         }, {
 293                 .name = "88pm860x-regulator",
 294                 .id = 14,
 295                 .num_resources = ARRAY_SIZE(ldo_vibrator_resources),
 296                 .resources = ldo_vibrator_resources,
 297         }, {
 298                 .name = "88pm860x-regulator",
 299                 .id = 15,
 300                 .num_resources = ARRAY_SIZE(ldo14_resources),
 301                 .resources = ldo14_resources,
 302         },
 303 };
 304
 305 static struct mfd_cell touch_devs[] = {
 306         {"88pm860x-touch", -1,},
 307 };
 308
 309 static struct mfd_cell onkey_devs[] = {
 310         {"88pm860x-onkey", -1,},
 311 };
 312
 313 static struct mfd_cell codec_devs[] = {
 314         {"88pm860x-codec", -1,},
 315 };
 316
 317 static struct regulator_consumer_supply preg_supply[] = {
 318         REGULATOR_SUPPLY("preg", "charger-manager"),
 319 };
 320
 321 static struct regulator_init_data preg_init_data = {
 322         .num_consumer_supplies  = ARRAY_SIZE(preg_supply),
 323         .consumer_supplies      = &preg_supply[0],
 324 };
 325
 326 static struct charger_regulator chg_desc_regulator_data[] = {
 327         { .regulator_name = "preg", },
 328 };
 329
 330 static struct mfd_cell power_devs[] = {
 331         {"88pm860x-battery", -1,},
 332         {"88pm860x-charger", -1,},
 333         {"88pm860x-preg",    -1,},
 334         {"charger-manager", -1,},
 335 };
 336
 337 static struct mfd_cell rtc_devs[] = {
 338         {"88pm860x-rtc", -1,},
 339 };
 340
 341
 342 struct pm860x_irq_data {
 343         int     reg;
 344         int     mask_reg;
 345         int     enable;         /* enable or not */
 346         int     offs;           /* bit offset in mask register */
 347 };
 348
 349 static struct pm860x_irq_data pm860x_irqs[] = {
 350         [PM8607_IRQ_ONKEY] = {
 351                 .reg            = PM8607_INT_STATUS1,
 352                 .mask_reg       = PM8607_INT_MASK_1,
 353                 .offs           = 1 << 0,
 354         },
 355         [PM8607_IRQ_EXTON] = {
 356                 .reg            = PM8607_INT_STATUS1,
 357                 .mask_reg       = PM8607_INT_MASK_1,
 358                 .offs           = 1 << 1,
 359         },
 360         [PM8607_IRQ_CHG] = {
 361                 .reg            = PM8607_INT_STATUS1,
 362                 .mask_reg       = PM8607_INT_MASK_1,
 363                 .offs           = 1 << 2,
 364         },
 365         [PM8607_IRQ_BAT] = {
 366                 .reg            = PM8607_INT_STATUS1,
 367                 .mask_reg       = PM8607_INT_MASK_1,
 368                 .offs           = 1 << 3,
 369         },
 370         [PM8607_IRQ_RTC] = {
 371                 .reg            = PM8607_INT_STATUS1,
 372                 .mask_reg       = PM8607_INT_MASK_1,
 373                 .offs           = 1 << 4,
 374         },
 375         [PM8607_IRQ_CC] = {
 376                 .reg            = PM8607_INT_STATUS1,
 377                 .mask_reg       = PM8607_INT_MASK_1,
 378                 .offs           = 1 << 5,
 379         },
 380         [PM8607_IRQ_VBAT] = {
 381                 .reg            = PM8607_INT_STATUS2,
 382                 .mask_reg       = PM8607_INT_MASK_2,
 383                 .offs           = 1 << 0,
 384         },
 385         [PM8607_IRQ_VCHG] = {
 386                 .reg            = PM8607_INT_STATUS2,
 387                 .mask_reg       = PM8607_INT_MASK_2,
 388                 .offs           = 1 << 1,
 389         },
 390         [PM8607_IRQ_VSYS] = {
 391                 .reg            = PM8607_INT_STATUS2,
 392                 .mask_reg       = PM8607_INT_MASK_2,
 393                 .offs           = 1 << 2,
 394         },
 395         [PM8607_IRQ_TINT] = {
 396                 .reg            = PM8607_INT_STATUS2,
 397                 .mask_reg       = PM8607_INT_MASK_2,
 398                 .offs           = 1 << 3,
 399         },
 400         [PM8607_IRQ_GPADC0] = {
 401                 .reg            = PM8607_INT_STATUS2,
 402                 .mask_reg       = PM8607_INT_MASK_2,
 403                 .offs           = 1 << 4,
 404         },
 405         [PM8607_IRQ_GPADC1] = {
 406                 .reg            = PM8607_INT_STATUS2,
 407                 .mask_reg       = PM8607_INT_MASK_2,
 408                 .offs           = 1 << 5,
 409         },
 410         [PM8607_IRQ_GPADC2] = {
 411                 .reg            = PM8607_INT_STATUS2,
 412                 .mask_reg       = PM8607_INT_MASK_2,
 413                 .offs           = 1 << 6,
 414         },
 415         [PM8607_IRQ_GPADC3] = {
 416                 .reg            = PM8607_INT_STATUS2,
 417                 .mask_reg       = PM8607_INT_MASK_2,
 418                 .offs           = 1 << 7,
 419         },
 420         [PM8607_IRQ_AUDIO_SHORT] = {
 421                 .reg            = PM8607_INT_STATUS3,
 422                 .mask_reg       = PM8607_INT_MASK_3,
 423                 .offs           = 1 << 0,
 424         },
 425         [PM8607_IRQ_PEN] = {
 426                 .reg            = PM8607_INT_STATUS3,
 427                 .mask_reg       = PM8607_INT_MASK_3,
 428                 .offs           = 1 << 1,
 429         },
 430         [PM8607_IRQ_HEADSET] = {
 431                 .reg            = PM8607_INT_STATUS3,
 432                 .mask_reg       = PM8607_INT_MASK_3,
 433                 .offs           = 1 << 2,
 434         },
 435         [PM8607_IRQ_HOOK] = {
 436                 .reg            = PM8607_INT_STATUS3,
 437                 .mask_reg       = PM8607_INT_MASK_3,
 438                 .offs           = 1 << 3,
 439         },
 440         [PM8607_IRQ_MICIN] = {
 441                 .reg            = PM8607_INT_STATUS3,
 442                 .mask_reg       = PM8607_INT_MASK_3,
 443                 .offs           = 1 << 4,
 444         },
 445         [PM8607_IRQ_CHG_FAIL] = {
 446                 .reg            = PM8607_INT_STATUS3,
 447                 .mask_reg       = PM8607_INT_MASK_3,
 448                 .offs           = 1 << 5,
 449         },
 450         [PM8607_IRQ_CHG_DONE] = {
 451                 .reg            = PM8607_INT_STATUS3,
 452                 .mask_reg       = PM8607_INT_MASK_3,
 453                 .offs           = 1 << 6,
 454         },
 455         [PM8607_IRQ_CHG_FAULT] = {
 456                 .reg            = PM8607_INT_STATUS3,
 457                 .mask_reg       = PM8607_INT_MASK_3,
 458                 .offs           = 1 << 7,
 459         },
 460 };
 461
 462 static irqreturn_t pm860x_irq(int irq, void *data)
 463 {
 464         struct pm860x_chip *chip = data;
 465         struct pm860x_irq_data *irq_data;
 466         struct i2c_client *i2c;
 467         int read_reg = -1, value = 0;
 468         int i;
 469
 470         i2c = (chip->id == CHIP_PM8607) ? chip->client : chip->companion;
 471         for (i = 0; i < ARRAY_SIZE(pm860x_irqs); i++) {
 472                 irq_data = &pm860x_irqs[i];
 473                 if (read_reg != irq_data->reg) {
 474                         read_reg = irq_data->reg;
 475                         value = pm860x_reg_read(i2c, irq_data->reg);
 476                 }
 477                 if (value & irq_data->enable)
 478                         handle_nested_irq(chip->irq_base + i);
 479         }
 480         return IRQ_HANDLED;
 481 }
 482
 483 static void pm860x_irq_lock(struct irq_data *data)
 484 {
 485         struct pm860x_chip *chip = irq_data_get_irq_chip_data(data);
 486
 487         mutex_lock(&chip->irq_lock);
 488 }
 489
 490 static void pm860x_irq_sync_unlock(struct irq_data *data)
 491 {
 492         struct pm860x_chip *chip = irq_data_get_irq_chip_data(data);
 493         struct pm860x_irq_data *irq_data;
 494         struct i2c_client *i2c;
 495         static unsigned char cached[3] = {0x0, 0x0, 0x0};
 496         unsigned char mask[3];
 497         int i;
 498
 499         i2c = (chip->id == CHIP_PM8607) ? chip->client : chip->companion;
 500         /* Load cached value. In initial, all IRQs are masked */
 501         for (i = 0; i < 3; i++)
 502                 mask[i] = cached[i];
 503         for (i = 0; i < ARRAY_SIZE(pm860x_irqs); i++) {
 504                 irq_data = &pm860x_irqs[i];
 505                 switch (irq_data->mask_reg) {
 506                 case PM8607_INT_MASK_1:
 507                         mask[0] &= ~irq_data->offs;
 508                         mask[0] |= irq_data->enable;
 509                         break;
 510                 case PM8607_INT_MASK_2:
 511                         mask[1] &= ~irq_data->offs;
 512                         mask[1] |= irq_data->enable;
 513                         break;
 514                 case PM8607_INT_MASK_3:
 515                         mask[2] &= ~irq_data->offs;
 516                         mask[2] |= irq_data->enable;
 517                         break;
 518                 default:
 519                         dev_err(chip->dev, "wrong IRQ\n");
 520                         break;
 521                 }
 522         }
 523         /* update mask into registers */
 524         for (i = 0; i < 3; i++) {
 525                 if (mask[i] != cached[i]) {
 526                         cached[i] = mask[i];
 527                         pm860x_reg_write(i2c, PM8607_INT_MASK_1 + i, mask[i]);
 528                 }
 529         }
 530
 531         mutex_unlock(&chip->irq_lock);
 532 }
 533
 534 static void pm860x_irq_enable(struct irq_data *data)
 535 {
 536         pm860x_irqs[data->hwirq].enable = pm860x_irqs[data->hwirq].offs;
 537 }
 538
 539 static void pm860x_irq_disable(struct irq_data *data)
 540 {
 541         pm860x_irqs[data->hwirq].enable = 0;
 542 }
 543
 544 static struct irq_chip pm860x_irq_chip = {
 545         .name           = "88pm860x",
 546         .irq_bus_lock   = pm860x_irq_lock,
 547         .irq_bus_sync_unlock = pm860x_irq_sync_unlock,
 548         .irq_enable     = pm860x_irq_enable,
 549         .irq_disable    = pm860x_irq_disable,
 550 };
 551
 552 static int pm860x_irq_domain_map(struct irq_domain *d, unsigned int virq,
 553                                  irq_hw_number_t hw)
 554 {
 555         irq_set_chip_data(virq, d->host_data);
 556         irq_set_chip_and_handler(virq, &pm860x_irq_chip, handle_edge_irq);
 557         irq_set_nested_thread(virq, 1);
 558         irq_set_noprobe(virq);
 559         return 0;
 560 }
 561
 562 static const struct irq_domain_ops pm860x_irq_domain_ops = {
 563         .map    = pm860x_irq_domain_map,
 564         .xlate  = irq_domain_xlate_onetwocell,
 565 };
 566
 567 static int device_irq_init(struct pm860x_chip *chip,
 568                                      struct pm860x_platform_data *pdata)
 569 {
 570         struct i2c_client *i2c = (chip->id == CHIP_PM8607) ?
 571                 chip->client : chip->companion;
 572         unsigned char status_buf[INT_STATUS_NUM];
 573         unsigned long flags = IRQF_TRIGGER_FALLING | IRQF_ONESHOT;
 574         int data, mask, ret = -EINVAL;
 575         int nr_irqs, irq_base = -1;
 576         struct device_node *node = i2c->dev.of_node;
 577
 578         mask = PM8607_B0_MISC1_INV_INT | PM8607_B0_MISC1_INT_CLEAR
 579                 | PM8607_B0_MISC1_INT_MASK;
 580         data = 0;
 581         chip->irq_mode = 0;
 582         if (pdata && pdata->irq_mode) {
 583                 /*
 584                  * irq_mode defines the way of clearing interrupt. If it's 1,
 585                  * clear IRQ by write. Otherwise, clear it by read.
 586                  * This control bit is valid from 88PM8607 B0 steping.
 587                  */
 588                 data |= PM8607_B0_MISC1_INT_CLEAR;
 589                 chip->irq_mode = 1;
 590         }
 591         ret = pm860x_set_bits(i2c, PM8607_B0_MISC1, mask, data);
 592         if (ret < 0)
 593                 goto out;
 594
 595         /* mask all IRQs */
 596         memset(status_buf, 0, INT_STATUS_NUM);
 597         ret = pm860x_bulk_write(i2c, PM8607_INT_MASK_1,
 598                                 INT_STATUS_NUM, status_buf);
 599         if (ret < 0)
 600                 goto out;
 601
 602         if (chip->irq_mode) {
 603                 /* clear interrupt status by write */
 604                 memset(status_buf, 0xFF, INT_STATUS_NUM);
 605                 ret = pm860x_bulk_write(i2c, PM8607_INT_STATUS1,
 606                                         INT_STATUS_NUM, status_buf);
 607         } else {
 608                 /* clear interrupt status by read */
 609                 ret = pm860x_bulk_read(i2c, PM8607_INT_STATUS1,
 610                                         INT_STATUS_NUM, status_buf);
 611         }
 612         if (ret < 0)
 613                 goto out;
 614
 615         mutex_init(&chip->irq_lock);
 616
 617         if (pdata && pdata->irq_base)
 618                 irq_base = pdata->irq_base;
 619         nr_irqs = ARRAY_SIZE(pm860x_irqs);
 620         chip->irq_base = irq_alloc_descs(irq_base, 0, nr_irqs, 0);
 621         if (chip->irq_base < 0) {
 622                 dev_err(&i2c->dev, "Failed to allocate interrupts, ret:%d\n",
 623                         chip->irq_base);
 624                 ret = -EBUSY;
 625                 goto out;
 626         }
 627         irq_domain_add_legacy(node, nr_irqs, chip->irq_base, 0,
 628                               &pm860x_irq_domain_ops, chip);
 629         chip->core_irq = i2c->irq;
 630         if (!chip->core_irq)
 631                 goto out;
 632
 633         ret = request_threaded_irq(chip->core_irq, NULL, pm860x_irq,
 634                                    flags | IRQF_ONESHOT, "88pm860x", chip);
 635         if (ret) {
 636                 dev_err(chip->dev, "Failed to request IRQ: %d\n", ret);
 637                 chip->core_irq = 0;
 638         }
 639
 640         return 0;
 641 out:
 642         chip->core_irq = 0;
 643         return ret;
 644 }
 645
 646 static void device_irq_exit(struct pm860x_chip *chip)
 647 {
 648         if (chip->core_irq)
 649                 free_irq(chip->core_irq, chip);
 650 }
 651
 652 int pm8606_osc_enable(struct pm860x_chip *chip, unsigned short client)
 653 {
 654         int ret = -EIO;
 655         struct i2c_client *i2c = (chip->id == CHIP_PM8606) ?
 656                 chip->client : chip->companion;
 657
 658         dev_dbg(chip->dev, "%s(B): client=0x%x\n", __func__, client);
 659         dev_dbg(chip->dev, "%s(B): vote=0x%x status=%d\n",
 660                         __func__, chip->osc_vote,
 661                         chip->osc_status);
 662
 663         mutex_lock(&chip->osc_lock);
 664         /* Update voting status */
 665         chip->osc_vote |= client;
 666         /* If reference group is off - turn on*/
 667         if (chip->osc_status != PM8606_REF_GP_OSC_ON) {
 668                 chip->osc_status = PM8606_REF_GP_OSC_UNKNOWN;
 669                 /* Enable Reference group Vsys */
 670                 if (pm860x_set_bits(i2c, PM8606_VSYS,
 671                                 PM8606_VSYS_EN, PM8606_VSYS_EN))
 672                         goto out;
 673
 674                 /*Enable Internal Oscillator */
 675                 if (pm860x_set_bits(i2c, PM8606_MISC,
 676                                 PM8606_MISC_OSC_EN, PM8606_MISC_OSC_EN))
 677                         goto out;
 678                 /* Update status (only if writes succeed) */
 679                 chip->osc_status = PM8606_REF_GP_OSC_ON;
 680         }
 681         mutex_unlock(&chip->osc_lock);
 682
 683         dev_dbg(chip->dev, "%s(A): vote=0x%x status=%d ret=%d\n",
 684                         __func__, chip->osc_vote,
 685                         chip->osc_status, ret);
 686         return 0;
 687 out:
 688         mutex_unlock(&chip->osc_lock);
 689         return ret;
 690 }
 691 EXPORT_SYMBOL(pm8606_osc_enable);
 692
 693 int pm8606_osc_disable(struct pm860x_chip *chip, unsigned short client)
 694 {
 695         int ret = -EIO;
 696         struct i2c_client *i2c = (chip->id == CHIP_PM8606) ?
 697                 chip->client : chip->companion;
 698
 699         dev_dbg(chip->dev, "%s(B): client=0x%x\n", __func__, client);
 700         dev_dbg(chip->dev, "%s(B): vote=0x%x status=%d\n",
 701                         __func__, chip->osc_vote,
 702                         chip->osc_status);
 703
 704         mutex_lock(&chip->osc_lock);
 705         /* Update voting status */
 706         chip->osc_vote &= ~(client);
 707         /*
 708          * If reference group is off and this is the last client to release
 709          * - turn off
 710          */
 711         if ((chip->osc_status != PM8606_REF_GP_OSC_OFF) &&
 712                         (chip->osc_vote == REF_GP_NO_CLIENTS)) {
 713                 chip->osc_status = PM8606_REF_GP_OSC_UNKNOWN;
 714                 /* Disable Reference group Vsys */
 715                 if (pm860x_set_bits(i2c, PM8606_VSYS, PM8606_VSYS_EN, 0))
 716                         goto out;
 717                 /* Disable Internal Oscillator */
 718                 if (pm860x_set_bits(i2c, PM8606_MISC, PM8606_MISC_OSC_EN, 0))
 719                         goto out;
 720                 chip->osc_status = PM8606_REF_GP_OSC_OFF;
 721         }
 722         mutex_unlock(&chip->osc_lock);
 723
 724         dev_dbg(chip->dev, "%s(A): vote=0x%x status=%d ret=%d\n",
 725                         __func__, chip->osc_vote,
 726                         chip->osc_status, ret);
 727         return 0;
 728 out:
 729         mutex_unlock(&chip->osc_lock);
 730         return ret;
 731 }
 732 EXPORT_SYMBOL(pm8606_osc_disable);
 733
 734 static void device_osc_init(struct i2c_client *i2c)
 735 {
 736         struct pm860x_chip *chip = i2c_get_clientdata(i2c);
 737
 738         mutex_init(&chip->osc_lock);
 739         /* init portofino reference group voting and status */
 740         /* Disable Reference group Vsys */
 741         pm860x_set_bits(i2c, PM8606_VSYS, PM8606_VSYS_EN, 0);
 742         /* Disable Internal Oscillator */
 743         pm860x_set_bits(i2c, PM8606_MISC, PM8606_MISC_OSC_EN, 0);
 744
 745         chip->osc_vote = REF_GP_NO_CLIENTS;
 746         chip->osc_status = PM8606_REF_GP_OSC_OFF;
 747 }
 748
 749 static void device_bk_init(struct pm860x_chip *chip,
 750                                      struct pm860x_platform_data *pdata)
 751 {
 752         int ret, i;
 753
 754         if (pdata && pdata->backlight) {
 755                 if (pdata->num_backlights > ARRAY_SIZE(bk_devs))
 756                         pdata->num_backlights = ARRAY_SIZE(bk_devs);
 757                 for (i = 0; i < pdata->num_backlights; i++) {
 758                         bk_devs[i].platform_data = &pdata->backlight[i];
 759                         bk_devs[i].pdata_size =
 760                                 sizeof(struct pm860x_backlight_pdata);
 761                 }
 762         }
 763         ret = mfd_add_devices(chip->dev, 0, bk_devs,
 764                               ARRAY_SIZE(bk_devs), NULL, 0, NULL);
 765         if (ret < 0)
 766                 dev_err(chip->dev, "Failed to add backlight subdev\n");
 767 }
 768
 769 static void device_led_init(struct pm860x_chip *chip,
 770                                       struct pm860x_platform_data *pdata)
 771 {
 772         int ret, i;
 773
 774         if (pdata && pdata->led) {
 775                 if (pdata->num_leds > ARRAY_SIZE(led_devs))
 776                         pdata->num_leds = ARRAY_SIZE(led_devs);
 777                 for (i = 0; i < pdata->num_leds; i++) {
 778                         led_devs[i].platform_data = &pdata->led[i];
 779                         led_devs[i].pdata_size =
 780                                 sizeof(struct pm860x_led_pdata);
 781                 }
 782         }
 783         ret = mfd_add_devices(chip->dev, 0, led_devs,
 784                               ARRAY_SIZE(led_devs), NULL, 0, NULL);
 785         if (ret < 0) {
 786                 dev_err(chip->dev, "Failed to add led subdev\n");
 787                 return;
 788         }
 789 }
 790
 791 static void device_regulator_init(struct pm860x_chip *chip,
 792                                             struct pm860x_platform_data *pdata)
 793 {
 794         int ret;
 795
 796         if (pdata == NULL)
 797                 return;
 798         if (pdata->buck1) {
 799                 reg_devs[0].platform_data = pdata->buck1;
 800                 reg_devs[0].pdata_size = sizeof(struct regulator_init_data);
 801         }
 802         if (pdata->buck2) {
 803                 reg_devs[1].platform_data = pdata->buck2;
 804                 reg_devs[1].pdata_size = sizeof(struct regulator_init_data);
 805         }
 806         if (pdata->buck3) {
 807                 reg_devs[2].platform_data = pdata->buck3;
 808                 reg_devs[2].pdata_size = sizeof(struct regulator_init_data);
 809         }
 810         if (pdata->ldo1) {
 811                 reg_devs[3].platform_data = pdata->ldo1;
 812                 reg_devs[3].pdata_size = sizeof(struct regulator_init_data);
 813         }
 814         if (pdata->ldo2) {
 815                 reg_devs[4].platform_data = pdata->ldo2;
 816                 reg_devs[4].pdata_size = sizeof(struct regulator_init_data);
 817         }
 818         if (pdata->ldo3) {
 819                 reg_devs[5].platform_data = pdata->ldo3;
 820                 reg_devs[5].pdata_size = sizeof(struct regulator_init_data);
 821         }
 822         if (pdata->ldo4) {
 823                 reg_devs[6].platform_data = pdata->ldo4;
 824                 reg_devs[6].pdata_size = sizeof(struct regulator_init_data);
 825         }
 826         if (pdata->ldo5) {
 827                 reg_devs[7].platform_data = pdata->ldo5;
 828                 reg_devs[7].pdata_size = sizeof(struct regulator_init_data);
 829         }
 830         if (pdata->ldo6) {
 831                 reg_devs[8].platform_data = pdata->ldo6;
 832                 reg_devs[8].pdata_size = sizeof(struct regulator_init_data);
 833         }
 834         if (pdata->ldo7) {
 835                 reg_devs[9].platform_data = pdata->ldo7;
 836                 reg_devs[9].pdata_size = sizeof(struct regulator_init_data);
 837         }
 838         if (pdata->ldo8) {
 839                 reg_devs[10].platform_data = pdata->ldo8;
 840                 reg_devs[10].pdata_size = sizeof(struct regulator_init_data);
 841         }
 842         if (pdata->ldo9) {
 843                 reg_devs[11].platform_data = pdata->ldo9;
 844                 reg_devs[11].pdata_size = sizeof(struct regulator_init_data);
 845         }
 846         if (pdata->ldo10) {
 847                 reg_devs[12].platform_data = pdata->ldo10;
 848                 reg_devs[12].pdata_size = sizeof(struct regulator_init_data);
 849         }
 850         if (pdata->ldo12) {
 851                 reg_devs[13].platform_data = pdata->ldo12;
 852                 reg_devs[13].pdata_size = sizeof(struct regulator_init_data);
 853         }
 854         if (pdata->ldo_vibrator) {
 855                 reg_devs[14].platform_data = pdata->ldo_vibrator;
 856                 reg_devs[14].pdata_size = sizeof(struct regulator_init_data);
 857         }
 858         if (pdata->ldo14) {
 859                 reg_devs[15].platform_data = pdata->ldo14;
 860                 reg_devs[15].pdata_size = sizeof(struct regulator_init_data);
 861         }
 862         ret = mfd_add_devices(chip->dev, 0, reg_devs,
 863                               ARRAY_SIZE(reg_devs), NULL, 0, NULL);
 864         if (ret < 0) {
 865                 dev_err(chip->dev, "Failed to add regulator subdev\n");
 866                 return;
 867         }
 868 }
 869
 870 static void device_rtc_init(struct pm860x_chip *chip,
 871                                       struct pm860x_platform_data *pdata)
 872 {
 873         int ret;
 874
 875         if (!pdata)
 876                 return;
 877
 878         rtc_devs[0].platform_data = pdata->rtc;
 879         rtc_devs[0].pdata_size = sizeof(struct pm860x_rtc_pdata);
 880         rtc_devs[0].num_resources = ARRAY_SIZE(rtc_resources);
 881         rtc_devs[0].resources = &rtc_resources[0];
 882         ret = mfd_add_devices(chip->dev, 0, &rtc_devs[0],
 883                               ARRAY_SIZE(rtc_devs), &rtc_resources[0],
 884                               chip->irq_base, NULL);
 885         if (ret < 0)
 886                 dev_err(chip->dev, "Failed to add rtc subdev\n");
 887 }
 888
 889 static void device_touch_init(struct pm860x_chip *chip,
 890                                         struct pm860x_platform_data *pdata)
 891 {
 892         int ret;
 893
 894         if (pdata == NULL)
 895                 return;
 896
 897         touch_devs[0].platform_data = pdata->touch;
 898         touch_devs[0].pdata_size = sizeof(struct pm860x_touch_pdata);
 899         touch_devs[0].num_resources = ARRAY_SIZE(touch_resources);
 900         touch_devs[0].resources = &touch_resources[0];
 901         ret = mfd_add_devices(chip->dev, 0, &touch_devs[0],
 902                               ARRAY_SIZE(touch_devs), &touch_resources[0],
 903                               chip->irq_base, NULL);
 904         if (ret < 0)
 905                 dev_err(chip->dev, "Failed to add touch subdev\n");
 906 }
 907
 908 static void device_power_init(struct pm860x_chip *chip,
 909                                         struct pm860x_platform_data *pdata)
 910 {
 911         int ret;
 912
 913         if (pdata == NULL)
 914                 return;
 915
 916         power_devs[0].platform_data = pdata->power;
 917         power_devs[0].pdata_size = sizeof(struct pm860x_power_pdata);
 918         power_devs[0].num_resources = ARRAY_SIZE(battery_resources);
 919         power_devs[0].resources = &battery_resources[0],
 920         ret = mfd_add_devices(chip->dev, 0, &power_devs[0], 1,
 921                               &battery_resources[0], chip->irq_base, NULL);
 922         if (ret < 0)
 923                 dev_err(chip->dev, "Failed to add battery subdev\n");
 924
 925         power_devs[1].platform_data = pdata->power;
 926         power_devs[1].pdata_size = sizeof(struct pm860x_power_pdata);
 927         power_devs[1].num_resources = ARRAY_SIZE(charger_resources);
 928         power_devs[1].resources = &charger_resources[0],
 929         ret = mfd_add_devices(chip->dev, 0, &power_devs[1], 1,
 930                               &charger_resources[0], chip->irq_base, NULL);
 931         if (ret < 0)
 932                 dev_err(chip->dev, "Failed to add charger subdev\n");
 933
 934         power_devs[2].platform_data = &preg_init_data;
 935         power_devs[2].pdata_size = sizeof(struct regulator_init_data);
 936         ret = mfd_add_devices(chip->dev, 0, &power_devs[2], 1,
 937                               NULL, chip->irq_base, NULL);
 938         if (ret < 0)
 939                 dev_err(chip->dev, "Failed to add preg subdev\n");
 940
 941         if (pdata->chg_desc) {
 942                 pdata->chg_desc->charger_regulators =
 943                         &chg_desc_regulator_data[0];
 944                 pdata->chg_desc->num_charger_regulators =
 945                         ARRAY_SIZE(chg_desc_regulator_data),
 946                 power_devs[3].platform_data = pdata->chg_desc;
 947                 power_devs[3].pdata_size = sizeof(*pdata->chg_desc);
 948                 ret = mfd_add_devices(chip->dev, 0, &power_devs[3], 1,
 949                                       NULL, chip->irq_base, NULL);
 950                 if (ret < 0)
 951                         dev_err(chip->dev, "Failed to add chg-manager subdev\n");
 952         }
 953 }
 954
 955 static void device_onkey_init(struct pm860x_chip *chip,
 956                                         struct pm860x_platform_data *pdata)
 957 {
 958         int ret;
 959
 960         onkey_devs[0].num_resources = ARRAY_SIZE(onkey_resources);
 961         onkey_devs[0].resources = &onkey_resources[0],
 962         ret = mfd_add_devices(chip->dev, 0, &onkey_devs[0],
 963                               ARRAY_SIZE(onkey_devs), &onkey_resources[0],
 964                               chip->irq_base, NULL);
 965         if (ret < 0)
 966                 dev_err(chip->dev, "Failed to add onkey subdev\n");
 967 }
 968
 969 static void device_codec_init(struct pm860x_chip *chip,
 970                                         struct pm860x_platform_data *pdata)
 971 {
 972         int ret;
 973
 974         codec_devs[0].num_resources = ARRAY_SIZE(codec_resources);
 975         codec_devs[0].resources = &codec_resources[0],
 976         ret = mfd_add_devices(chip->dev, 0, &codec_devs[0],
 977                               ARRAY_SIZE(codec_devs), &codec_resources[0], 0,
 978                               NULL);
 979         if (ret < 0)
 980                 dev_err(chip->dev, "Failed to add codec subdev\n");
 981 }
 982
 983 static void device_8607_init(struct pm860x_chip *chip,
 984                                        struct i2c_client *i2c,
 985                                        struct pm860x_platform_data *pdata)
 986 {
 987         int data, ret;
 988
 989         ret = pm860x_reg_read(i2c, PM8607_CHIP_ID);
 990         if (ret < 0) {
 991                 dev_err(chip->dev, "Failed to read CHIP ID: %d\n", ret);
 992                 goto out;
 993         }
 994         switch (ret & PM8607_VERSION_MASK) {
 995         case 0x40:
 996         case 0x50:
 997                 dev_info(chip->dev, "Marvell 88PM8607 (ID: %02x) detected\n",
 998                          ret);
 999                 break;
1000         default:
1001                 dev_err(chip->dev,
1002                         "Failed to detect Marvell 88PM8607. Chip ID: %02x\n",
1003                         ret);
1004                 goto out;
1005         }
1006
1007         ret = pm860x_reg_read(i2c, PM8607_BUCK3);
1008         if (ret < 0) {
1009                 dev_err(chip->dev, "Failed to read BUCK3 register: %d\n", ret);
1010                 goto out;
1011         }
1012         if (ret & PM8607_BUCK3_DOUBLE)
1013                 chip->buck3_double = 1;
1014
1015         ret = pm860x_reg_read(i2c, PM8607_B0_MISC1);
1016         if (ret < 0) {
1017                 dev_err(chip->dev, "Failed to read MISC1 register: %d\n", ret);
1018                 goto out;
1019         }
1020
1021         if (pdata && (pdata->i2c_port == PI2C_PORT))
1022                 data = PM8607_B0_MISC1_PI2C;
1023         else
1024                 data = 0;
1025         ret = pm860x_set_bits(i2c, PM8607_B0_MISC1, PM8607_B0_MISC1_PI2C, data);
1026         if (ret < 0) {
1027                 dev_err(chip->dev, "Failed to access MISC1:%d\n", ret);
1028                 goto out;
1029         }
1030
1031         ret = device_irq_init(chip, pdata);
1032         if (ret < 0)
1033                 goto out;
1034
1035         device_regulator_init(chip, pdata);
1036         device_rtc_init(chip, pdata);
1037         device_onkey_init(chip, pdata);
1038         device_touch_init(chip, pdata);
1039         device_power_init(chip, pdata);
1040         device_codec_init(chip, pdata);
1041 out:
1042         return;
1043 }
1044
1045 static void device_8606_init(struct pm860x_chip *chip,
1046                                        struct i2c_client *i2c,
1047                                        struct pm860x_platform_data *pdata)
1048 {
1049         device_osc_init(i2c);
1050         device_bk_init(chip, pdata);
1051         device_led_init(chip, pdata);
1052 }
1053
1054 static int pm860x_device_init(struct pm860x_chip *chip,
1055                                         struct pm860x_platform_data *pdata)
1056 {
1057         chip->core_irq = 0;
1058
1059         switch (chip->id) {
1060         case CHIP_PM8606:
1061                 device_8606_init(chip, chip->client, pdata);
1062                 break;
1063         case CHIP_PM8607:
1064                 device_8607_init(chip, chip->client, pdata);
1065                 break;
1066         }
1067
1068         if (chip->companion) {
1069                 switch (chip->id) {
1070                 case CHIP_PM8607:
1071                         device_8606_init(chip, chip->companion, pdata);
1072                         break;
1073                 case CHIP_PM8606:
1074                         device_8607_init(chip, chip->companion, pdata);
1075                         break;
1076                 }
1077         }
1078
1079         return 0;
1080 }
1081
1082 static void pm860x_device_exit(struct pm860x_chip *chip)
1083 {
1084         device_irq_exit(chip);
1085         mfd_remove_devices(chip->dev);
1086 }
1087
1088 static int verify_addr(struct i2c_client *i2c)
1089 {
1090         unsigned short addr_8607[] = {0x30, 0x34};
1091         unsigned short addr_8606[] = {0x10, 0x11};
1092         int size, i;
1093
1094         if (i2c == NULL)
1095                 return 0;
1096         size = ARRAY_SIZE(addr_8606);
1097         for (i = 0; i < size; i++) {
1098                 if (i2c->addr == *(addr_8606 + i))
1099                         return CHIP_PM8606;
1100         }
1101         size = ARRAY_SIZE(addr_8607);
1102         for (i = 0; i < size; i++) {
1103                 if (i2c->addr == *(addr_8607 + i))
1104                         return CHIP_PM8607;
1105         }
1106         return 0;
1107 }
1108
1109 static const struct regmap_config pm860x_regmap_config = {
1110         .reg_bits = 8,
1111         .val_bits = 8,
1112 };
1113
1114 static int pm860x_dt_init(struct device_node *np,
1115                                     struct device *dev,
1116                                     struct pm860x_platform_data *pdata)
1117 {
1118         int ret;
1119
1120         if (of_get_property(np, "marvell,88pm860x-irq-read-clr", NULL))
1121                 pdata->irq_mode = 1;
1122         ret = of_property_read_u32(np, "marvell,88pm860x-slave-addr",
1123                                    &pdata->companion_addr);
1124         if (ret) {
1125                 dev_err(dev,
1126                         "Not found \"marvell,88pm860x-slave-addr\" property\n");
1127                 pdata->companion_addr = 0;
1128         }
1129         return 0;
1130 }
1131
1132 static int pm860x_probe(struct i2c_client *client)
1133 {
1134         struct pm860x_platform_data *pdata = dev_get_platdata(&client->dev);
1135         struct device_node *node = client->dev.of_node;
1136         struct pm860x_chip *chip;
1137         int ret;
1138
1139         if (node && !pdata) {
1140                 /* parse DT to get platform data */
1141                 pdata = devm_kzalloc(&client->dev,
1142                                      sizeof(struct pm860x_platform_data),
1143                                      GFP_KERNEL);
1144                 if (!pdata)
1145                         return -ENOMEM;
1146                 ret = pm860x_dt_init(node, &client->dev, pdata);
1147                 if (ret)
1148                         return ret;
1149         } else if (!pdata) {
1150                 pr_info("No platform data in %s!\n", __func__);
1151                 return -EINVAL;
1152         }
1153
1154         chip = devm_kzalloc(&client->dev,
1155                             sizeof(struct pm860x_chip), GFP_KERNEL);
1156         if (chip == NULL)
1157                 return -ENOMEM;
1158
1159         chip->id = verify_addr(client);
1160         chip->regmap = devm_regmap_init_i2c(client, &pm860x_regmap_config);
1161         if (IS_ERR(chip->regmap)) {
1162                 ret = PTR_ERR(chip->regmap);
1163                 dev_err(&client->dev, "Failed to allocate register map: %d\n",
1164                                 ret);
1165                 return ret;
1166         }
1167         chip->client = client;
1168         i2c_set_clientdata(client, chip);
1169         chip->dev = &client->dev;
1170         dev_set_drvdata(chip->dev, chip);
1171
1172         /*
1173          * Both client and companion client shares same platform driver.
1174          * Driver distinguishes them by pdata->companion_addr.
1175          * pdata->companion_addr is only assigned if companion chip exists.
1176          * At the same time, the companion_addr shouldn't equal to client
1177          * address.
1178          */
1179         if (pdata->companion_addr && (pdata->companion_addr != client->addr)) {
1180                 chip->companion_addr = pdata->companion_addr;
1181                 chip->companion = i2c_new_dummy_device(chip->client->adapter,
1182                                                 chip->companion_addr);
1183                 if (IS_ERR(chip->companion)) {
1184                         dev_err(&client->dev,
1185                                 "Failed to allocate I2C companion device\n");
1186                         return PTR_ERR(chip->companion);
1187                 }
1188                 chip->regmap_companion = regmap_init_i2c(chip->companion,
1189                                                         &pm860x_regmap_config);
1190                 if (IS_ERR(chip->regmap_companion)) {
1191                         ret = PTR_ERR(chip->regmap_companion);
1192                         dev_err(&chip->companion->dev,
1193                                 "Failed to allocate register map: %d\n", ret);
1194                         i2c_unregister_device(chip->companion);
1195                         return ret;
1196                 }
1197                 i2c_set_clientdata(chip->companion, chip);
1198         }
1199
1200         pm860x_device_init(chip, pdata);
1201         return 0;
1202 }
1203
1204 static int pm860x_remove(struct i2c_client *client)
1205 {
1206         struct pm860x_chip *chip = i2c_get_clientdata(client);
1207
1208         pm860x_device_exit(chip);
1209         if (chip->companion) {
1210                 regmap_exit(chip->regmap_companion);
1211                 i2c_unregister_device(chip->companion);
1212         }
1213         return 0;
1214 }
1215
1216 #ifdef CONFIG_PM_SLEEP
1217 static int pm860x_suspend(struct device *dev)
1218 {
1219         struct i2c_client *client = to_i2c_client(dev);
1220         struct pm860x_chip *chip = i2c_get_clientdata(client);
1221
1222         if (device_may_wakeup(dev) && chip->wakeup_flag)
1223                 enable_irq_wake(chip->core_irq);
1224         return 0;
1225 }
1226
1227 static int pm860x_resume(struct device *dev)
1228 {
1229         struct i2c_client *client = to_i2c_client(dev);
1230         struct pm860x_chip *chip = i2c_get_clientdata(client);
1231
1232         if (device_may_wakeup(dev) && chip->wakeup_flag)
1233                 disable_irq_wake(chip->core_irq);
1234         return 0;
1235 }
1236 #endif
1237
1238 static SIMPLE_DEV_PM_OPS(pm860x_pm_ops, pm860x_suspend, pm860x_resume);
1239
1240 static const struct i2c_device_id pm860x_id_table[] = {
1241         { "88PM860x", 0 },
1242         {}
1243 };
1244 MODULE_DEVICE_TABLE(i2c, pm860x_id_table);
1245
1246 static const struct of_device_id pm860x_dt_ids[] = {
1247         { .compatible = "marvell,88pm860x", },
1248         {},
1249 };
1250 MODULE_DEVICE_TABLE(of, pm860x_dt_ids);
1251
1252 static struct i2c_driver pm860x_driver = {
1253         .driver = {
1254                 .name   = "88PM860x",
1255                 .pm     = &pm860x_pm_ops,
1256                 .of_match_table = pm860x_dt_ids,
1257         },
1258         .probe_new      = pm860x_probe,
1259         .remove         = pm860x_remove,
1260         .id_table       = pm860x_id_table,
1261 };
1262
1263 static int __init pm860x_i2c_init(void)
1264 {
1265         int ret;
1266
1267         ret = i2c_add_driver(&pm860x_driver);
1268         if (ret != 0)
1269                 pr_err("Failed to register 88PM860x I2C driver: %d\n", ret);
1270         return ret;
1271 }
1272 subsys_initcall(pm860x_i2c_init);
1273
1274 static void __exit pm860x_i2c_exit(void)
1275 {
1276         i2c_del_driver(&pm860x_driver);
1277 }
1278 module_exit(pm860x_i2c_exit);
1279
1280 MODULE_DESCRIPTION("PMIC Driver for Marvell 88PM860x");
1281 MODULE_AUTHOR("Haojian Zhuang <haojian.zhuang@marvell.com>");
1282 MODULE_LICENSE("GPL");