2 * Device driver for regulators in Hi655x IC
4 * Copyright (c) 2016 Hisilicon.
7 * Chen Feng <puck.chen@hisilicon.com>
8 * Fei Wang <w.f@huawei.com>
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License version 2 as
12 * published by the Free Software Foundation.
15 #include <linux/bitops.h>
16 #include <linux/device.h>
17 #include <linux/err.h>
18 #include <linux/module.h>
21 #include <linux/platform_device.h>
22 #include <linux/regmap.h>
23 #include <linux/regulator/driver.h>
24 #include <linux/regulator/machine.h>
25 #include <linux/regulator/of_regulator.h>
26 #include <linux/mfd/hi655x-pmic.h>
28 struct hi655x_regulator
{
29 unsigned int disable_reg
;
30 unsigned int status_reg
;
31 unsigned int ctrl_regs
;
32 unsigned int ctrl_mask
;
33 struct regulator_desc rdesc
;
37 static const unsigned int ldo7_voltages
[] = {
38 1800000, 1850000, 2850000, 2900000,
39 3000000, 3100000, 3200000, 3300000,
42 static const unsigned int ldo19_voltages
[] = {
43 1800000, 1850000, 1900000, 1750000,
44 2800000, 2850000, 2900000, 3000000,
47 static const unsigned int ldo22_voltages
[] = {
48 900000, 1000000, 1050000, 1100000,
49 1150000, 1175000, 1185000, 1200000,
52 enum hi655x_regulator_id
{
78 static int hi655x_is_enabled(struct regulator_dev
*rdev
)
80 unsigned int value
= 0;
82 struct hi655x_regulator
*regulator
= rdev_get_drvdata(rdev
);
84 regmap_read(rdev
->regmap
, regulator
->status_reg
, &value
);
85 return (value
& BIT(regulator
->ctrl_mask
));
88 static int hi655x_disable(struct regulator_dev
*rdev
)
92 struct hi655x_regulator
*regulator
= rdev_get_drvdata(rdev
);
94 ret
= regmap_write(rdev
->regmap
, regulator
->disable_reg
,
95 BIT(regulator
->ctrl_mask
));
99 static struct regulator_ops hi655x_regulator_ops
= {
100 .enable
= regulator_enable_regmap
,
101 .disable
= hi655x_disable
,
102 .is_enabled
= hi655x_is_enabled
,
103 .list_voltage
= regulator_list_voltage_table
,
104 .get_voltage_sel
= regulator_get_voltage_sel_regmap
,
105 .set_voltage_sel
= regulator_set_voltage_sel_regmap
,
108 static struct regulator_ops hi655x_ldo_linear_ops
= {
109 .enable
= regulator_enable_regmap
,
110 .disable
= hi655x_disable
,
111 .is_enabled
= hi655x_is_enabled
,
112 .list_voltage
= regulator_list_voltage_linear
,
113 .get_voltage_sel
= regulator_get_voltage_sel_regmap
,
114 .set_voltage_sel
= regulator_set_voltage_sel_regmap
,
117 #define HI655X_LDO(_ID, vreg, vmask, ereg, dreg, \
118 sreg, cmask, vtable) { \
121 .of_match = of_match_ptr(#_ID), \
122 .ops = &hi655x_regulator_ops, \
123 .regulators_node = of_match_ptr("regulators"), \
124 .type = REGULATOR_VOLTAGE, \
125 .id = HI655X_##_ID, \
126 .owner = THIS_MODULE, \
127 .n_voltages = ARRAY_SIZE(vtable), \
128 .volt_table = vtable, \
129 .vsel_reg = HI655X_BUS_ADDR(vreg), \
130 .vsel_mask = vmask, \
131 .enable_reg = HI655X_BUS_ADDR(ereg), \
132 .enable_mask = BIT(cmask), \
134 .disable_reg = HI655X_BUS_ADDR(dreg), \
135 .status_reg = HI655X_BUS_ADDR(sreg), \
136 .ctrl_mask = cmask, \
139 #define HI655X_LDO_LINEAR(_ID, vreg, vmask, ereg, dreg, \
140 sreg, cmask, minv, nvolt, vstep) { \
143 .of_match = of_match_ptr(#_ID), \
144 .ops = &hi655x_ldo_linear_ops, \
145 .regulators_node = of_match_ptr("regulators"), \
146 .type = REGULATOR_VOLTAGE, \
147 .id = HI655X_##_ID, \
148 .owner = THIS_MODULE, \
150 .n_voltages = nvolt, \
152 .vsel_reg = HI655X_BUS_ADDR(vreg), \
153 .vsel_mask = vmask, \
154 .enable_reg = HI655X_BUS_ADDR(ereg), \
155 .enable_mask = BIT(cmask), \
157 .disable_reg = HI655X_BUS_ADDR(dreg), \
158 .status_reg = HI655X_BUS_ADDR(sreg), \
159 .ctrl_mask = cmask, \
162 static struct hi655x_regulator regulators
[] = {
163 HI655X_LDO_LINEAR(LDO2
, 0x72, 0x07, 0x29, 0x2a, 0x2b, 0x01,
165 HI655X_LDO(LDO7
, 0x78, 0x07, 0x29, 0x2a, 0x2b, 0x06, ldo7_voltages
),
166 HI655X_LDO(LDO10
, 0x78, 0x07, 0x29, 0x2a, 0x2b, 0x01, ldo7_voltages
),
167 HI655X_LDO_LINEAR(LDO13
, 0x7e, 0x07, 0x2c, 0x2d, 0x2e, 0x04,
169 HI655X_LDO_LINEAR(LDO14
, 0x7f, 0x07, 0x2c, 0x2d, 0x2e, 0x05,
171 HI655X_LDO_LINEAR(LDO15
, 0x80, 0x07, 0x2c, 0x2d, 0x2e, 0x06,
173 HI655X_LDO_LINEAR(LDO17
, 0x82, 0x07, 0x2f, 0x30, 0x31, 0x00,
175 HI655X_LDO(LDO19
, 0x84, 0x07, 0x2f, 0x30, 0x31, 0x02, ldo19_voltages
),
176 HI655X_LDO_LINEAR(LDO21
, 0x86, 0x07, 0x2f, 0x30, 0x31, 0x04,
178 HI655X_LDO(LDO22
, 0x87, 0x07, 0x2f, 0x30, 0x31, 0x05, ldo22_voltages
),
181 static int hi655x_regulator_probe(struct platform_device
*pdev
)
184 struct hi655x_regulator
*regulator
;
185 struct hi655x_pmic
*pmic
;
186 struct regulator_config config
= { };
187 struct regulator_dev
*rdev
;
189 pmic
= dev_get_drvdata(pdev
->dev
.parent
);
191 dev_err(&pdev
->dev
, "no pmic in the regulator parent node\n");
195 regulator
= devm_kzalloc(&pdev
->dev
, sizeof(*regulator
), GFP_KERNEL
);
199 platform_set_drvdata(pdev
, regulator
);
201 config
.dev
= pdev
->dev
.parent
;
202 config
.regmap
= pmic
->regmap
;
203 config
.driver_data
= regulator
;
204 for (i
= 0; i
< ARRAY_SIZE(regulators
); i
++) {
205 rdev
= devm_regulator_register(&pdev
->dev
,
206 ®ulators
[i
].rdesc
,
209 dev_err(&pdev
->dev
, "failed to register regulator %s\n",
210 regulator
->rdesc
.name
);
211 return PTR_ERR(rdev
);
217 static const struct platform_device_id hi655x_regulator_table
[] = {
218 { .name
= "hi655x-regulator" },
221 MODULE_DEVICE_TABLE(platform
, hi655x_regulator_table
);
223 static struct platform_driver hi655x_regulator_driver
= {
224 .id_table
= hi655x_regulator_table
,
226 .name
= "hi655x-regulator",
228 .probe
= hi655x_regulator_probe
,
230 module_platform_driver(hi655x_regulator_driver
);
232 MODULE_AUTHOR("Chen Feng <puck.chen@hisilicon.com>");
233 MODULE_DESCRIPTION("Hisilicon Hi655x regulator driver");
234 MODULE_LICENSE("GPL v2");