[mirror_ubuntu-artful-kernel.git] / drivers / regulator / pv88090-regulator.c

/*
 * pv88090-regulator.c - Regulator device driver for PV88090
 * Copyright (C) 2015  Powerventure Semiconductor Ltd.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 */

#include <linux/err.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/of_regulator.h>
#include "pv88090-regulator.h"

#define PV88090_MAX_REGULATORS	5

/* PV88090 REGULATOR IDs */
enum {
	/* BUCKs */
	PV88090_ID_BUCK1,
	PV88090_ID_BUCK2,
	PV88090_ID_BUCK3,

	/* LDOs */
	PV88090_ID_LDO1,
	PV88090_ID_LDO2,
};

struct pv88090_regulator {
	struct regulator_desc desc;
	/* Current limiting */
	unsigned	n_current_limits;
	const int	*current_limits;
	unsigned int limit_mask;
	unsigned int conf;
	unsigned int conf2;
};

struct pv88090 {
	struct device *dev;
	struct regmap *regmap;
	struct regulator_dev *rdev[PV88090_MAX_REGULATORS];
};

struct pv88090_buck_voltage {
	int min_uV;
	int max_uV;
	int uV_step;
};

static const struct regmap_config pv88090_regmap_config = {
	.reg_bits = 8,
	.val_bits = 8,
};

/* Current limits array (in uA) for BUCK1, BUCK2, BUCK3.
 *  Entry indexes corresponds to register values.
 */

static const int pv88090_buck1_limits[] = {
	 220000,  440000,  660000,  880000, 1100000, 1320000, 1540000, 1760000,
	1980000, 2200000, 2420000, 2640000, 2860000, 3080000, 3300000, 3520000,
	3740000, 3960000, 4180000, 4400000, 4620000, 4840000, 5060000, 5280000,
	5500000, 5720000, 5940000, 6160000, 6380000, 6600000, 6820000, 7040000
};

static const int pv88090_buck23_limits[] = {
	1496000, 2393000, 3291000, 4189000
};

static const struct pv88090_buck_voltage pv88090_buck_vol[3] = {
	{
		.min_uV = 600000,
		.max_uV = 1393750,
		.uV_step = 6250,
	},

	{
		.min_uV = 1400000,
		.max_uV = 2193750,
		.uV_step = 6250,
	},
	{
		.min_uV = 1250000,
		.max_uV = 2837500,
		.uV_step = 12500,
	},
};

static unsigned int pv88090_buck_get_mode(struct regulator_dev *rdev)
{
	struct pv88090_regulator *info = rdev_get_drvdata(rdev);
	unsigned int data;
	int ret, mode = 0;

	ret = regmap_read(rdev->regmap, info->conf, &data);
	if (ret < 0)
		return ret;

	switch (data & PV88090_BUCK1_MODE_MASK) {
	case PV88090_BUCK_MODE_SYNC:
		mode = REGULATOR_MODE_FAST;
		break;
	case PV88090_BUCK_MODE_AUTO:
		mode = REGULATOR_MODE_NORMAL;
		break;
	case PV88090_BUCK_MODE_SLEEP:
		mode = REGULATOR_MODE_STANDBY;
		break;
	}

	return mode;
}

static int pv88090_buck_set_mode(struct regulator_dev *rdev,
					unsigned int mode)
{
	struct pv88090_regulator *info = rdev_get_drvdata(rdev);
	int val = 0;

	switch (mode) {
	case REGULATOR_MODE_FAST:
		val = PV88090_BUCK_MODE_SYNC;
		break;
	case REGULATOR_MODE_NORMAL:
		val = PV88090_BUCK_MODE_AUTO;
		break;
	case REGULATOR_MODE_STANDBY:
		val = PV88090_BUCK_MODE_SLEEP;
		break;
	default:
		return -EINVAL;
	}

	return regmap_update_bits(rdev->regmap, info->conf,
					PV88090_BUCK1_MODE_MASK, val);
}

static int pv88090_set_current_limit(struct regulator_dev *rdev, int min,
				    int max)
{
	struct pv88090_regulator *info = rdev_get_drvdata(rdev);
	int i;

	/* search for closest to maximum */
	for (i = info->n_current_limits; i >= 0; i--) {
		if (min <= info->current_limits[i]
			&& max >= info->current_limits[i]) {
			return regmap_update_bits(rdev->regmap,
				info->conf,
				info->limit_mask,
				i << PV88090_BUCK1_ILIM_SHIFT);
		}
	}

	return -EINVAL;
}

