[PATCH V1] regulator: DA9211 : new regulator driver

From: James Ban
Date: Mon May 12 2014 - 23:16:58 EST

This is the driver for the Dialog DA9211 Multi-phase 12A DC-DC Buck
Converter regulator. It communicates via an I2C bus to the device.

Signed-off-by: James Ban <james.ban.opensource@xxxxxxxxxxx>
---

This patch is relative to linux-next repository tag next-20140509

drivers/regulator/Kconfig | 10 +
drivers/regulator/Makefile | 1 +
drivers/regulator/da9211-regulator.c | 922 +++++++++++++++++++++++++++++++++++
drivers/regulator/da9211-regulator.h | 271 ++++++++++
include/linux/regulator/da9211.h | 81 +++
5 files changed, 1285 insertions(+)
create mode 100644 drivers/regulator/da9211-regulator.c
create mode 100644 drivers/regulator/da9211-regulator.h
create mode 100644 include/linux/regulator/da9211.h

diff --git a/drivers/regulator/Kconfig b/drivers/regulator/Kconfig
index b4f57a4..3b0c28d 100644
--- a/drivers/regulator/Kconfig
+++ b/drivers/regulator/Kconfig
@@ -198,6 +198,16 @@ config REGULATOR_DA9210
converter 12A DC-DC Buck controlled through an I2C
interface.

+config REGULATOR_DA9211
+ tristate "Dialog Semiconductor DA9211/DA9212 regulator"
+ depends on I2C
+ select REGMAP_I2C
+ help
+ Say y here to support for the Dialog Semiconductor DA9211/DA9212.
+ The DA9211/DA9212 is a multi-phase synchronous step down
+ converter 12A DC-DC Buck controlled through an I2C
+ interface.
+
config REGULATOR_DBX500_PRCMU
bool

