Merge tag 'regulator-fix-v6.14-rc7' of git://git.kernel.org/pub/scm/linux/kernel/git/broonie/regulator

+54 -34

drivers/regulator/core.c

··· 1830 1830 1831 1831 #define REG_STR_SIZE 64 1832 1832 1833 + static void link_and_create_debugfs(struct regulator *regulator, struct regulator_dev *rdev, 1834 + struct device *dev) 1835 + { 1836 + int err = 0; 1837 + 1838 + if (dev) { 1839 + regulator->dev = dev; 1840 + 1841 + /* Add a link to the device sysfs entry */ 1842 + err = sysfs_create_link_nowarn(&rdev->dev.kobj, &dev->kobj, 1843 + regulator->supply_name); 1844 + if (err) { 1845 + rdev_dbg(rdev, "could not add device link %s: %pe\n", 1846 + dev->kobj.name, ERR_PTR(err)); 1847 + /* non-fatal */ 1848 + } 1849 + } 1850 + 1851 + if (err != -EEXIST) { 1852 + regulator->debugfs = debugfs_create_dir(regulator->supply_name, rdev->debugfs); 1853 + if (IS_ERR(regulator->debugfs)) { 1854 + rdev_dbg(rdev, "Failed to create debugfs directory\n"); 1855 + regulator->debugfs = NULL; 1856 + } 1857 + } 1858 + 1859 + if (regulator->debugfs) { 1860 + debugfs_create_u32("uA_load", 0444, regulator->debugfs, 1861 + &regulator->uA_load); 1862 + debugfs_create_u32("min_uV", 0444, regulator->debugfs, 1863 + &regulator->voltage[PM_SUSPEND_ON].min_uV); 1864 + debugfs_create_u32("max_uV", 0444, regulator->debugfs, 1865 + &regulator->voltage[PM_SUSPEND_ON].max_uV); 1866 + debugfs_create_file("constraint_flags", 0444, regulator->debugfs, 1867 + regulator, &constraint_flags_fops); 1868 + } 1869 + } 1870 + 1833 1871 static struct regulator *create_regulator(struct regulator_dev *rdev, 1834 1872 struct device *dev, 1835 1873 const char *supply_name) 1836 1874 { 1837 1875 struct regulator *regulator; 1838 - int err = 0; 1839 1876 1840 1877 lockdep_assert_held_once(&rdev->mutex.base); 1841 1878 ··· 1904 1867 regulator->supply_name = supply_name; 1905 1868 1906 1869 list_add(&regulator->list, &rdev->consumer_list); 1907 - 1908 - if (dev) { 1909 - regulator->dev = dev; 1910 - 1911 - /* Add a link to the device sysfs entry */ 1912 - err = sysfs_create_link_nowarn(&rdev->dev.kobj, &dev->kobj, 1913 - supply_name); 1914 - if (err) { 1915 - rdev_dbg(rdev, "could not add device link %s: %pe\n", 1916 - dev->kobj.name, ERR_PTR(err)); 1917 - /* non-fatal */ 1918 - } 1919 - } 1920 - 1921 - if (err != -EEXIST) { 1922 - regulator->debugfs = debugfs_create_dir(supply_name, rdev->debugfs); 1923 - if (IS_ERR(regulator->debugfs)) { 1924 - rdev_dbg(rdev, "Failed to create debugfs directory\n"); 1925 - regulator->debugfs = NULL; 1926 - } 1927 - } 1928 - 1929 - if (regulator->debugfs) { 1930 - debugfs_create_u32("uA_load", 0444, regulator->debugfs, 1931 - &regulator->uA_load); 1932 - debugfs_create_u32("min_uV", 0444, regulator->debugfs, 1933 - &regulator->voltage[PM_SUSPEND_ON].min_uV); 1934 - debugfs_create_u32("max_uV", 0444, regulator->debugfs, 1935 - &regulator->voltage[PM_SUSPEND_ON].max_uV); 1936 - debugfs_create_file("constraint_flags", 0444, regulator->debugfs, 1937 - regulator, &constraint_flags_fops); 1938 - } 1939 1870 1940 1871 /* 1941 1872 * Check now if the regulator is an always on regulator - if ··· 2074 2069 2075 2070 if (have_full_constraints()) { 2076 2071 r = dummy_regulator_rdev; 2072 + if (!r) { 2073 + ret = -EPROBE_DEFER; 2074 + goto out; 2075 + } 2077 2076 get_device(&r->dev); 2078 2077 } else { 2079 2078 dev_err(dev, "Failed to resolve %s-supply for %s\n", ··· 2095 2086 goto out; 2096 2087 } 2097 2088 r = dummy_regulator_rdev; 2089 + if (!r) { 2090 + ret = -EPROBE_DEFER; 2091 + goto out; 2092 + } 2098 2093 get_device(&r->dev); 2099 2094 } 2100 2095 ··· 2145 2132 } 2146 2133 2147 2134 regulator_unlock_two(rdev, r, &ww_ctx); 2135 + 2136 + /* rdev->supply was created in set_supply() */ 2137 + link_and_create_debugfs(rdev->supply, r, &rdev->dev); 2148 2138 2149 2139 /* 2150 2140 * In set_machine_constraints() we may have turned this regulator on ··· 2227 2211 * enabled, even if it isn't hooked up, and just 2228 2212 * provide a dummy. 2229 2213 */ 2230 - dev_warn(dev, "supply %s not found, using dummy regulator\n", id); 2231 2214 rdev = dummy_regulator_rdev; 2215 + if (!rdev) 2216 + return ERR_PTR(-EPROBE_DEFER); 2217 + dev_warn(dev, "supply %s not found, using dummy regulator\n", id); 2232 2218 get_device(&rdev->dev); 2233 2219 break; 2234 2220 ··· 2288 2270 put_device(&rdev->dev); 2289 2271 return regulator; 2290 2272 } 2273 + 2274 + link_and_create_debugfs(regulator, rdev, dev); 2291 2275 2292 2276 rdev->open_count++; 2293 2277 if (get_type == EXCLUSIVE_GET) {

