[mirror_ubuntu-zesty-kernel.git] / drivers / regulator / max8907-regulator.c

/*
 * max8907-regulator.c -- support regulators in max8907
 *
 * Copyright (C) 2010 Gyungoh Yoo <jack.yoo@maxim-ic.com>
 * Copyright (C) 2010-2012, NVIDIA CORPORATION. All rights reserved.
 *
 * Portions based on drivers/regulator/tps65910-regulator.c,
 *     Copyright 2010 Texas Instruments Inc.
 *     Author: Graeme Gregory <gg@slimlogic.co.uk>
 *     Author: Jorge Eduardo Candelaria <jedu@slimlogic.co.uk>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#include <linux/err.h>
#include <linux/init.h>
#include <linux/mfd/core.h>
#include <linux/mfd/max8907.h>
#include <linux/module.h>
#include <linux/of.h>
#include <linux/platform_device.h>
#include <linux/regulator/driver.h>
#include <linux/regulator/machine.h>
#include <linux/regulator/of_regulator.h>
#include <linux/regmap.h>
#include <linux/slab.h>

#define MAX8907_II2RR_VERSION_MASK	0xF0
#define MAX8907_II2RR_VERSION_REV_A	0x00
#define MAX8907_II2RR_VERSION_REV_B	0x10
#define MAX8907_II2RR_VERSION_REV_C	0x30

struct max8907_regulator {
	struct regulator_desc desc[MAX8907_NUM_REGULATORS];
	struct regulator_dev *rdev[MAX8907_NUM_REGULATORS];
};

#define REG_MBATT() \
	[MAX8907_MBATT] = { \
		.name = "MBATT", \
		.supply_name = "mbatt", \
		.id = MAX8907_MBATT, \
		.ops = &max8907_mbatt_ops, \
		.type = REGULATOR_VOLTAGE, \
		.owner = THIS_MODULE, \
	}

#define REG_LDO(ids, supply, base, min, max, step) \
	[MAX8907_##ids] = { \
		.name = #ids, \
		.supply_name = supply, \
		.id = MAX8907_##ids, \
		.n_voltages = ((max) - (min)) / (step) + 1, \
		.ops = &max8907_ldo_ops, \
		.type = REGULATOR_VOLTAGE, \
		.owner = THIS_MODULE, \
		.min_uV = (min), \
		.uV_step = (step), \
		.vsel_reg = (base) + MAX8907_VOUT, \
		.vsel_mask = 0x3f, \
		.enable_reg = (base) + MAX8907_CTL, \
		.enable_mask = MAX8907_MASK_LDO_EN, \
	}

#define REG_FIXED(ids, supply, voltage) \
	[MAX8907_##ids] = { \
		.name = #ids, \
		.supply_name = supply, \
		.id = MAX8907_##ids, \
		.n_voltages = 1, \
		.ops = &max8907_fixed_ops, \
		.type = REGULATOR_VOLTAGE, \
		.owner = THIS_MODULE, \
		.min_uV = (voltage), \
	}

#define REG_OUT5V(ids, supply, base, voltage) \
	[MAX8907_##ids] = { \
		.name = #ids, \
		.supply_name = supply, \
		.id = MAX8907_##ids, \
		.n_voltages = 1, \
		.ops = &max8907_out5v_ops, \
		.type = REGULATOR_VOLTAGE, \
		.owner = THIS_MODULE, \
		.min_uV = (voltage), \
		.enable_reg = (base), \
		.enable_mask = MAX8907_MASK_OUT5V_EN, \
	}

#define REG_BBAT(ids, supply, base, min, max, step) \
	[MAX8907_##ids] = { \
		.name = #ids, \
		.supply_name = supply, \
		.id = MAX8907_##ids, \
		.n_voltages = ((max) - (min)) / (step) + 1, \
		.ops = &max8907_bbat_ops, \
		.type = REGULATOR_VOLTAGE, \
		.owner = THIS_MODULE, \
		.min_uV = (min), \
		.uV_step = (step), \
		.vsel_reg = (base), \
		.vsel_mask = MAX8907_MASK_VBBATTCV, \
	}

#define LDO_750_50(id, supply, base) REG_LDO(id, supply, (base), \
			750000, 3900000, 50000)
#define LDO_650_25(id, supply, base) REG_LDO(id, supply, (base), \
			650000, 2225000, 25000)

static struct regulator_ops max8907_mbatt_ops = {
};

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

static struct regulator_ops max8907_ldo_hwctl_ops = {
	.list_voltage = regulator_list_voltage_linear,
	.set_voltage_sel = regulator_set_voltage_sel_regmap,
	.get_voltage_sel = regulator_get_voltage_sel_regmap,
};

static struct regulator_ops max8907_fixed_ops = {
	.list_voltage = regulator_list_voltage_linear,
};

static struct regulator_ops max8907_out5v_ops = {
	.list_voltage = regulator_list_voltage_linear,
	.enable = regulator_enable_regmap,
	.disable = regulator_disable_regmap,
	.is_enabled = regulator_is_enabled_regmap,
};

static struct regulator_ops max8907_out5v_hwctl_ops = {
	.list_voltage = regulator_list_voltage_linear,
};

static struct regulator_ops max8907_bbat_ops = {
	.list_voltage = regulator_list_voltage_linear,
	.set_voltage_sel = regulator_set_voltage_sel_regmap,
	.get_voltage_sel = regulator_get_voltage_sel_regmap,
};

static struct regulator_desc max8907_regulators[] = {
	REG_MBATT(),
	REG_LDO(SD1, "in-v1", MAX8907_REG_SDCTL1, 650000, 2225000, 25000),
	REG_LDO(SD2, "in-v2", MAX8907_REG_SDCTL2, 637500, 1425000, 12500),
	REG_LDO(SD3, "in-v3", MAX8907_REG_SDCTL3, 750000, 3900000, 50000),
	LDO_750_50(LDO1, "in1", MAX8907_REG_LDOCTL1),
	LDO_650_25(LDO2, "in2", MAX8907_REG_LDOCTL2),
	LDO_650_25(LDO3, "in3", MAX8907_REG_LDOCTL3),
	LDO_750_50(LDO4, "in4", MAX8907_REG_LDOCTL4),
	LDO_750_50(LDO5, "in5", MAX8907_REG_LDOCTL5),
	LDO_750_50(LDO6, "in6", MAX8907_REG_LDOCTL6),
	LDO_750_50(LDO7, "in7", MAX8907_REG_LDOCTL7),
	LDO_750_50(LDO8, "in8", MAX8907_REG_LDOCTL8),
	LDO_750_50(LDO9, "in9", MAX8907_REG_LDOCTL9),
	LDO_750_50(LDO10, "in10", MAX8907_REG_LDOCTL10),
	LDO_750_50(LDO11, "in11", MAX8907_REG_LDOCTL11),
	LDO_750_50(LDO12, "in12", MAX8907_REG_LDOCTL12),
	LDO_750_50(LDO13, "in13", MAX8907_REG_LDOCTL13),
	LDO_750_50(LDO14, "in14", MAX8907_REG_LDOCTL14),
	LDO_750_50(LDO15, "in15", MAX8907_REG_LDOCTL15),
	LDO_750_50(LDO16, "in16", MAX8907_REG_LDOCTL16),
	LDO_650_25(LDO17, "in17", MAX8907_REG_LDOCTL17),
	LDO_650_25(LDO18, "in18", MAX8907_REG_LDOCTL18),
	LDO_750_50(LDO19, "in19", MAX8907_REG_LDOCTL19),
	LDO_750_50(LDO20, "in20", MAX8907_REG_LDOCTL20),
	REG_OUT5V(OUT5V, "mbatt", MAX8907_REG_OUT5VEN, 5000000),
	REG_OUT5V(OUT33V, "mbatt",  MAX8907_REG_OUT33VEN, 3300000),
	REG_BBAT(BBAT, "MBATT", MAX8907_REG_BBAT_CNFG,
						2400000, 3000000, 200000),
	REG_FIXED(SDBY, "MBATT", 1200000),
	REG_FIXED(VRTC, "MBATT", 3300000),
};

#ifdef CONFIG_OF

#define MATCH(_name, _id) \
	[MAX8907_##_id] = { \
		.name = #_name, \
		.driver_data = (void *)&max8907_regulators[MAX8907_##_id], \
	}

static struct of_regulator_match max8907_matches[] = {
	MATCH(mbatt, MBATT),
	MATCH(sd1, SD1),
	MATCH(sd2, SD2),
	MATCH(sd3, SD3),
	MATCH(ldo1, LDO1),
	MATCH(ldo2, LDO2),
	MATCH(ldo3, LDO3),
	MATCH(ldo4, LDO4),
	MATCH(ldo5, LDO5),
	MATCH(ldo6, LDO6),
	MATCH(ldo7, LDO7),
	MATCH(ldo8, LDO8),
	MATCH(ldo9, LDO9),
	MATCH(ldo10, LDO10),
	MATCH(ldo11, LDO11),
	MATCH(ldo12, LDO12),
	MATCH(ldo13, LDO13),
	MATCH(ldo14, LDO14),
	MATCH(ldo15, LDO15),
	MATCH(ldo16, LDO16),
	MATCH(ldo17, LDO17),
	MATCH(ldo18, LDO18),
	MATCH(ldo19, LDO19),
	MATCH(ldo20, LDO20),
	MATCH(out5v, OUT5V),
	MATCH(out33v, OUT33V),
	MATCH(bbat, BBAT),
	MATCH(sdby, SDBY),
	MATCH(vrtc, VRTC),
};

static int max8907_regulator_parse_dt(struct platform_device *pdev)
{
	struct device_node *np = pdev->dev.parent->of_node;
	struct device_node *regulators;
	int ret;

	if (!pdev->dev.parent->of_node)
		return 0;

	regulators = of_find_node_by_name(np, "regulators");
	if (!regulators) {
		dev_err(&pdev->dev, "regulators node not found\n");
		return -EINVAL;
	}

	ret = of_regulator_match(pdev->dev.parent, regulators,
				 max8907_matches,
				 ARRAY_SIZE(max8907_matches));
	if (ret < 0) {
		dev_err(&pdev->dev, "Error parsing regulator init data: %d\n",
			ret);
		return ret;
	}

	return 0;
}

static inline struct regulator_init_data *match_init_data(int index)
{
	return max8907_matches[index].init_data;
}

static inline struct device_node *match_of_node(int index)
{
	return max8907_matches[index].of_node;
}
#else
static int max8907_regulator_parse_dt(struct platform_device *pdev)
{
	return 0;
}

static inline struct regulator_init_data *match_init_data(int index)
{
	return NULL;
}

static inline struct device_node *match_of_node(int index)
{
	return NULL;
}
#endif

static __devinit int max8907_regulator_probe(struct platform_device *pdev)
{
	struct max8907 *max8907 = dev_get_drvdata(pdev->dev.parent);
	struct max8907_platform_data *pdata = dev_get_platdata(max8907->dev);
	int ret;
	struct max8907_regulator *pmic;
	unsigned int val;
	int i;
	struct regulator_config config = {};
	struct regulator_init_data *idata;
	const char *mbatt_rail_name = NULL;

	ret = max8907_regulator_parse_dt(pdev);
	if (ret)
		return ret;

	pmic = devm_kzalloc(&pdev->dev, sizeof(*pmic), GFP_KERNEL);
	if (!pmic) {
		dev_err(&pdev->dev, "Failed to alloc pmic\n");
		return -ENOMEM;
	}
	platform_set_drvdata(pdev, pmic);

	memcpy(pmic->desc, max8907_regulators, sizeof(pmic->desc));

	/* Backwards compatibility with MAX8907B; SD1 uses different voltages */
	regmap_read(max8907->regmap_gen, MAX8907_REG_II2RR, &val);
	if ((val & MAX8907_II2RR_VERSION_MASK) ==
	    MAX8907_II2RR_VERSION_REV_B) {
		pmic->desc[MAX8907_SD1].min_uV = 637500;
		pmic->desc[MAX8907_SD1].uV_step = 12500;
		pmic->desc[MAX8907_SD1].n_voltages =
						(1425000 - 637500) / 12500 + 1;
	}

	for (i = 0; i < MAX8907_NUM_REGULATORS; i++) {
		config.dev = pdev->dev.parent;
		if (pdata)
			idata = pdata->init_data[i];
		else
			idata = match_init_data(i);
		config.init_data = idata;
		config.driver_data = pmic;
		config.regmap = max8907->regmap_gen;
		config.of_node = match_of_node(i);

		switch (pmic->desc[i].id) {
		case MAX8907_MBATT:
			mbatt_rail_name = idata->constraints.name;
			break;
		case MAX8907_BBAT:
		case MAX8907_SDBY:
		case MAX8907_VRTC:
			idata->supply_regulator = mbatt_rail_name;
			break;
		}

		if (pmic->desc[i].ops == &max8907_ldo_ops) {
			regmap_read(config.regmap, pmic->desc[i].enable_reg,
				    &val);
			if ((val & MAX8907_MASK_LDO_SEQ) !=
			    MAX8907_MASK_LDO_SEQ)
				pmic->desc[i].ops = &max8907_ldo_hwctl_ops;
		} else if (pmic->desc[i].ops == &max8907_out5v_ops) {
			regmap_read(config.regmap, pmic->desc[i].enable_reg,
				    &val);
			if ((val & (MAX8907_MASK_OUT5V_VINEN |
						MAX8907_MASK_OUT5V_ENSRC)) !=
			    MAX8907_MASK_OUT5V_ENSRC)
				pmic->desc[i].ops = &max8907_out5v_hwctl_ops;
		}

		pmic->rdev[i] = regulator_register(&pmic->desc[i], &config);
		if (IS_ERR(pmic->rdev[i])) {
			dev_err(&pdev->dev,
				"failed to register %s regulator\n",
				pmic->desc[i].name);
			ret = PTR_ERR(pmic->rdev[i]);
			goto err_unregister_regulator;
		}
	}

	return 0;

