linux/drivers/mfd/88pm860x-core.c
<<
>>
Prefs
   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
  24static 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
  30static 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
  39static 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
  60static struct resource touch_resources[] __initdata = {
  61        {PM8607_IRQ_PEN, PM8607_IRQ_PEN, "touch", IORESOURCE_IRQ,},
  62};
  63
  64static struct resource onkey_resources[] __initdata = {
  65        {PM8607_IRQ_ONKEY, PM8607_IRQ_ONKEY, "onkey", IORESOURCE_IRQ,},
  66};
  67
  68static 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
  79static 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
  84static 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
  93static struct mfd_cell bk_devs[] __initdata = {
  94        {"88pm860x-backlight", 0,},
  95        {"88pm860x-backlight", 1,},
  96        {"88pm860x-backlight", 2,},
  97};
  98
  99static 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
 108static 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
 129static struct mfd_cell touch_devs[] __initdata = {
 130        {"88pm860x-touch", -1,},
 131};
 132
 133static struct mfd_cell onkey_devs[] __initdata = {
 134        {"88pm860x-onkey", -1,},
 135};
 136
 137static struct mfd_cell codec_devs[] __initdata = {
 138        {"88pm860x-codec", -1,},
 139};
 140
 141static struct mfd_cell power_devs[] = {
 142        {"88pm860x-battery", -1,},
 143        {"88pm860x-charger", -1,},
 144};
 145
 146static struct pm860x_backlight_pdata bk_pdata[ARRAY_SIZE(bk_devs)];
 147static struct pm860x_led_pdata led_pdata[ARRAY_SIZE(led_devs)];
 148static struct regulator_init_data regulator_pdata[ARRAY_SIZE(regulator_devs)];
 149static struct pm860x_touch_pdata touch_pdata;
 150static struct pm860x_power_pdata power_pdata;
 151
 152struct 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
 159static 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
 272static 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
 293static 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
 300static 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
 344static 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
 351static 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
 357static 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
 365static 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);
 408out:
 409        return ret;
 410}
 411
 412static 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        int i, data, mask, ret = -EINVAL;
 420        int __irq;
 421
 422        if (!pdata || !pdata->irq_base) {
 423                dev_warn(chip->dev, "No interrupt support on IRQ base\n");
 424                return -EINVAL;
 425        }
 426
 427        mask = PM8607_B0_MISC1_INV_INT | PM8607_B0_MISC1_INT_CLEAR
 428                | PM8607_B0_MISC1_INT_MASK;
 429        data = 0;
 430        chip->irq_mode = 0;
 431        if (pdata && pdata->irq_mode) {
 432                /*
 433                 * irq_mode defines the way of clearing interrupt. If it's 1,
 434                 * clear IRQ by write. Otherwise, clear it by read.
 435                 * This control bit is valid from 88PM8607 B0 steping.
 436                 */
 437                data |= PM8607_B0_MISC1_INT_CLEAR;
 438                chip->irq_mode = 1;
 439        }
 440        ret = pm860x_set_bits(i2c, PM8607_B0_MISC1, mask, data);
 441        if (ret < 0)
 442                goto out;
 443
 444        /* mask all IRQs */
 445        memset(status_buf, 0, INT_STATUS_NUM);
 446        ret = pm860x_bulk_write(i2c, PM8607_INT_MASK_1,
 447                                INT_STATUS_NUM, status_buf);
 448        if (ret < 0)
 449                goto out;
 450
 451        if (chip->irq_mode) {
 452                /* clear interrupt status by write */
 453                memset(status_buf, 0xFF, INT_STATUS_NUM);
 454                ret = pm860x_bulk_write(i2c, PM8607_INT_STATUS1,
 455                                        INT_STATUS_NUM, status_buf);
 456        } else {
 457                /* clear interrupt status by read */
 458                ret = pm860x_bulk_read(i2c, PM8607_INT_STATUS1,
 459                                        INT_STATUS_NUM, status_buf);
 460        }
 461        if (ret < 0)
 462                goto out;
 463
 464        mutex_init(&chip->irq_lock);
 465        chip->irq_base = pdata->irq_base;
 466        chip->core_irq = i2c->irq;
 467        if (!chip->core_irq)
 468                goto out;
 469
 470        /* register IRQ by genirq */
 471        for (i = 0; i < ARRAY_SIZE(pm860x_irqs); i++) {
 472                __irq = i + chip->irq_base;
 473                irq_set_chip_data(__irq, chip);
 474                irq_set_chip_and_handler(__irq, &pm860x_irq_chip,
 475                                         handle_edge_irq);
 476                irq_set_nested_thread(__irq, 1);
 477#ifdef CONFIG_ARM
 478                set_irq_flags(__irq, IRQF_VALID);
 479#else
 480                irq_set_noprobe(__irq);
 481#endif
 482        }
 483
 484        ret = request_threaded_irq(chip->core_irq, NULL, pm860x_irq, flags,
 485                                   "88pm860x", chip);
 486        if (ret) {
 487                dev_err(chip->dev, "Failed to request IRQ: %d\n", ret);
 488                chip->core_irq = 0;
 489        }
 490
 491        return 0;
 492out:
 493        chip->core_irq = 0;
 494        return ret;
 495}
 496
 497static void device_irq_exit(struct pm860x_chip *chip)
 498{
 499        if (chip->core_irq)
 500                free_irq(chip->core_irq, chip);
 501}
 502
 503static void __devinit device_bk_init(struct pm860x_chip *chip,
 504                                     struct i2c_client *i2c,
 505                                     struct pm860x_platform_data *pdata)
 506{
 507        int ret;
 508        int i, j, id;
 509
 510        if ((pdata == NULL) || (pdata->backlight == NULL))
 511                return;
 512
 513        if (pdata->num_backlights > ARRAY_SIZE(bk_devs))
 514                pdata->num_backlights = ARRAY_SIZE(bk_devs);
 515
 516        for (i = 0; i < pdata->num_backlights; i++) {
 517                memcpy(&bk_pdata[i], &pdata->backlight[i],
 518                        sizeof(struct pm860x_backlight_pdata));
 519                bk_devs[i].mfd_data = &bk_pdata[i];
 520
 521                for (j = 0; j < ARRAY_SIZE(bk_devs); j++) {
 522                        id = bk_resources[j].start;
 523                        if (bk_pdata[i].flags != id)
 524                                continue;
 525
 526                        bk_devs[i].num_resources = 1;
 527                        bk_devs[i].resources = &bk_resources[j];
 528                        ret = mfd_add_devices(chip->dev, 0,
 529                                              &bk_devs[i], 1,
 530                                              &bk_resources[j], 0);
 531                        if (ret < 0) {
 532                                dev_err(chip->dev, "Failed to add "
 533                                        "backlight subdev\n");
 534                                return;
 535                        }
 536                }
 537        }
 538}
 539
 540static void __devinit device_led_init(struct pm860x_chip *chip,
 541                                      struct i2c_client *i2c,
 542                                      struct pm860x_platform_data *pdata)
 543{
 544        int ret;
 545        int i, j, id;
 546
 547        if ((pdata == NULL) || (pdata->led == NULL))
 548                return;
 549
 550        if (pdata->num_leds > ARRAY_SIZE(led_devs))
 551                pdata->num_leds = ARRAY_SIZE(led_devs);
 552
 553        for (i = 0; i < pdata->num_leds; i++) {
 554                memcpy(&led_pdata[i], &pdata->led[i],
 555                        sizeof(struct pm860x_led_pdata));
 556                led_devs[i].mfd_data = &led_pdata[i];
 557
 558                for (j = 0; j < ARRAY_SIZE(led_devs); j++) {
 559                        id = led_resources[j].start;
 560                        if (led_pdata[i].flags != id)
 561                                continue;
 562
 563                        led_devs[i].num_resources = 1;
 564                        led_devs[i].resources = &led_resources[j],
 565                        ret = mfd_add_devices(chip->dev, 0,
 566                                              &led_devs[i], 1,
 567                                              &led_resources[j], 0);
 568                        if (ret < 0) {
 569                                dev_err(chip->dev, "Failed to add "
 570                                        "led subdev\n");
 571                                return;
 572                        }
 573                }
 574        }
 575}
 576
 577static void __devinit device_regulator_init(struct pm860x_chip *chip,
 578                                            struct i2c_client *i2c,
 579                                            struct pm860x_platform_data *pdata)
 580{
 581        struct regulator_init_data *initdata;
 582        int ret;
 583        int i, j;
 584
 585        if ((pdata == NULL) || (pdata->regulator == NULL))
 586                return;
 587
 588        if (pdata->num_regulators > ARRAY_SIZE(regulator_devs))
 589                pdata->num_regulators = ARRAY_SIZE(regulator_devs);
 590
 591        for (i = 0, j = -1; i < pdata->num_regulators; i++) {
 592                initdata = &pdata->regulator[i];
 593                if (strstr(initdata->constraints.name, "BUCK")) {
 594                        sscanf(initdata->constraints.name, "BUCK%d", &j);
 595                        /* BUCK1 ~ BUCK3 */
 596                        if ((j < 1) || (j > 3)) {
 597                                dev_err(chip->dev, "Failed to add constraint "
 598                                        "(%s)\n", initdata->constraints.name);
 599                                goto out;
 600                        }
 601                        j = (j - 1) + PM8607_ID_BUCK1;
 602                }
 603                if (strstr(initdata->constraints.name, "LDO")) {
 604                        sscanf(initdata->constraints.name, "LDO%d", &j);
 605                        /* LDO1 ~ LDO15 */
 606                        if ((j < 1) || (j > 15)) {
 607                                dev_err(chip->dev, "Failed to add constraint "
 608                                        "(%s)\n", initdata->constraints.name);
 609                                goto out;
 610                        }
 611                        j = (j - 1) + PM8607_ID_LDO1;
 612                }
 613                if (j == -1) {
 614                        dev_err(chip->dev, "Failed to add constraint (%s)\n",
 615                                initdata->constraints.name);
 616                        goto out;
 617                }
 618                memcpy(&regulator_pdata[i], &pdata->regulator[i],
 619                        sizeof(struct regulator_init_data));
 620                regulator_devs[i].mfd_data = &regulator_pdata[i];
 621                regulator_devs[i].num_resources = 1;
 622                regulator_devs[i].resources = &regulator_resources[j];
 623
 624                ret = mfd_add_devices(chip->dev, 0, &regulator_devs[i], 1,
 625                                      &regulator_resources[j], 0);
 626                if (ret < 0) {
 627                        dev_err(chip->dev, "Failed to add regulator subdev\n");
 628                        goto out;
 629                }
 630        }
 631out:
 632        return;
 633}
 634
 635static void __devinit device_touch_init(struct pm860x_chip *chip,
 636                                        struct i2c_client *i2c,
 637                                        struct pm860x_platform_data *pdata)
 638{
 639        int ret;
 640
 641        if ((pdata == NULL) || (pdata->touch == NULL))
 642                return;
 643
 644        memcpy(&touch_pdata, pdata->touch, sizeof(struct pm860x_touch_pdata));
 645        touch_devs[0].mfd_data = &touch_pdata;
 646        touch_devs[0].num_resources = ARRAY_SIZE(touch_resources);
 647        touch_devs[0].resources = &touch_resources[0];
 648        ret = mfd_add_devices(chip->dev, 0, &touch_devs[0],
 649                              ARRAY_SIZE(touch_devs), &touch_resources[0],
 650                              chip->irq_base);
 651        if (ret < 0)
 652                dev_err(chip->dev, "Failed to add touch subdev\n");
 653}
 654
 655static void __devinit device_power_init(struct pm860x_chip *chip,
 656                                        struct i2c_client *i2c,
 657                                        struct pm860x_platform_data *pdata)
 658{
 659        int ret;
 660
 661        if ((pdata == NULL) || (pdata->power == NULL))
 662                return;
 663
 664        memcpy(&power_pdata, pdata->power, sizeof(struct pm860x_power_pdata));
 665        power_devs[0].mfd_data = &power_pdata;
 666        power_devs[0].num_resources = ARRAY_SIZE(battery_resources);
 667        power_devs[0].resources = &battery_resources[0],
 668        ret = mfd_add_devices(chip->dev, 0, &power_devs[0], 1,
 669                              &battery_resources[0], chip->irq_base);
 670        if (ret < 0)
 671                dev_err(chip->dev, "Failed to add battery subdev\n");
 672
 673        power_devs[1].mfd_data = &power_pdata;
 674        power_devs[1].num_resources = ARRAY_SIZE(charger_resources);
 675        power_devs[1].resources = &charger_resources[0],
 676        ret = mfd_add_devices(chip->dev, 0, &power_devs[1], 1,
 677                              &charger_resources[0], chip->irq_base);
 678        if (ret < 0)
 679                dev_err(chip->dev, "Failed to add charger subdev\n");
 680}
 681
 682static void __devinit device_onkey_init(struct pm860x_chip *chip,
 683                                        struct i2c_client *i2c,
 684                                        struct pm860x_platform_data *pdata)
 685{
 686        int ret;
 687
 688        onkey_devs[0].num_resources = ARRAY_SIZE(onkey_resources);
 689        onkey_devs[0].resources = &onkey_resources[0],
 690        ret = mfd_add_devices(chip->dev, 0, &onkey_devs[0],
 691                              ARRAY_SIZE(onkey_devs), &onkey_resources[0],
 692                              chip->irq_base);
 693        if (ret < 0)
 694                dev_err(chip->dev, "Failed to add onkey subdev\n");
 695}
 696
 697static void __devinit device_codec_init(struct pm860x_chip *chip,
 698                                        struct i2c_client *i2c,
 699                                        struct pm860x_platform_data *pdata)
 700{
 701        int ret;
 702
 703        codec_devs[0].num_resources = ARRAY_SIZE(codec_resources);
 704        codec_devs[0].resources = &codec_resources[0],
 705        ret = mfd_add_devices(chip->dev, 0, &codec_devs[0],
 706                              ARRAY_SIZE(codec_devs), &codec_resources[0], 0);
 707        if (ret < 0)
 708                dev_err(chip->dev, "Failed to add codec subdev\n");
 709}
 710
 711static void __devinit device_8607_init(struct pm860x_chip *chip,
 712                                       struct i2c_client *i2c,
 713                                       struct pm860x_platform_data *pdata)
 714{
 715        int data, ret;
 716
 717        ret = pm860x_reg_read(i2c, PM8607_CHIP_ID);
 718        if (ret < 0) {
 719                dev_err(chip->dev, "Failed to read CHIP ID: %d\n", ret);
 720                goto out;
 721        }
 722        switch (ret & PM8607_VERSION_MASK) {
 723        case 0x40:
 724        case 0x50:
 725                dev_info(chip->dev, "Marvell 88PM8607 (ID: %02x) detected\n",
 726                         ret);
 727                break;
 728        default:
 729                dev_err(chip->dev, "Failed to detect Marvell 88PM8607. "
 730                        "Chip ID: %02x\n", ret);
 731                goto out;
 732        }
 733
 734        ret = pm860x_reg_read(i2c, PM8607_BUCK3);
 735        if (ret < 0) {
 736                dev_err(chip->dev, "Failed to read BUCK3 register: %d\n", ret);
 737                goto out;
 738        }
 739        if (ret & PM8607_BUCK3_DOUBLE)
 740                chip->buck3_double = 1;
 741
 742        ret = pm860x_reg_read(i2c, PM8607_B0_MISC1);
 743        if (ret < 0) {
 744                dev_err(chip->dev, "Failed to read MISC1 register: %d\n", ret);
 745                goto out;
 746        }
 747
 748        if (pdata && (pdata->i2c_port == PI2C_PORT))
 749                data = PM8607_B0_MISC1_PI2C;
 750        else
 751                data = 0;
 752        ret = pm860x_set_bits(i2c, PM8607_B0_MISC1, PM8607_B0_MISC1_PI2C, data);
 753        if (ret < 0) {
 754                dev_err(chip->dev, "Failed to access MISC1:%d\n", ret);
 755                goto out;
 756        }
 757
 758        ret = device_gpadc_init(chip, pdata);
 759        if (ret < 0)
 760                goto out;
 761
 762        ret = device_irq_init(chip, pdata);
 763        if (ret < 0)
 764                goto out;
 765
 766        device_regulator_init(chip, i2c, pdata);
 767        device_onkey_init(chip, i2c, pdata);
 768        device_touch_init(chip, i2c, pdata);
 769        device_power_init(chip, i2c, pdata);
 770        device_codec_init(chip, i2c, pdata);
 771out:
 772        return;
 773}
 774
 775int __devinit pm860x_device_init(struct pm860x_chip *chip,
 776                       struct pm860x_platform_data *pdata)
 777{
 778        chip->core_irq = 0;
 779
 780        switch (chip->id) {
 781        case CHIP_PM8606:
 782                device_bk_init(chip, chip->client, pdata);
 783                device_led_init(chip, chip->client, pdata);
 784                break;
 785        case CHIP_PM8607:
 786                device_8607_init(chip, chip->client, pdata);
 787                break;
 788        }
 789
 790        if (chip->companion) {
 791                switch (chip->id) {
 792                case CHIP_PM8607:
 793                        device_bk_init(chip, chip->companion, pdata);
 794                        device_led_init(chip, chip->companion, pdata);
 795                        break;
 796                case CHIP_PM8606:
 797                        device_8607_init(chip, chip->companion, pdata);
 798                        break;
 799                }
 800        }
 801
 802        return 0;
 803}
 804
 805void __devexit pm860x_device_exit(struct pm860x_chip *chip)
 806{
 807        device_irq_exit(chip);
 808        mfd_remove_devices(chip->dev);
 809}
 810
 811MODULE_DESCRIPTION("PMIC Driver for Marvell 88PM860x");
 812MODULE_AUTHOR("Haojian Zhuang <haojian.zhuang@marvell.com>");
 813MODULE_LICENSE("GPL");
 814