Heiko Stübner | 662a958 | 2014-09-11 15:48:55 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Rockchip IO Voltage Domain driver |
| 3 | * |
| 4 | * Copyright 2014 MundoReader S.L. |
| 5 | * Copyright 2014 Google, Inc. |
| 6 | * |
| 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. |
| 10 | * |
| 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. |
| 15 | */ |
| 16 | |
| 17 | #include <linux/kernel.h> |
| 18 | #include <linux/module.h> |
| 19 | #include <linux/err.h> |
| 20 | #include <linux/mfd/syscon.h> |
| 21 | #include <linux/of.h> |
| 22 | #include <linux/platform_device.h> |
| 23 | #include <linux/regmap.h> |
| 24 | #include <linux/regulator/consumer.h> |
| 25 | |
| 26 | #define MAX_SUPPLIES 16 |
| 27 | |
| 28 | /* |
| 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. |
| 32 | * |
| 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 |
| 35 | * SoC we're at 3.3. |
| 36 | * - If the voltage on a rail is above the "3.3" voltage (3.6V) we'll consider |
| 37 | * that to be an error. |
| 38 | */ |
| 39 | #define MAX_VOLTAGE_1_8 1980000 |
| 40 | #define MAX_VOLTAGE_3_3 3600000 |
| 41 | |
| 42 | #define RK3288_SOC_CON2 0x24c |
| 43 | #define RK3288_SOC_CON2_FLASH0 BIT(7) |
| 44 | #define RK3288_SOC_FLASH_SUPPLY_NUM 2 |
| 45 | |
| 46 | struct rockchip_iodomain; |
| 47 | |
| 48 | /** |
| 49 | * @supplies: voltage settings matching the register bits. |
| 50 | */ |
| 51 | struct rockchip_iodomain_soc_data { |
| 52 | int grf_offset; |
| 53 | const char *supply_names[MAX_SUPPLIES]; |
| 54 | void (*init)(struct rockchip_iodomain *iod); |
| 55 | }; |
| 56 | |
| 57 | struct rockchip_iodomain_supply { |
| 58 | struct rockchip_iodomain *iod; |
| 59 | struct regulator *reg; |
| 60 | struct notifier_block nb; |
| 61 | int idx; |
| 62 | }; |
| 63 | |
| 64 | struct rockchip_iodomain { |
| 65 | struct device *dev; |
| 66 | struct regmap *grf; |
| 67 | struct rockchip_iodomain_soc_data *soc_data; |
| 68 | struct rockchip_iodomain_supply supplies[MAX_SUPPLIES]; |
| 69 | }; |
| 70 | |
| 71 | static int rockchip_iodomain_write(struct rockchip_iodomain_supply *supply, |
| 72 | int uV) |
| 73 | { |
| 74 | struct rockchip_iodomain *iod = supply->iod; |
| 75 | u32 val; |
| 76 | int ret; |
| 77 | |
| 78 | /* set value bit */ |
| 79 | val = (uV > MAX_VOLTAGE_1_8) ? 0 : 1; |
| 80 | val <<= supply->idx; |
| 81 | |
| 82 | /* apply hiword-mask */ |
| 83 | val |= (BIT(supply->idx) << 16); |
| 84 | |
| 85 | ret = regmap_write(iod->grf, iod->soc_data->grf_offset, val); |
| 86 | if (ret) |
| 87 | dev_err(iod->dev, "Couldn't write to GRF\n"); |
| 88 | |
| 89 | return ret; |
| 90 | } |
| 91 | |
| 92 | static int rockchip_iodomain_notify(struct notifier_block *nb, |
| 93 | unsigned long event, |
| 94 | void *data) |
| 95 | { |
| 96 | struct rockchip_iodomain_supply *supply = |
| 97 | container_of(nb, struct rockchip_iodomain_supply, nb); |
| 98 | int uV; |
| 99 | int ret; |
| 100 | |
| 101 | /* |
| 102 | * According to Rockchip it's important to keep the SoC IO domain |
| 103 | * higher than (or equal to) the external voltage. That means we need |
| 104 | * to change it before external voltage changes happen in the case |
| 105 | * of an increase. |
| 106 | * |
| 107 | * Note that in the "pre" change we pick the max possible voltage that |
| 108 | * the regulator might end up at (the client requests a range and we |
| 109 | * don't know for certain the exact voltage). Right now we rely on the |
| 110 | * slop in MAX_VOLTAGE_1_8 and MAX_VOLTAGE_3_3 to save us if clients |
| 111 | * request something like a max of 3.6V when they really want 3.3V. |
| 112 | * We could attempt to come up with better rules if this fails. |
| 113 | */ |
| 114 | if (event & REGULATOR_EVENT_PRE_VOLTAGE_CHANGE) { |
| 115 | struct pre_voltage_change_data *pvc_data = data; |
| 116 | |
| 117 | uV = max_t(unsigned long, pvc_data->old_uV, pvc_data->max_uV); |
| 118 | } else if (event & (REGULATOR_EVENT_VOLTAGE_CHANGE | |
| 119 | REGULATOR_EVENT_ABORT_VOLTAGE_CHANGE)) { |
| 120 | uV = (unsigned long)data; |
| 121 | } else { |
| 122 | return NOTIFY_OK; |
| 123 | } |
| 124 | |
| 125 | dev_dbg(supply->iod->dev, "Setting to %d\n", uV); |
| 126 | |
| 127 | if (uV > MAX_VOLTAGE_3_3) { |
| 128 | dev_err(supply->iod->dev, "Voltage too high: %d\n", uV); |
| 129 | |
| 130 | if (event == REGULATOR_EVENT_PRE_VOLTAGE_CHANGE) |
| 131 | return NOTIFY_BAD; |
| 132 | } |
| 133 | |
| 134 | ret = rockchip_iodomain_write(supply, uV); |
| 135 | if (ret && event == REGULATOR_EVENT_PRE_VOLTAGE_CHANGE) |
| 136 | return NOTIFY_BAD; |
| 137 | |
| 138 | dev_info(supply->iod->dev, "Setting to %d done\n", uV); |
| 139 | return NOTIFY_OK; |
| 140 | } |
| 141 | |
| 142 | static void rk3288_iodomain_init(struct rockchip_iodomain *iod) |
| 143 | { |
| 144 | int ret; |
| 145 | u32 val; |
| 146 | |
| 147 | /* if no flash supply we should leave things alone */ |
| 148 | if (!iod->supplies[RK3288_SOC_FLASH_SUPPLY_NUM].reg) |
| 149 | return; |
| 150 | |
| 151 | /* |
| 152 | * set flash0 iodomain to also use this framework |
| 153 | * instead of a special gpio. |
| 154 | */ |
| 155 | val = RK3288_SOC_CON2_FLASH0 | (RK3288_SOC_CON2_FLASH0 << 16); |
| 156 | ret = regmap_write(iod->grf, RK3288_SOC_CON2, val); |
| 157 | if (ret < 0) |
| 158 | dev_warn(iod->dev, "couldn't update flash0 ctrl\n"); |
| 159 | } |
| 160 | |
| 161 | /* |
| 162 | * On the rk3188 the io-domains are handled by a shared register with the |
| 163 | * lower 8 bits being still being continuing drive-strength settings. |
| 164 | */ |
| 165 | static const struct rockchip_iodomain_soc_data soc_data_rk3188 = { |
| 166 | .grf_offset = 0x104, |
| 167 | .supply_names = { |
| 168 | NULL, |
| 169 | NULL, |
| 170 | NULL, |
| 171 | NULL, |
| 172 | NULL, |
| 173 | NULL, |
| 174 | NULL, |
| 175 | NULL, |
| 176 | "ap0", |
| 177 | "ap1", |
| 178 | "cif", |
| 179 | "flash", |
| 180 | "vccio0", |
| 181 | "vccio1", |
| 182 | "lcdc0", |
| 183 | "lcdc1", |
| 184 | }, |
| 185 | }; |
| 186 | |
| 187 | static const struct rockchip_iodomain_soc_data soc_data_rk3288 = { |
| 188 | .grf_offset = 0x380, |
| 189 | .supply_names = { |
| 190 | "lcdc", /* LCDC_VDD */ |
| 191 | "dvp", /* DVPIO_VDD */ |
| 192 | "flash0", /* FLASH0_VDD (emmc) */ |
| 193 | "flash1", /* FLASH1_VDD (sdio1) */ |
| 194 | "wifi", /* APIO3_VDD (sdio0) */ |
| 195 | "bb", /* APIO5_VDD */ |
| 196 | "audio", /* APIO4_VDD */ |
| 197 | "sdcard", /* SDMMC0_VDD (sdmmc) */ |
| 198 | "gpio30", /* APIO1_VDD */ |
| 199 | "gpio1830", /* APIO2_VDD */ |
| 200 | }, |
| 201 | .init = rk3288_iodomain_init, |
| 202 | }; |
| 203 | |
| 204 | static const struct of_device_id rockchip_iodomain_match[] = { |
| 205 | { |
| 206 | .compatible = "rockchip,rk3188-io-voltage-domain", |
| 207 | .data = (void *)&soc_data_rk3188 |
| 208 | }, |
| 209 | { |
| 210 | .compatible = "rockchip,rk3288-io-voltage-domain", |
| 211 | .data = (void *)&soc_data_rk3288 |
| 212 | }, |
| 213 | { /* sentinel */ }, |
| 214 | }; |
| 215 | |
| 216 | static int rockchip_iodomain_probe(struct platform_device *pdev) |
| 217 | { |
| 218 | struct device_node *np = pdev->dev.of_node; |
| 219 | const struct of_device_id *match; |
| 220 | struct rockchip_iodomain *iod; |
| 221 | int i, ret = 0; |
| 222 | |
| 223 | if (!np) |
| 224 | return -ENODEV; |
| 225 | |
| 226 | iod = devm_kzalloc(&pdev->dev, sizeof(*iod), GFP_KERNEL); |
| 227 | if (!iod) |
| 228 | return -ENOMEM; |
| 229 | |
| 230 | iod->dev = &pdev->dev; |
| 231 | platform_set_drvdata(pdev, iod); |
| 232 | |
| 233 | match = of_match_node(rockchip_iodomain_match, np); |
| 234 | iod->soc_data = (struct rockchip_iodomain_soc_data *)match->data; |
| 235 | |
| 236 | iod->grf = syscon_regmap_lookup_by_phandle(np, "rockchip,grf"); |
| 237 | if (IS_ERR(iod->grf)) { |
| 238 | dev_err(&pdev->dev, "couldn't find grf regmap\n"); |
| 239 | return PTR_ERR(iod->grf); |
| 240 | } |
| 241 | |
| 242 | for (i = 0; i < MAX_SUPPLIES; i++) { |
| 243 | const char *supply_name = iod->soc_data->supply_names[i]; |
| 244 | struct rockchip_iodomain_supply *supply = &iod->supplies[i]; |
| 245 | struct regulator *reg; |
| 246 | int uV; |
| 247 | |
| 248 | if (!supply_name) |
| 249 | continue; |
| 250 | |
| 251 | reg = devm_regulator_get_optional(iod->dev, supply_name); |
| 252 | if (IS_ERR(reg)) { |
| 253 | ret = PTR_ERR(reg); |
| 254 | |
| 255 | /* If a supply wasn't specified, that's OK */ |
| 256 | if (ret == -ENODEV) |
| 257 | continue; |
| 258 | else if (ret != -EPROBE_DEFER) |
| 259 | dev_err(iod->dev, "couldn't get regulator %s\n", |
| 260 | supply_name); |
| 261 | goto unreg_notify; |
| 262 | } |
| 263 | |
| 264 | /* set initial correct value */ |
| 265 | uV = regulator_get_voltage(reg); |
| 266 | |
| 267 | /* must be a regulator we can get the voltage of */ |
| 268 | if (uV < 0) { |
| 269 | dev_err(iod->dev, "Can't determine voltage: %s\n", |
| 270 | supply_name); |
| 271 | goto unreg_notify; |
| 272 | } |
| 273 | |
| 274 | if (uV > MAX_VOLTAGE_3_3) { |
| 275 | dev_crit(iod->dev, |
| 276 | "%d uV is too high. May damage SoC!\n", |
| 277 | uV); |
| 278 | ret = -EINVAL; |
| 279 | goto unreg_notify; |
| 280 | } |
| 281 | |
| 282 | /* setup our supply */ |
| 283 | supply->idx = i; |
| 284 | supply->iod = iod; |
| 285 | supply->reg = reg; |
| 286 | supply->nb.notifier_call = rockchip_iodomain_notify; |
| 287 | |
| 288 | ret = rockchip_iodomain_write(supply, uV); |
| 289 | if (ret) { |
| 290 | supply->reg = NULL; |
| 291 | goto unreg_notify; |
| 292 | } |
| 293 | |
| 294 | /* register regulator notifier */ |
| 295 | ret = regulator_register_notifier(reg, &supply->nb); |
| 296 | if (ret) { |
| 297 | dev_err(&pdev->dev, |
| 298 | "regulator notifier request failed\n"); |
| 299 | supply->reg = NULL; |
| 300 | goto unreg_notify; |
| 301 | } |
| 302 | } |
| 303 | |
| 304 | if (iod->soc_data->init) |
| 305 | iod->soc_data->init(iod); |
| 306 | |
| 307 | return 0; |
| 308 | |
| 309 | unreg_notify: |
| 310 | for (i = MAX_SUPPLIES - 1; i >= 0; i--) { |
| 311 | struct rockchip_iodomain_supply *io_supply = &iod->supplies[i]; |
| 312 | |
| 313 | if (io_supply->reg) |
| 314 | regulator_unregister_notifier(io_supply->reg, |
| 315 | &io_supply->nb); |
| 316 | } |
| 317 | |
| 318 | return ret; |
| 319 | } |
| 320 | |
| 321 | static int rockchip_iodomain_remove(struct platform_device *pdev) |
| 322 | { |
| 323 | struct rockchip_iodomain *iod = platform_get_drvdata(pdev); |
| 324 | int i; |
| 325 | |
| 326 | for (i = MAX_SUPPLIES - 1; i >= 0; i--) { |
| 327 | struct rockchip_iodomain_supply *io_supply = &iod->supplies[i]; |
| 328 | |
| 329 | if (io_supply->reg) |
| 330 | regulator_unregister_notifier(io_supply->reg, |
| 331 | &io_supply->nb); |
| 332 | } |
| 333 | |
| 334 | return 0; |
| 335 | } |
| 336 | |
| 337 | static struct platform_driver rockchip_iodomain_driver = { |
| 338 | .probe = rockchip_iodomain_probe, |
| 339 | .remove = rockchip_iodomain_remove, |
| 340 | .driver = { |
| 341 | .name = "rockchip-iodomain", |
| 342 | .of_match_table = rockchip_iodomain_match, |
| 343 | }, |
| 344 | }; |
| 345 | |
| 346 | module_platform_driver(rockchip_iodomain_driver); |
| 347 | |
| 348 | MODULE_DESCRIPTION("Rockchip IO-domain driver"); |
| 349 | MODULE_AUTHOR("Heiko Stuebner <heiko@sntech.de>"); |
| 350 | MODULE_AUTHOR("Doug Anderson <dianders@chromium.org>"); |
| 351 | MODULE_LICENSE("GPL v2"); |