drivers/mfd/88pm860x-core.c

   1 /*
   2  * Base driver for Marvell 88PM8607
   3  *
   4  * Copyright (C) 2009 Marvell International Ltd.
   5  *      Haojian Zhuang <haojian.zhuang@marvell.com>
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License version 2 as
   9  * published by the Free Software Foundation.
  10  */
  11
  12 #include <linux/kernel.h>
  13 #include <linux/module.h>
  14 #include <linux/i2c.h>
  15 #include <linux/irq.h>
  16 #include <linux/interrupt.h>
  17 #include <linux/platform_device.h>
  18 #include <linux/mfd/core.h>
  19 #include <linux/mfd/88pm860x.h>
  20 #include <linux/regulator/machine.h>
  21
  22 #define INT_STATUS_NUM                  3
  23
  24 static struct resource bk_resources[] __initdata = {
  25         {PM8606_BACKLIGHT1, PM8606_BACKLIGHT1, "backlight-0", IORESOURCE_IO,},
  26         {PM8606_BACKLIGHT2, PM8606_BACKLIGHT2, "backlight-1", IORESOURCE_IO,},
  27         {PM8606_BACKLIGHT3, PM8606_BACKLIGHT3, "backlight-2", IORESOURCE_IO,},
  28 };
  29
  30 static struct resource led_resources[] __initdata = {
  31         {PM8606_LED1_RED,   PM8606_LED1_RED,   "led0-red",   IORESOURCE_IO,},
  32         {PM8606_LED1_GREEN, PM8606_LED1_GREEN, "led0-green", IORESOURCE_IO,},
  33         {PM8606_LED1_BLUE,  PM8606_LED1_BLUE,  "led0-blue",  IORESOURCE_IO,},
  34         {PM8606_LED2_RED,   PM8606_LED2_RED,   "led1-red",   IORESOURCE_IO,},
  35         {PM8606_LED2_GREEN, PM8606_LED2_GREEN, "led1-green", IORESOURCE_IO,},
  36         {PM8606_LED2_BLUE,  PM8606_LED2_BLUE,  "led1-blue",  IORESOURCE_IO,},
  37 };
  38
  39 static struct resource regulator_resources[] __initdata = {
  40         {PM8607_ID_BUCK1, PM8607_ID_BUCK1, "buck-1", IORESOURCE_IO,},
  41         {PM8607_ID_BUCK2, PM8607_ID_BUCK2, "buck-2", IORESOURCE_IO,},
  42         {PM8607_ID_BUCK3, PM8607_ID_BUCK3, "buck-3", IORESOURCE_IO,},
  43         {PM8607_ID_LDO1,  PM8607_ID_LDO1,  "ldo-01", IORESOURCE_IO,},
  44         {PM8607_ID_LDO2,  PM8607_ID_LDO2,  "ldo-02", IORESOURCE_IO,},
  45         {PM8607_ID_LDO3,  PM8607_ID_LDO3,  "ldo-03", IORESOURCE_IO,},
  46         {PM8607_ID_LDO4,  PM8607_ID_LDO4,  "ldo-04", IORESOURCE_IO,},
  47         {PM8607_ID_LDO5,  PM8607_ID_LDO5,  "ldo-05", IORESOURCE_IO,},
  48         {PM8607_ID_LDO6,  PM8607_ID_LDO6,  "ldo-06", IORESOURCE_IO,},
  49         {PM8607_ID_LDO7,  PM8607_ID_LDO7,  "ldo-07", IORESOURCE_IO,},
  50         {PM8607_ID_LDO8,  PM8607_ID_LDO8,  "ldo-08", IORESOURCE_IO,},
  51         {PM8607_ID_LDO9,  PM8607_ID_LDO9,  "ldo-09", IORESOURCE_IO,},
  52         {PM8607_ID_LDO10, PM8607_ID_LDO10, "ldo-10", IORESOURCE_IO,},
  53         {PM8607_ID_LDO11, PM8607_ID_LDO11, "ldo-11", IORESOURCE_IO,},
  54         {PM8607_ID_LDO12, PM8607_ID_LDO12, "ldo-12", IORESOURCE_IO,},
  55         {PM8607_ID_LDO13, PM8607_ID_LDO13, "ldo-13", IORESOURCE_IO,},
  56         {PM8607_ID_LDO14, PM8607_ID_LDO14, "ldo-14", IORESOURCE_IO,},
  57         {PM8607_ID_LDO15, PM8607_ID_LDO15, "ldo-15", IORESOURCE_IO,},
  58 };
  59
  60 static struct resource touch_resources[] __initdata = {
  61         {PM8607_IRQ_PEN, PM8607_IRQ_PEN, "touch", IORESOURCE_IRQ,},
  62 };
  63
  64 static struct resource onkey_resources[] __initdata = {
  65         {PM8607_IRQ_ONKEY, PM8607_IRQ_ONKEY, "onkey", IORESOURCE_IRQ,},
  66 };
  67
  68 static struct resource codec_resources[] __initdata = {
  69         /* Headset microphone insertion or removal */
  70         {PM8607_IRQ_MICIN,   PM8607_IRQ_MICIN,   "micin",   IORESOURCE_IRQ,},
  71         /* Hook-switch press or release */
  72         {PM8607_IRQ_HOOK,    PM8607_IRQ_HOOK,    "hook",    IORESOURCE_IRQ,},
  73         /* Headset insertion or removal */
  74         {PM8607_IRQ_HEADSET, PM8607_IRQ_HEADSET, "headset", IORESOURCE_IRQ,},
  75         /* Audio short */
  76         {PM8607_IRQ_AUDIO_SHORT, PM8607_IRQ_AUDIO_SHORT, "audio-short", IORESOURCE_IRQ,},
  77 };
  78
  79 static struct resource battery_resources[] __initdata = {
  80         {PM8607_IRQ_CC,  PM8607_IRQ_CC,  "columb counter", IORESOURCE_IRQ,},
  81         {PM8607_IRQ_BAT, PM8607_IRQ_BAT, "battery",        IORESOURCE_IRQ,},
  82 };
  83
  84 static struct resource charger_resources[] __initdata = {
  85         {PM8607_IRQ_CHG,  PM8607_IRQ_CHG,  "charger detect",  IORESOURCE_IRQ,},
  86         {PM8607_IRQ_CHG_DONE,  PM8607_IRQ_CHG_DONE,  "charging done",       IORESOURCE_IRQ,},
  87         {PM8607_IRQ_CHG_FAULT, PM8607_IRQ_CHG_FAULT, "charging timeout",    IORESOURCE_IRQ,},
  88         {PM8607_IRQ_GPADC1,    PM8607_IRQ_GPADC1,    "battery temperature", IORESOURCE_IRQ,},
  89         {PM8607_IRQ_VBAT, PM8607_IRQ_VBAT, "battery voltage", IORESOURCE_IRQ,},
  90         {PM8607_IRQ_VCHG, PM8607_IRQ_VCHG, "vchg voltage",    IORESOURCE_IRQ,},
  91 };
  92
  93 static struct mfd_cell bk_devs[] __initdata = {
  94         {"88pm860x-backlight", 0,},
  95         {"88pm860x-backlight", 1,},
  96         {"88pm860x-backlight", 2,},
  97 };
  98
  99 static struct mfd_cell led_devs[] __initdata = {
 100         {"88pm860x-led", 0,},
 101         {"88pm860x-led", 1,},
 102         {"88pm860x-led", 2,},
 103         {"88pm860x-led", 3,},
 104         {"88pm860x-led", 4,},
 105         {"88pm860x-led", 5,},
 106 };
 107
 108 static struct mfd_cell regulator_devs[] __initdata = {
 109         {"88pm860x-regulator", 0,},
 110         {"88pm860x-regulator", 1,},
 111         {"88pm860x-regulator", 2,},
 112         {"88pm860x-regulator", 3,},
 113         {"88pm860x-regulator", 4,},
 114         {"88pm860x-regulator", 5,},
 115         {"88pm860x-regulator", 6,},
 116         {"88pm860x-regulator", 7,},
 117         {"88pm860x-regulator", 8,},
 118         {"88pm860x-regulator", 9,},
 119         {"88pm860x-regulator", 10,},
 120         {"88pm860x-regulator", 11,},
 121         {"88pm860x-regulator", 12,},
 122         {"88pm860x-regulator", 13,},
 123         {"88pm860x-regulator", 14,},
 124         {"88pm860x-regulator", 15,},
 125         {"88pm860x-regulator", 16,},
 126         {"88pm860x-regulator", 17,},
 127 };
 128
 129 static struct mfd_cell touch_devs[] __initdata = {
 130         {"88pm860x-touch", -1,},
 131 };
 132
 133 static struct mfd_cell onkey_devs[] __initdata = {
 134         {"88pm860x-onkey", -1,},
 135 };
 136
 137 static struct mfd_cell codec_devs[] __initdata = {
 138         {"88pm860x-codec", -1,},
 139 };
 140
 141 static struct mfd_cell power_devs[] = {
 142         {"88pm860x-battery", -1,},
 143         {"88pm860x-charger", -1,},
 144 };
 145
 146 static struct pm860x_backlight_pdata bk_pdata[ARRAY_SIZE(bk_devs)];
 147 static struct pm860x_led_pdata led_pdata[ARRAY_SIZE(led_devs)];
 148 static struct regulator_init_data regulator_pdata[ARRAY_SIZE(regulator_devs)];
 149 static struct pm860x_touch_pdata touch_pdata;
 150 static struct pm860x_power_pdata power_pdata;
 151
 152 struct pm860x_irq_data {
 153         int     reg;
 154         int     mask_reg;
 155         int     enable;         /* enable or not */
 156         int     offs;           /* bit offset in mask register */
 157 };
 158
 159 static struct pm860x_irq_data pm860x_irqs[] = {
 160         [PM8607_IRQ_ONKEY] = {
 161                 .reg            = PM8607_INT_STATUS1,
 162                 .mask_reg       = PM8607_INT_MASK_1,
 163                 .offs           = 1 << 0,
 164         },
 165         [PM8607_IRQ_EXTON] = {
 166                 .reg            = PM8607_INT_STATUS1,
 167                 .mask_reg       = PM8607_INT_MASK_1,
 168                 .offs           = 1 << 1,
 169         },
 170         [PM8607_IRQ_CHG] = {
 171                 .reg            = PM8607_INT_STATUS1,
 172                 .mask_reg       = PM8607_INT_MASK_1,
 173                 .offs           = 1 << 2,
 174         },
 175         [PM8607_IRQ_BAT] = {
 176                 .reg            = PM8607_INT_STATUS1,
 177                 .mask_reg       = PM8607_INT_MASK_1,
 178                 .offs           = 1 << 3,
 179         },
 180         [PM8607_IRQ_RTC] = {
 181                 .reg            = PM8607_INT_STATUS1,
 182                 .mask_reg       = PM8607_INT_MASK_1,
 183                 .offs           = 1 << 4,
 184         },
 185         [PM8607_IRQ_CC] = {
 186                 .reg            = PM8607_INT_STATUS1,
 187                 .mask_reg       = PM8607_INT_MASK_1,
 188                 .offs           = 1 << 5,
 189         },
 190         [PM8607_IRQ_VBAT] = {
 191                 .reg            = PM8607_INT_STATUS2,
 192                 .mask_reg       = PM8607_INT_MASK_2,
 193                 .offs           = 1 << 0,
 194         },
 195         [PM8607_IRQ_VCHG] = {
 196                 .reg            = PM8607_INT_STATUS2,
 197                 .mask_reg       = PM8607_INT_MASK_2,
 198                 .offs           = 1 << 1,
 199         },
 200         [PM8607_IRQ_VSYS] = {
 201                 .reg            = PM8607_INT_STATUS2,
 202                 .mask_reg       = PM8607_INT_MASK_2,
 203                 .offs           = 1 << 2,
 204         },
 205         [PM8607_IRQ_TINT] = {
 206                 .reg            = PM8607_INT_STATUS2,
 207                 .mask_reg       = PM8607_INT_MASK_2,
 208                 .offs           = 1 << 3,
 209         },
 210         [PM8607_IRQ_GPADC0] = {
 211                 .reg            = PM8607_INT_STATUS2,
 212                 .mask_reg       = PM8607_INT_MASK_2,
 213                 .offs           = 1 << 4,
 214         },
 215         [PM8607_IRQ_GPADC1] = {
 216                 .reg            = PM8607_INT_STATUS2,
 217                 .mask_reg       = PM8607_INT_MASK_2,
 218                 .offs           = 1 << 5,
 219         },
 220         [PM8607_IRQ_GPADC2] = {
 221                 .reg            = PM8607_INT_STATUS2,
 222                 .mask_reg       = PM8607_INT_MASK_2,
 223                 .offs           = 1 << 6,
 224         },
 225         [PM8607_IRQ_GPADC3] = {
 226                 .reg            = PM8607_INT_STATUS2,
 227                 .mask_reg       = PM8607_INT_MASK_2,
 228                 .offs           = 1 << 7,
 229         },
 230         [PM8607_IRQ_AUDIO_SHORT] = {
 231                 .reg            = PM8607_INT_STATUS3,
 232                 .mask_reg       = PM8607_INT_MASK_3,
 233                 .offs           = 1 << 0,
 234         },
 235         [PM8607_IRQ_PEN] = {
 236                 .reg            = PM8607_INT_STATUS3,
 237                 .mask_reg       = PM8607_INT_MASK_3,
 238                 .offs           = 1 << 1,
 239         },
 240         [PM8607_IRQ_HEADSET] = {
 241                 .reg            = PM8607_INT_STATUS3,
 242                 .mask_reg       = PM8607_INT_MASK_3,
 243                 .offs           = 1 << 2,
 244         },
 245         [PM8607_IRQ_HOOK] = {
 246                 .reg            = PM8607_INT_STATUS3,
 247                 .mask_reg       = PM8607_INT_MASK_3,
 248                 .offs           = 1 << 3,
 249         },
 250         [PM8607_IRQ_MICIN] = {
 251                 .reg            = PM8607_INT_STATUS3,
 252                 .mask_reg       = PM8607_INT_MASK_3,
 253                 .offs           = 1 << 4,
 254         },
 255         [PM8607_IRQ_CHG_FAIL] = {
 256                 .reg            = PM8607_INT_STATUS3,
 257                 .mask_reg       = PM8607_INT_MASK_3,
 258                 .offs           = 1 << 5,
 259         },
 260         [PM8607_IRQ_CHG_DONE] = {
 261                 .reg            = PM8607_INT_STATUS3,
 262                 .mask_reg       = PM8607_INT_MASK_3,
 263                 .offs           = 1 << 6,
 264         },
 265         [PM8607_IRQ_CHG_FAULT] = {
 266                 .reg            = PM8607_INT_STATUS3,
 267                 .mask_reg       = PM8607_INT_MASK_3,
 268                 .offs           = 1 << 7,
 269         },
 270 };
 271
 272 static irqreturn_t pm860x_irq(int irq, void *data)
 273 {
 274         struct pm860x_chip *chip = data;
 275         struct pm860x_irq_data *irq_data;
 276         struct i2c_client *i2c;
 277         int read_reg = -1, value = 0;
 278         int i;
 279
 280         i2c = (chip->id == CHIP_PM8607) ? chip->client : chip->companion;
 281         for (i = 0; i < ARRAY_SIZE(pm860x_irqs); i++) {
 282                 irq_data = &pm860x_irqs[i];
 283                 if (read_reg != irq_data->reg) {
 284                         read_reg = irq_data->reg;
 285                         value = pm860x_reg_read(i2c, irq_data->reg);
 286                 }
 287                 if (value & irq_data->enable)
 288                         handle_nested_irq(chip->irq_base + i);
 289         }
 290         return IRQ_HANDLED;
 291 }
 292
 293 static void pm860x_irq_lock(struct irq_data *data)
 294 {
 295         struct pm860x_chip *chip = irq_data_get_irq_chip_data(data);
 296
 297         mutex_lock(&chip->irq_lock);
 298 }
 299
 300 static void pm860x_irq_sync_unlock(struct irq_data *data)
 301 {
 302         struct pm860x_chip *chip = irq_data_get_irq_chip_data(data);
 303         struct pm860x_irq_data *irq_data;
 304         struct i2c_client *i2c;
 305         static unsigned char cached[3] = {0x0, 0x0, 0x0};
 306         unsigned char mask[3];
 307         int i;
 308
 309         i2c = (chip->id == CHIP_PM8607) ? chip->client : chip->companion;
 310         /* Load cached value. In initial, all IRQs are masked */
 311         for (i = 0; i < 3; i++)
 312                 mask[i] = cached[i];
 313         for (i = 0; i < ARRAY_SIZE(pm860x_irqs); i++) {
 314                 irq_data = &pm860x_irqs[i];
 315                 switch (irq_data->mask_reg) {
 316                 case PM8607_INT_MASK_1:
 317                         mask[0] &= ~irq_data->offs;
 318                         mask[0] |= irq_data->enable;
 319                         break;
 320                 case PM8607_INT_MASK_2:
 321                         mask[1] &= ~irq_data->offs;
 322                         mask[1] |= irq_data->enable;
 323                         break;
 324                 case PM8607_INT_MASK_3:
 325                         mask[2] &= ~irq_data->offs;
 326                         mask[2] |= irq_data->enable;
 327                         break;
 328                 default:
 329                         dev_err(chip->dev, "wrong IRQ\n");
 330                         break;
 331                 }
 332         }
 333         /* update mask into registers */
 334         for (i = 0; i < 3; i++) {
 335                 if (mask[i] != cached[i]) {
 336                         cached[i] = mask[i];
 337                         pm860x_reg_write(i2c, PM8607_INT_MASK_1 + i, mask[i]);
 338                 }
 339         }
 340
 341         mutex_unlock(&chip->irq_lock);
 342 }
 343
 344 static void pm860x_irq_enable(struct irq_data *data)
 345 {
 346         struct pm860x_chip *chip = irq_data_get_irq_chip_data(data);
 347         pm860x_irqs[data->irq - chip->irq_base].enable
 348                 = pm860x_irqs[data->irq - chip->irq_base].offs;
 349 }
 350
 351 static void pm860x_irq_disable(struct irq_data *data)
 352 {
 353         struct pm860x_chip *chip = irq_data_get_irq_chip_data(data);
 354         pm860x_irqs[data->irq - chip->irq_base].enable = 0;
 355 }
 356
 357 static struct irq_chip pm860x_irq_chip = {
 358         .name           = "88pm860x",
 359         .irq_bus_lock   = pm860x_irq_lock,
 360         .irq_bus_sync_unlock = pm860x_irq_sync_unlock,
 361         .irq_enable     = pm860x_irq_enable,
 362         .irq_disable    = pm860x_irq_disable,
 363 };
 364
 365 static int __devinit device_gpadc_init(struct pm860x_chip *chip,
 366                                        struct pm860x_platform_data *pdata)
 367 {
 368         struct i2c_client *i2c = (chip->id == CHIP_PM8607) ? chip->client \
 369                                 : chip->companion;
 370         int data;
 371         int ret;
 372
 373         /* initialize GPADC without activating it */
 374
 375         if (!pdata || !pdata->touch)
 376                 return -EINVAL;
 377
 378         /* set GPADC MISC1 register */
 379         data = 0;
 380         data |= (pdata->touch->gpadc_prebias << 1) & PM8607_GPADC_PREBIAS_MASK;
 381         data |= (pdata->touch->slot_cycle << 3) & PM8607_GPADC_SLOT_CYCLE_MASK;
 382         data |= (pdata->touch->off_scale << 5) & PM8607_GPADC_OFF_SCALE_MASK;
 383         data |= (pdata->touch->sw_cal << 7) & PM8607_GPADC_SW_CAL_MASK;
 384         if (data) {
 385                 ret = pm860x_reg_write(i2c, PM8607_GPADC_MISC1, data);
 386                 if (ret < 0)
 387                         goto out;
 388         }
 389         /* set tsi prebias time */
 390         if (pdata->touch->tsi_prebias) {
 391                 data = pdata->touch->tsi_prebias;
 392                 ret = pm860x_reg_write(i2c, PM8607_TSI_PREBIAS, data);
 393                 if (ret < 0)
 394                         goto out;
 395         }
 396         /* set prebias & prechg time of pen detect */
 397         data = 0;
 398         data |= pdata->touch->pen_prebias & PM8607_PD_PREBIAS_MASK;
 399         data |= (pdata->touch->pen_prechg << 5) & PM8607_PD_PRECHG_MASK;
 400         if (data) {
 401                 ret = pm860x_reg_write(i2c, PM8607_PD_PREBIAS, data);
 402                 if (ret < 0)
 403                         goto out;
 404         }
 405
 406         ret = pm860x_set_bits(i2c, PM8607_GPADC_MISC1,
 407                               PM8607_GPADC_EN, PM8607_GPADC_EN);
 408 out:
 409         return ret;
 410 }
 411
 412 static int __devinit device_irq_init(struct pm860x_chip *chip,
 413                                      struct pm860x_platform_data *pdata)
 414 {
 415         struct i2c_client *i2c = (chip->id == CHIP_PM8607) ? chip->client \
 416                                 : chip->companion;
 417         unsigned char status_buf[INT_STATUS_NUM];
 418         unsigned long flags = IRQF_TRIGGER_FALLING | IRQF_ONESHOT;
 419         struct irq_desc *desc;
 420         int i, data, mask, ret = -EINVAL;
 421         int __irq;
 422
 423         if (!pdata || !pdata->irq_base) {
 424                 dev_warn(chip->dev, "No interrupt support on IRQ base\n");
 425                 return -EINVAL;
 426         }
 427
 428         mask = PM8607_B0_MISC1_INV_INT | PM8607_B0_MISC1_INT_CLEAR
 429                 | PM8607_B0_MISC1_INT_MASK;
 430         data = 0;
 431         chip->irq_mode = 0;
 432         if (pdata && pdata->irq_mode) {
 433                 /*
 434                  * irq_mode defines the way of clearing interrupt. If it's 1,
 435                  * clear IRQ by write. Otherwise, clear it by read.
 436                  * This control bit is valid from 88PM8607 B0 steping.
 437                  */
 438                 data |= PM8607_B0_MISC1_INT_CLEAR;
 439                 chip->irq_mode = 1;
 440         }
 441         ret = pm860x_set_bits(i2c, PM8607_B0_MISC1, mask, data);
 442         if (ret < 0)
 443                 goto out;
 444
 445         /* mask all IRQs */
 446         memset(status_buf, 0, INT_STATUS_NUM);
 447         ret = pm860x_bulk_write(i2c, PM8607_INT_MASK_1,
 448                                 INT_STATUS_NUM, status_buf);
 449         if (ret < 0)
 450                 goto out;
 451
 452         if (chip->irq_mode) {
 453                 /* clear interrupt status by write */
 454                 memset(status_buf, 0xFF, INT_STATUS_NUM);
 455                 ret = pm860x_bulk_write(i2c, PM8607_INT_STATUS1,
 456                                         INT_STATUS_NUM, status_buf);
 457         } else {
 458                 /* clear interrupt status by read */
 459                 ret = pm860x_bulk_read(i2c, PM8607_INT_STATUS1,
 460                                         INT_STATUS_NUM, status_buf);
 461         }
 462         if (ret < 0)
 463                 goto out;
 464
 465         mutex_init(&chip->irq_lock);
 466         chip->irq_base = pdata->irq_base;
 467         chip->core_irq = i2c->irq;
 468         if (!chip->core_irq)
 469                 goto out;
 470
 471         desc = irq_to_desc(chip->core_irq);
 472
 473         /* register IRQ by genirq */
 474         for (i = 0; i < ARRAY_SIZE(pm860x_irqs); i++) {
 475                 __irq = i + chip->irq_base;
 476                 set_irq_chip_data(__irq, chip);
 477                 set_irq_chip_and_handler(__irq, &pm860x_irq_chip,
 478                                          handle_edge_irq);
 479                 set_irq_nested_thread(__irq, 1);
 480 #ifdef CONFIG_ARM
 481                 set_irq_flags(__irq, IRQF_VALID);
 482 #else
 483                 set_irq_noprobe(__irq);
 484 #endif
 485         }
 486
 487         ret = request_threaded_irq(chip->core_irq, NULL, pm860x_irq, flags,
 488                                    "88pm860x", chip);
 489         if (ret) {
 490                 dev_err(chip->dev, "Failed to request IRQ: %d\n", ret);
 491                 chip->core_irq = 0;
 492         }
 493
 494         return 0;
 495 out:
 496         chip->core_irq = 0;
 497         return ret;
 498 }
 499
 500 static void device_irq_exit(struct pm860x_chip *chip)
 501 {
 502         if (chip->core_irq)
 503                 free_irq(chip->core_irq, chip);
 504 }
 505
 506 static void __devinit device_bk_init(struct pm860x_chip *chip,
 507                                      struct i2c_client *i2c,
 508                                      struct pm860x_platform_data *pdata)
 509 {
 510         int ret;
 511         int i, j, id;
 512
 513         if ((pdata == NULL) || (pdata->backlight == NULL))
 514                 return;
 515
 516         if (pdata->num_backlights > ARRAY_SIZE(bk_devs))
 517                 pdata->num_backlights = ARRAY_SIZE(bk_devs);
 518
 519         for (i = 0; i < pdata->num_backlights; i++) {
 520                 memcpy(&bk_pdata[i], &pdata->backlight[i],
 521                         sizeof(struct pm860x_backlight_pdata));
 522                 bk_devs[i].mfd_data = &bk_pdata[i];
 523
 524                 for (j = 0; j < ARRAY_SIZE(bk_devs); j++) {
 525                         id = bk_resources[j].start;
 526                         if (bk_pdata[i].flags != id)
 527                                 continue;
 528
 529                         bk_devs[i].num_resources = 1;
 530                         bk_devs[i].resources = &bk_resources[j];
 531                         ret = mfd_add_devices(chip->dev, 0,
 532                                               &bk_devs[i], 1,
 533                                               &bk_resources[j], 0);
 534                         if (ret < 0) {
 535                                 dev_err(chip->dev, "Failed to add "
 536                                         "backlight subdev\n");
 537                                 return;
 538                         }
 539                 }
 540         }
 541 }
 542
 543 static void __devinit device_led_init(struct pm860x_chip *chip,
 544                                       struct i2c_client *i2c,
 545                                       struct pm860x_platform_data *pdata)
 546 {
 547         int ret;
 548         int i, j, id;
 549
 550         if ((pdata == NULL) || (pdata->led == NULL))
 551                 return;
 552
 553         if (pdata->num_leds > ARRAY_SIZE(led_devs))
 554                 pdata->num_leds = ARRAY_SIZE(led_devs);
 555
 556         for (i = 0; i < pdata->num_leds; i++) {
 557                 memcpy(&led_pdata[i], &pdata->led[i],
 558                         sizeof(struct pm860x_led_pdata));
 559                 led_devs[i].mfd_data = &led_pdata[i];
 560
 561                 for (j = 0; j < ARRAY_SIZE(led_devs); j++) {
 562                         id = led_resources[j].start;
 563                         if (led_pdata[i].flags != id)
 564                                 continue;
 565
 566                         led_devs[i].num_resources = 1;
 567                         led_devs[i].resources = &led_resources[j],
 568                         ret = mfd_add_devices(chip->dev, 0,
 569                                               &led_devs[i], 1,
 570                                               &led_resources[j], 0);
 571                         if (ret < 0) {
 572                                 dev_err(chip->dev, "Failed to add "
 573                                         "led subdev\n");
 574                                 return;
 575                         }
 576                 }
 577         }
 578 }
 579
 580 static void __devinit device_regulator_init(struct pm860x_chip *chip,
 581                                             struct i2c_client *i2c,
 582                                             struct pm860x_platform_data *pdata)
 583 {
 584         struct regulator_init_data *initdata;
 585         int ret;
 586         int i, j;
 587
 588         if ((pdata == NULL) || (pdata->regulator == NULL))
 589                 return;
 590
 591         if (pdata->num_regulators > ARRAY_SIZE(regulator_devs))
 592                 pdata->num_regulators = ARRAY_SIZE(regulator_devs);
 593
 594         for (i = 0, j = -1; i < pdata->num_regulators; i++) {
 595                 initdata = &pdata->regulator[i];
 596                 if (strstr(initdata->constraints.name, "BUCK")) {
 597                         sscanf(initdata->constraints.name, "BUCK%d", &j);
 598                         /* BUCK1 ~ BUCK3 */
 599                         if ((j < 1) || (j > 3)) {
 600                                 dev_err(chip->dev, "Failed to add constraint "
 601                                         "(%s)\n", initdata->constraints.name);
 602                                 goto out;
 603                         }
 604                         j = (j - 1) + PM8607_ID_BUCK1;
 605                 }
 606                 if (strstr(initdata->constraints.name, "LDO")) {
 607                         sscanf(initdata->constraints.name, "LDO%d", &j);
 608                         /* LDO1 ~ LDO15 */
 609                         if ((j < 1) || (j > 15)) {
 610                                 dev_err(chip->dev, "Failed to add constraint "
 611                                         "(%s)\n", initdata->constraints.name);
 612                                 goto out;
 613                         }
 614                         j = (j - 1) + PM8607_ID_LDO1;
 615                 }
 616                 if (j == -1) {
 617                         dev_err(chip->dev, "Failed to add constraint (%s)\n",
 618                                 initdata->constraints.name);
 619                         goto out;
 620                 }
 621                 memcpy(&regulator_pdata[i], &pdata->regulator[i],
 622                         sizeof(struct regulator_init_data));
 623                 regulator_devs[i].mfd_data = &regulator_pdata[i];
 624                 regulator_devs[i].num_resources = 1;
 625                 regulator_devs[i].resources = &regulator_resources[j];
 626
 627                 ret = mfd_add_devices(chip->dev, 0, &regulator_devs[i], 1,
 628                                       &regulator_resources[j], 0);
 629                 if (ret < 0) {
 630                         dev_err(chip->dev, "Failed to add regulator subdev\n");
 631                         goto out;
 632                 }
 633         }
 634 out:
 635         return;
 636 }
 637
 638 static void __devinit device_touch_init(struct pm860x_chip *chip,
 639                                         struct i2c_client *i2c,
 640                                         struct pm860x_platform_data *pdata)
 641 {
 642         int ret;
 643
 644         if ((pdata == NULL) || (pdata->touch == NULL))
 645                 return;
 646
 647         memcpy(&touch_pdata, pdata->touch, sizeof(struct pm860x_touch_pdata));
 648         touch_devs[0].mfd_data = &touch_pdata;
 649         touch_devs[0].num_resources = ARRAY_SIZE(touch_resources);
 650         touch_devs[0].resources = &touch_resources[0];
 651         ret = mfd_add_devices(chip->dev, 0, &touch_devs[0],
 652                               ARRAY_SIZE(touch_devs), &touch_resources[0],
 653                               chip->irq_base);
 654         if (ret < 0)
 655                 dev_err(chip->dev, "Failed to add touch subdev\n");
 656 }
 657
 658 static void __devinit device_power_init(struct pm860x_chip *chip,
 659                                         struct i2c_client *i2c,
 660                                         struct pm860x_platform_data *pdata)
 661 {
 662         int ret;
 663
 664         if ((pdata == NULL) || (pdata->power == NULL))
 665                 return;
 666
 667         memcpy(&power_pdata, pdata->power, sizeof(struct pm860x_power_pdata));
 668         power_devs[0].mfd_data = &power_pdata;
 669         power_devs[0].num_resources = ARRAY_SIZE(battery_resources);
 670         power_devs[0].resources = &battery_resources[0],
 671         ret = mfd_add_devices(chip->dev, 0, &power_devs[0], 1,
 672                               &battery_resources[0], chip->irq_base);
 673         if (ret < 0)
 674                 dev_err(chip->dev, "Failed to add battery subdev\n");
 675
 676         power_devs[1].mfd_data = &power_pdata;
 677         power_devs[1].num_resources = ARRAY_SIZE(charger_resources);
 678         power_devs[1].resources = &charger_resources[0],
 679         ret = mfd_add_devices(chip->dev, 0, &power_devs[1], 1,
 680                               &charger_resources[0], chip->irq_base);
 681         if (ret < 0)
 682                 dev_err(chip->dev, "Failed to add charger subdev\n");
 683 }
 684
 685 static void __devinit device_onkey_init(struct pm860x_chip *chip,
 686                                         struct i2c_client *i2c,
 687                                         struct pm860x_platform_data *pdata)
 688 {
 689         int ret;
 690
 691         onkey_devs[0].num_resources = ARRAY_SIZE(onkey_resources);
 692         onkey_devs[0].resources = &onkey_resources[0],
 693         ret = mfd_add_devices(chip->dev, 0, &onkey_devs[0],
 694                               ARRAY_SIZE(onkey_devs), &onkey_resources[0],
 695                               chip->irq_base);
 696         if (ret < 0)
 697                 dev_err(chip->dev, "Failed to add onkey subdev\n");
 698 }
 699
 700 static void __devinit device_codec_init(struct pm860x_chip *chip,
 701                                         struct i2c_client *i2c,
 702                                         struct pm860x_platform_data *pdata)
 703 {
 704         int ret;
 705
 706         codec_devs[0].num_resources = ARRAY_SIZE(codec_resources);
 707         codec_devs[0].resources = &codec_resources[0],
 708         ret = mfd_add_devices(chip->dev, 0, &codec_devs[0],
 709                               ARRAY_SIZE(codec_devs), &codec_resources[0], 0);
 710         if (ret < 0)
 711                 dev_err(chip->dev, "Failed to add codec subdev\n");
 712 }
 713
 714 static void __devinit device_8607_init(struct pm860x_chip *chip,
 715                                        struct i2c_client *i2c,
 716                                        struct pm860x_platform_data *pdata)
 717 {
 718         int data, ret;
 719
 720         ret = pm860x_reg_read(i2c, PM8607_CHIP_ID);
 721         if (ret < 0) {
 722                 dev_err(chip->dev, "Failed to read CHIP ID: %d\n", ret);
 723                 goto out;
 724         }
 725         switch (ret & PM8607_VERSION_MASK) {
 726         case 0x40:
 727         case 0x50:
 728                 dev_info(chip->dev, "Marvell 88PM8607 (ID: %02x) detected\n",
 729                          ret);
 730                 break;
 731         default:
 732                 dev_err(chip->dev, "Failed to detect Marvell 88PM8607. "
 733                         "Chip ID: %02x\n", ret);
 734                 goto out;
 735         }
 736
 737         ret = pm860x_reg_read(i2c, PM8607_BUCK3);
 738         if (ret < 0) {
 739                 dev_err(chip->dev, "Failed to read BUCK3 register: %d\n", ret);
 740                 goto out;
 741         }
 742         if (ret & PM8607_BUCK3_DOUBLE)
 743                 chip->buck3_double = 1;
 744
 745         ret = pm860x_reg_read(i2c, PM8607_B0_MISC1);
 746         if (ret < 0) {
 747                 dev_err(chip->dev, "Failed to read MISC1 register: %d\n", ret);
 748                 goto out;
 749         }
 750
 751         if (pdata && (pdata->i2c_port == PI2C_PORT))
 752                 data = PM8607_B0_MISC1_PI2C;
 753         else
 754                 data = 0;
 755         ret = pm860x_set_bits(i2c, PM8607_B0_MISC1, PM8607_B0_MISC1_PI2C, data);
 756         if (ret < 0) {
 757                 dev_err(chip->dev, "Failed to access MISC1:%d\n", ret);
 758                 goto out;
 759         }
 760
 761         ret = device_gpadc_init(chip, pdata);
 762         if (ret < 0)
 763                 goto out;
 764
 765         ret = device_irq_init(chip, pdata);
 766         if (ret < 0)
 767                 goto out;
 768
 769         device_regulator_init(chip, i2c, pdata);
 770         device_onkey_init(chip, i2c, pdata);
 771         device_touch_init(chip, i2c, pdata);
 772         device_power_init(chip, i2c, pdata);
 773         device_codec_init(chip, i2c, pdata);
 774 out:
 775         return;
 776 }
 777
 778 int __devinit pm860x_device_init(struct pm860x_chip *chip,
 779                        struct pm860x_platform_data *pdata)
 780 {
 781         chip->core_irq = 0;
 782
 783         switch (chip->id) {
 784         case CHIP_PM8606:
 785                 device_bk_init(chip, chip->client, pdata);
 786                 device_led_init(chip, chip->client, pdata);
 787                 break;
 788         case CHIP_PM8607:
 789                 device_8607_init(chip, chip->client, pdata);
 790                 break;
 791         }
 792
 793         if (chip->companion) {
 794                 switch (chip->id) {
 795                 case CHIP_PM8607:
 796                         device_bk_init(chip, chip->companion, pdata);
 797                         device_led_init(chip, chip->companion, pdata);
 798                         break;
 799                 case CHIP_PM8606:
 800                         device_8607_init(chip, chip->companion, pdata);
 801                         break;
 802                 }
 803         }
 804
 805         return 0;
 806 }
 807
 808 void __devexit pm860x_device_exit(struct pm860x_chip *chip)
 809 {
 810         device_irq_exit(chip);
 811         mfd_remove_devices(chip->dev);
 812 }
 813
 814 MODULE_DESCRIPTION("PMIC Driver for Marvell 88PM860x");
 815 MODULE_AUTHOR("Haojian Zhuang <haojian.zhuang@marvell.com>");
 816 MODULE_LICENSE("GPL");