static struct platform_driver pm800_regulator_driver = {
        .driver         = {
                .name   = "88pm80x-regulator",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
        .probe          = pm800_regulator_probe,
 };
 
 static struct platform_driver pm8607_regulator_driver = {
        .driver         = {
                .name   = "88pm860x-regulator",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
        .probe          = pm8607_regulator_probe,
        .id_table       = pm8607_regulator_driver_ids,
 
 static struct platform_driver aat2870_regulator_driver = {
        .driver = {
                .name   = "aat2870-regulator",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
        .probe  = aat2870_regulator_probe,
 };
 
        .probe = ab8500_ext_regulator_probe,
        .driver         = {
                .name   = "ab8500-ext-regulator",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
 };
 
 
        .probe = ab8500_regulator_probe,
        .driver         = {
                .name   = "ab8500-regulator",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
 };
 
 
 static struct i2c_driver act8865_pmic_driver = {
        .driver = {
                .name   = "act8865",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
        .probe_new      = act8865_pmic_probe,
        .id_table       = act8865_ids,
 
 static struct platform_driver act8945a_pmic_driver = {
        .driver = {
                .name = "act8945a-regulator",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
                .pm = &act8945a_pm,
        },
        .probe = act8945a_pmic_probe,
 
        .probe_new = ad5398_probe,
        .driver         = {
                .name   = "ad5398",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
        .id_table       = ad5398_id,
 };
 
 static struct platform_driver anatop_regulator_driver = {
        .driver = {
                .name   = "anatop_regulator",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
                .of_match_table = of_anatop_regulator_match_tbl,
        },
        .probe  = anatop_regulator_probe,
 
        .remove = arizona_ldo1_remove,
        .driver         = {
                .name   = "arizona-ldo1",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
 };
 
 
        .probe = arizona_micsupp_probe,
        .driver         = {
                .name   = "arizona-micsupp",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
 };
 
 
 static struct platform_driver as3711_regulator_driver = {
        .driver = {
                .name   = "as3711-regulator",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
        .probe          = as3711_regulator_probe,
 };
 
 static struct platform_driver as3722_regulator_driver = {
        .driver = {
                .name = "as3722-regulator",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
                .of_match_table = of_as3722_regulator_match,
        },
        .probe = as3722_regulator_probe,
 
        .probe  = axp20x_regulator_probe,
        .driver = {
                .name           = "axp20x-regulator",
+               .probe_type     = PROBE_PREFER_ASYNCHRONOUS,
        },
 };
 
 
 static struct platform_driver bcm590xx_regulator_driver = {
        .driver = {
                .name = "bcm590xx-vregs",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
        .probe = bcm590xx_probe,
 };
 
 static struct platform_driver bd9571mwv_regulator_driver = {
        .driver = {
                .name = "bd9571mwv-regulator",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
                .pm = DEV_PM_OPS,
        },
        .probe = bd9571mwv_regulator_probe,
 
        .probe          = cpcap_regulator_probe,
        .driver         = {
                .name   = "cpcap-regulator",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
                .of_match_table = of_match_ptr(cpcap_regulator_id_table),
        },
 };
 
 static struct platform_driver da903x_regulator_driver = {
        .driver = {
                .name   = "da903x-regulator",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
        .probe          = da903x_regulator_probe,
 };
 
        .probe = da9052_regulator_probe,
        .driver = {
                .name = "da9052-regulator",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
 };
 
 
        .probe = da9055_regulator_probe,
        .driver = {
                .name = "da9055-regulator",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
 };
 
 
 static struct platform_driver da9062_regulator_driver = {
        .driver = {
                .name = "da9062-regulators",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
        .probe = da9062_regulator_probe,
 };
 
 static struct platform_driver da9063_regulator_driver = {
        .driver = {
                .name = DA9063_DRVNAME_REGULATORS,
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
        .probe = da9063_regulator_probe,
 };
 
 static struct i2c_driver da9210_regulator_driver = {
        .driver = {
                .name = "da9210",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
                .of_match_table = of_match_ptr(da9210_dt_ids),
        },
        .probe_new = da9210_i2c_probe,
 
 static struct i2c_driver da9211_regulator_driver = {
        .driver = {
                .name = "da9211",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
                .of_match_table = of_match_ptr(da9211_dt_ids),
        },
        .probe_new = da9211_i2c_probe,
 
 static struct platform_driver db8500_regulator_driver = {
        .driver = {
                .name = "db8500-prcmu-regulators",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
        .probe = db8500_regulator_probe,
        .remove = db8500_regulator_remove,
 
        .probe          = dummy_regulator_probe,
        .driver         = {
                .name           = "reg-dummy",
+               .probe_type     = PROBE_PREFER_ASYNCHRONOUS,
        },
 };
 
 
 static struct i2c_driver fan53555_regulator_driver = {
        .driver = {
                .name = "fan53555-regulator",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
                .of_match_table = of_match_ptr(fan53555_dt_ids),
        },
        .probe_new = fan53555_regulator_probe,
 
        .probe          = reg_fixed_voltage_probe,
        .driver         = {
                .name           = "reg-fixed-voltage",
+               .probe_type     = PROBE_PREFER_ASYNCHRONOUS,
                .of_match_table = of_match_ptr(fixed_of_match),
        },
 };
 
        .probe          = gpio_regulator_probe,
        .driver         = {
                .name           = "gpio-regulator",
+               .probe_type     = PROBE_PREFER_ASYNCHRONOUS,
                .of_match_table = of_match_ptr(regulator_gpio_of_match),
        },
 };
 
        .id_table = hi6421_regulator_table,
        .driver = {
                .name   = "hi6421-regulator",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
        .probe  = hi6421_regulator_probe,
 };
 
        .id_table = hi6421v530_regulator_table,
        .driver = {
                .name   = "hi6421v530-regulator",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
        .probe  = hi6421v530_regulator_probe,
 };
 
        .id_table = hi655x_regulator_table,
        .driver = {
                .name   = "hi655x-regulator",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
        .probe  = hi655x_regulator_probe,
 };
 
 static struct i2c_driver isl6271a_i2c_driver = {
        .driver = {
                .name = "isl6271a",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
        .probe_new = isl6271a_probe,
        .id_table = isl6271a_id,
 
 static struct i2c_driver isl9305_regulator_driver = {
        .driver = {
                .name = "isl9305",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
                .of_match_table = of_match_ptr(isl9305_dt_ids),
        },
        .probe_new = isl9305_i2c_probe,
 
        .probe = lm363x_regulator_probe,
        .driver = {
                .name = "lm363x-regulator",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
 };
 
 
 static struct i2c_driver lp3971_i2c_driver = {
        .driver = {
                .name = "LP3971",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
        .probe_new = lp3971_i2c_probe,
        .id_table = lp3971_i2c_id,
 
 static struct i2c_driver lp3972_i2c_driver = {
        .driver = {
                .name = "lp3972",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
        .probe_new = lp3972_i2c_probe,
        .id_table = lp3972_i2c_id,
 
 static struct i2c_driver lp872x_driver = {
        .driver = {
                .name = "lp872x",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
                .of_match_table = of_match_ptr(lp872x_dt_ids),
        },
        .probe_new = lp872x_probe,
 
 static struct platform_driver lp873x_regulator_driver = {
        .driver = {
                .name = "lp873x-pmic",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
        .probe = lp873x_regulator_probe,
        .id_table = lp873x_regulator_id_table,
 
 static struct i2c_driver lp8755_i2c_driver = {
        .driver = {
                   .name = LP8755_NAME,
+                  .probe_type = PROBE_PREFER_ASYNCHRONOUS,
                   },
        .probe_new = lp8755_probe,
        .remove = lp8755_remove,
 
 static struct platform_driver lp87565_regulator_driver = {
        .driver = {
                .name = "lp87565-pmic",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
        .probe = lp87565_regulator_probe,
        .id_table = lp87565_regulator_id_table,
 
        .probe = lp8788_buck_probe,
        .driver = {
                .name = LP8788_DEV_BUCK,
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
 };
 
 
        .probe = lp8788_dldo_probe,
        .driver = {
                .name = LP8788_DEV_DLDO,
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
 };
 
        .probe = lp8788_aldo_probe,
        .driver = {
                .name = LP8788_DEV_ALDO,
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
 };
 
 
 static struct i2c_driver ltc3589_driver = {
        .driver = {
                .name = DRIVER_NAME,
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
                .of_match_table = of_match_ptr(ltc3589_of_match),
        },
        .probe_new = ltc3589_probe,
 
 static struct i2c_driver ltc3676_driver = {
        .driver = {
                .name = DRIVER_NAME,
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
                .of_match_table = of_match_ptr(ltc3676_of_match),
        },
        .probe_new = ltc3676_regulator_probe,
 
 static struct platform_driver max14577_regulator_driver = {
        .driver = {
                   .name = "max14577-regulator",
+                  .probe_type = PROBE_PREFER_ASYNCHRONOUS,
                   },
        .probe          = max14577_regulator_probe,
        .id_table       = max14577_regulator_id,
 
        .probe_new = max1586_pmic_probe,
        .driver         = {
                .name   = "max1586",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
                .of_match_table = of_match_ptr(max1586_of_match),
        },
        .id_table       = max1586_id,
 
        .id_table = max77620_regulator_devtype,
        .driver = {
                .name = "max77620-pmic",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
                .pm = &max77620_regulator_pm_ops,
        },
 };
 
 static struct platform_driver max77686_pmic_driver = {
        .driver = {
                .name = "max77686-pmic",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
        .probe = max77686_pmic_probe,
        .id_table = max77686_pmic_id,
 
 static struct platform_driver max77693_pmic_driver = {
        .driver = {
                   .name = "max77693-pmic",
+                  .probe_type = PROBE_PREFER_ASYNCHRONOUS,
                   },
        .probe = max77693_pmic_probe,
        .id_table = max77693_pmic_id,
 
 static struct platform_driver max77802_pmic_driver = {
        .driver = {
                .name = "max77802-pmic",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
        .probe = max77802_pmic_probe,
        .id_table = max77802_pmic_id,
 
        .probe_new      = max8649_regulator_probe,
        .driver         = {
                .name   = "max8649",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
        .id_table       = max8649_id,
 };
 
        .probe_new = max8660_probe,
        .driver         = {
                .name   = "max8660",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
        .id_table       = max8660_id,
 };
 
 static struct platform_driver max8907_regulator_driver = {
        .driver = {
                   .name = "max8907-regulator",
+                  .probe_type = PROBE_PREFER_ASYNCHRONOUS,
                   },
        .probe = max8907_regulator_probe,
 };
 
 static struct platform_driver max8925_regulator_driver = {
        .driver         = {
                .name   = "max8925-regulator",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
        .probe          = max8925_regulator_probe,
 };
 
        .probe_new      = max8952_pmic_probe,
        .driver         = {
                .name   = "max8952",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
                .of_match_table = of_match_ptr(max8952_dt_match),
        },
        .id_table       = max8952_ids,
 
 static struct i2c_driver max8973_i2c_driver = {
        .driver = {
                .name = "max8973",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
                .of_match_table = of_max8973_match_tbl,
        },
        .probe_new = max8973_probe,
 
 static struct platform_driver max8997_pmic_driver = {
        .driver = {
                .name = "max8997-pmic",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
        .probe = max8997_pmic_probe,
        .id_table = max8997_pmic_id,
 
 static struct platform_driver max8998_pmic_driver = {
        .driver = {
                .name = "max8998-pmic",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
        .probe = max8998_pmic_probe,
        .id_table = max8998_pmic_id,
 
 static struct platform_driver mc13783_regulator_driver = {
        .driver = {
                .name   = "mc13783-regulator",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
        .probe          = mc13783_regulator_probe,
 };
 
 static struct platform_driver mc13892_regulator_driver = {
        .driver = {
                .name   = "mc13892-regulator",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
        .probe  = mc13892_regulator_probe,
 };
 
 static struct i2c_driver mt6311_regulator_driver = {
        .driver = {
                .name = "mt6311",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
                .of_match_table = of_match_ptr(mt6311_dt_ids),
        },
        .probe_new = mt6311_i2c_probe,
 
 static struct platform_driver mt6323_regulator_driver = {
        .driver = {
                .name = "mt6323-regulator",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
        .probe = mt6323_regulator_probe,
        .id_table = mt6323_platform_ids,
 
 static struct platform_driver mt6380_regulator_driver = {
        .driver = {
                .name = "mt6380-regulator",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
                .of_match_table = of_match_ptr(mt6380_of_match),
        },
        .probe = mt6380_regulator_probe,
 
 static struct platform_driver mt6397_regulator_driver = {
        .driver = {
                .name = "mt6397-regulator",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
                .of_match_table = of_match_ptr(mt6397_of_match),
        },
        .probe = mt6397_regulator_probe,
 
 static struct platform_driver palmas_driver = {
        .driver = {
                .name = "palmas-pmic",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
                .of_match_table = of_palmas_match_tbl,
        },
        .probe = palmas_regulators_probe,
 
        .probe          = pbias_regulator_probe,
        .driver         = {
                .name           = "pbias-regulator",
+               .probe_type     = PROBE_PREFER_ASYNCHRONOUS,
                .of_match_table = of_match_ptr(pbias_of_match),
        },
 };
 
 static struct platform_driver pcap_regulator_driver = {
        .driver = {
                .name   = "pcap-regulator",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
        .probe  = pcap_regulator_probe,
 };
 
 static struct platform_driver pcf50633_regulator_driver = {
        .driver = {
                .name = "pcf50633-regulator",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
        .probe = pcf50633_regulator_probe,
 };
 
 static struct i2c_driver pfuze_driver = {
        .driver = {
                .name = "pfuze100-regulator",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
                .of_match_table = pfuze_dt_ids,
        },
        .probe_new = pfuze100_regulator_probe,
 
 static struct i2c_driver pv88060_regulator_driver = {
        .driver = {
                .name = "pv88060",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
                .of_match_table = of_match_ptr(pv88060_dt_ids),
        },
        .probe_new = pv88060_i2c_probe,
 
 static struct i2c_driver pv88080_regulator_driver = {
        .driver = {
                .name = "pv88080",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
                .of_match_table = of_match_ptr(pv88080_dt_ids),
        },
        .probe_new = pv88080_i2c_probe,
 
 static struct i2c_driver pv88090_regulator_driver = {
        .driver = {
                .name = "pv88090",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
                .of_match_table = of_match_ptr(pv88090_dt_ids),
        },
        .probe_new = pv88090_i2c_probe,
 
 static struct platform_driver pwm_regulator_driver = {
        .driver = {
                .name           = "pwm-regulator",
+               .probe_type     = PROBE_PREFER_ASYNCHRONOUS,
                .of_match_table = of_match_ptr(pwm_of_match),
        },
        .probe = pwm_regulator_probe,
 
        .probe          = rpm_reg_probe,
        .driver  = {
                .name  = "qcom_rpm_reg",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
                .of_match_table = of_match_ptr(rpm_of_match),
        },
 };
 
        .probe = rpm_reg_probe,
        .driver = {
                .name  = "qcom_rpm_smd_regulator",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
                .of_match_table = rpm_of_match,
        },
 };
 
 static struct platform_driver qcom_spmi_regulator_driver = {
        .driver         = {
                .name   = "qcom-spmi-regulator",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
                .of_match_table = qcom_spmi_regulator_match,
        },
        .probe          = qcom_spmi_regulator_probe,
 
 static struct platform_driver rc5t583_regulator_driver = {
        .driver = {
                .name   = "rc5t583-regulator",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
        .probe          = rc5t583_regulator_probe,
 };
 
 static struct platform_driver rk808_regulator_driver = {
        .probe = rk808_regulator_probe,
        .driver = {
-               .name = "rk808-regulator"
+               .name = "rk808-regulator",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
 };
 
 
        .probe = rn5t618_regulator_probe,
        .driver = {
                .name   = "rn5t618-regulator",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
 };
 
 
 static struct platform_driver rt5033_regulator_driver = {
        .driver = {
                .name = "rt5033-regulator",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
        .probe          = rt5033_regulator_probe,
        .id_table       = rt5033_regulator_id,
 
 static struct platform_driver s2mpa01_pmic_driver = {
        .driver = {
                .name = "s2mpa01-pmic",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
        .probe = s2mpa01_pmic_probe,
        .id_table = s2mpa01_pmic_id,
 
 static struct platform_driver s2mps11_pmic_driver = {
        .driver = {
                .name = "s2mps11-pmic",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
        .probe = s2mps11_pmic_probe,
        .id_table = s2mps11_pmic_id,
 
 static struct platform_driver s5m8767_pmic_driver = {
        .driver = {
                .name = "s5m8767-pmic",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
        .probe = s5m8767_pmic_probe,
        .id_table = s5m8767_pmic_id,
 
 static struct platform_driver sky81452_reg_driver = {
        .driver = {
                .name = "sky81452-regulator",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
        .probe = sky81452_reg_probe,
 };
 
        .remove = stm32_vrefbuf_remove,
        .driver = {
                .name  = "stm32-vrefbuf",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
                .of_match_table = of_match_ptr(stm32_vrefbuf_of_match),
                .pm = &stm32_vrefbuf_pm_ops,
        },
 
 static struct platform_driver stw481x_vmmc_regulator_driver = {
        .driver = {
                .name  = "stw481x-vmmc-regulator",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
                .of_match_table = stw481x_vmmc_match,
        },
        .probe = stw481x_vmmc_regulator_probe,
 
        .probe = ti_abb_probe,
        .driver = {
                   .name = "ti_abb",
+                  .probe_type = PROBE_PREFER_ASYNCHRONOUS,
                   .of_match_table = of_match_ptr(ti_abb_of_match),
                   },
 };
 
 static struct i2c_driver tps51632_i2c_driver = {
        .driver = {
                .name = "tps51632",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
                .of_match_table = of_match_ptr(tps51632_of_match),
        },
        .probe_new = tps51632_probe,
 
 static struct platform_driver tps6105x_regulator_driver = {
        .driver = {
                .name  = "tps6105x-regulator",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
        .probe = tps6105x_regulator_probe,
 };
 
 static struct i2c_driver tps62360_i2c_driver = {
        .driver = {
                .name = "tps62360",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
                .of_match_table = of_match_ptr(tps62360_of_match),
        },
        .probe_new = tps62360_probe,
 
 static struct i2c_driver tps_65023_i2c_driver = {
        .driver = {
                .name = "tps65023",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
                .of_match_table = of_match_ptr(tps65023_of_match),
        },
        .probe_new = tps_65023_probe,
 
 static struct platform_driver tps6507x_pmic_driver = {
        .driver = {
                .name = "tps6507x-pmic",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
        .probe = tps6507x_pmic_probe,
 };
 
 static struct platform_driver tps65086_regulator_driver = {
        .driver = {
                .name = "tps65086-regulator",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
        .probe = tps65086_regulator_probe,
        .id_table = tps65086_regulator_id_table,
 
 static struct platform_driver tps65090_regulator_driver = {
        .driver = {
                .name   = "tps65090-pmic",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
        .probe          = tps65090_regulator_probe,
 };
 
 static struct i2c_driver tps65132_i2c_driver = {
        .driver = {
                .name = "tps65132",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
        .probe_new = tps65132_probe,
        .id_table = tps65132_id,
 
 static struct platform_driver tps65217_regulator_driver = {
        .driver = {
                .name = "tps65217-pmic",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
        .probe = tps65217_regulator_probe,
 };
 
 static struct platform_driver tps65218_regulator_driver = {
        .driver = {
                .name = "tps65218-pmic",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
        .probe = tps65218_regulator_probe,
        .id_table = tps65218_regulator_id_table,
 
        .probe          = pmic_probe,
        .driver         = {
                .name   = "tps6524x",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
 };
 
 
 static struct platform_driver tps6586x_regulator_driver = {
        .driver = {
                .name   = "tps6586x-regulator",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
        .probe          = tps6586x_regulator_probe,
 };
 
 static struct platform_driver tps65910_driver = {
        .driver = {
                .name = "tps65910-pmic",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
        .probe = tps65910_probe,
        .shutdown = tps65910_shutdown,
 
 static struct platform_driver tps65912_regulator_driver = {
        .driver = {
                .name = "tps65912-regulator",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
        .probe = tps65912_regulator_probe,
        .id_table = tps65912_regulator_id_table,
 
         */
        .driver  = {
                .name  = "twl4030_reg",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
                .of_match_table = of_match_ptr(twl_of_match),
        },
 };
 
         */
        .driver  = {
                .name  = "twl6030_reg",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
                .of_match_table = of_match_ptr(twl_of_match),
        },
 };
 
        .remove         = regulator_userspace_consumer_remove,
        .driver         = {
                .name           = "reg-userspace-consumer",
+               .probe_type     = PROBE_PREFER_ASYNCHRONOUS,
                .of_match_table = regulator_userspace_consumer_of_match,
        },
 };
 
        .probe          = vctrl_probe,
        .driver         = {
                .name           = "vctrl-regulator",
+               .probe_type     = PROBE_PREFER_ASYNCHRONOUS,
                .of_match_table = of_match_ptr(vctrl_of_match),
        },
 };
 
        .probe = vexpress_regulator_probe,
        .driver = {
                .name = DRVNAME,
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
                .of_match_table = vexpress_regulator_of_match,
        },
 };
 
        .remove         = regulator_virtual_remove,
        .driver         = {
                .name           = "reg-virt-consumer",
+               .probe_type     = PROBE_PREFER_ASYNCHRONOUS,
                .of_match_table = of_match_ptr(regulator_virtual_consumer_of_match),
        },
 };
 
        .probe = wm831x_buckv_probe,
        .driver         = {
                .name   = "wm831x-buckv",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
 };
 
        .probe = wm831x_buckp_probe,
        .driver         = {
                .name   = "wm831x-buckp",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
 };
 
        .probe = wm831x_boostp_probe,
        .driver         = {
                .name   = "wm831x-boostp",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
 };
 
        .probe = wm831x_epe_probe,
        .driver         = {
                .name   = "wm831x-epe",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
 };
 
 
        .probe = wm831x_isink_probe,
        .driver         = {
                .name   = "wm831x-isink",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
 };
 
 
        .probe = wm831x_gp_ldo_probe,
        .driver         = {
                .name   = "wm831x-ldo",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
 };
 
        .probe = wm831x_aldo_probe,
        .driver         = {
                .name   = "wm831x-aldo",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
 };
 
        .probe = wm831x_alive_ldo_probe,
        .driver         = {
                .name   = "wm831x-alive-ldo",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
 };
 
 
        .remove = wm8350_regulator_remove,
        .driver         = {
                .name   = "wm8350-regulator",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
 };
 
 
 static struct platform_driver wm8400_regulator_driver = {
        .driver = {
                .name = "wm8400-regulator",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
        .probe = wm8400_regulator_probe,
 };
 
        .probe = wm8994_ldo_probe,
        .driver         = {
                .name   = "wm8994-ldo",
+               .probe_type = PROBE_PREFER_ASYNCHRONOUS,
        },
 };