+1 -1

drivers/regulator/dummy.c

··· 60 60 .probe = dummy_regulator_probe, 61 61 .driver = { 62 62 .name = "reg-dummy", 63 - .probe_type = PROBE_PREFER_ASYNCHRONOUS, 63 + .probe_type = PROBE_FORCE_SYNCHRONOUS, 64 64 }, 65 65 }; 66 66

+123 -93

drivers/regulator/rtq2208-regulator.c

··· 27 27 #define RTQ2208_REG_LDO1_CFG 0xB1 28 28 #define RTQ2208_REG_LDO2_CFG 0xC1 29 29 #define RTQ2208_REG_LDO_DVS_CTRL 0xD0 30 + #define RTQ2208_REG_HIDDEN_BUCKPH 0x55 31 + #define RTQ2208_REG_HIDDEN_LDOCFG0 0x8F 32 + #define RTQ2208_REG_HIDDEN_LDOCFG1 0x96 33 + #define RTQ2208_REG_HIDDEN0 0xFE 34 + #define RTQ2208_REG_HIDDEN1 0xFF 30 35 31 36 /* Mask */ 32 37 #define RTQ2208_BUCK_NR_MTP_SEL_MASK GENMASK(7, 0) ··· 50 45 #define RTQ2208_LDO1_VOSEL_SD_MASK BIT(5) 51 46 #define RTQ2208_LDO2_DISCHG_EN_MASK BIT(6) 52 47 #define RTQ2208_LDO2_VOSEL_SD_MASK BIT(7) 48 + #define RTQ2208_MASK_BUCKPH_GROUP1 GENMASK(6, 4) 49 + #define RTQ2208_MASK_BUCKPH_GROUP2 GENMASK(2, 0) 50 + #define RTQ2208_MASK_LDO2_OPT0 BIT(7) 51 + #define RTQ2208_MASK_LDO2_OPT1 BIT(6) 52 + #define RTQ2208_MASK_LDO1_FIXED BIT(6) 53 53 54 54 /* Size */ 55 55 #define RTQ2208_VOUT_MAXNUM 256 ··· 255 245 3300000, 256 246 }; 257 247 258 - static struct of_regulator_match rtq2208_ldo_match[] = { 259 - {.name = "ldo2", }, 260 - {.name = "ldo1", }, 261 - }; 262 - 263 248 static unsigned int rtq2208_of_map_mode(unsigned int mode) 264 249 { 265 250 switch (mode) { ··· 349 344 return IRQ_HANDLED; 350 345 } 351 346 352 - static int rtq2208_of_get_ldo_dvs_ability(struct device *dev) 353 - { 354 - struct device_node *np; 355 - struct of_regulator_match *match; 356 - struct regulator_desc *desc; 357 - struct regulator_init_data *init_data; 358 - u32 fixed_uV; 359 - int ret, i; 360 - 361 - if (!dev->of_node) 362 - return -ENODEV; 363 - 364 - np = of_get_child_by_name(dev->of_node, "regulators"); 365 - if (!np) 366 - np = dev->of_node; 367 - 368 - ret = of_regulator_match(dev, np, rtq2208_ldo_match, ARRAY_SIZE(rtq2208_ldo_match)); 369 - 370 - of_node_put(np); 371 - 372 - if (ret < 0) 373 - return ret; 374 - 375 - for (i = 0; i < ARRAY_SIZE(rtq2208_ldo_match); i++) { 376 - match = rtq2208_ldo_match + i; 377 - init_data = match->init_data; 378 - desc = (struct regulator_desc *)match->desc; 379 - 380 - if (!init_data || !desc) 381 - continue; 382 - 383 - /* specify working fixed voltage if the propery exists */ 384 - ret = of_property_read_u32(match->of_node, "richtek,fixed-microvolt", &fixed_uV); 385 - 386 - if (!ret) { 387 - if (fixed_uV != init_data->constraints.min_uV || 388 - fixed_uV != init_data->constraints.max_uV) 389 - return -EINVAL; 390 - desc->n_voltages = 1; 391 - desc->fixed_uV = fixed_uV; 392 - desc->fixed_uV = init_data->constraints.min_uV; 393 - desc->ops = &rtq2208_regulator_ldo_fix_ops; 394 - } else { 395 - desc->n_voltages = ARRAY_SIZE(rtq2208_ldo_volt_table); 396 - desc->volt_table = rtq2208_ldo_volt_table; 397 - desc->ops = &rtq2208_regulator_ldo_adj_ops; 398 - } 399 - } 400 - 401 - return 0; 402 - } 403 - 404 - 405 347 #define BUCK_INFO(_name, _id) \ 406 348 { \ 407 349 .name = _name, \ ··· 376 424 REGULATOR_LINEAR_RANGE(1310000, 181, 255, 10000), 377 425 }; 378 426 379 - static void rtq2208_init_regulator_desc(struct rtq2208_regulator_desc *rdesc, int mtp_sel, int idx) 427 + static void rtq2208_init_regulator_desc(struct rtq2208_regulator_desc *rdesc, int mtp_sel, int idx, 428 + unsigned int ldo1_fixed, unsigned int ldo2_fixed) 380 429 { 381 430 struct regulator_desc *desc; 431 + unsigned int fixed_uV; 382 432 static const struct { 383 433 char *name; 384 434 int base; ··· 416 462 417 463 rdesc->mode_mask = RTQ2208_BUCK_NRMODE_MASK; 418 464 419 - if (idx >= RTQ2208_BUCK_B && idx <= RTQ2208_BUCK_E) { 465 + switch (idx) { 466 + case RTQ2208_BUCK_B ... RTQ2208_BUCK_E: 420 467 /* init buck desc */ 421 468 desc->ops = &rtq2208_regulator_buck_ops; 422 469 desc->vsel_reg = curr_info->base + VSEL_SHIFT(mtp_sel); ··· 435 480 rdesc->suspend_config_reg = BUCK_RG_SHIFT(curr_info->base, 4); 436 481 rdesc->suspend_enable_mask = RTQ2208_BUCK_EN_STR_MASK; 437 482 rdesc->suspend_mode_mask = RTQ2208_BUCK_STRMODE_MASK; 438 - } else { 483 + break; 484 + default: 485 + fixed_uV = idx == RTQ2208_LDO2 ? ldo2_fixed : ldo1_fixed; 486 + if (fixed_uV) { 487 + desc->n_voltages = 1; 488 + desc->fixed_uV = fixed_uV; 489 + desc->ops = &rtq2208_regulator_ldo_fix_ops; 490 + } else { 491 + desc->n_voltages = ARRAY_SIZE(rtq2208_ldo_volt_table); 492 + desc->volt_table = rtq2208_ldo_volt_table; 493 + desc->ops = &rtq2208_regulator_ldo_adj_ops; 494 + } 495 + 439 496 /* init ldo desc */ 440 497 desc->active_discharge_reg = RTQ2208_REG_LDO_DVS_CTRL; 441 498 desc->active_discharge_on = curr_info->dis_on; ··· 457 490 458 491 rdesc->suspend_config_reg = curr_info->base; 459 492 rdesc->suspend_enable_mask = RTQ2208_LDO_EN_STR_MASK; 493 + break; 460 494 } 461 495 } 462 496 463 497 static int rtq2208_parse_regulator_dt_data(int n_regulator, const unsigned int *regulator_idx_table, 464 - struct rtq2208_regulator_desc *rdesc[RTQ2208_LDO_MAX], struct device *dev) 498 + struct rtq2208_regulator_desc *rdesc[RTQ2208_LDO_MAX], struct device *dev, 499 + unsigned int ldo1_fixed, unsigned int ldo2_fixed) 465 500 { 466 - int mtp_sel, i, idx, ret; 501 + int mtp_sel, i, idx; 467 502 468 503 /* get mtp_sel0 or mtp_sel1 */ 469 504 mtp_sel = device_property_read_bool(dev, "richtek,mtp-sel-high"); ··· 477 508 if (!rdesc[i]) 478 509 return -ENOMEM; 479 510 480 - rtq2208_init_regulator_desc(rdesc[i], mtp_sel, idx); 481 - 482 - /* init ldo dvs ability */ 483 - if (idx >= RTQ2208_LDO2) 484 - rtq2208_ldo_match[idx - RTQ2208_LDO2].desc = &rdesc[i]->desc; 511 + rtq2208_init_regulator_desc(rdesc[i], mtp_sel, idx, ldo1_fixed, ldo2_fixed); 485 512 } 486 - 487 - /* init ldo fixed_uV */ 488 - ret = rtq2208_of_get_ldo_dvs_ability(dev); 489 - if (ret) 490 - return dev_err_probe(dev, ret, "Failed to get ldo fixed_uV\n"); 491 513 492 514 return 0; 493 515 494 516 } 495 517 496 - /** different slave address corresponds different used bucks 497 - * slave address 0x10: BUCK[BCA FGE] 498 - * slave address 0x20: BUCK[BC FGHE] 499 - * slave address 0x40: BUCK[C G] 500 - */ 501 - static int rtq2208_regulator_check(int slave_addr, int *num, 502 - int *regulator_idx_table, unsigned int *buck_masks) 518 + static int rtq2208_regulator_check(struct device *dev, int *num, int *regulator_idx_table, 519 + unsigned int *buck_masks, unsigned int *ldo1_fixed_uV, 520 + unsigned int *ldo2_fixed_uV) 503 521 { 504 - static bool rtq2208_used_table[3][RTQ2208_LDO_MAX] = { 505 - /* BUCK[BCA FGE], LDO[12] */ 506 - {1, 1, 0, 1, 1, 1, 0, 1, 1, 1}, 507 - /* BUCK[BC FGHE], LDO[12]*/ 508 - {1, 1, 0, 0, 1, 1, 1, 1, 1, 1}, 509 - /* BUCK[C G], LDO[12] */ 510 - {0, 1, 0, 0, 0, 1, 0, 0, 1, 1}, 511 - }; 512 - int i, idx = ffs(slave_addr >> 4) - 1; 522 + struct regmap *regmap = dev_get_regmap(dev, NULL); 523 + bool rtq2208_used_table[RTQ2208_LDO_MAX] = {0}; 524 + u8 entry_key[] = { 0x69, 0x01 }; 525 + unsigned int buck_phase, ldo_cfg0, ldo_cfg1; 526 + int i, ret; 513 527 u8 mask; 514 528 529 + ret = regmap_raw_write(regmap, RTQ2208_REG_HIDDEN0, entry_key, ARRAY_SIZE(entry_key)); 530 + if (ret) 531 + return dev_err_probe(dev, ret, "Failed to enter hidden page\n"); 532 + 533 + ret = regmap_read(regmap, RTQ2208_REG_HIDDEN_BUCKPH, &buck_phase); 534 + if (ret) 535 + return dev_err_probe(dev, ret, "Failed to read buck phase configuration\n"); 536 + 537 + ret = regmap_read(regmap, RTQ2208_REG_HIDDEN_LDOCFG0, &ldo_cfg0); 538 + if (ret) 539 + return dev_err_probe(dev, ret, "Failed to read ldo cfg0\n"); 540 + 541 + ret = regmap_read(regmap, RTQ2208_REG_HIDDEN_LDOCFG1, &ldo_cfg1); 542 + if (ret) 543 + return dev_err_probe(dev, ret, "Failed to read ldo cfg1\n"); 544 + 545 + ret = regmap_write(regmap, RTQ2208_REG_HIDDEN1, 0x00); 546 + if (ret) 547 + return dev_err_probe(dev, ret, "Failed to exit hidden page\n"); 548 + 549 + dev_info(dev, "BUCK Phase 0x%x\n", buck_phase); 550 + /* 551 + * Use buck phase configuration to assign used table mask 552 + * GROUP1 GROUP2 553 + * 0 -> 2P + 2P BC FG 554 + * 1 -> 2P + 1P + 1P BCA FGE 555 + * 2 -> 1P + 1P + 1P + 1P BCDA FGHE 556 + * 3 -> 3P + 1P BC FG 557 + * others -> 4P C G 558 + */ 559 + switch (FIELD_GET(RTQ2208_MASK_BUCKPH_GROUP1, buck_phase)) { 560 + case 2: 561 + rtq2208_used_table[RTQ2208_BUCK_D] = true; 562 + fallthrough; 563 + case 1: 564 + rtq2208_used_table[RTQ2208_BUCK_A] = true; 565 + fallthrough; 566 + case 0: 567 + case 3: 568 + rtq2208_used_table[RTQ2208_BUCK_B] = true; 569 + fallthrough; 570 + default: 571 + rtq2208_used_table[RTQ2208_BUCK_C] = true; 572 + break; 573 + } 574 + 575 + switch (FIELD_GET(RTQ2208_MASK_BUCKPH_GROUP2, buck_phase)) { 576 + case 2: 577 + rtq2208_used_table[RTQ2208_BUCK_F] = true; 578 + fallthrough; 579 + case 1: 580 + rtq2208_used_table[RTQ2208_BUCK_E] = true; 581 + fallthrough; 582 + case 0: 583 + case 3: 584 + rtq2208_used_table[RTQ2208_BUCK_H] = true; 585 + fallthrough; 586 + default: 587 + rtq2208_used_table[RTQ2208_BUCK_G] = true; 588 + break; 589 + } 590 + 591 + *ldo1_fixed_uV = FIELD_GET(RTQ2208_MASK_LDO1_FIXED, ldo_cfg1) ? 1200000 : 0; 592 + 593 + if (!FIELD_GET(RTQ2208_MASK_LDO2_OPT0, ldo_cfg0) && 594 + !FIELD_GET(RTQ2208_MASK_LDO2_OPT1, ldo_cfg1)) 595 + *ldo2_fixed_uV = 0; 596 + else if (FIELD_GET(RTQ2208_MASK_LDO2_OPT1, ldo_cfg1)) 597 + *ldo2_fixed_uV = 900000; 598 + else 599 + *ldo2_fixed_uV = 1200000; 600 + 601 + /* By default, LDO1 & LDO2 are always used */ 602 + rtq2208_used_table[RTQ2208_LDO1] = rtq2208_used_table[RTQ2208_LDO2] = true; 603 + 515 604 for (i = 0; i < RTQ2208_LDO_MAX; i++) { 516 - if (!rtq2208_used_table[idx][i]) 605 + if (!rtq2208_used_table[i]) 517 606 continue; 518 607 519 608 regulator_idx_table[(*num)++] = i; ··· 586 559 static const struct regmap_config rtq2208_regmap_config = { 587 560 .reg_bits = 8, 588 561 .val_bits = 8, 589 - .max_register = 0xEF, 562 + .max_register = 0xFF, 590 563 }; 591 564 592 565 static int rtq2208_probe(struct i2c_client *i2c) ··· 600 573 int i, ret = 0, idx, n_regulator = 0; 601 574 unsigned int regulator_idx_table[RTQ2208_LDO_MAX], 602 575 buck_masks[RTQ2208_BUCK_NUM_IRQ_REGS] = {0x33, 0x33, 0x33, 0x33, 0x33}; 576 + unsigned int ldo1_fixed_uV, ldo2_fixed_uV; 603 577 604 578 rdev_map = devm_kzalloc(dev, sizeof(struct rtq2208_rdev_map), GFP_KERNEL); 605 579 if (!rdev_map) ··· 611 583 return dev_err_probe(dev, PTR_ERR(regmap), "Failed to allocate regmap\n"); 612 584 613 585 /* get needed regulator */ 614 - ret = rtq2208_regulator_check(i2c->addr, &n_regulator, regulator_idx_table, buck_masks); 586 + ret = rtq2208_regulator_check(dev, &n_regulator, regulator_idx_table, buck_masks, 587 + &ldo1_fixed_uV, &ldo2_fixed_uV); 615 588 if (ret) 616 589 return dev_err_probe(dev, ret, "Failed to check used regulators\n"); 617 590 ··· 622 593 cfg.dev = dev; 623 594 624 595 /* init regulator desc */ 625 - ret = rtq2208_parse_regulator_dt_data(n_regulator, regulator_idx_table, rdesc, dev); 596 + ret = rtq2208_parse_regulator_dt_data(n_regulator, regulator_idx_table, rdesc, dev, 597 + ldo1_fixed_uV, ldo2_fixed_uV); 626 598 if (ret) 627 599 return ret; 628 600

Configure Feed

Configure Feed