diff --git a/drivers/regulator/Makefile b/drivers/regulator/Makefile
index c14696b2..8c0c0e3 100644
--- a/drivers/regulator/Makefile
+++ b/drivers/regulator/Makefile
@@ -27,6 +27,7 @@ obj-$(CONFIG_REGULATOR_DA9052) += da9052-regulator.o
obj-$(CONFIG_REGULATOR_DA9055) += da9055-regulator.o
obj-$(CONFIG_REGULATOR_DA9063) += da9063-regulator.o
obj-$(CONFIG_REGULATOR_DA9210) += da9210-regulator.o
+obj-$(CONFIG_REGULATOR_DA9211) += da9211-regulator.o
obj-$(CONFIG_REGULATOR_DBX500_PRCMU) += dbx500-prcmu.o
obj-$(CONFIG_REGULATOR_DB8500_PRCMU) += db8500-prcmu.o
obj-$(CONFIG_REGULATOR_FAN53555) += fan53555.o
diff --git a/drivers/regulator/da9211-regulator.c b/drivers/regulator/da9211-regulator.c
new file mode 100644
index 0000000..04a97f9
--- /dev/null
+++ b/drivers/regulator/da9211-regulator.c
@@ -0,0 +1,922 @@
+/*
+ * da9211-regulator.c - Regulator device driver for DA9211
+ * Copyright (C) 2014 Dialog Semiconductor Ltd.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ */
+
+#include <linux/err.h>
+#include <linux/gpio.h>
+#include <linux/i2c.h>
+#include <linux/module.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/regulator/driver.h>
+#include <linux/regulator/machine.h>
+#include <linux/regmap.h>
+#include <linux/irq.h>
+#include <linux/interrupt.h>
+#include <linux/regulator/da9211.h>
+#include "da9211-regulator.h"
+
+#define DA9211_BUCK_MODE_SLEEP 1
+#define DA9211_BUCK_MODE_SYNC 2
+#define DA9211_BUCK_MODE_AUTO 3
+
+/* DA9211 REGULATOR IDs */
+#define DA9211_ID_BUCKA 0
+#define DA9211_ID_BUCKB 1
+
+struct da9211_conf_reg {
+ int reg;
+ int sel_mask;
+};
+
+struct da9211_volt_reg {
+ int reg_a;
+ int reg_b;
+ int v_mask;
+};
+
+struct da9211_mode_reg {
+ int reg;
+ int mask;
+ int shift;
+};
+
+struct da9211_regulator_info {
+ struct regulator_desc reg_desc;
+ struct da9211_conf_reg conf;
+ struct da9211_volt_reg volt;
+ struct da9211_mode_reg mode;
+ int current_shift;
+};
+
+/* Number of IRQ and IRQ offset */
+enum {
+ DA9211_INT_OFFSET_1 = 0,
+ DA9211_INT_OFFSET_2,
+ DA9211_NUM_IRQ_EVT_REGS
+};
+
+struct da9211_irq {
+ irq_handler_t handler;
+ void *data;
+};
+
+struct da9211 {
+ struct device *dev;
+ struct regmap *regmap;
+ struct da9211_pdata *pdata;
+ struct da9211_regulator_info *info;
+ struct regulator_dev *rdev[DA9211_MAX_REGULATORS];
+ int num_regulator;
+ /* Interrupt handling */
+ struct work_struct irq_work;
+ struct task_struct *irq_task;
+ struct mutex irq_mutex; /* IRQ table mutex */
+ struct da9211_irq irq[DA9211_NUM_IRQ];
+ int chip_irq;
+};
+
+struct da9211_regulator {
+ struct da9211 *da9211;
+ struct da9211_regulator_info *info;
+ struct regulator_dev *rdev;
+ enum da9211_gpio_rsel_select reg_rselect;
+};
+
+static const struct regmap_config da9211_regmap_config = {
+ .reg_bits = 8,
+ .val_bits = 8,
+};
+
+/* Default limits measured in millivolts and milliamps */
+#define DA9211_MIN_MV 300
+#define DA9211_MAX_MV 1570
+#define DA9211_STEP_MV 10
+
+/* Current limits for buck (uA) indices corresponds with register values */
+static const int da9211_current_limits[] = {
+ 2000000, 2200000, 2400000, 2600000, 2800000, 3000000, 3200000, 3400000,
+ 3600000, 3800000, 4000000, 4200000, 4400000, 4600000, 4800000, 5000000
+};
+
+/* struct of IRQ's register and mask */
+struct da9211_irq_data {
+ int reg_offset;
+ int mask;
+};
+
+static struct da9211_irq_data da9211_irqs[] = {
+ [DA9211_IRQ_EGPI0] = {
+ .reg_offset = DA9211_INT_OFFSET_1,
+ .mask = DA9211_M_GPI0,
+ },
+ [DA9211_IRQ_EGPI1] = {
+ .reg_offset = DA9211_INT_OFFSET_1,
+ .mask = DA9211_M_GPI1,
+ },
+ [DA9211_IRQ_EGPI2] = {
+ .reg_offset = DA9211_INT_OFFSET_1,
+ .mask = DA9211_M_GPI2,
+ },
+ [DA9211_IRQ_EGPI3] = {
+ .reg_offset = DA9211_INT_OFFSET_1,
+ .mask = DA9211_M_GPI3,
+ },
+ [DA9211_IRQ_EGPI4] = {
+ .reg_offset = DA9211_INT_OFFSET_1,
+ .mask = DA9211_M_GPI4,
+ },
+ [DA9211_IRQ_EUVLO_IO] = {
+ .reg_offset = DA9211_INT_OFFSET_1,
+ .mask = DA9211_M_UVLO_IO,
+ },
+ [DA9211_IRQ_EPWRGOOD_A] = {
+ .reg_offset = DA9211_INT_OFFSET_2,
+ .mask = DA9211_M_PWRGOOD_A,
+ },
+ [DA9211_IRQ_EPWRGOOD_B] = {
+ .reg_offset = DA9211_INT_OFFSET_2,
+ .mask = DA9211_M_PWRGOOD_B,
+ },
+ [DA9211_IRQ_ETEMP_WARN] = {
+ .reg_offset = DA9211_INT_OFFSET_2,
+ .mask = DA9211_M_TEMP_WARN,
+ },
+ [DA9211_IRQ_ETEMP_CRIT] = {
+ .reg_offset = DA9211_INT_OFFSET_2,
+ .mask = DA9211_M_TEMP_CRIT,
+ },
+ [DA9211_IRQ_EOV_CURR_A] = {
+ .reg_offset = DA9211_INT_OFFSET_2,
+ .mask = DA9211_M_OV_CURR_A,
+ },
+ [DA9211_IRQ_EOV_CURR_B] = {
+ .reg_offset = DA9211_INT_OFFSET_2,
+ .mask = DA9211_M_OV_CURR_B,
+ },
+};
+
+static unsigned int da9211_buck_get_mode(struct regulator_dev *rdev)
+{
+ struct da9211_regulator *regulator = rdev_get_drvdata(rdev);
+ struct da9211_regulator_info *info = regulator->info;
+ struct da9211 *chip = regulator->da9211;
+ unsigned int data;
+ int ret, mode = 0;
+
+ ret = regmap_read(chip->regmap, info->mode.reg, &data);
+
+ if (ret < 0)
+ return ret;
+
+ switch ((data & info->mode.mask) >> info->mode.shift) {
+ case DA9211_BUCK_MODE_SYNC:
+ mode = REGULATOR_MODE_FAST;
+ break;
+ case DA9211_BUCK_MODE_AUTO:
+ mode = REGULATOR_MODE_NORMAL;
+ break;
+ case DA9211_BUCK_MODE_SLEEP:
+ mode = REGULATOR_MODE_STANDBY;
+ break;
+ }
+
+ return mode;
+}
+
+static int da9211_buck_set_mode(struct regulator_dev *rdev,
+ unsigned int mode)
+{
+ struct da9211_regulator *regulator = rdev_get_drvdata(rdev);
+ struct da9211_regulator_info *info = regulator->info;
+ struct da9211 *chip = regulator->da9211;
+ int val = 0;
+
+ switch (mode) {
+ case REGULATOR_MODE_FAST:
+ val = DA9211_BUCK_MODE_SYNC << info->mode.shift;
+ break;
+ case REGULATOR_MODE_NORMAL:
+ val = DA9211_BUCK_MODE_AUTO << info->mode.shift;
+ break;
+ case REGULATOR_MODE_STANDBY:
+ val = DA9211_BUCK_MODE_SLEEP << info->mode.shift;
+ break;
+ }
+
+ return regmap_update_bits(chip->regmap, info->mode.reg,
+ info->mode.mask, val);
+}
+
+static int da9211_set_current_limit(struct regulator_dev *rdev, int min,
+ int max)
+{
+ struct da9211_regulator *regulator = rdev_get_drvdata(rdev);
+ struct da9211_regulator_info *info = regulator->info;
+ struct da9211 *chip = regulator->da9211;
+ int i;
+
+ /* search for closest to maximum */
+ for (i = ARRAY_SIZE(da9211_current_limits)-1; i >= 0; i--) {
+ if (min <= da9211_current_limits[i] &&
+ max >= da9211_current_limits[i]) {
+ return regmap_update_bits(chip->regmap,
+ DA9211_REG_BUCK_ILIM,
+ (0x0F << info->current_shift), i);
+ }
+ }
+
+ return -EINVAL;
+}
+
+static int da9211_regulator_enable(struct regulator_dev *rdev)
+{
+ struct da9211_regulator *regulator = rdev_get_drvdata(rdev);
+ struct da9211_regulator_info *info = regulator->info;
+ struct da9211 *chip = regulator->da9211;
+ int ret;
+
+ /* Make sure to exit from suspend mode on enable */
+ if (regulator->reg_rselect == DA9211_RSEL_NO_GPIO) {
+ ret = regmap_update_bits(chip->regmap, info->conf.reg,
+ info->conf.sel_mask,
+ DA9211_VBUCKA_SEL_A);
+ if (ret < 0)
+ return ret;
+ }
+
+ return regulator_enable_regmap(rdev);
+}
+
+static int da9211_get_current_limit(struct regulator_dev *rdev)
+{
+ struct da9211_regulator *regulator = rdev_get_drvdata(rdev);
+ struct da9211_regulator_info *info = regulator->info;
+ struct da9211 *chip = regulator->da9211;
+ unsigned int data;
+ int ret;
+
+ ret = regmap_read(chip->regmap, DA9211_REG_BUCK_ILIM, &data);
+ if (ret < 0)
+ return ret;
+
+ /* select one of 16 values: 0000 (2000mA) to 1111 (5000mA) */
+ data = (data >> info->current_shift) & 0x0F;
+ return da9211_current_limits[data];
+}
+
+static int da9211_regulator_get_voltage_sel(struct regulator_dev *rdev)
+{
+ struct da9211_regulator *regulator = rdev_get_drvdata(rdev);
+ struct da9211_regulator_info *info = regulator->info;
+ struct da9211 *chip = regulator->da9211;
+ struct da9211_volt_reg volt = info->volt;
+ unsigned int data;
+ int ret, sel;
+
+ /*
+ * There are two voltage register set A & B for voltage ramping but
+ * either one of then can be active therefore we first determine
+ * the active register set.
+ */
+ ret = regmap_read(chip->regmap, info->conf.reg, &data);
+ if (ret < 0)
+ return ret;
+
+ data &= info->conf.sel_mask;
+
+ /* Get the voltage for the active register set A/B */
+ if (data == DA9211_VBUCKA_SEL_A)
+ ret = regmap_read(chip->regmap, volt.reg_a, &data);
+ else
+ ret = regmap_read(chip->regmap, volt.reg_b, &data);
+
+ if (ret < 0)
+ return ret;
+
+ sel = (data & volt.v_mask);
+ return sel;
+}
+
+static int da9211_regulator_set_voltage_sel(struct regulator_dev *rdev,
+ unsigned int selector)
+{
+ struct da9211_regulator *regulator = rdev_get_drvdata(rdev);
+ struct da9211_regulator_info *info = regulator->info;
+ struct da9211 *chip = regulator->da9211;
+ unsigned int data;
+ int ret;
+
+ /*
+ * Regulator register set A/B is not selected through GPIO therefore
+ * we use default register set A for voltage ramping.
+ */
+ if (regulator->reg_rselect == DA9211_RSEL_NO_GPIO) {
+ /* Select register set A */
+ ret = regmap_update_bits(chip->regmap, info->conf.reg,
+ info->conf.sel_mask,
+ DA9211_VBUCKA_SEL_A);
+ if (ret < 0)
+ return ret;
+
+ /* Set the voltage */
+ return regmap_update_bits(chip->regmap, info->volt.reg_a,
+ info->volt.v_mask, selector);
+ }
+
+ /*
+ * Here regulator register set A/B is selected through GPIO.
+ * Therefore we first determine the selected register set A/B and
+ * then set the desired voltage for that register set A/B.
+ */
+ ret = regmap_read(chip->regmap, info->conf.reg, &data);
+ if (ret < 0)
+ return ret;
+
+ data &= info->conf.sel_mask;
+
+ /* Set the voltage */
+ if (data == DA9211_VBUCKA_SEL_A)
+ return regmap_update_bits(chip->regmap, info->volt.reg_a,
+ info->volt.v_mask, selector);
+ else
+ return regmap_update_bits(chip->regmap, info->volt.reg_b,
+ info->volt.v_mask, selector);
+}
+
+static int da9211_regulator_set_suspend_voltage(struct regulator_dev *rdev,
+ int uV)
+{
+ struct da9211_regulator *regulator = rdev_get_drvdata(rdev);
+ struct da9211_regulator_info *info = regulator->info;
+ struct da9211 *chip = regulator->da9211;
+ int ret;
+
+ /* Select register set B for suspend voltage ramping. */
+ if (regulator->reg_rselect == DA9211_RSEL_NO_GPIO) {
+ ret = regmap_update_bits(chip->regmap, info->conf.reg,
+ info->conf.sel_mask,
+ DA9211_VBUCKA_SEL_B);
+ if (ret < 0)
+ return ret;
+ }
+
+ ret = regulator_map_voltage_linear(rdev, uV, uV);
+ if (ret < 0)
+ return ret;
+
+ return regmap_update_bits(chip->regmap, info->volt.reg_b,
+ info->volt.v_mask, ret);
+}
+
+static int da9211_suspend_enable(struct regulator_dev *rdev)
+{
+ struct da9211_regulator *regulator = rdev_get_drvdata(rdev);
+ struct da9211_regulator_info *info = regulator->info;
+ struct da9211 *chip = regulator->da9211;
+
+ /* Select register set B for voltage ramping. */
+ if (regulator->reg_rselect == DA9211_RSEL_NO_GPIO)
+ return regmap_update_bits(chip->regmap, info->conf.reg,
+ info->conf.sel_mask,
+ DA9211_VBUCKA_SEL_B);
+ else
+ return 0;
+}
+
+static int da9211_suspend_disable(struct regulator_dev *rdev)
+{
+ struct da9211_regulator *regulator = rdev_get_drvdata(rdev);
+ struct da9211_regulator_info *info = regulator->info;
+ struct da9211 *chip = regulator->da9211;
+
+ /* Diselect register set B. */
+ if (regulator->reg_rselect == DA9211_RSEL_NO_GPIO)
+ return regmap_update_bits(chip->regmap, info->conf.reg,
+ info->conf.sel_mask,
+ DA9211_VBUCKA_SEL_A);
+ else
+ return 0;
+}
+
+static struct regulator_ops da9211_buck_ops = {
+ .get_mode = da9211_buck_get_mode,
+ .set_mode = da9211_buck_set_mode,
+ .enable = da9211_regulator_enable,
+ .disable = regulator_disable_regmap,
+ .is_enabled = regulator_is_enabled_regmap,
+ .map_voltage = regulator_map_voltage_linear,
+ .set_voltage_sel = da9211_regulator_set_voltage_sel,
+ .get_voltage_sel = da9211_regulator_get_voltage_sel,
+ .list_voltage = regulator_list_voltage_linear,
+ .set_current_limit = da9211_set_current_limit,
+ .get_current_limit = da9211_get_current_limit,
+ .set_suspend_voltage = da9211_regulator_set_suspend_voltage,
+ .set_suspend_enable = da9211_suspend_enable,
+ .set_suspend_disable = da9211_suspend_disable,
+ .set_suspend_mode = da9211_buck_set_mode,
+};
+
+#define DA9211_BUCK(_id, step, min, max, vbits, voffset, cshift, oc_irq) \
+{\
+ .reg_desc = {\
+ .name = #_id,\
+ .ops = &da9211_buck_ops,\
+ .irq = oc_irq, \
+ .type = REGULATOR_VOLTAGE,\
+ .id = DA9211_ID_##_id,\
+ .n_voltages = (max - min) / step + 1 + (voffset), \
+ .enable_reg = DA9211_REG_BUCKA_CONT + DA9211_ID_##_id, \
+ .enable_mask = 1,\
+ .min_uV = (min) * 1000,\
+ .uV_step = (step) * 1000,\
+ .linear_min_sel = (voffset),\
+ .owner = THIS_MODULE,\
+ },\
+ .conf = {\
+ .reg = DA9211_REG_BUCKA_CONT + DA9211_ID_##_id, \
+ .sel_mask = (1 << 4),\
+ },\
+ .volt = {\
+ .reg_a = DA9211_REG_VBUCKA_A + DA9211_ID_##_id * 2, \
+ .reg_b = DA9211_REG_VBUCKA_B + DA9211_ID_##_id * 2, \
+ .v_mask = (1 << (vbits)) - 1,\
+ },\
+ .mode = {\
+ .reg = DA9211_REG_BUCKA_CONF + DA9211_ID_##_id,\
+ .mask = 3,\
+ .shift = 0,\
+ },\
+ .current_shift = cshift,\
+}
+
+static struct da9211_regulator_info da9211_regulator_info[] = {
+ DA9211_BUCK(BUCKA, DA9211_STEP_MV, DA9211_MIN_MV, DA9211_MAX_MV, 7, 0,
+ 0, DA9211_IRQ_EOV_CURR_A),
+ DA9211_BUCK(BUCKB, DA9211_STEP_MV, DA9211_MIN_MV, DA9211_MAX_MV, 7, 0,
+ 4, DA9211_IRQ_EOV_CURR_B),
+};
+
+/*
+ * Configures regulator to be controlled either through GPIO 0, 1 or 3.
+ * GPIO can control regulator state and/or select the regulator register
+ * set A/B for voltage ramping.
+ */
+static int da9211_gpio_init(struct da9211_regulator *regulator,
+ struct regulator_config *config,
+ struct da9211_pdata *pdata, int id)
+{
+ struct da9211 *chip = regulator->da9211;
+ int ret = 0;
+
+ if (pdata->buck_data[id].gpio_ren) {
+
+ config->ena_gpio = pdata->buck_data[id].gpio_ren;
+ config->ena_gpio_flags = pdata->buck_data[id].ena_init_state;
+ config->ena_gpio_invert = 0;
+
+ /*
+ * Let the regulator know that its state is controlled
+ * through GPI.
+ */
+ ret = regmap_update_bits(chip->regmap, DA9211_REG_BUCKA_CONT+id,
+ DA9211_BUCKA_GPI_MASK,
+ pdata->buck_data[id].reg_ren
+ << DA9211_BUCKA_GPI_SHIFT);
+ if (ret < 0)
+ goto err;
+ }
+
+ if (pdata->buck_data[id].gpio_rsel) {
+ char name[18];
+
+ regulator->reg_rselect = pdata->buck_data[id].reg_rsel;
+ /*
+ * GPI pin is muxed with regulator to select the
+ * regulator register set A/B for voltage ramping.
+ */
+ sprintf(name, "DA9211 RSEL %d", id);
+ ret = devm_gpio_request_one(config->dev,
+ pdata->buck_data[id].gpio_rsel,
+ GPIOF_OUT_INIT_LOW, name);
+ if (ret < 0)
+ goto err;
+
+ /*
+ * Let the regulator know that its register set A/B
+ * will be selected through GPI for voltage ramping.
+ */
+ ret = regmap_update_bits(chip->regmap,
+ DA9211_REG_BUCKA_CONT+id,
+ DA9211_VBUCKA_GPI_MASK,
+ pdata->buck_data[id].reg_rsel
+ << DA9211_VBUCKA_GPI_SHIFT);
+ }
+
+err:
+ return ret;
+}
+
+static inline struct da9211_regulator_info *find_regulator_info(int id)
+{
+ struct da9211_regulator_info *info;
+ int i;
+
+ for (i = 0; i < ARRAY_SIZE(da9211_regulator_info); i++) {
+ info = &da9211_regulator_info[i];
+ if (info->reg_desc.id == id)
+ return info;
+ }
+
+ return NULL;
+}
+
+int da9211_enable_irq(struct da9211 *chip, int irq)
+{
+ enable_irq(irq);
+
+ return 0;
+}
+EXPORT_SYMBOL_GPL(da9211_enable_irq);
+
+int da9211_disable_irq(struct da9211 *chip, int irq)
+{
+
+ disable_irq(irq);
+
+ return 0;
+}
+EXPORT_SYMBOL_GPL(da9211_disable_irq);
+
+int da9211_mask_irq(struct da9211 *chip, int irq)
+{
+ regmap_update_bits(chip->regmap, DA9211_REG_MASK_A
+ + da9211_irqs[irq].reg_offset, da9211_irqs[irq].mask, 1);
+ return 0;
+}
+EXPORT_SYMBOL_GPL(da9211_mask_irq);
+
+int da9211_unmask_irq(struct da9211 *chip, int irq)
+{
+ regmap_update_bits(chip->regmap, DA9211_REG_MASK_A
+ + da9211_irqs[irq].reg_offset, da9211_irqs[irq].mask, 0);
+ return 0;
+}
+EXPORT_SYMBOL_GPL(da9211_unmask_irq);
+
+static void da9211_irq_call_handler(struct da9211 *chip, int irq)
+{
+ mutex_lock(&chip->irq_mutex);
+
+ if (chip->irq[irq].handler)
+ chip->irq[irq].handler(irq, chip->irq[irq].data);
+ else
+ da9211_mask_irq(chip, irq);
+
+ mutex_unlock(&chip->irq_mutex);
+}
+
+static irqreturn_t da9211_irq(int irq, void *data)
+{
+ struct da9211 *chip = data;
+ int reg_val;
+ int sub_reg[DA9211_NUM_IRQ_EVT_REGS] = {0,};
+ int read_done[DA9211_NUM_IRQ_EVT_REGS];
+ struct da9211_irq_data *irq_data;
+ int i, ret;
+
+ memset(&read_done, 0, sizeof(read_done));
+
+ for (i = 0; i < ARRAY_SIZE(da9211_irqs); i++) {
+ irq_data = &da9211_irqs[i];
+
+ if (!read_done[irq_data->reg_offset]) {
+ ret = regmap_read(chip->regmap, DA9211_REG_EVENT_A
+ + irq_data->reg_offset, &reg_val);
+
+ if (ret < 0)
+ return ret;
+
+ sub_reg[irq_data->reg_offset] = reg_val;
+ ret = regmap_read(chip->regmap, DA9211_REG_MASK_A
+ + irq_data->reg_offset, &reg_val);
+
+ if (ret < 0)
+ return ret;
+
+ sub_reg[irq_data->reg_offset] &= ~reg_val;
+ read_done[irq_data->reg_offset] = 1;
+ }
+
+ if (sub_reg[irq_data->reg_offset] & irq_data->mask) {
+ da9211_irq_call_handler(chip, i);
+ /* Now clear EVENT registers */
+ ret = regmap_write(chip->regmap, DA9211_REG_EVENT_A
+ + irq_data->reg_offset, da9211_irqs[i].mask);
+
+ if (ret < 0)
+ return ret;
+ }
+ }
+ return IRQ_HANDLED;
+}
+
+int da9211_request_irq(struct da9211 *chip, int irq, char *name,
+ irq_handler_t handler, void *data)
+{
+ if (irq < 0 || irq >= DA9211_NUM_IRQ || !handler)
+ return -EINVAL;
+
+ if (chip->irq[irq].handler)
+ return -EBUSY;
+ mutex_lock(&chip->irq_mutex);
+ chip->irq[irq].handler = handler;
+ chip->irq[irq].data = data;
+ mutex_unlock(&chip->irq_mutex);
+
+ da9211_unmask_irq(chip, irq);
+ return 0;
+}
+EXPORT_SYMBOL_GPL(da9211_request_irq);
+
+void da9211_free_irq(struct da9211 *chip, int irq)
+{
+ if (irq < 0 || irq >= DA9211_NUM_IRQ)
+ return;
+
+ da9211_mask_irq(chip, irq);
+
+ mutex_lock(&chip->irq_mutex);
+ chip->irq[irq].handler = NULL;
+ mutex_unlock(&chip->irq_mutex);
+}
+EXPORT_SYMBOL_GPL(da9211_free_irq);
+
+int da9211_irq_exit(struct da9211 *chip)
+{
+ free_irq(chip->chip_irq, chip);
+
+ return 0;
+}
+
+static int da9211_irq_init(struct da9211 *chip)
+{
+ int ret = -EINVAL;
+
+ mutex_init(&chip->irq_mutex);
+
+ ret = regmap_write(chip->regmap, DA9211_REG_EVENT_A, 0xFF);
+ if (ret != 0) {
+ dev_err(chip->dev, "Failed to clear event A\n");
+ return ret;
+ }
+ ret = regmap_write(chip->regmap, DA9211_REG_EVENT_B, 0xFF);
+ if (ret != 0) {
+ dev_err(chip->dev, "Failed to clear event B\n");
+ return ret;
+ }
+ ret = request_threaded_irq(chip->chip_irq, NULL, da9211_irq,
+ IRQF_TRIGGER_LOW|IRQF_ONESHOT,
+ "da9211", chip);
+ if (ret != 0) {
+ dev_err(chip->dev, "Failed to request IRQ: %d\n",
+ chip->chip_irq);
+ return ret;
+ }
+ dev_info(chip->dev, "# IRQ configured [%d]\n", chip->chip_irq);
+
+ enable_irq_wake(chip->chip_irq);
+
+ return ret;
+}
+
+static irqreturn_t da9211_oc_handler(int irq, void *data)
+{
+ struct regulator_dev *rdev = (struct regulator_dev *)data;
+ struct da9211_regulator *regulator = rdev_get_drvdata(rdev);
+
+ regulator_notifier_call_chain(rdev, REGULATOR_EVENT_OVER_CURRENT,
+ regulator);
+
+ return IRQ_HANDLED;
+}
+
+static int da9211_regulator_init(struct da9211 *chip)
+{
+ struct regulator_config config = { };
+ struct da9211_regulator *regulator;
+ int i, ret;
+ unsigned int data;
+
+ ret = regmap_update_bits(chip->regmap, DA9211_REG_PAGE_CON,
+ DA9211_REG_PAGE_MASK, DA9211_REG_PAGE2);
+
+ if (ret < 0) {
+ dev_err(chip->dev, "Failed to update PAGE reg: %d\n", ret);
+ goto err;
+ }
+
+ ret = regmap_read(chip->regmap, DA9211_REG_CONTROL_E, &data);
+
+ if (ret < 0) {
+ ret = regmap_update_bits(chip->regmap, DA9211_REG_PAGE_CON,
+ DA9211_REG_PAGE_MASK, DA9211_REG_PAGE0);
+ ret = -EINVAL;
+ dev_err(chip->dev, "Failed to read CONTROL_E reg: %d\n", ret);
+ goto err;
+ }
+
+ data &= DA9211_SLAVE_SEL;
+ /* If configuration for 1/2 bucks is different between platform data
+ * and the register, driver should exit.
+ */
+ if ((chip->pdata->num_buck == 2 && data == 1)
+ || (chip->pdata->num_buck == 1 && data == 0)) {
+ if (data == 0)
+ chip->num_regulator = 1;
+ else
+ chip->num_regulator = 2;
+ } else {
+ ret = regmap_update_bits(chip->regmap, DA9211_REG_PAGE_CON,
+ DA9211_REG_PAGE_MASK, DA9211_REG_PAGE0);
+ ret = -EINVAL;
+ dev_err(chip->dev, "Configuration is mismatched\n");
+ goto err;
+ }
+
+ ret = regmap_update_bits(chip->regmap, DA9211_REG_PAGE_CON,
+ DA9211_REG_PAGE_MASK, DA9211_REG_PAGE0);
+
+ if (ret < 0) {
+ dev_err(chip->dev, "Failed to update PAGE reg: %d\n", ret);
+ goto err;
+ }
+
+ for (i = 0; i < chip->num_regulator; i++) {
+ regulator = devm_kzalloc(chip->dev,
+ sizeof(struct da9211_regulator),
+ GFP_KERNEL);
+ if (!regulator) {
+ ret = -ENOMEM;
+ goto err_regulator;
+ }
+
+ regulator->da9211 = chip;
+
+ regulator->info = find_regulator_info(i);
+ if (regulator->info == NULL) {
+ dev_err(chip->dev,
+ "Invalid regulator ID specified\n");
+ ret = -EINVAL;
+ goto err_regulator;
+ }
+
+ if (chip->pdata)
+ config.init_data =
+ chip->pdata->buck_data[i].constraints;
+
+ config.dev = chip->dev;
+ config.driver_data = regulator;
+ config.regmap = chip->regmap;
+
+ ret = da9211_gpio_init(regulator, &config, chip->pdata, i);
+
+ if (ret < 0)
+ goto err_regulator;
+
+ regulator->rdev = regulator_register(&regulator->info->reg_desc,
+ &config);
+ if (IS_ERR(regulator->rdev)) {
+ dev_err(chip->dev,
+ "Failed to register DA9211 regulator\n");
+ ret = PTR_ERR(regulator->rdev);
+ goto err_regulator;
+ }
+
+ chip->rdev[i] = regulator->rdev;
+
+ if (chip->irq > 0) {
+ ret = da9211_request_irq(chip,
+ da9211_regulator_info[i].reg_desc.irq, NULL,
+ da9211_oc_handler, regulator->rdev);
+ if (ret < 0) {
+ regulator_unregister(chip->rdev[i]);
+ dev_err(chip->dev,
+ "Failed to register OC irq\n");
+ goto err_irq;
+ }
+ }
+ }
+
+ return 0;
+
+err_irq:
+ i++;
+err_regulator:
+ while (--i >= 0)
+ regulator_unregister(chip->rdev[i]);
+err:
+ return ret;
+}
+/*
+ * I2C driver interface functions
+ */
+static int da9211_i2c_probe(struct i2c_client *i2c,
+ const struct i2c_device_id *id)
+{
+ struct da9211 *chip;
+ int error, ret;
+
+ chip = devm_kzalloc(&i2c->dev, sizeof(struct da9211), GFP_KERNEL);
+ if (NULL == chip) {
+ dev_err(&i2c->dev,
+ "Cannot kzalloc memory for regulator structure\n");
+ return -ENOMEM;
+ }
+
+ chip->dev = &i2c->dev;
+ chip->regmap = devm_regmap_init_i2c(i2c, &da9211_regmap_config);
+ if (IS_ERR(chip->regmap)) {
+ error = PTR_ERR(chip->regmap);
+ dev_err(&i2c->dev, "Failed to allocate register map: %d\n",
+ error);
+ return error;
+ }
+
+ i2c_set_clientdata(i2c, chip);
+
+ chip->pdata = i2c->dev.platform_data;
+
+ if (!chip->pdata) {
+ dev_err(&i2c->dev, "No platform init data supplied\n");
+ return -ENODEV;
+ }
+
+ chip->chip_irq = i2c->irq;
+
+ if (chip->chip_irq != 0) {
+ ret = da9211_irq_init(chip);
+ if (ret < 0) {
+ dev_err(&i2c->dev, "Failed to initialize irq: %d\n",
+ ret);
+ return ret;
+ }
+ } else {
+ dev_warn(chip->dev, "No IRQ configured\n");
+ }
+
+ ret = da9211_regulator_init(chip);
+
+ if (ret < 0)
+ dev_err(&i2c->dev, "Failed to initialize regulator: %d\n", ret);
+
+ return ret;
+}
+
+static int da9211_i2c_remove(struct i2c_client *i2c)
+{
+ struct da9211 *chip = i2c_get_clientdata(i2c);
+ int i;
+
+ for (i = 0; i < chip->num_regulator; i++)
+ regulator_unregister(chip->rdev[i]);
+
+ if (chip->irq != 0)
+ da9211_free_irq(chip, chip->chip_irq);
+
+ return 0;
+}
+
+static const struct i2c_device_id da9211_i2c_id[] = {
+ {"da9211", 0},
+ {},
+};
+
+MODULE_DEVICE_TABLE(i2c, da9211_i2c_id);
+
+static struct i2c_driver da9211_regulator_driver = {
+ .driver = {
+ .name = "da9211",
+ .owner = THIS_MODULE,
+ },
+ .probe = da9211_i2c_probe,
+ .remove = da9211_i2c_remove,
+ .id_table = da9211_i2c_id,
+};
+
+module_i2c_driver(da9211_regulator_driver);
+
+MODULE_AUTHOR("James Ban <James.Ban.opensource@xxxxxxxxxxx>");
+MODULE_DESCRIPTION("Regulator device driver for Dialog DA9211");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/regulator/da9211-regulator.h b/drivers/regulator/da9211-regulator.h
new file mode 100644
index 0000000..afba596
--- /dev/null
+++ b/drivers/regulator/da9211-regulator.h
@@ -0,0 +1,271 @@
+/*
+ * da9211-regulator.h - Regulator definitions for DA9211
+ * Copyright (C) 2014 Dialog Semiconductor Ltd.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ */
+
+#ifndef __DA9211_REGISTERS_H__
+#define __DA9211_REGISTERS_H__
+
+/* Page selection */
+#define DA9211_REG_PAGE_CON 0x00
+
+/* System Control and Event Registers */
+#define DA9211_REG_STATUS_A 0x50
+#define DA9211_REG_STATUS_B 0x51
+#define DA9211_REG_EVENT_A 0x52
+#define DA9211_REG_EVENT_B 0x53
+#define DA9211_REG_MASK_A 0x54
+#define DA9211_REG_MASK_B 0x55
+#define DA9211_REG_CONTROL_A 0x56
+
+/* GPIO Control Registers */
+#define DA9211_REG_GPIO_0_1 0x58
+#define DA9211_REG_GPIO_2_3 0x59
+#define DA9211_REG_GPIO_4 0x5A
+
+/* Regulator Registers */
+#define DA9211_REG_BUCKA_CONT 0x5D
+#define DA9211_REG_BUCKB_CONT 0x5E
+#define DA9211_REG_BUCK_ILIM 0xD0
+#define DA9211_REG_BUCKA_CONF 0xD1
+#define DA9211_REG_BUCKB_CONF 0xD2
+#define DA9211_REG_BUCK_CONF 0xD3
+#define DA9211_REG_VBACKA_MAX 0xD5
+#define DA9211_REG_VBACKB_MAX 0xD6
+#define DA9211_REG_VBUCKA_A 0xD7
+#define DA9211_REG_VBUCKA_B 0xD8
+#define DA9211_REG_VBUCKB_A 0xD9
+#define DA9211_REG_VBUCKB_B 0xDA
+
+/* I2C Interface Settings */
+#define DA9211_REG_INTERFACE (0x105 - 0x100)
+
+/* BUCK Phase Selection*/
+#define DA9211_REG_CONTROL_E (0x147 - 0x100)
+
+/*
+ * Registers bits
+ */
+/* DA9211_REG_PAGE_CON (addr=0x00) */
+#define DA9211_REG_PAGE_SHIFT 0
+#define DA9211_REG_PAGE_MASK 0x0F
+/* On I2C registers 0x00 - 0xFF */
+#define DA9211_REG_PAGE0 0
+/* On I2C registers 0x100 - 0x1FF */
+#define DA9211_REG_PAGE2 2
+#define DA9211_PAGE_WRITE_MODE 0x00
+#define DA9211_REPEAT_WRITE_MODE 0x40
+#define DA9211_PAGE_REVERT 0x80
+
+/* DA9211_REG_STATUS_A (addr=0x50) */
+#define DA9211_GPI0 0x01
+#define DA9211_GPI1 0x02
+#define DA9211_GPI2 0x04
+#define DA9211_GPI3 0x08
+#define DA9211_GPI4 0x10
+
+/* DA9211_REG_EVENT_A (addr=0x52) */
+#define DA9211_E_GPI0 0x01
+#define DA9211_E_GPI1 0x02
+#define DA9211_E_GPI2 0x04
+#define DA9211_E_GPI3 0x08
+#define DA9211_E_GPI4 0x10
+#define DA9211_E_UVLO_IO 0x40
+
+/* DA9211_REG_EVENT_B (addr=0x53) */
+#define DA9211_E_PWRGOOD_A 0x01
+#define DA9211_E_PWRGOOD_B 0x02
+#define DA9211_E_TEMP_WARN 0x04
+#define DA9211_E_TEMP_CRIT 0x08
+#define DA9211_E_OV_CURR_A 0x10
+#define DA9211_E_OV_CURR_B 0x20
+
+/* DA9211_REG_MASK_A (addr=0x54) */
+#define DA9211_M_GPI0 0x01
+#define DA9211_M_GPI1 0x02
+#define DA9211_M_GPI2 0x04
+#define DA9211_M_GPI3 0x08
+#define DA9211_M_GPI4 0x10
+#define DA9211_M_UVLO_IO 0x40
+
+/* DA9211_REG_MASK_B (addr=0x55) */
+#define DA9211_M_PWRGOOD_A 0x01
+#define DA9211_M_PWRGOOD_B 0x02
+#define DA9211_M_TEMP_WARN 0x04
+#define DA9211_M_TEMP_CRIT 0x08
+#define DA9211_M_OV_CURR_A 0x10
+#define DA9211_M_OV_CURR_B 0x20
+
+/* DA9211_REG_CONTROL_A (addr=0x56) */
+#define DA9211_DEBOUNCING_SHIFT 0
+#define DA9211_DEBOUNCING_MASK 0x07
+#define DA9211_SLEW_RATE_SHIFT 3
+#define DA9211_SLEW_RATE_A_MASK 0x18
+#define DA9211_SLEW_RATE_B_SHIFT 5
+#define DA9211_SLEW_RATE_B_MASK 0x60
+#define DA9211_V_LOCK 0x80
+
+/* DA9211_REG_GPIO_0_1 (addr=0x58) */
+#define DA9211_GPIO0_PIN_SHIFT 0
+#define DA9211_GPIO0_PIN_MASK 0x03
+#define DA9211_GPIO0_PIN_GPI 0x00
+#define DA9211_GPIO0_PIN_GPO_OD 0x02
+#define DA9211_GPIO0_PIN_GPO 0x03
+#define DA9211_GPIO0_TYPE 0x04
+#define DA9211_GPIO0_TYPE_GPI 0x00
+#define DA9211_GPIO0_TYPE_GPO 0x04
+#define DA9211_GPIO0_MODE 0x08
+#define DA9211_GPIO1_PIN_SHIFT 4
+#define DA9211_GPIO1_PIN_MASK 0x30
+#define DA9211_GPIO1_PIN_GPI 0x00
+#define DA9211_GPIO1_PIN_VERROR 0x10
+#define DA9211_GPIO1_PIN_GPO_OD 0x20
+#define DA9211_GPIO1_PIN_GPO 0x30
+#define DA9211_GPIO1_TYPE_SHIFT 0x40
+#define DA9211_GPIO1_TYPE_GPI 0x00
+#define DA9211_GPIO1_TYPE_GPO 0x40
+#define DA9211_GPIO1_MODE 0x80
+
+/* DA9211_REG_GPIO_2_3 (addr=0x59) */
+#define DA9211_GPIO2_PIN_SHIFT 0
+#define DA9211_GPIO2_PIN_MASK 0x03
+#define DA9211_GPIO2_PIN_GPI 0x00
+#define DA9211_GPIO5_PIN_BUCK_CLK 0x10
+#define DA9211_GPIO2_PIN_GPO_OD 0x02
+#define DA9211_GPIO2_PIN_GPO 0x03
+#define DA9211_GPIO2_TYPE 0x04
+#define DA9211_GPIO2_TYPE_GPI 0x00
+#define DA9211_GPIO2_TYPE_GPO 0x04
+#define DA9211_GPIO2_MODE 0x08
+#define DA9211_GPIO3_PIN_SHIFT 4
+#define DA9211_GPIO3_PIN_MASK 0x30
+#define DA9211_GPIO3_PIN_GPI 0x00
+#define DA9211_GPIO3_PIN_IERROR 0x10
+#define DA9211_GPIO3_PIN_GPO_OD 0x20
+#define DA9211_GPIO3_PIN_GPO 0x30
+#define DA9211_GPIO3_TYPE_SHIFT 0x40
+#define DA9211_GPIO3_TYPE_GPI 0x00
+#define DA9211_GPIO3_TYPE_GPO 0x40
+#define DA9211_GPIO3_MODE 0x80
+
+/* DA9211_REG_GPIO_4 (addr=0x5A) */
+#define DA9211_GPIO4_PIN_SHIFT 0
+#define DA9211_GPIO4_PIN_MASK 0x03
+#define DA9211_GPIO4_PIN_GPI 0x00
+#define DA9211_GPIO4_PIN_GPO_OD 0x02
+#define DA9211_GPIO4_PIN_GPO 0x03
+#define DA9211_GPIO4_TYPE 0x04
+#define DA9211_GPIO4_TYPE_GPI 0x00
+#define DA9211_GPIO4_TYPE_GPO 0x04
+#define DA9211_GPIO4_MODE 0x08
+
+/* DA9211_REG_BUCKA_CONT (addr=0x5D) */
+#define DA9211_BUCKA_EN 0x01
+#define DA9211_BUCKA_GPI_SHIFT 1
+#define DA9211_BUCKA_GPI_MASK 0x06
+#define DA9211_BUCKA_GPI_OFF 0x00
+#define DA9211_BUCKA_GPI_GPIO0 0x02
+#define DA9211_BUCKA_GPI_GPIO1 0x04
+#define DA9211_BUCKA_GPI_GPIO3 0x06
+#define DA9211_BUCKA_PD_DIS 0x08
+#define DA9211_VBUCKA_SEL 0x10
+#define DA9211_VBUCKA_SEL_A 0x00
+#define DA9211_VBUCKA_SEL_B 0x10
+#define DA9211_VBUCKA_GPI_SHIFT 5
+#define DA9211_VBUCKA_GPI_MASK 0x60
+#define DA9211_VBUCKA_GPI_OFF 0x00
+#define DA9211_VBUCKA_GPI_GPIO1 0x20
+#define DA9211_VBUCKA_GPI_GPIO2 0x40
+#define DA9211_VBUCKA_GPI_GPIO4 0x60
+
+/* DA9211_REG_BUCKB_CONT (addr=0x5E) */
+#define DA9211_BUCKB_EN 0x01
+#define DA9211_BUCKB_GPI_SHIFT 1
+#define DA9211_BUCKB_GPI_MASK 0x06
+#define DA9211_BUCKB_GPI_OFF 0x00
+#define DA9211_BUCKB_GPI_GPIO0 0x02
+#define DA9211_BUCKB_GPI_GPIO1 0x04
+#define DA9211_BUCKB_GPI_GPIO3 0x06
+#define DA9211_BUCKB_PD_DIS 0x08
+#define DA9211_VBUCKB_SEL 0x10
+#define DA9211_VBUCKB_SEL_A 0x00
+#define DA9211_VBUCKB_SEL_B 0x10
+#define DA9211_VBUCKB_GPI_SHIFT 5
+#define DA9211_VBUCKB_GPI_MASK 0x60
+#define DA9211_VBUCKB_GPI_OFF 0x00
+#define DA9211_VBUCKB_GPI_GPIO1 0x20
+#define DA9211_VBUCKB_GPI_GPIO2 0x40
+#define DA9211_VBUCKB_GPI_GPIO4 0x60
+
+/* DA9211_REG_BUCK_ILIM (addr=0xD0) */
+#define DA9211_BUCKA_ILIM_SHIFT 0
+#define DA9211_BUCKA_ILIM_MASK 0x0F
+#define DA9211_BUCKB_ILIM_SHIFT 4
+#define DA9211_BUCKB_ILIM_MASK 0xF0
+
+/* DA9211_REG_BUCKA_CONF (addr=0xD1) */
+#define DA9211_BUCKA_MODE_SHIFT 0
+#define DA9211_BUCKA_MODE_MASK 0x03
+#define DA9211_BUCKA_MODE_MANUAL 0x00
+#define DA9211_BUCKA_MODE_SLEEP 0x01
+#define DA9211_BUCKA_MODE_SYNC 0x02
+#define DA9211_BUCKA_MODE_AUTO 0x03
+#define DA9211_BUCKA_UP_CTRL_SHIFT 2
+#define DA9211_BUCKA_UP_CTRL_MASK 0x1C
+#define DA9211_BUCKA_DOWN_CTRL_SHIFT 5
+#define DA9211_BUCKA_DOWN_CTRL_MASK 0xE0
+
+/* DA9211_REG_BUCKB_CONF (addr=0xD2) */
+#define DA9211_BUCKB_MODE_SHIFT 0
+#define DA9211_BUCKB_MODE_MASK 0x03
+#define DA9211_BUCKB_MODE_MANUAL 0x00
+#define DA9211_BUCKB_MODE_SLEEP 0x01
+#define DA9211_BUCKB_MODE_SYNC 0x02
+#define DA9211_BUCKB_MODE_AUTO 0x03
+#define DA9211_BUCKB_UP_CTRL_SHIFT 2
+#define DA9211_BUCKB_UP_CTRL_MASK 0x1C
+#define DA9211_BUCKB_DOWN_CTRL_SHIFT 5
+#define DA9211_BUCKB_DOWN_CTRL_MASK 0xE0
+
+/* DA9211_REG_BUCK_CONF (addr=0xD3) */
+#define DA9211_PHASE_SEL_A_SHIFT 0
+#define DA9211_PHASE_SEL_A_MASK 0x03
+#define DA9211_PHASE_SEL_B_SHIFT 2
+#define DA9211_PHASE_SEL_B_MASK 0x04
+#define DA9211_PH_SH_EN_A_SHIFT 3
+#define DA9211_PH_SH_EN_A_MASK 0x08
+#define DA9211_PH_SH_EN_B_SHIFT 4
+#define DA9211_PH_SH_EN_B_MASK 0x10
+
+/* DA9211_REG_VBUCKA_MAX (addr=0xD5) */
+#define DA9211_VBUCKA_BASE_SHIFT 0
+#define DA9211_VBUCKA_BASE_MASK 0x7F
+
+/* DA9211_REG_VBUCKB_MAX (addr=0xD6) */
+#define DA9211_VBUCKB_BASE_SHIFT 0
+#define DA9211_VBUCKB_BASE_MASK 0x7F
+
+/* DA9211_REG_VBUCKA/B_A/B (addr=0xD7/0xD8/0xD9/0xDA) */
+#define DA9211_VBUCK_SHIFT 0
+#define DA9211_VBUCK_MASK 0x7F
+#define DA9211_VBUCK_BIAS 0
+#define DA9211_BUCK_SL 0x80
+
+/* DA9211_REG_INTERFACE (addr=0x105) */
+#define DA9211_IF_BASE_ADDR_SHIFT 4
+#define DA9211_IF_BASE_ADDR_MASK 0xF0
+
+/* DA9211_REG_CONFIG_E (addr=0x147) */
+#define DA9211_SLAVE_SEL 0x40
+
+#endif /* __DA9211_REGISTERS_H__ */
diff --git a/include/linux/regulator/da9211.h b/include/linux/regulator/da9211.h
new file mode 100644
index 0000000..3575de2
--- /dev/null
+++ b/include/linux/regulator/da9211.h
@@ -0,0 +1,81 @@
+/*
+ * da9211.h - Regulator device driver for DA9211
+ * Copyright (C) 2014 Dialog Semiconductor Ltd.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Library General Public License for more details.
+ */
+
+#ifndef __LINUX_REGULATOR_DA9211_H
+#define __LINUX_REGULATOR_DA9211_H
+
+#include <linux/regulator/machine.h>
+
+#define DA9211_MAX_REGULATORS 2
+
+enum da9211_gpio_ren_select {
+ DA9211_REN_NO_GPIO = 0,
+ DA9211_REN_GPIO_0,
+ DA9211_REN_GPIO_1,
+ DA9211_REN_GPIO_3,
+};
+
+enum da9211_gpio_rsel_select {
+ DA9211_RSEL_NO_GPIO = 0,
+ DA9211_RSEL_GPIO_1,
+ DA9211_RSEL_GPIO_2,
+ DA9211_RSEL_GPIO_4,
+};
+
+enum DA9211_IRQ {
+ DA9211_IRQ_EGPI0 = 0,
+ DA9211_IRQ_EGPI1,
+ DA9211_IRQ_EGPI2,
+ DA9211_IRQ_EGPI3,
+ DA9211_IRQ_EGPI4,
+ DA9211_IRQ_EUVLO_IO,
+ DA9211_IRQ_EPWRGOOD_A,
+ DA9211_IRQ_EPWRGOOD_B,
+ DA9211_IRQ_ETEMP_WARN,
+ DA9211_IRQ_ETEMP_CRIT,
+ DA9211_IRQ_EOV_CURR_A,
+ DA9211_IRQ_EOV_CURR_B,
+ DA9211_NUM_IRQ,
+};
+
+struct da9211_buck_data {
+ /* gpio of platform for buck eanble/disable */
+ int gpio_ren;
+
+ /* gpio of platform for buck(a/b) selection */
+ int gpio_rsel;
+
+ /* init state of gpio_ren */
+ int ena_init_state;
+
+ /* gpio of da9211 for buck eanble/disable */
+ enum da9211_gpio_ren_select reg_ren;
+
+ /* gpio of da9211 for buck(a/b) selection */
+ enum da9211_gpio_rsel_select reg_rsel;
+
+ struct regulator_init_data *constraints;
+};
+
+struct da9211_pdata {
+ /*
+ * Number of buck
+ * 1 : 4 phase 1 buck
+ * 2 : 2 phase 2 buck
+ */
+ int num_buck;
+ struct da9211_buck_data buck_data[DA9211_MAX_REGULATORS];
+};
+#endif
--
end-of-patch for regulator: DA9211 : new regulator driver V1

--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/