static int pv88090_get_current_limit(struct regulator_dev *rdev)
{
	struct pv88090_regulator *info = rdev_get_drvdata(rdev);
	unsigned int data;
	int ret;

	ret = regmap_read(rdev->regmap, info->conf, &data);
	if (ret < 0)
		return ret;

	data = (data & info->limit_mask) >> PV88090_BUCK1_ILIM_SHIFT;
	return info->current_limits[data];
}

static const struct regulator_ops pv88090_buck_ops = {
	.get_mode = pv88090_buck_get_mode,
	.set_mode = pv88090_buck_set_mode,
	.enable = regulator_enable_regmap,
	.disable = regulator_disable_regmap,
	.is_enabled = regulator_is_enabled_regmap,
	.set_voltage_sel = regulator_set_voltage_sel_regmap,
	.get_voltage_sel = regulator_get_voltage_sel_regmap,
	.list_voltage = regulator_list_voltage_linear,
	.set_current_limit = pv88090_set_current_limit,
	.get_current_limit = pv88090_get_current_limit,
};

static const struct regulator_ops pv88090_ldo_ops = {
	.enable = regulator_enable_regmap,
	.disable = regulator_disable_regmap,
	.is_enabled = regulator_is_enabled_regmap,
	.set_voltage_sel = regulator_set_voltage_sel_regmap,
	.get_voltage_sel = regulator_get_voltage_sel_regmap,
	.list_voltage = regulator_list_voltage_linear,
};

