Commit | Line | Data |
---|---|---|
49f53951 | 1 | // SPDX-License-Identifier: GPL-2.0 |
e85c5a15 MV |
2 | /* |
3 | * ROHM BD9571MWV-M regulator driver | |
4 | * | |
5 | * Copyright (C) 2017 Marek Vasut <marek.vasut+renesas@gmail.com> | |
6 | * | |
e85c5a15 MV |
7 | * Based on the TPS65086 driver |
8 | * | |
9 | * NOTE: VD09 is missing | |
10 | */ | |
11 | ||
12 | #include <linux/module.h> | |
13 | #include <linux/of.h> | |
14 | #include <linux/platform_device.h> | |
15 | #include <linux/regulator/driver.h> | |
16 | ||
17 | #include <linux/mfd/bd9571mwv.h> | |
18 | ||
6eb0bfae GU |
19 | struct bd9571mwv_reg { |
20 | struct bd9571mwv *bd; | |
21 | ||
22 | /* DDR Backup Power */ | |
23 | u8 bkup_mode_cnt_keepon; /* from "rohm,ddr-backup-power" */ | |
24 | u8 bkup_mode_cnt_saved; | |
02b3a073 | 25 | bool bkup_mode_enabled; |
6eb0bfae GU |
26 | |
27 | /* Power switch type */ | |
28 | bool rstbmode_level; | |
29 | bool rstbmode_pulse; | |
30 | }; | |
31 | ||
e85c5a15 MV |
32 | enum bd9571mwv_regulators { VD09, VD18, VD25, VD33, DVFS }; |
33 | ||
34 | #define BD9571MWV_REG(_name, _of, _id, _ops, _vr, _vm, _nv, _min, _step, _lmin)\ | |
35 | { \ | |
36 | .name = _name, \ | |
37 | .of_match = of_match_ptr(_of), \ | |
38 | .regulators_node = "regulators", \ | |
39 | .id = _id, \ | |
40 | .ops = &_ops, \ | |
41 | .n_voltages = _nv, \ | |
42 | .type = REGULATOR_VOLTAGE, \ | |
43 | .owner = THIS_MODULE, \ | |
44 | .vsel_reg = _vr, \ | |
45 | .vsel_mask = _vm, \ | |
46 | .min_uV = _min, \ | |
47 | .uV_step = _step, \ | |
48 | .linear_min_sel = _lmin, \ | |
49 | } | |
50 | ||
cb42b648 | 51 | static int bd9571mwv_avs_get_moni_state(struct regulator_dev *rdev) |
e85c5a15 MV |
52 | { |
53 | unsigned int val; | |
54 | int ret; | |
55 | ||
56 | ret = regmap_read(rdev->regmap, BD9571MWV_AVS_SET_MONI, &val); | |
57 | if (ret != 0) | |
58 | return ret; | |
59 | ||
60 | return val & BD9571MWV_AVS_SET_MONI_MASK; | |
61 | } | |
62 | ||
cb42b648 AL |
63 | static int bd9571mwv_avs_set_voltage_sel_regmap(struct regulator_dev *rdev, |
64 | unsigned int sel) | |
e85c5a15 MV |
65 | { |
66 | int ret; | |
67 | ||
68 | ret = bd9571mwv_avs_get_moni_state(rdev); | |
69 | if (ret < 0) | |
70 | return ret; | |
71 | ||
72 | return regmap_write_bits(rdev->regmap, BD9571MWV_AVS_VD09_VID(ret), | |
73 | rdev->desc->vsel_mask, sel); | |
74 | } | |
75 | ||
cb42b648 | 76 | static int bd9571mwv_avs_get_voltage_sel_regmap(struct regulator_dev *rdev) |
e85c5a15 MV |
77 | { |
78 | unsigned int val; | |
79 | int ret; | |
80 | ||
81 | ret = bd9571mwv_avs_get_moni_state(rdev); | |
82 | if (ret < 0) | |
83 | return ret; | |
84 | ||
85 | ret = regmap_read(rdev->regmap, BD9571MWV_AVS_VD09_VID(ret), &val); | |
86 | if (ret != 0) | |
87 | return ret; | |
88 | ||
89 | val &= rdev->desc->vsel_mask; | |
90 | val >>= ffs(rdev->desc->vsel_mask) - 1; | |
91 | ||
92 | return val; | |
93 | } | |
94 | ||
cb42b648 AL |
95 | static int bd9571mwv_reg_set_voltage_sel_regmap(struct regulator_dev *rdev, |
96 | unsigned int sel) | |
e85c5a15 MV |
97 | { |
98 | return regmap_write_bits(rdev->regmap, BD9571MWV_DVFS_SETVID, | |
99 | rdev->desc->vsel_mask, sel); | |
100 | } | |
101 | ||
102 | /* Operations permitted on AVS voltage regulator */ | |
103 | static struct regulator_ops avs_ops = { | |
104 | .set_voltage_sel = bd9571mwv_avs_set_voltage_sel_regmap, | |
105 | .map_voltage = regulator_map_voltage_linear, | |
106 | .get_voltage_sel = bd9571mwv_avs_get_voltage_sel_regmap, | |
107 | .list_voltage = regulator_list_voltage_linear, | |
108 | }; | |
109 | ||
110 | /* Operations permitted on voltage regulators */ | |
111 | static struct regulator_ops reg_ops = { | |
112 | .set_voltage_sel = bd9571mwv_reg_set_voltage_sel_regmap, | |
113 | .map_voltage = regulator_map_voltage_linear, | |
114 | .get_voltage_sel = regulator_get_voltage_sel_regmap, | |
115 | .list_voltage = regulator_list_voltage_linear, | |
116 | }; | |
117 | ||
118 | /* Operations permitted on voltage monitors */ | |
119 | static struct regulator_ops vid_ops = { | |
120 | .map_voltage = regulator_map_voltage_linear, | |
121 | .get_voltage_sel = regulator_get_voltage_sel_regmap, | |
122 | .list_voltage = regulator_list_voltage_linear, | |
123 | }; | |
124 | ||
125 | static struct regulator_desc regulators[] = { | |
126 | BD9571MWV_REG("VD09", "vd09", VD09, avs_ops, 0, 0x7f, | |
127 | 0x80, 600000, 10000, 0x3c), | |
128 | BD9571MWV_REG("VD18", "vd18", VD18, vid_ops, BD9571MWV_VD18_VID, 0xf, | |
129 | 16, 1625000, 25000, 0), | |
130 | BD9571MWV_REG("VD25", "vd25", VD25, vid_ops, BD9571MWV_VD25_VID, 0xf, | |
131 | 16, 2150000, 50000, 0), | |
132 | BD9571MWV_REG("VD33", "vd33", VD33, vid_ops, BD9571MWV_VD33_VID, 0xf, | |
133 | 11, 2800000, 100000, 0), | |
134 | BD9571MWV_REG("DVFS", "dvfs", DVFS, reg_ops, | |
135 | BD9571MWV_DVFS_MONIVDAC, 0x7f, | |
136 | 0x80, 600000, 10000, 0x3c), | |
137 | }; | |
138 | ||
6eb0bfae GU |
139 | #ifdef CONFIG_PM_SLEEP |
140 | static int bd9571mwv_bkup_mode_read(struct bd9571mwv *bd, unsigned int *mode) | |
141 | { | |
142 | int ret; | |
143 | ||
144 | ret = regmap_read(bd->regmap, BD9571MWV_BKUP_MODE_CNT, mode); | |
145 | if (ret) { | |
146 | dev_err(bd->dev, "failed to read backup mode (%d)\n", ret); | |
147 | return ret; | |
148 | } | |
149 | ||
150 | return 0; | |
151 | } | |
152 | ||
153 | static int bd9571mwv_bkup_mode_write(struct bd9571mwv *bd, unsigned int mode) | |
154 | { | |
155 | int ret; | |
156 | ||
157 | ret = regmap_write(bd->regmap, BD9571MWV_BKUP_MODE_CNT, mode); | |
158 | if (ret) { | |
159 | dev_err(bd->dev, "failed to configure backup mode 0x%x (%d)\n", | |
160 | mode, ret); | |
161 | return ret; | |
162 | } | |
163 | ||
164 | return 0; | |
165 | } | |
166 | ||
02b3a073 GU |
167 | static ssize_t backup_mode_show(struct device *dev, |
168 | struct device_attribute *attr, char *buf) | |
169 | { | |
170 | struct bd9571mwv_reg *bdreg = dev_get_drvdata(dev); | |
171 | ||
172 | return sprintf(buf, "%s\n", bdreg->bkup_mode_enabled ? "on" : "off"); | |
173 | } | |
174 | ||
175 | static ssize_t backup_mode_store(struct device *dev, | |
176 | struct device_attribute *attr, | |
177 | const char *buf, size_t count) | |
178 | { | |
179 | struct bd9571mwv_reg *bdreg = dev_get_drvdata(dev); | |
e436875f | 180 | unsigned int mode; |
02b3a073 GU |
181 | int ret; |
182 | ||
183 | if (!count) | |
184 | return 0; | |
185 | ||
186 | ret = kstrtobool(buf, &bdreg->bkup_mode_enabled); | |
187 | if (ret) | |
188 | return ret; | |
189 | ||
e436875f GU |
190 | if (!bdreg->rstbmode_level) |
191 | return count; | |
192 | ||
193 | /* | |
194 | * Configure DDR Backup Mode, to change the role of the accessory power | |
195 | * switch from a power switch to a wake-up switch, or vice versa | |
196 | */ | |
197 | ret = bd9571mwv_bkup_mode_read(bdreg->bd, &mode); | |
198 | if (ret) | |
199 | return ret; | |
200 | ||
201 | mode &= ~BD9571MWV_BKUP_MODE_CNT_KEEPON_MASK; | |
202 | if (bdreg->bkup_mode_enabled) | |
203 | mode |= bdreg->bkup_mode_cnt_keepon; | |
204 | ||
205 | ret = bd9571mwv_bkup_mode_write(bdreg->bd, mode); | |
206 | if (ret) | |
207 | return ret; | |
208 | ||
02b3a073 GU |
209 | return count; |
210 | } | |
211 | ||
a70a4694 | 212 | static DEVICE_ATTR_RW(backup_mode); |
02b3a073 | 213 | |
6eb0bfae GU |
214 | static int bd9571mwv_suspend(struct device *dev) |
215 | { | |
216 | struct bd9571mwv_reg *bdreg = dev_get_drvdata(dev); | |
217 | unsigned int mode; | |
218 | int ret; | |
219 | ||
02b3a073 | 220 | if (!bdreg->bkup_mode_enabled) |
6eb0bfae GU |
221 | return 0; |
222 | ||
223 | /* Save DDR Backup Mode */ | |
224 | ret = bd9571mwv_bkup_mode_read(bdreg->bd, &mode); | |
225 | if (ret) | |
226 | return ret; | |
227 | ||
228 | bdreg->bkup_mode_cnt_saved = mode; | |
229 | ||
230 | if (!bdreg->rstbmode_pulse) | |
231 | return 0; | |
232 | ||
233 | /* Enable DDR Backup Mode */ | |
234 | mode &= ~BD9571MWV_BKUP_MODE_CNT_KEEPON_MASK; | |
235 | mode |= bdreg->bkup_mode_cnt_keepon; | |
236 | ||
237 | if (mode != bdreg->bkup_mode_cnt_saved) | |
238 | return bd9571mwv_bkup_mode_write(bdreg->bd, mode); | |
239 | ||
240 | return 0; | |
241 | } | |
242 | ||
243 | static int bd9571mwv_resume(struct device *dev) | |
244 | { | |
245 | struct bd9571mwv_reg *bdreg = dev_get_drvdata(dev); | |
246 | ||
02b3a073 | 247 | if (!bdreg->bkup_mode_enabled) |
6eb0bfae GU |
248 | return 0; |
249 | ||
250 | /* Restore DDR Backup Mode */ | |
251 | return bd9571mwv_bkup_mode_write(bdreg->bd, bdreg->bkup_mode_cnt_saved); | |
252 | } | |
253 | ||
254 | static const struct dev_pm_ops bd9571mwv_pm = { | |
255 | SET_SYSTEM_SLEEP_PM_OPS(bd9571mwv_suspend, bd9571mwv_resume) | |
256 | }; | |
257 | ||
02b3a073 GU |
258 | static int bd9571mwv_regulator_remove(struct platform_device *pdev) |
259 | { | |
260 | device_remove_file(&pdev->dev, &dev_attr_backup_mode); | |
261 | return 0; | |
262 | } | |
6eb0bfae GU |
263 | #define DEV_PM_OPS &bd9571mwv_pm |
264 | #else | |
265 | #define DEV_PM_OPS NULL | |
02b3a073 | 266 | #define bd9571mwv_regulator_remove NULL |
6eb0bfae GU |
267 | #endif /* CONFIG_PM_SLEEP */ |
268 | ||
e85c5a15 MV |
269 | static int bd9571mwv_regulator_probe(struct platform_device *pdev) |
270 | { | |
271 | struct bd9571mwv *bd = dev_get_drvdata(pdev->dev.parent); | |
272 | struct regulator_config config = { }; | |
6eb0bfae | 273 | struct bd9571mwv_reg *bdreg; |
e85c5a15 | 274 | struct regulator_dev *rdev; |
6eb0bfae | 275 | unsigned int val; |
e85c5a15 MV |
276 | int i; |
277 | ||
6eb0bfae GU |
278 | bdreg = devm_kzalloc(&pdev->dev, sizeof(*bdreg), GFP_KERNEL); |
279 | if (!bdreg) | |
280 | return -ENOMEM; | |
281 | ||
282 | bdreg->bd = bd; | |
283 | ||
284 | platform_set_drvdata(pdev, bdreg); | |
e85c5a15 MV |
285 | |
286 | config.dev = &pdev->dev; | |
287 | config.dev->of_node = bd->dev->of_node; | |
288 | config.driver_data = bd; | |
289 | config.regmap = bd->regmap; | |
290 | ||
291 | for (i = 0; i < ARRAY_SIZE(regulators); i++) { | |
292 | rdev = devm_regulator_register(&pdev->dev, ®ulators[i], | |
293 | &config); | |
294 | if (IS_ERR(rdev)) { | |
295 | dev_err(bd->dev, "failed to register %s regulator\n", | |
296 | pdev->name); | |
297 | return PTR_ERR(rdev); | |
298 | } | |
299 | } | |
300 | ||
6eb0bfae GU |
301 | val = 0; |
302 | of_property_read_u32(bd->dev->of_node, "rohm,ddr-backup-power", &val); | |
303 | if (val & ~BD9571MWV_BKUP_MODE_CNT_KEEPON_MASK) { | |
304 | dev_err(bd->dev, "invalid %s mode %u\n", | |
305 | "rohm,ddr-backup-power", val); | |
306 | return -EINVAL; | |
307 | } | |
308 | bdreg->bkup_mode_cnt_keepon = val; | |
309 | ||
310 | bdreg->rstbmode_level = of_property_read_bool(bd->dev->of_node, | |
311 | "rohm,rstbmode-level"); | |
312 | bdreg->rstbmode_pulse = of_property_read_bool(bd->dev->of_node, | |
313 | "rohm,rstbmode-pulse"); | |
314 | if (bdreg->rstbmode_level && bdreg->rstbmode_pulse) { | |
315 | dev_err(bd->dev, "only one rohm,rstbmode-* may be specified"); | |
316 | return -EINVAL; | |
317 | } | |
318 | ||
02b3a073 | 319 | #ifdef CONFIG_PM_SLEEP |
6eb0bfae | 320 | if (bdreg->bkup_mode_cnt_keepon) { |
02b3a073 GU |
321 | int ret; |
322 | ||
6eb0bfae | 323 | /* |
02b3a073 | 324 | * Backup mode is enabled by default in pulse mode, but needs |
6eb0bfae GU |
325 | * explicit user setup in level mode. |
326 | */ | |
02b3a073 GU |
327 | bdreg->bkup_mode_enabled = bdreg->rstbmode_pulse; |
328 | ||
329 | ret = device_create_file(&pdev->dev, &dev_attr_backup_mode); | |
330 | if (ret) | |
331 | return ret; | |
6eb0bfae | 332 | } |
02b3a073 | 333 | #endif /* CONFIG_PM_SLEEP */ |
6eb0bfae | 334 | |
e85c5a15 MV |
335 | return 0; |
336 | } | |
337 | ||
338 | static const struct platform_device_id bd9571mwv_regulator_id_table[] = { | |
339 | { "bd9571mwv-regulator", }, | |
340 | { /* sentinel */ } | |
341 | }; | |
342 | MODULE_DEVICE_TABLE(platform, bd9571mwv_regulator_id_table); | |
343 | ||
344 | static struct platform_driver bd9571mwv_regulator_driver = { | |
345 | .driver = { | |
346 | .name = "bd9571mwv-regulator", | |
6eb0bfae | 347 | .pm = DEV_PM_OPS, |
e85c5a15 MV |
348 | }, |
349 | .probe = bd9571mwv_regulator_probe, | |
02b3a073 | 350 | .remove = bd9571mwv_regulator_remove, |
e85c5a15 MV |
351 | .id_table = bd9571mwv_regulator_id_table, |
352 | }; | |
353 | module_platform_driver(bd9571mwv_regulator_driver); | |
354 | ||
355 | MODULE_AUTHOR("Marek Vasut <marek.vasut+renesas@gmail.com>"); | |
356 | MODULE_DESCRIPTION("BD9571MWV Regulator driver"); | |
357 | MODULE_LICENSE("GPL v2"); |