err_unregister_regulator:
	while (--i >= 0)
		regulator_unregister(pmic->rdev[i]);
	return ret;
}

static __devexit int max8907_regulator_remove(struct platform_device *pdev)
{
	struct max8907_regulator *pmic = platform_get_drvdata(pdev);
	int i;

	for (i = 0; i < MAX8907_NUM_REGULATORS; i++)
		regulator_unregister(pmic->rdev[i]);

	return 0;
}

static struct platform_driver max8907_regulator_driver = {
	.driver = {
		   .name = "max8907-regulator",
		   .owner = THIS_MODULE,
		   },
	.probe = max8907_regulator_probe,
	.remove = __devexit_p(max8907_regulator_remove),
};

static int __init max8907_regulator_init(void)
{
	return platform_driver_register(&max8907_regulator_driver);
}

subsys_initcall(max8907_regulator_init);

static void __exit max8907_reg_exit(void)
{
	platform_driver_unregister(&max8907_regulator_driver);
}

module_exit(max8907_reg_exit);

MODULE_DESCRIPTION("MAX8907 regulator driver");
MODULE_AUTHOR("Gyungoh Yoo <jack.yoo@maxim-ic.com>");
MODULE_LICENSE("GPL v2");
Commit	Line	Data
ffee1909 GY	1	/*
	2	* max8907-regulator.c -- support regulators in max8907
	3	*
	4	* Copyright (C) 2010 Gyungoh Yoo <jack.yoo@maxim-ic.com>
	5	* Copyright (C) 2010-2012, NVIDIA CORPORATION. All rights reserved.
	6	*
	7	* Portions based on drivers/regulator/tps65910-regulator.c,
	8	* Copyright 2010 Texas Instruments Inc.
	9	* Author: Graeme Gregory <gg@slimlogic.co.uk>
	10	* Author: Jorge Eduardo Candelaria <jedu@slimlogic.co.uk>
	11	*
	12	* This program is free software; you can redistribute it and/or modify
	13	* it under the terms of the GNU General Public License version 2 as
	14	* published by the Free Software Foundation.
	15	*/
	16
	17	#include <linux/err.h>
	18	#include <linux/init.h>
	19	#include <linux/mfd/core.h>
	20	#include <linux/mfd/max8907.h>
	21	#include <linux/module.h>
	22	#include <linux/of.h>
	23	#include <linux/platform_device.h>
	24	#include <linux/regulator/driver.h>
	25	#include <linux/regulator/machine.h>
	26	#include <linux/regulator/of_regulator.h>
	27	#include <linux/regmap.h>
	28	#include <linux/slab.h>
	29
	30	#define MAX8907_II2RR_VERSION_MASK 0xF0
	31	#define MAX8907_II2RR_VERSION_REV_A 0x00
	32	#define MAX8907_II2RR_VERSION_REV_B 0x10
	33	#define MAX8907_II2RR_VERSION_REV_C 0x30
	34
	35	struct max8907_regulator {
	36	struct regulator_desc desc[MAX8907_NUM_REGULATORS];
	37	struct regulator_dev *rdev[MAX8907_NUM_REGULATORS];
	38	};
	39
	40	#define REG_MBATT() \
	41	[MAX8907_MBATT] = { \
	42	.name = "MBATT", \
	43	.supply_name = "mbatt", \
	44	.id = MAX8907_MBATT, \
	45	.ops = &max8907_mbatt_ops, \
	46	.type = REGULATOR_VOLTAGE, \
	47	.owner = THIS_MODULE, \
	48	}
	49
	50	#define REG_LDO(ids, supply, base, min, max, step) \
	51	[MAX8907_##ids] = { \
	52	.name = #ids, \
	53	.supply_name = supply, \
	54	.id = MAX8907_##ids, \
	55	.n_voltages = ((max) - (min)) / (step) + 1, \
	56	.ops = &max8907_ldo_ops, \
	57	.type = REGULATOR_VOLTAGE, \
	58	.owner = THIS_MODULE, \
	59	.min_uV = (min), \
	60	.uV_step = (step), \
	61	.vsel_reg = (base) + MAX8907_VOUT, \
	62	.vsel_mask = 0x3f, \
	63	.enable_reg = (base) + MAX8907_CTL, \
	64	.enable_mask = MAX8907_MASK_LDO_EN, \
65	}
66
67	#define REG_FIXED(ids, supply, voltage) \
68	[MAX8907_##ids] = { \
69	.name = #ids, \
70	.supply_name = supply, \
71	.id = MAX8907_##ids, \
72	.n_voltages = 1, \
73	.ops = &max8907_fixed_ops, \
74	.type = REGULATOR_VOLTAGE, \
75	.owner = THIS_MODULE, \
76	.min_uV = (voltage), \
77	}
78
79	#define REG_OUT5V(ids, supply, base, voltage) \
80	[MAX8907_##ids] = { \
81	.name = #ids, \
82	.supply_name = supply, \
83	.id = MAX8907_##ids, \
84	.n_voltages = 1, \
85	.ops = &max8907_out5v_ops, \
86	.type = REGULATOR_VOLTAGE, \
87	.owner = THIS_MODULE, \
88	.min_uV = (voltage), \
89	.enable_reg = (base), \
90	.enable_mask = MAX8907_MASK_OUT5V_EN, \
91	}
92
93	#define REG_BBAT(ids, supply, base, min, max, step) \
94	[MAX8907_##ids] = { \
95	.name = #ids, \
96	.supply_name = supply, \
97	.id = MAX8907_##ids, \
98	.n_voltages = ((max) - (min)) / (step) + 1, \
99	.ops = &max8907_bbat_ops, \
100	.type = REGULATOR_VOLTAGE, \
101	.owner = THIS_MODULE, \
102	.min_uV = (min), \
103	.uV_step = (step), \
104	.vsel_reg = (base), \
105	.vsel_mask = MAX8907_MASK_VBBATTCV, \
106	}
107
108	#define LDO_750_50(id, supply, base) REG_LDO(id, supply, (base), \
109	750000, 3900000, 50000)
110	#define LDO_650_25(id, supply, base) REG_LDO(id, supply, (base), \
111	650000, 2225000, 25000)
112
113	static struct regulator_ops max8907_mbatt_ops = {
114	};
115
116	static struct regulator_ops max8907_ldo_ops = {
117	.list_voltage = regulator_list_voltage_linear,
118	.set_voltage_sel = regulator_set_voltage_sel_regmap,
119	.get_voltage_sel = regulator_get_voltage_sel_regmap,
120	.enable = regulator_enable_regmap,
121	.disable = regulator_disable_regmap,
122	.is_enabled = regulator_is_enabled_regmap,
123	};
124
125	static struct regulator_ops max8907_ldo_hwctl_ops = {
126	.list_voltage = regulator_list_voltage_linear,
127	.set_voltage_sel = regulator_set_voltage_sel_regmap,
128	.get_voltage_sel = regulator_get_voltage_sel_regmap,
129	};
130
131	static struct regulator_ops max8907_fixed_ops = {
132	.list_voltage = regulator_list_voltage_linear,
133	};
134
135	static struct regulator_ops max8907_out5v_ops = {
136	.list_voltage = regulator_list_voltage_linear,
137	.enable = regulator_enable_regmap,
138	.disable = regulator_disable_regmap,
139	.is_enabled = regulator_is_enabled_regmap,
140	};
141
142	static struct regulator_ops max8907_out5v_hwctl_ops = {
143	.list_voltage = regulator_list_voltage_linear,
144	};
145
146	static struct regulator_ops max8907_bbat_ops = {
147	.list_voltage = regulator_list_voltage_linear,
148	.set_voltage_sel = regulator_set_voltage_sel_regmap,
149	.get_voltage_sel = regulator_get_voltage_sel_regmap,
150	};
151
152	static struct regulator_desc max8907_regulators[] = {
153	REG_MBATT(),
154	REG_LDO(SD1, "in-v1", MAX8907_REG_SDCTL1, 650000, 2225000, 25000),
155	REG_LDO(SD2, "in-v2", MAX8907_REG_SDCTL2, 637500, 1425000, 12500),
156	REG_LDO(SD3, "in-v3", MAX8907_REG_SDCTL3, 750000, 3900000, 50000),
157	LDO_750_50(LDO1, "in1", MAX8907_REG_LDOCTL1),
158	LDO_650_25(LDO2, "in2", MAX8907_REG_LDOCTL2),
159	LDO_650_25(LDO3, "in3", MAX8907_REG_LDOCTL3),
160	LDO_750_50(LDO4, "in4", MAX8907_REG_LDOCTL4),
161	LDO_750_50(LDO5, "in5", MAX8907_REG_LDOCTL5),
162	LDO_750_50(LDO6, "in6", MAX8907_REG_LDOCTL6),
163	LDO_750_50(LDO7, "in7", MAX8907_REG_LDOCTL7),
164	LDO_750_50(LDO8, "in8", MAX8907_REG_LDOCTL8),
165	LDO_750_50(LDO9, "in9", MAX8907_REG_LDOCTL9),
166	LDO_750_50(LDO10, "in10", MAX8907_REG_LDOCTL10),
167	LDO_750_50(LDO11, "in11", MAX8907_REG_LDOCTL11),
168	LDO_750_50(LDO12, "in12", MAX8907_REG_LDOCTL12),
169	LDO_750_50(LDO13, "in13", MAX8907_REG_LDOCTL13),
170	LDO_750_50(LDO14, "in14", MAX8907_REG_LDOCTL14),
171	LDO_750_50(LDO15, "in15", MAX8907_REG_LDOCTL15),
172	LDO_750_50(LDO16, "in16", MAX8907_REG_LDOCTL16),
173	LDO_650_25(LDO17, "in17", MAX8907_REG_LDOCTL17),
174	LDO_650_25(LDO18, "in18", MAX8907_REG_LDOCTL18),
175	LDO_750_50(LDO19, "in19", MAX8907_REG_LDOCTL19),
176	LDO_750_50(LDO20, "in20", MAX8907_REG_LDOCTL20),
177	REG_OUT5V(OUT5V, "mbatt", MAX8907_REG_OUT5VEN, 5000000),
178	REG_OUT5V(OUT33V, "mbatt", MAX8907_REG_OUT33VEN, 3300000),
179	REG_BBAT(BBAT, "MBATT", MAX8907_REG_BBAT_CNFG,
180	2400000, 3000000, 200000),
181	REG_FIXED(SDBY, "MBATT", 1200000),
182	REG_FIXED(VRTC, "MBATT", 3300000),
183	};
184
185	#ifdef CONFIG_OF
186
187	#define MATCH(_name, _id) \
188	[MAX8907_##_id] = { \
189	.name = #_name, \
190	.driver_data = (void *)&max8907_regulators[MAX8907_##_id], \
191	}
192
193	static struct of_regulator_match max8907_matches[] = {
194	MATCH(mbatt, MBATT),
195	MATCH(sd1, SD1),
196	MATCH(sd2, SD2),
197	MATCH(sd3, SD3),
198	MATCH(ldo1, LDO1),
199	MATCH(ldo2, LDO2),
200	MATCH(ldo3, LDO3),
201	MATCH(ldo4, LDO4),
202	MATCH(ldo5, LDO5),
203	MATCH(ldo6, LDO6),
204	MATCH(ldo7, LDO7),
205	MATCH(ldo8, LDO8),
206	MATCH(ldo9, LDO9),
207	MATCH(ldo10, LDO10),
208	MATCH(ldo11, LDO11),
209	MATCH(ldo12, LDO12),
210	MATCH(ldo13, LDO13),
211	MATCH(ldo14, LDO14),
212	MATCH(ldo15, LDO15),
213	MATCH(ldo16, LDO16),
214	MATCH(ldo17, LDO17),
215	MATCH(ldo18, LDO18),
216	MATCH(ldo19, LDO19),
217	MATCH(ldo20, LDO20),
218	MATCH(out5v, OUT5V),
219	MATCH(out33v, OUT33V),
220	MATCH(bbat, BBAT),
221	MATCH(sdby, SDBY),
222	MATCH(vrtc, VRTC),
223	};
224
225	static int max8907_regulator_parse_dt(struct platform_device *pdev)
226	{
227	struct device_node *np = pdev->dev.parent->of_node;
228	struct device_node *regulators;
229	int ret;
230
231	if (!pdev->dev.parent->of_node)
232	return 0;
233
234	regulators = of_find_node_by_name(np, "regulators");
235	if (!regulators) {
236	dev_err(&pdev->dev, "regulators node not found\n");
237	return -EINVAL;
238	}
239
240	ret = of_regulator_match(pdev->dev.parent, regulators,
241	max8907_matches,
242	ARRAY_SIZE(max8907_matches));
243	if (ret < 0) {
244	dev_err(&pdev->dev, "Error parsing regulator init data: %d\n",
245	ret);
246	return ret;
247	}
248
249	return 0;
250	}
db551682 SW	251
	252	static inline struct regulator_init_data *match_init_data(int index)
	253	{
	254	return max8907_matches[index].init_data;
	255	}
	256
	257	static inline struct device_node *match_of_node(int index)
	258	{
	259	return max8907_matches[index].of_node;
	260	}
ffee1909 GY	261	#else
	262	static int max8907_regulator_parse_dt(struct platform_device *pdev)
	263	{
	264	return 0;
	265	}
db551682 SW	266
	267	static inline struct regulator_init_data *match_init_data(int index)
	268	{
	269	return NULL;
	270	}
	271
	272	static inline struct device_node *match_of_node(int index)
	273	{
	274	return NULL;
	275	}
ffee1909 GY	276	#endif
	277
	278	static __devinit int max8907_regulator_probe(struct platform_device *pdev)
	279	{
	280	struct max8907 *max8907 = dev_get_drvdata(pdev->dev.parent);
	281	struct max8907_platform_data *pdata = dev_get_platdata(max8907->dev);
	282	int ret;
	283	struct max8907_regulator *pmic;
	284	unsigned int val;
	285	int i;
	286	struct regulator_config config = {};
	287	struct regulator_init_data *idata;
	288	const char *mbatt_rail_name = NULL;
	289
	290	ret = max8907_regulator_parse_dt(pdev);
	291	if (ret)
	292	return ret;
	293
	294	pmic = devm_kzalloc(&pdev->dev, sizeof(*pmic), GFP_KERNEL);
	295	if (!pmic) {
	296	dev_err(&pdev->dev, "Failed to alloc pmic\n");
	297	return -ENOMEM;
	298	}
	299	platform_set_drvdata(pdev, pmic);
	300
	301	memcpy(pmic->desc, max8907_regulators, sizeof(pmic->desc));
	302
	303	/* Backwards compatibility with MAX8907B; SD1 uses different voltages */
	304	regmap_read(max8907->regmap_gen, MAX8907_REG_II2RR, &val);
	305	if ((val & MAX8907_II2RR_VERSION_MASK) ==
	306	MAX8907_II2RR_VERSION_REV_B) {
	307	pmic->desc[MAX8907_SD1].min_uV = 637500;
	308	pmic->desc[MAX8907_SD1].uV_step = 12500;
7305608b AL	309	pmic->desc[MAX8907_SD1].n_voltages =
7305608b AL	310	(1425000 - 637500) / 12500 + 1;
ffee1909 GY	311	}
	312
	313	for (i = 0; i < MAX8907_NUM_REGULATORS; i++) {
	314	config.dev = pdev->dev.parent;
	315	if (pdata)
	316	idata = pdata->init_data[i];
	317	else
db551682	318	idata = match_init_data(i);
ffee1909 GY	319	config.init_data = idata;
	320	config.driver_data = pmic;
	321	config.regmap = max8907->regmap_gen;
db551682	322	config.of_node = match_of_node(i);
ffee1909 GY	323
	324	switch (pmic->desc[i].id) {
	325	case MAX8907_MBATT:
	326	mbatt_rail_name = idata->constraints.name;
	327	break;
	328	case MAX8907_BBAT:
	329	case MAX8907_SDBY:
	330	case MAX8907_VRTC:
	331	idata->supply_regulator = mbatt_rail_name;
	332	break;
	333	}
	334
	335	if (pmic->desc[i].ops == &max8907_ldo_ops) {
	336	regmap_read(config.regmap, pmic->desc[i].enable_reg,
	337	&val);
	338	if ((val & MAX8907_MASK_LDO_SEQ) !=
	339	MAX8907_MASK_LDO_SEQ)
	340	pmic->desc[i].ops = &max8907_ldo_hwctl_ops;
	341	} else if (pmic->desc[i].ops == &max8907_out5v_ops) {
	342	regmap_read(config.regmap, pmic->desc[i].enable_reg,
	343	&val);
	344	if ((val & (MAX8907_MASK_OUT5V_VINEN \|
	345	MAX8907_MASK_OUT5V_ENSRC)) !=
	346	MAX8907_MASK_OUT5V_ENSRC)
	347	pmic->desc[i].ops = &max8907_out5v_hwctl_ops;
	348	}
	349
	350	pmic->rdev[i] = regulator_register(&pmic->desc[i], &config);
	351	if (IS_ERR(pmic->rdev[i])) {
	352	dev_err(&pdev->dev,
	353	"failed to register %s regulator\n",
	354	pmic->desc[i].name);
	355	ret = PTR_ERR(pmic->rdev[i]);
	356	goto err_unregister_regulator;
	357	}
	358	}
	359
	360	return 0;
	361
	362	err_unregister_regulator:
	363	while (--i >= 0)
	364	regulator_unregister(pmic->rdev[i]);
	365	return ret;
	366	}
	367
	368	static __devexit int max8907_regulator_remove(struct platform_device *pdev)
	369	{
0764ef59	370	struct max8907_regulator *pmic = platform_get_drvdata(pdev);
ffee1909 GY	371	int i;
	372
	373	for (i = 0; i < MAX8907_NUM_REGULATORS; i++)
	374	regulator_unregister(pmic->rdev[i]);
	375
	376	return 0;
	377	}
	378
	379	static struct platform_driver max8907_regulator_driver = {
	380	.driver = {
	381	.name = "max8907-regulator",
	382	.owner = THIS_MODULE,
	383	},
	384	.probe = max8907_regulator_probe,
	385	.remove = __devexit_p(max8907_regulator_remove),
	386	};
	387
	388	static int __init max8907_regulator_init(void)
	389	{
	390	return platform_driver_register(&max8907_regulator_driver);
	391	}
	392
	393	subsys_initcall(max8907_regulator_init);
	394
	395	static void __exit max8907_reg_exit(void)
	396	{
	397	platform_driver_unregister(&max8907_regulator_driver);
	398	}
	399
	400	module_exit(max8907_reg_exit);
	401
	402	MODULE_DESCRIPTION("MAX8907 regulator driver");
	403	MODULE_AUTHOR("Gyungoh Yoo <jack.yoo@maxim-ic.com>");
	404	MODULE_LICENSE("GPL v2");