#define PV88090_BUCK(chip, regl_name, min, step, max, limits_array) \
{\
	.desc	=	{\
		.id = chip##_ID_##regl_name,\
		.name = __stringify(chip##_##regl_name),\
		.of_match = of_match_ptr(#regl_name),\
		.regulators_node = of_match_ptr("regulators"),\
		.type = REGULATOR_VOLTAGE,\
		.owner = THIS_MODULE,\
		.ops = &pv88090_buck_ops,\
		.min_uV = min, \
		.uV_step = step, \
		.n_voltages = ((max) - (min))/(step) + 1, \
		.enable_reg = PV88090_REG_##regl_name##_CONF0, \
		.enable_mask = PV88090_##regl_name##_EN, \
		.vsel_reg = PV88090_REG_##regl_name##_CONF0, \
		.vsel_mask = PV88090_V##regl_name##_MASK, \
	},\
	.current_limits = limits_array, \
	.n_current_limits = ARRAY_SIZE(limits_array), \
	.limit_mask = PV88090_##regl_name##_ILIM_MASK, \
	.conf = PV88090_REG_##regl_name##_CONF1, \
	.conf2 = PV88090_REG_##regl_name##_CONF2, \
}

#define PV88090_LDO(chip, regl_name, min, step, max) \
{\
	.desc	=	{\
		.id = chip##_ID_##regl_name,\
		.name = __stringify(chip##_##regl_name),\
		.of_match = of_match_ptr(#regl_name),\
		.regulators_node = of_match_ptr("regulators"),\
		.type = REGULATOR_VOLTAGE,\
		.owner = THIS_MODULE,\
		.ops = &pv88090_ldo_ops,\
		.min_uV = min, \
		.uV_step = step, \
		.n_voltages = ((max) - (min))/(step) + 1, \
		.enable_reg = PV88090_REG_##regl_name##_CONT, \
		.enable_mask = PV88090_##regl_name##_EN, \
		.vsel_reg = PV88090_REG_##regl_name##_CONT, \
		.vsel_mask = PV88090_V##regl_name##_MASK, \
	},\
}

static struct pv88090_regulator pv88090_regulator_info[] = {
	PV88090_BUCK(PV88090, BUCK1, 600000, 6250, 1393750,
		pv88090_buck1_limits),
	PV88090_BUCK(PV88090, BUCK2, 600000, 6250, 1393750,
		pv88090_buck23_limits),
	PV88090_BUCK(PV88090, BUCK3, 600000, 6250, 1393750,
		pv88090_buck23_limits),
	PV88090_LDO(PV88090, LDO1, 1200000, 50000, 4350000),
	PV88090_LDO(PV88090, LDO2,  650000, 25000, 2225000),
};

static irqreturn_t pv88090_irq_handler(int irq, void *data)
{
	struct pv88090 *chip = data;
	int i, reg_val, err, ret = IRQ_NONE;

	err = regmap_read(chip->regmap, PV88090_REG_EVENT_A, &reg_val);
	if (err < 0)
		goto error_i2c;

	if (reg_val & PV88090_E_VDD_FLT) {
		for (i = 0; i < PV88090_MAX_REGULATORS; i++) {
			if (chip->rdev[i] != NULL) {
				regulator_notifier_call_chain(chip->rdev[i],
					REGULATOR_EVENT_UNDER_VOLTAGE,
					NULL);
			}
		}

		err = regmap_write(chip->regmap, PV88090_REG_EVENT_A,
			PV88090_E_VDD_FLT);
		if (err < 0)
			goto error_i2c;

		ret = IRQ_HANDLED;
	}

	if (reg_val & PV88090_E_OVER_TEMP) {
		for (i = 0; i < PV88090_MAX_REGULATORS; i++) {
			if (chip->rdev[i] != NULL) {
				regulator_notifier_call_chain(chip->rdev[i],
					REGULATOR_EVENT_OVER_TEMP,
					NULL);
			}
		}

		err = regmap_write(chip->regmap, PV88090_REG_EVENT_A,
			PV88090_E_OVER_TEMP);
		if (err < 0)
			goto error_i2c;

		ret = IRQ_HANDLED;
	}

	return ret;

error_i2c:
	dev_err(chip->dev, "I2C error : %d\n", err);
	return IRQ_NONE;
}

/*
 * I2C driver interface functions
 */
static int pv88090_i2c_probe(struct i2c_client *i2c,
		const struct i2c_device_id *id)
{
	struct regulator_init_data *init_data = dev_get_platdata(&i2c->dev);
	struct pv88090 *chip;
	struct regulator_config config = { };
	int error, i, ret = 0;
	unsigned int conf2, range, index;

	chip = devm_kzalloc(&i2c->dev, sizeof(struct pv88090), GFP_KERNEL);
	if (!chip)
		return -ENOMEM;

	chip->dev = &i2c->dev;
	chip->regmap = devm_regmap_init_i2c(i2c, &pv88090_regmap_config);
	if (IS_ERR(chip->regmap)) {
		error = PTR_ERR(chip->regmap);
		dev_err(chip->dev, "Failed to allocate register map: %d\n",
			error);
		return error;
	}

	i2c_set_clientdata(i2c, chip);

	if (i2c->irq != 0) {
		ret = regmap_write(chip->regmap, PV88090_REG_MASK_A, 0xFF);
		if (ret < 0) {
			dev_err(chip->dev,
				"Failed to mask A reg: %d\n", ret);
			return ret;
		}

		ret = regmap_write(chip->regmap, PV88090_REG_MASK_B, 0xFF);
		if (ret < 0) {
			dev_err(chip->dev,
				"Failed to mask B reg: %d\n", ret);
			return ret;
		}

		ret = devm_request_threaded_irq(&i2c->dev, i2c->irq, NULL,
					pv88090_irq_handler,
					IRQF_TRIGGER_LOW|IRQF_ONESHOT,
					"pv88090", chip);
		if (ret != 0) {
			dev_err(chip->dev, "Failed to request IRQ: %d\n",
				i2c->irq);
			return ret;
		}

		ret = regmap_update_bits(chip->regmap, PV88090_REG_MASK_A,
			PV88090_M_VDD_FLT | PV88090_M_OVER_TEMP, 0);
		if (ret < 0) {
			dev_err(chip->dev,
				"Failed to update mask reg: %d\n", ret);
			return ret;
		}

	} else {
		dev_warn(chip->dev, "No IRQ configured\n");
	}

	config.dev = chip->dev;
	config.regmap = chip->regmap;

	for (i = 0; i < PV88090_MAX_REGULATORS; i++) {
		if (init_data)
			config.init_data = &init_data[i];

		if (i == PV88090_ID_BUCK2 || i == PV88090_ID_BUCK3) {
			ret = regmap_read(chip->regmap,
				pv88090_regulator_info[i].conf2, &conf2);
			if (ret < 0)
				return ret;

			conf2 = (conf2 >> PV88090_BUCK_VDAC_RANGE_SHIFT) &
				PV88090_BUCK_VDAC_RANGE_MASK;

			ret = regmap_read(chip->regmap,
				PV88090_REG_BUCK_FOLD_RANGE, &range);
			if (ret < 0)
				return ret;

			range = (range >>
				 (PV88080_BUCK_VRANGE_GAIN_SHIFT + i - 1)) &
				PV88080_BUCK_VRANGE_GAIN_MASK;
			index = ((range << 1) | conf2);

			pv88090_regulator_info[i].desc.min_uV
				= pv88090_buck_vol[index].min_uV;
			pv88090_regulator_info[i].desc.uV_step
				= pv88090_buck_vol[index].uV_step;
			pv88090_regulator_info[i].desc.n_voltages
				= ((pv88090_buck_vol[index].max_uV)
				- (pv88090_buck_vol[index].min_uV))
				/(pv88090_buck_vol[index].uV_step) + 1;
		}

		config.driver_data = (void *)&pv88090_regulator_info[i];
		chip->rdev[i] = devm_regulator_register(chip->dev,
			&pv88090_regulator_info[i].desc, &config);
		if (IS_ERR(chip->rdev[i])) {
			dev_err(chip->dev,
				"Failed to register PV88090 regulator\n");
			return PTR_ERR(chip->rdev[i]);
		}
	}

	return 0;
}

static const struct i2c_device_id pv88090_i2c_id[] = {
	{"pv88090", 0},
	{},
};
MODULE_DEVICE_TABLE(i2c, pv88090_i2c_id);

#ifdef CONFIG_OF
static const struct of_device_id pv88090_dt_ids[] = {
	{ .compatible = "pvs,pv88090", .data = &pv88090_i2c_id[0] },
	{},
};
MODULE_DEVICE_TABLE(of, pv88090_dt_ids);
#endif

static struct i2c_driver pv88090_regulator_driver = {
	.driver = {
		.name = "pv88090",
		.of_match_table = of_match_ptr(pv88090_dt_ids),
	},
	.probe = pv88090_i2c_probe,
	.id_table = pv88090_i2c_id,
};

module_i2c_driver(pv88090_regulator_driver);

MODULE_AUTHOR("James Ban <James.Ban.opensource@diasemi.com>");
MODULE_DESCRIPTION("Regulator device driver for Powerventure PV88090");
MODULE_LICENSE("GPL");
Commit	Line	Data
c90456e3 JB	1	/*
	2	* pv88090-regulator.c - Regulator device driver for PV88090
	3	* Copyright (C) 2015 Powerventure Semiconductor Ltd.
	4	*
	5	* This program is free software; you can redistribute it and/or
	6	* modify it under the terms of the GNU General Public License
	7	* as published by the Free Software Foundation; either version 2
	8	* of the License, or (at your option) any later version.
	9	*
	10	* This program is distributed in the hope that it will be useful,
	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	* GNU General Public License for more details.
	14	*/
	15
	16	#include <linux/err.h>
c90456e3 JB	17	#include <linux/i2c.h>
	18	#include <linux/module.h>
	19	#include <linux/init.h>
	20	#include <linux/slab.h>
	21	#include <linux/regulator/driver.h>
	22	#include <linux/regulator/machine.h>
	23	#include <linux/regmap.h>
	24	#include <linux/irq.h>
	25	#include <linux/interrupt.h>
	26	#include <linux/regulator/of_regulator.h>
c90456e3 JB	27	#include "pv88090-regulator.h"
	28
	29	#define PV88090_MAX_REGULATORS 5
	30
	31	/* PV88090 REGULATOR IDs */
	32	enum {
	33	/* BUCKs */
	34	PV88090_ID_BUCK1,
	35	PV88090_ID_BUCK2,
	36	PV88090_ID_BUCK3,
	37
	38	/* LDOs */
	39	PV88090_ID_LDO1,
	40	PV88090_ID_LDO2,
	41	};
	42
	43	struct pv88090_regulator {
	44	struct regulator_desc desc;
	45	/* Current limiting */
	46	unsigned n_current_limits;
	47	const int *current_limits;
	48	unsigned int limit_mask;
	49	unsigned int conf;
	50	unsigned int conf2;
	51	};
	52
	53	struct pv88090 {
	54	struct device *dev;
	55	struct regmap *regmap;
	56	struct regulator_dev *rdev[PV88090_MAX_REGULATORS];
	57	};
	58
	59	struct pv88090_buck_voltage {
	60	int min_uV;
	61	int max_uV;
	62	int uV_step;
	63	};
	64
	65	static const struct regmap_config pv88090_regmap_config = {
	66	.reg_bits = 8,
	67	.val_bits = 8,
	68	};
	69
	70	/* Current limits array (in uA) for BUCK1, BUCK2, BUCK3.
	71	* Entry indexes corresponds to register values.
	72	*/
	73
	74	static const int pv88090_buck1_limits[] = {
	75	220000, 440000, 660000, 880000, 1100000, 1320000, 1540000, 1760000,
	76	1980000, 2200000, 2420000, 2640000, 2860000, 3080000, 3300000, 3520000,
	77	3740000, 3960000, 4180000, 4400000, 4620000, 4840000, 5060000, 5280000,
	78	5500000, 5720000, 5940000, 6160000, 6380000, 6600000, 6820000, 7040000
	79	};
	80
	81	static const int pv88090_buck23_limits[] = {
	82	1496000, 2393000, 3291000, 4189000
	83	};
	84
	85	static const struct pv88090_buck_voltage pv88090_buck_vol[3] = {
	86	{
	87	.min_uV = 600000,
	88	.max_uV = 1393750,
	89	.uV_step = 6250,
	90	},
91
92	{
93	.min_uV = 1400000,
94	.max_uV = 2193750,
95	.uV_step = 6250,
96	},
97	{
98	.min_uV = 1250000,
99	.max_uV = 2837500,
100	.uV_step = 12500,
101	},
102	};
103
104	static unsigned int pv88090_buck_get_mode(struct regulator_dev *rdev)
105	{
106	struct pv88090_regulator *info = rdev_get_drvdata(rdev);
107	unsigned int data;
108	int ret, mode = 0;
109
110	ret = regmap_read(rdev->regmap, info->conf, &data);
111	if (ret < 0)
112	return ret;
113
114	switch (data & PV88090_BUCK1_MODE_MASK) {
115	case PV88090_BUCK_MODE_SYNC:
116	mode = REGULATOR_MODE_FAST;
117	break;
118	case PV88090_BUCK_MODE_AUTO:
119	mode = REGULATOR_MODE_NORMAL;
120	break;
121	case PV88090_BUCK_MODE_SLEEP:
122	mode = REGULATOR_MODE_STANDBY;
123	break;
124	}
125
126	return mode;
127	}
128
129	static int pv88090_buck_set_mode(struct regulator_dev *rdev,
130	unsigned int mode)
131	{
132	struct pv88090_regulator *info = rdev_get_drvdata(rdev);
133	int val = 0;
134
135	switch (mode) {
136	case REGULATOR_MODE_FAST:
137	val = PV88090_BUCK_MODE_SYNC;
138	break;
139	case REGULATOR_MODE_NORMAL:
140	val = PV88090_BUCK_MODE_AUTO;
141	break;
142	case REGULATOR_MODE_STANDBY:
143	val = PV88090_BUCK_MODE_SLEEP;
144	break;
145	default:
146	return -EINVAL;
147	}
148
149	return regmap_update_bits(rdev->regmap, info->conf,
150	PV88090_BUCK1_MODE_MASK, val);
151	}
152
153	static int pv88090_set_current_limit(struct regulator_dev *rdev, int min,
154	int max)
155	{
156	struct pv88090_regulator *info = rdev_get_drvdata(rdev);
157	int i;
158
159	/* search for closest to maximum */
160	for (i = info->n_current_limits; i >= 0; i--) {
161	if (min <= info->current_limits[i]
162	&& max >= info->current_limits[i]) {
163	return regmap_update_bits(rdev->regmap,
164	info->conf,
165	info->limit_mask,
166	i << PV88090_BUCK1_ILIM_SHIFT);
167	}
168	}
169
170	return -EINVAL;
171	}
172
173	static int pv88090_get_current_limit(struct regulator_dev *rdev)
174	{
175	struct pv88090_regulator *info = rdev_get_drvdata(rdev);
176	unsigned int data;
177	int ret;
178
179	ret = regmap_read(rdev->regmap, info->conf, &data);
180	if (ret < 0)
181	return ret;
182
183	data = (data & info->limit_mask) >> PV88090_BUCK1_ILIM_SHIFT;
184	return info->current_limits[data];
185	}
186
36fe20c7	187	static const struct regulator_ops pv88090_buck_ops = {
c90456e3 JB	188	.get_mode = pv88090_buck_get_mode,
	189	.set_mode = pv88090_buck_set_mode,
	190	.enable = regulator_enable_regmap,
	191	.disable = regulator_disable_regmap,
	192	.is_enabled = regulator_is_enabled_regmap,
	193	.set_voltage_sel = regulator_set_voltage_sel_regmap,
	194	.get_voltage_sel = regulator_get_voltage_sel_regmap,
	195	.list_voltage = regulator_list_voltage_linear,
	196	.set_current_limit = pv88090_set_current_limit,
	197	.get_current_limit = pv88090_get_current_limit,
	198	};
	199
36fe20c7	200	static const struct regulator_ops pv88090_ldo_ops = {
c90456e3 JB	201	.enable = regulator_enable_regmap,
	202	.disable = regulator_disable_regmap,
	203	.is_enabled = regulator_is_enabled_regmap,
	204	.set_voltage_sel = regulator_set_voltage_sel_regmap,
	205	.get_voltage_sel = regulator_get_voltage_sel_regmap,
	206	.list_voltage = regulator_list_voltage_linear,
	207	};
	208
	209	#define PV88090_BUCK(chip, regl_name, min, step, max, limits_array) \
	210	{\
	211	.desc = {\
	212	.id = chip##_ID_##regl_name,\
	213	.name = __stringify(chip##_##regl_name),\
	214	.of_match = of_match_ptr(#regl_name),\
	215	.regulators_node = of_match_ptr("regulators"),\
	216	.type = REGULATOR_VOLTAGE,\
	217	.owner = THIS_MODULE,\
	218	.ops = &pv88090_buck_ops,\
	219	.min_uV = min, \
	220	.uV_step = step, \
	221	.n_voltages = ((max) - (min))/(step) + 1, \
	222	.enable_reg = PV88090_REG_##regl_name##_CONF0, \
	223	.enable_mask = PV88090_##regl_name##_EN, \
	224	.vsel_reg = PV88090_REG_##regl_name##_CONF0, \
	225	.vsel_mask = PV88090_V##regl_name##_MASK, \
	226	},\
	227	.current_limits = limits_array, \
	228	.n_current_limits = ARRAY_SIZE(limits_array), \
	229	.limit_mask = PV88090_##regl_name##_ILIM_MASK, \
	230	.conf = PV88090_REG_##regl_name##_CONF1, \
	231	.conf2 = PV88090_REG_##regl_name##_CONF2, \
	232	}
	233
	234	#define PV88090_LDO(chip, regl_name, min, step, max) \
	235	{\
	236	.desc = {\
	237	.id = chip##_ID_##regl_name,\
	238	.name = __stringify(chip##_##regl_name),\
	239	.of_match = of_match_ptr(#regl_name),\
	240	.regulators_node = of_match_ptr("regulators"),\
	241	.type = REGULATOR_VOLTAGE,\
	242	.owner = THIS_MODULE,\
	243	.ops = &pv88090_ldo_ops,\
	244	.min_uV = min, \
	245	.uV_step = step, \
	246	.n_voltages = ((max) - (min))/(step) + 1, \
	247	.enable_reg = PV88090_REG_##regl_name##_CONT, \
	248	.enable_mask = PV88090_##regl_name##_EN, \
	249	.vsel_reg = PV88090_REG_##regl_name##_CONT, \
	250	.vsel_mask = PV88090_V##regl_name##_MASK, \
	251	},\
	252	}
	253
	254	static struct pv88090_regulator pv88090_regulator_info[] = {
	255	PV88090_BUCK(PV88090, BUCK1, 600000, 6250, 1393750,
	256	pv88090_buck1_limits),
	257	PV88090_BUCK(PV88090, BUCK2, 600000, 6250, 1393750,
	258	pv88090_buck23_limits),
	259	PV88090_BUCK(PV88090, BUCK3, 600000, 6250, 1393750,
	260	pv88090_buck23_limits),
	261	PV88090_LDO(PV88090, LDO1, 1200000, 50000, 4350000),
	262	PV88090_LDO(PV88090, LDO2, 650000, 25000, 2225000),
	263	};
	264
265	static irqreturn_t pv88090_irq_handler(int irq, void *data)
266	{
267	struct pv88090 *chip = data;
268	int i, reg_val, err, ret = IRQ_NONE;
269
270	err = regmap_read(chip->regmap, PV88090_REG_EVENT_A, &reg_val);
271	if (err < 0)
272	goto error_i2c;
273
274	if (reg_val & PV88090_E_VDD_FLT) {
275	for (i = 0; i < PV88090_MAX_REGULATORS; i++) {
276	if (chip->rdev[i] != NULL) {
277	regulator_notifier_call_chain(chip->rdev[i],
278	REGULATOR_EVENT_UNDER_VOLTAGE,
279	NULL);
280	}
281	}
282
623f7b93 JB	283	err = regmap_write(chip->regmap, PV88090_REG_EVENT_A,
623f7b93 JB	284	PV88090_E_VDD_FLT);
c90456e3 JB	285	if (err < 0)
	286	goto error_i2c;
	287
	288	ret = IRQ_HANDLED;
	289	}
	290
	291	if (reg_val & PV88090_E_OVER_TEMP) {
	292	for (i = 0; i < PV88090_MAX_REGULATORS; i++) {
	293	if (chip->rdev[i] != NULL) {
	294	regulator_notifier_call_chain(chip->rdev[i],
	295	REGULATOR_EVENT_OVER_TEMP,
	296	NULL);
	297	}
	298	}
	299
623f7b93 JB	300	err = regmap_write(chip->regmap, PV88090_REG_EVENT_A,
623f7b93 JB	301	PV88090_E_OVER_TEMP);
c90456e3 JB	302	if (err < 0)
	303	goto error_i2c;
	304
	305	ret = IRQ_HANDLED;
	306	}
	307
	308	return ret;
	309
	310	error_i2c:
	311	dev_err(chip->dev, "I2C error : %d\n", err);
	312	return IRQ_NONE;
	313	}
	314
	315	/*
	316	* I2C driver interface functions
	317	*/
	318	static int pv88090_i2c_probe(struct i2c_client *i2c,
	319	const struct i2c_device_id *id)
	320	{
	321	struct regulator_init_data *init_data = dev_get_platdata(&i2c->dev);
	322	struct pv88090 *chip;
	323	struct regulator_config config = { };
	324	int error, i, ret = 0;
	325	unsigned int conf2, range, index;
	326
	327	chip = devm_kzalloc(&i2c->dev, sizeof(struct pv88090), GFP_KERNEL);
	328	if (!chip)
	329	return -ENOMEM;
	330
	331	chip->dev = &i2c->dev;
	332	chip->regmap = devm_regmap_init_i2c(i2c, &pv88090_regmap_config);
	333	if (IS_ERR(chip->regmap)) {
	334	error = PTR_ERR(chip->regmap);
	335	dev_err(chip->dev, "Failed to allocate register map: %d\n",
	336	error);
	337	return error;
	338	}
	339
	340	i2c_set_clientdata(i2c, chip);
	341
	342	if (i2c->irq != 0) {
	343	ret = regmap_write(chip->regmap, PV88090_REG_MASK_A, 0xFF);
	344	if (ret < 0) {
	345	dev_err(chip->dev,
	346	"Failed to mask A reg: %d\n", ret);
	347	return ret;
	348	}
	349
	350	ret = regmap_write(chip->regmap, PV88090_REG_MASK_B, 0xFF);
	351	if (ret < 0) {
	352	dev_err(chip->dev,
	353	"Failed to mask B reg: %d\n", ret);
	354	return ret;
	355	}
	356
ecee988a	357	ret = devm_request_threaded_irq(&i2c->dev, i2c->irq, NULL,
c90456e3 JB	358	pv88090_irq_handler,
	359	IRQF_TRIGGER_LOW\|IRQF_ONESHOT,
	360	"pv88090", chip);
	361	if (ret != 0) {
	362	dev_err(chip->dev, "Failed to request IRQ: %d\n",
	363	i2c->irq);
	364	return ret;
	365	}
	366
	367	ret = regmap_update_bits(chip->regmap, PV88090_REG_MASK_A,
	368	PV88090_M_VDD_FLT \| PV88090_M_OVER_TEMP, 0);
	369	if (ret < 0) {
	370	dev_err(chip->dev,
	371	"Failed to update mask reg: %d\n", ret);
	372	return ret;
	373	}
	374
	375	} else {
	376	dev_warn(chip->dev, "No IRQ configured\n");
	377	}
	378
	379	config.dev = chip->dev;
	380	config.regmap = chip->regmap;
	381
	382	for (i = 0; i < PV88090_MAX_REGULATORS; i++) {
	383	if (init_data)
	384	config.init_data = &init_data[i];
	385
	386	if (i == PV88090_ID_BUCK2 \|\| i == PV88090_ID_BUCK3) {
	387	ret = regmap_read(chip->regmap,
	388	pv88090_regulator_info[i].conf2, &conf2);
	389	if (ret < 0)
	390	return ret;
	391
d761c906 DC	392	conf2 = (conf2 >> PV88090_BUCK_VDAC_RANGE_SHIFT) &
d761c906 DC	393	PV88090_BUCK_VDAC_RANGE_MASK;
c90456e3 JB	394
	395	ret = regmap_read(chip->regmap,
	396	PV88090_REG_BUCK_FOLD_RANGE, &range);
	397	if (ret < 0)
	398	return ret;
	399
d761c906 DC	400	range = (range >>
	401	(PV88080_BUCK_VRANGE_GAIN_SHIFT + i - 1)) &
	402	PV88080_BUCK_VRANGE_GAIN_MASK;
c90456e3 JB	403	index = ((range << 1) \| conf2);
	404
	405	pv88090_regulator_info[i].desc.min_uV
	406	= pv88090_buck_vol[index].min_uV;
	407	pv88090_regulator_info[i].desc.uV_step
	408	= pv88090_buck_vol[index].uV_step;
	409	pv88090_regulator_info[i].desc.n_voltages
	410	= ((pv88090_buck_vol[index].max_uV)
	411	- (pv88090_buck_vol[index].min_uV))
	412	/(pv88090_buck_vol[index].uV_step) + 1;
	413	}
	414
	415	config.driver_data = (void *)&pv88090_regulator_info[i];
	416	chip->rdev[i] = devm_regulator_register(chip->dev,
	417	&pv88090_regulator_info[i].desc, &config);
	418	if (IS_ERR(chip->rdev[i])) {
	419	dev_err(chip->dev,
	420	"Failed to register PV88090 regulator\n");
	421	return PTR_ERR(chip->rdev[i]);
	422	}
	423	}
	424
	425	return 0;
	426	}
	427
	428	static const struct i2c_device_id pv88090_i2c_id[] = {
	429	{"pv88090", 0},
	430	{},
	431	};
	432	MODULE_DEVICE_TABLE(i2c, pv88090_i2c_id);
	433
	434	#ifdef CONFIG_OF
	435	static const struct of_device_id pv88090_dt_ids[] = {
	436	{ .compatible = "pvs,pv88090", .data = &pv88090_i2c_id[0] },
	437	{},
	438	};
	439	MODULE_DEVICE_TABLE(of, pv88090_dt_ids);
	440	#endif
	441
	442	static struct i2c_driver pv88090_regulator_driver = {
	443	.driver = {
	444	.name = "pv88090",
	445	.of_match_table = of_match_ptr(pv88090_dt_ids),
	446	},
	447	.probe = pv88090_i2c_probe,
	448	.id_table = pv88090_i2c_id,
	449	};
	450
	451	module_i2c_driver(pv88090_regulator_driver);
	452
	453	MODULE_AUTHOR("James Ban <James.Ban.opensource@diasemi.com>");
	454	MODULE_DESCRIPTION("Regulator device driver for Powerventure PV88090");
	455	MODULE_LICENSE("GPL");