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