2 * Rockchip IO Voltage Domain driver
4 * Copyright 2014 MundoReader S.L.
5 * Copyright 2014 Google, Inc.
7 * This software is licensed under the terms of the GNU General Public
8 * License version 2, as published by the Free Software Foundation, and
9 * may be copied, distributed, and modified under those terms.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
17 #include <linux/kernel.h>
18 #include <linux/module.h>
19 #include <linux/err.h>
20 #include <linux/mfd/syscon.h>
22 #include <linux/platform_device.h>
23 #include <linux/regmap.h>
24 #include <linux/regulator/consumer.h>
26 #define MAX_SUPPLIES 16
29 * The max voltage for 1.8V and 3.3V come from the Rockchip datasheet under
30 * "Recommended Operating Conditions" for "Digital GPIO". When the typical
31 * is 3.3V the max is 3.6V. When the typical is 1.8V the max is 1.98V.
33 * They are used like this:
34 * - If the voltage on a rail is above the "1.8" voltage (1.98V) we'll tell the
36 * - If the voltage on a rail is above the "3.3" voltage (3.6V) we'll consider
37 * that to be an error.
39 #define MAX_VOLTAGE_1_8 1980000
40 #define MAX_VOLTAGE_3_3 3600000
42 #define RK3288_SOC_CON2 0x24c
43 #define RK3288_SOC_CON2_FLASH0 BIT(7)
44 #define RK3288_SOC_FLASH_SUPPLY_NUM 2
46 #define RK3368_GRF_SOC_CON15 0x43c
47 #define RK3368_GRF_SOC_CON15_FLASH0 BIT(14)
48 #define RK3368_SOC_FLASH_SUPPLY_NUM 2
50 #define MAX_ROCKCHIP_GRF_NUM 2
52 struct rockchip_iodomain;
55 * @supplies: voltage settings matching the register bits.
58 enum rockchip_iodomain_grf_type {
63 struct rockchip_iodomain_soc_data {
66 const char *grf_supply_names[MAX_SUPPLIES];
67 const char *pmugrf_supply_names[MAX_SUPPLIES];
68 void (*init)(struct rockchip_iodomain *iod);
71 struct rockchip_iodomain_supply {
72 struct rockchip_iodomain *iod;
73 struct regulator *reg;
74 struct notifier_block nb;
76 enum rockchip_iodomain_grf_type type;
79 struct rockchip_iodomain {
83 struct rockchip_iodomain_soc_data *soc_data;
84 struct rockchip_iodomain_supply grf_supplies[MAX_SUPPLIES];
85 struct rockchip_iodomain_supply pmugrf_supplies[MAX_SUPPLIES];
88 static int rockchip_iodomain_write(struct rockchip_iodomain_supply *supply,
91 struct rockchip_iodomain *iod = supply->iod;
98 val = (uV > MAX_VOLTAGE_1_8) ? 0 : 1;
101 /* apply hiword-mask */
102 val |= (BIT(supply->idx) << 16);
104 if (supply->type == GRF) {
106 offset = iod->soc_data->grf_offset;
107 } else if (supply->type == PMU_GRF) {
109 offset = iod->soc_data->pmugrf_offset;
112 ret = regmap_write(reg, offset, val);
114 dev_err(iod->dev, "Couldn't write to GRF\n");
119 static int rockchip_iodomain_notify(struct notifier_block *nb,
123 struct rockchip_iodomain_supply *supply =
124 container_of(nb, struct rockchip_iodomain_supply, nb);
129 * According to Rockchip it's important to keep the SoC IO domain
130 * higher than (or equal to) the external voltage. That means we need
131 * to change it before external voltage changes happen in the case
134 * Note that in the "pre" change we pick the max possible voltage that
135 * the regulator might end up at (the client requests a range and we
136 * don't know for certain the exact voltage). Right now we rely on the
137 * slop in MAX_VOLTAGE_1_8 and MAX_VOLTAGE_3_3 to save us if clients
138 * request something like a max of 3.6V when they really want 3.3V.
139 * We could attempt to come up with better rules if this fails.
141 if (event & REGULATOR_EVENT_PRE_VOLTAGE_CHANGE) {
142 struct pre_voltage_change_data *pvc_data = data;
144 uV = max_t(unsigned long, pvc_data->old_uV, pvc_data->max_uV);
145 } else if (event & (REGULATOR_EVENT_VOLTAGE_CHANGE |
146 REGULATOR_EVENT_ABORT_VOLTAGE_CHANGE)) {
147 uV = (unsigned long)data;
152 dev_dbg(supply->iod->dev, "Setting to %d\n", uV);
154 if (uV > MAX_VOLTAGE_3_3) {
155 dev_err(supply->iod->dev, "Voltage too high: %d\n", uV);
157 if (event == REGULATOR_EVENT_PRE_VOLTAGE_CHANGE)
161 ret = rockchip_iodomain_write(supply, uV);
162 if (ret && event == REGULATOR_EVENT_PRE_VOLTAGE_CHANGE)
165 dev_info(supply->iod->dev, "Setting to %d done\n", uV);
169 static void rk3288_iodomain_init(struct rockchip_iodomain *iod)
174 /* if no flash supply we should leave things alone */
175 if (!iod->grf_supplies[RK3288_SOC_FLASH_SUPPLY_NUM].reg)
179 * set flash0 iodomain to also use this framework
180 * instead of a special gpio.
182 val = RK3288_SOC_CON2_FLASH0 | (RK3288_SOC_CON2_FLASH0 << 16);
183 ret = regmap_write(iod->grf, RK3288_SOC_CON2, val);
185 dev_warn(iod->dev, "couldn't update flash0 ctrl\n");
188 static void rk3368_iodomain_init(struct rockchip_iodomain *iod)
193 /* if no flash supply we should leave things alone */
194 if (!iod->grf_supplies[RK3368_SOC_FLASH_SUPPLY_NUM].reg)
198 * set flash0 iodomain to also use this framework
199 * instead of a special gpio.
201 val = RK3368_GRF_SOC_CON15_FLASH0 | (RK3368_GRF_SOC_CON15_FLASH0 << 16);
202 ret = regmap_write(iod->grf, RK3368_GRF_SOC_CON15, val);
204 dev_warn(iod->dev, "couldn't update flash0 ctrl\n");
209 * On the rk3188 the io-domains are handled by a shared register with the
210 * lower 8 bits being still being continuing drive-strength settings.
212 static const struct rockchip_iodomain_soc_data soc_data_rk3188 = {
214 .grf_supply_names = {
234 static const struct rockchip_iodomain_soc_data soc_data_rk3288 = {
236 .grf_supply_names = {
237 "lcdc", /* LCDC_VDD */
238 "dvp", /* DVPIO_VDD */
239 "flash0", /* FLASH0_VDD (emmc) */
240 "flash1", /* FLASH1_VDD (sdio1) */
241 "wifi", /* APIO3_VDD (sdio0) */
242 "bb", /* APIO5_VDD */
243 "audio", /* APIO4_VDD */
244 "sdcard", /* SDMMC0_VDD (sdmmc) */
245 "gpio30", /* APIO1_VDD */
246 "gpio1830", /* APIO2_VDD */
248 .init = rk3288_iodomain_init,
251 static const struct rockchip_iodomain_soc_data soc_data_rk3368 = {
253 .pmugrf_offset = 0x100,
254 .grf_supply_names = {
256 "dvp", /*DVP IO domain*/
257 "flash0", /*FLASH0 IO domain*/
258 "wifi", /*APIO2 IO domain*/
260 "audio", /*APIO3 IO domain*/
261 "sdcard", /*SDCARD IO domain*/
262 "gpio30", /*APIO1 IO domain*/
263 "gpio1830", /*ADIO4 IO domain*/
265 .pmugrf_supply_names = {
270 "pmu", /*PMU IO domain*/
271 "vop", /*LCDC IO domain*/
273 .init = rk3368_iodomain_init,
277 static const struct of_device_id rockchip_iodomain_match[] = {
279 .compatible = "rockchip,rk3188-io-voltage-domain",
280 .data = (void *)&soc_data_rk3188
283 .compatible = "rockchip,rk3288-io-voltage-domain",
284 .data = (void *)&soc_data_rk3288
287 .compatible = "rockchip,rk3368-io-voltage-domain",
288 .data = (void *)&soc_data_rk3368
293 static int rockchip_iodomain_parse_supply(struct rockchip_iodomain *iod,
294 struct device_node *np,
295 enum rockchip_iodomain_grf_type type)
297 struct rockchip_iodomain_supply *group_supply;
298 const char **group_supply_names;
303 (const char **)iod->soc_data->grf_supply_names;
304 group_supply = iod->grf_supplies;
305 } else if (type == PMU_GRF) {
307 (const char **)iod->soc_data->pmugrf_supply_names;
308 group_supply = iod->pmugrf_supplies;
311 for (i = 0; i < MAX_SUPPLIES; i++) {
312 const char *supply_name = group_supply_names[i];
313 struct rockchip_iodomain_supply *supply = &group_supply[i];
314 struct regulator *reg;
320 reg = devm_regulator_get_optional(iod->dev, supply_name);
324 /* If a supply wasn't specified, that's OK */
327 else if (ret != -EPROBE_DEFER)
328 dev_err(iod->dev, "couldn't get regulator %s\n",
333 /* set initial correct value */
334 uV = regulator_get_voltage(reg);
336 /* must be a regulator we can get the voltage of */
338 dev_err(iod->dev, "Can't determine voltage: %s\n",
343 if (uV > MAX_VOLTAGE_3_3) {
345 "%d uV is too high. May damage SoC!\n",
351 /* setup our supply */
356 supply->nb.notifier_call = rockchip_iodomain_notify;
358 ret = rockchip_iodomain_write(supply, uV);
364 /* register regulator notifier */
365 ret = regulator_register_notifier(reg, &supply->nb);
368 "regulator notifier request failed\n");
375 for (i = MAX_SUPPLIES - 1; i >= 0; i--) {
376 struct rockchip_iodomain_supply *io_supply = &group_supply[i];
379 regulator_unregister_notifier(io_supply->reg,
386 static int rockchip_iodomain_probe(struct platform_device *pdev)
388 struct device_node *np = pdev->dev.of_node, *node;
389 const struct of_device_id *match;
390 struct rockchip_iodomain *iod;
396 iod = devm_kzalloc(&pdev->dev, sizeof(*iod), GFP_KERNEL);
400 iod->dev = &pdev->dev;
401 platform_set_drvdata(pdev, iod);
403 match = of_match_node(rockchip_iodomain_match, np);
404 iod->soc_data = (struct rockchip_iodomain_soc_data *)match->data;
406 iod->grf = syscon_regmap_lookup_by_phandle(np, "rockchip,grf");
407 if (IS_ERR(iod->grf)) {
408 dev_err(&pdev->dev, "couldn't find grf regmap\n");
409 return PTR_ERR(iod->grf);
411 ret = rockchip_iodomain_parse_supply(iod, np, GRF);
414 "rockchip iodomain parse grf supply failed\n");
418 /* try to find the optional reference to the pmu syscon */
419 node = of_parse_phandle(np, "rockchip,pmugrf", 0);
421 iod->pmu = syscon_node_to_regmap(node);
422 if (IS_ERR(iod->pmu))
423 return PTR_ERR(iod->pmu);
424 ret = rockchip_iodomain_parse_supply(iod, np, PMU_GRF);
427 "rockchip iodomain parse pmu_grf supply failed\n");
432 if (iod->soc_data->init)
433 iod->soc_data->init(iod);
438 static int rockchip_iodomain_remove(struct platform_device *pdev)
440 struct rockchip_iodomain *iod = platform_get_drvdata(pdev);
443 for (i = MAX_SUPPLIES - 1; i >= 0; i--) {
444 struct rockchip_iodomain_supply *io_supply
445 = &iod->grf_supplies[i];
448 regulator_unregister_notifier(io_supply->reg,
452 for (i = MAX_SUPPLIES - 1; i >= 0; i--) {
453 struct rockchip_iodomain_supply *io_supply =
454 &iod->pmugrf_supplies[i];
457 regulator_unregister_notifier(io_supply->reg,
464 static struct platform_driver rockchip_iodomain_driver = {
465 .probe = rockchip_iodomain_probe,
466 .remove = rockchip_iodomain_remove,
468 .name = "rockchip-iodomain",
469 .of_match_table = rockchip_iodomain_match,
473 module_platform_driver(rockchip_iodomain_driver);
475 MODULE_DESCRIPTION("Rockchip IO-domain driver");
476 MODULE_AUTHOR("Heiko Stuebner <heiko@sntech.de>");
477 MODULE_AUTHOR("Doug Anderson <dianders@chromium.org>");
478 MODULE_LICENSE("GPL v2");