1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Copyright (C) ST-Ericsson SA 2010 4 * 5 * Authors: Bengt Jonsson <bengt.g.jonsson@stericsson.com> 6 * 7 * This file is based on drivers/regulator/ab8500.c 8 * 9 * AB8500 external regulators 10 * 11 * ab8500-ext supports the following regulators: 12 * - VextSupply3 13 */ 14 #include <linux/init.h> 15 #include <linux/kernel.h> 16 #include <linux/err.h> 17 #include <linux/module.h> 18 #include <linux/of.h> 19 #include <linux/platform_device.h> 20 #include <linux/regulator/driver.h> 21 #include <linux/regulator/machine.h> 22 #include <linux/regulator/of_regulator.h> 23 #include <linux/mfd/abx500.h> 24 #include <linux/mfd/abx500/ab8500.h> 25 26 /* AB8500 external regulators */ 27 enum ab8500_ext_regulator_id { 28 AB8500_EXT_SUPPLY1, 29 AB8500_EXT_SUPPLY2, 30 AB8500_EXT_SUPPLY3, 31 AB8500_NUM_EXT_REGULATORS, 32 }; 33 34 struct ab8500_ext_regulator_cfg { 35 bool hwreq; /* requires hw mode or high power mode */ 36 }; 37 38 /* supply for VextSupply3 */ 39 static struct regulator_consumer_supply ab8500_ext_supply3_consumers[] = { 40 /* SIM supply for 3 V SIM cards */ 41 REGULATOR_SUPPLY("vinvsim", "sim-detect.0"), 42 }; 43 44 /* 45 * AB8500 external regulators 46 */ 47 static struct regulator_init_data ab8500_ext_regulators[] = { 48 /* fixed Vbat supplies VSMPS1_EXT_1V8 */ 49 [AB8500_EXT_SUPPLY1] = { 50 .constraints = { 51 .name = "ab8500-ext-supply1", 52 .min_uV = 1800000, 53 .max_uV = 1800000, 54 .initial_mode = REGULATOR_MODE_IDLE, 55 .boot_on = 1, 56 .always_on = 1, 57 }, 58 }, 59 /* fixed Vbat supplies VSMPS2_EXT_1V36 and VSMPS5_EXT_1V15 */ 60 [AB8500_EXT_SUPPLY2] = { 61 .constraints = { 62 .name = "ab8500-ext-supply2", 63 .min_uV = 1360000, 64 .max_uV = 1360000, 65 }, 66 }, 67 /* fixed Vbat supplies VSMPS3_EXT_3V4 and VSMPS4_EXT_3V4 */ 68 [AB8500_EXT_SUPPLY3] = { 69 .constraints = { 70 .name = "ab8500-ext-supply3", 71 .min_uV = 3400000, 72 .max_uV = 3400000, 73 .valid_ops_mask = REGULATOR_CHANGE_STATUS, 74 .boot_on = 1, 75 }, 76 .num_consumer_supplies = 77 ARRAY_SIZE(ab8500_ext_supply3_consumers), 78 .consumer_supplies = ab8500_ext_supply3_consumers, 79 }, 80 }; 81 82 /** 83 * struct ab8500_ext_regulator_info - ab8500 regulator information 84 * @dev: device pointer 85 * @desc: regulator description 86 * @cfg: regulator configuration (extension of regulator FW configuration) 87 * @update_bank: bank to control on/off 88 * @update_reg: register to control on/off 89 * @update_mask: mask to enable/disable and set mode of regulator 90 * @update_val: bits holding the regulator current mode 91 * @update_val_hp: bits to set EN pin active (LPn pin deactive) 92 * normally this means high power mode 93 * @update_val_lp: bits to set EN pin active and LPn pin active 94 * normally this means low power mode 95 * @update_val_hw: bits to set regulator pins in HW control 96 * SysClkReq pins and logic will choose mode 97 */ 98 struct ab8500_ext_regulator_info { 99 struct device *dev; 100 struct regulator_desc desc; 101 struct ab8500_ext_regulator_cfg *cfg; 102 u8 update_bank; 103 u8 update_reg; 104 u8 update_mask; 105 u8 update_val; 106 u8 update_val_hp; 107 u8 update_val_lp; 108 u8 update_val_hw; 109 }; 110 111 static int ab8500_ext_regulator_enable(struct regulator_dev *rdev) 112 { 113 int ret; 114 struct ab8500_ext_regulator_info *info = rdev_get_drvdata(rdev); 115 u8 regval; 116 117 if (info == NULL) { 118 dev_err(rdev_get_dev(rdev), "regulator info null pointer\n"); 119 return -EINVAL; 120 } 121 122 /* 123 * To satisfy both HW high power request and SW request, the regulator 124 * must be on in high power. 125 */ 126 if (info->cfg && info->cfg->hwreq) 127 regval = info->update_val_hp; 128 else 129 regval = info->update_val; 130 131 ret = abx500_mask_and_set_register_interruptible(info->dev, 132 info->update_bank, info->update_reg, 133 info->update_mask, regval); 134 if (ret < 0) { 135 dev_err(rdev_get_dev(rdev), 136 "couldn't set enable bits for regulator\n"); 137 return ret; 138 } 139 140 dev_dbg(rdev_get_dev(rdev), 141 "%s-enable (bank, reg, mask, value): 0x%02x, 0x%02x, 0x%02x, 0x%02x\n", 142 info->desc.name, info->update_bank, info->update_reg, 143 info->update_mask, regval); 144 145 return 0; 146 } 147 148 static int ab8500_ext_regulator_disable(struct regulator_dev *rdev) 149 { 150 int ret; 151 struct ab8500_ext_regulator_info *info = rdev_get_drvdata(rdev); 152 u8 regval; 153 154 if (info == NULL) { 155 dev_err(rdev_get_dev(rdev), "regulator info null pointer\n"); 156 return -EINVAL; 157 } 158 159 /* 160 * Set the regulator in HW request mode if configured 161 */ 162 if (info->cfg && info->cfg->hwreq) 163 regval = info->update_val_hw; 164 else 165 regval = 0; 166 167 ret = abx500_mask_and_set_register_interruptible(info->dev, 168 info->update_bank, info->update_reg, 169 info->update_mask, regval); 170 if (ret < 0) { 171 dev_err(rdev_get_dev(rdev), 172 "couldn't set disable bits for regulator\n"); 173 return ret; 174 } 175 176 dev_dbg(rdev_get_dev(rdev), "%s-disable (bank, reg, mask, value):" 177 " 0x%02x, 0x%02x, 0x%02x, 0x%02x\n", 178 info->desc.name, info->update_bank, info->update_reg, 179 info->update_mask, regval); 180 181 return 0; 182 } 183 184 static int ab8500_ext_regulator_is_enabled(struct regulator_dev *rdev) 185 { 186 int ret; 187 struct ab8500_ext_regulator_info *info = rdev_get_drvdata(rdev); 188 u8 regval; 189 190 if (info == NULL) { 191 dev_err(rdev_get_dev(rdev), "regulator info null pointer\n"); 192 return -EINVAL; 193 } 194 195 ret = abx500_get_register_interruptible(info->dev, 196 info->update_bank, info->update_reg, ®val); 197 if (ret < 0) { 198 dev_err(rdev_get_dev(rdev), 199 "couldn't read 0x%x register\n", info->update_reg); 200 return ret; 201 } 202 203 dev_dbg(rdev_get_dev(rdev), "%s-is_enabled (bank, reg, mask, value):" 204 " 0x%02x, 0x%02x, 0x%02x, 0x%02x\n", 205 info->desc.name, info->update_bank, info->update_reg, 206 info->update_mask, regval); 207 208 if (((regval & info->update_mask) == info->update_val_lp) || 209 ((regval & info->update_mask) == info->update_val_hp)) 210 return 1; 211 else 212 return 0; 213 } 214 215 static int ab8500_ext_regulator_set_mode(struct regulator_dev *rdev, 216 unsigned int mode) 217 { 218 int ret = 0; 219 struct ab8500_ext_regulator_info *info = rdev_get_drvdata(rdev); 220 u8 regval; 221 222 if (info == NULL) { 223 dev_err(rdev_get_dev(rdev), "regulator info null pointer\n"); 224 return -EINVAL; 225 } 226 227 switch (mode) { 228 case REGULATOR_MODE_NORMAL: 229 regval = info->update_val_hp; 230 break; 231 case REGULATOR_MODE_IDLE: 232 regval = info->update_val_lp; 233 break; 234 235 default: 236 return -EINVAL; 237 } 238 239 /* If regulator is enabled and info->cfg->hwreq is set, the regulator 240 must be on in high power, so we don't need to write the register with 241 the same value. 242 */ 243 if (ab8500_ext_regulator_is_enabled(rdev) && 244 !(info->cfg && info->cfg->hwreq)) { 245 ret = abx500_mask_and_set_register_interruptible(info->dev, 246 info->update_bank, info->update_reg, 247 info->update_mask, regval); 248 if (ret < 0) { 249 dev_err(rdev_get_dev(rdev), 250 "Could not set regulator mode.\n"); 251 return ret; 252 } 253 254 dev_dbg(rdev_get_dev(rdev), 255 "%s-set_mode (bank, reg, mask, value): " 256 "0x%x, 0x%x, 0x%x, 0x%x\n", 257 info->desc.name, info->update_bank, info->update_reg, 258 info->update_mask, regval); 259 } 260 261 info->update_val = regval; 262 263 return 0; 264 } 265 266 static unsigned int ab8500_ext_regulator_get_mode(struct regulator_dev *rdev) 267 { 268 struct ab8500_ext_regulator_info *info = rdev_get_drvdata(rdev); 269 int ret; 270 271 if (info == NULL) { 272 dev_err(rdev_get_dev(rdev), "regulator info null pointer\n"); 273 return -EINVAL; 274 } 275 276 if (info->update_val == info->update_val_hp) 277 ret = REGULATOR_MODE_NORMAL; 278 else if (info->update_val == info->update_val_lp) 279 ret = REGULATOR_MODE_IDLE; 280 else 281 ret = -EINVAL; 282 283 return ret; 284 } 285 286 static int ab8500_ext_set_voltage(struct regulator_dev *rdev, int min_uV, 287 int max_uV, unsigned *selector) 288 { 289 struct regulation_constraints *regu_constraints = rdev->constraints; 290 291 if (!regu_constraints) { 292 dev_err(rdev_get_dev(rdev), "No regulator constraints\n"); 293 return -EINVAL; 294 } 295 296 if (regu_constraints->min_uV == min_uV && 297 regu_constraints->max_uV == max_uV) 298 return 0; 299 300 dev_err(rdev_get_dev(rdev), 301 "Requested min %duV max %duV != constrained min %duV max %duV\n", 302 min_uV, max_uV, 303 regu_constraints->min_uV, regu_constraints->max_uV); 304 305 return -EINVAL; 306 } 307 308 static int ab8500_ext_list_voltage(struct regulator_dev *rdev, 309 unsigned selector) 310 { 311 struct regulation_constraints *regu_constraints = rdev->constraints; 312 313 if (regu_constraints == NULL) { 314 dev_err(rdev_get_dev(rdev), "regulator constraints null pointer\n"); 315 return -EINVAL; 316 } 317 /* return the uV for the fixed regulators */ 318 if (regu_constraints->min_uV && regu_constraints->max_uV) { 319 if (regu_constraints->min_uV == regu_constraints->max_uV) 320 return regu_constraints->min_uV; 321 } 322 return -EINVAL; 323 } 324 325 static const struct regulator_ops ab8500_ext_regulator_ops = { 326 .enable = ab8500_ext_regulator_enable, 327 .disable = ab8500_ext_regulator_disable, 328 .is_enabled = ab8500_ext_regulator_is_enabled, 329 .set_mode = ab8500_ext_regulator_set_mode, 330 .get_mode = ab8500_ext_regulator_get_mode, 331 .set_voltage = ab8500_ext_set_voltage, 332 .list_voltage = ab8500_ext_list_voltage, 333 }; 334 335 static struct ab8500_ext_regulator_info 336 ab8500_ext_regulator_info[AB8500_NUM_EXT_REGULATORS] = { 337 [AB8500_EXT_SUPPLY1] = { 338 .desc = { 339 .name = "VEXTSUPPLY1", 340 .of_match = of_match_ptr("ab8500_ext1"), 341 .ops = &ab8500_ext_regulator_ops, 342 .type = REGULATOR_VOLTAGE, 343 .id = AB8500_EXT_SUPPLY1, 344 .owner = THIS_MODULE, 345 .n_voltages = 1, 346 }, 347 .update_bank = 0x04, 348 .update_reg = 0x08, 349 .update_mask = 0x03, 350 .update_val = 0x01, 351 .update_val_hp = 0x01, 352 .update_val_lp = 0x03, 353 .update_val_hw = 0x02, 354 }, 355 [AB8500_EXT_SUPPLY2] = { 356 .desc = { 357 .name = "VEXTSUPPLY2", 358 .of_match = of_match_ptr("ab8500_ext2"), 359 .ops = &ab8500_ext_regulator_ops, 360 .type = REGULATOR_VOLTAGE, 361 .id = AB8500_EXT_SUPPLY2, 362 .owner = THIS_MODULE, 363 .n_voltages = 1, 364 }, 365 .update_bank = 0x04, 366 .update_reg = 0x08, 367 .update_mask = 0x0c, 368 .update_val = 0x04, 369 .update_val_hp = 0x04, 370 .update_val_lp = 0x0c, 371 .update_val_hw = 0x08, 372 }, 373 [AB8500_EXT_SUPPLY3] = { 374 .desc = { 375 .name = "VEXTSUPPLY3", 376 .of_match = of_match_ptr("ab8500_ext3"), 377 .ops = &ab8500_ext_regulator_ops, 378 .type = REGULATOR_VOLTAGE, 379 .id = AB8500_EXT_SUPPLY3, 380 .owner = THIS_MODULE, 381 .n_voltages = 1, 382 }, 383 .update_bank = 0x04, 384 .update_reg = 0x08, 385 .update_mask = 0x30, 386 .update_val = 0x10, 387 .update_val_hp = 0x10, 388 .update_val_lp = 0x30, 389 .update_val_hw = 0x20, 390 }, 391 }; 392 393 static int ab8500_ext_regulator_probe(struct platform_device *pdev) 394 { 395 struct ab8500 *ab8500 = dev_get_drvdata(pdev->dev.parent); 396 struct regulator_config config = { }; 397 struct regulator_dev *rdev; 398 int i; 399 400 if (!ab8500) { 401 dev_err(&pdev->dev, "null mfd parent\n"); 402 return -EINVAL; 403 } 404 405 /* check for AB8500 2.x */ 406 if (is_ab8500_2p0_or_earlier(ab8500)) { 407 struct ab8500_ext_regulator_info *info; 408 409 /* VextSupply3LPn is inverted on AB8500 2.x */ 410 info = &ab8500_ext_regulator_info[AB8500_EXT_SUPPLY3]; 411 info->update_val = 0x30; 412 info->update_val_hp = 0x30; 413 info->update_val_lp = 0x10; 414 } 415 416 /* register all regulators */ 417 for (i = 0; i < ARRAY_SIZE(ab8500_ext_regulator_info); i++) { 418 struct ab8500_ext_regulator_info *info = NULL; 419 420 /* assign per-regulator data */ 421 info = &ab8500_ext_regulator_info[i]; 422 info->dev = &pdev->dev; 423 info->cfg = (struct ab8500_ext_regulator_cfg *) 424 ab8500_ext_regulators[i].driver_data; 425 426 config.dev = &pdev->dev; 427 config.driver_data = info; 428 config.init_data = &ab8500_ext_regulators[i]; 429 430 /* register regulator with framework */ 431 rdev = devm_regulator_register(&pdev->dev, &info->desc, 432 &config); 433 if (IS_ERR(rdev)) { 434 dev_err(&pdev->dev, "failed to register regulator %s\n", 435 info->desc.name); 436 return PTR_ERR(rdev); 437 } 438 439 dev_dbg(&pdev->dev, "%s-probed\n", info->desc.name); 440 } 441 442 return 0; 443 } 444 445 static struct platform_driver ab8500_ext_regulator_driver = { 446 .probe = ab8500_ext_regulator_probe, 447 .driver = { 448 .name = "ab8500-ext-regulator", 449 .probe_type = PROBE_PREFER_ASYNCHRONOUS, 450 }, 451 }; 452 453 static int __init ab8500_ext_regulator_init(void) 454 { 455 int ret; 456 457 ret = platform_driver_register(&ab8500_ext_regulator_driver); 458 if (ret) 459 pr_err("Failed to register ab8500 ext regulator: %d\n", ret); 460 461 return ret; 462 } 463 subsys_initcall(ab8500_ext_regulator_init); 464 465 static void __exit ab8500_ext_regulator_exit(void) 466 { 467 platform_driver_unregister(&ab8500_ext_regulator_driver); 468 } 469 module_exit(ab8500_ext_regulator_exit); 470 471 MODULE_LICENSE("GPL v2"); 472 MODULE_AUTHOR("Bengt Jonsson <bengt.g.jonsson@stericsson.com>"); 473 MODULE_DESCRIPTION("AB8500 external regulator driver"); 474 MODULE_ALIAS("platform:ab8500-ext-regulator"); 475